Add keyed service support to DataLoaders

src/HotChocolate/Core/src/Types.Analyzers/DataLoaderKeyedServiceAttributeIgnoredAnalyzer.cs

@@ -0,0 +1,111 @@
+using System.Collections.Immutable;
+using HotChocolate.Types.Analyzers.Helpers;
+using HotChocolate.Types.Analyzers.Models;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace HotChocolate.Types.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class DataLoaderKeyedServiceAttributeIgnoredAnalyzer : DiagnosticAnalyzer
+{
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
+        [Errors.DataLoaderKeyedServiceAttributeIgnored];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeMethodDeclaration, SyntaxKind.MethodDeclaration);
+    }
+
+    private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
+    {
+        var methodDeclaration = (MethodDeclarationSyntax)context.Node;
+        var attributes = GenericDataLoaderAnalyzerHelper.GetDataLoaderAttributes(
+            context.SemanticModel,
+            methodDeclaration,
+            context.Compilation,
+            context.CancellationToken);
+
+        if (attributes.IsEmpty
+            || context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken)
+                is not IMethodSymbol methodSymbol
+            || methodSymbol.Parameters.IsEmpty)
+        {
+            return;
+        }
+
+        var parameters = DataLoaderInfo.CreateParameters(methodSymbol, context.Compilation);
+
+        foreach (var parameter in methodDeclaration.ParameterList.Parameters)
+        {
+            if (context.SemanticModel.GetDeclaredSymbol(parameter, context.CancellationToken)
+                is not IParameterSymbol parameterSymbol
+                || parameters.FirstOrDefault(t => SymbolEqualityComparer.Default.Equals(
+                    t.Parameter,
+                    parameterSymbol)) is not { Kind: not DataLoaderParameterKind.Service })
+            {
+                continue;
+            }
+
+            foreach (var attributeList in parameter.AttributeLists)
+            {
+                foreach (var attribute in attributeList.Attributes)
+                {
+                    if (IsKeyedServiceAttribute(
+                        attribute,
+                        parameterSymbol,
+                        context.SemanticModel,
+                        context.Compilation,
+                        context.CancellationToken))
+                    {
+                        context.ReportDiagnostic(Diagnostic.Create(
+                            Errors.DataLoaderKeyedServiceAttributeIgnored,
+                            attribute.GetLocation()));
+                    }
+                }
+            }
+        }
+    }
+
+    private static bool IsKeyedServiceAttribute(
+        AttributeSyntax attribute,
+        IParameterSymbol parameter,
+        SemanticModel semanticModel,
+        Compilation compilation,
+        CancellationToken cancellationToken)
+    {
+        if (semanticModel.GetSymbolInfo(attribute, cancellationToken).Symbol is not IMethodSymbol attributeConstructor)
+        {
+            return false;
+        }
+
+        var attributeType = attributeConstructor.ContainingType;
+
+        if (attributeType.ToDisplayString() == WellKnownAttributes.FromKeyedServicesAttribute)
+        {
+            return true;
+        }
+
+        if (!attributeType.IsOrInheritsFrom(WellKnownAttributes.ServiceAttribute))
+        {
+            return false;
+        }
+
+        if (attributeType.ToDisplayString() == WellKnownAttributes.ServiceAttribute)
+        {
+            return attributeConstructor.Parameters.Length == 1;
+        }
+
+        var attributeData = parameter.GetAttributes().FirstOrDefault(t =>
+            t.ApplicationSyntaxReference is { } syntaxReference
+            && syntaxReference.SyntaxTree == attribute.SyntaxTree
+            && syntaxReference.Span == attribute.Span);
+
+        return attributeData?.GetDerivedServiceKey(compilation, out _)
+            == SymbolExtensions.ServiceKeyExtractionResult.Key;
+    }
+}

src/HotChocolate/Core/src/Types.Analyzers/DataLoaderKeyedServiceAttributeIgnoredCodeFixProvider.cs

@@ -0,0 +1,75 @@
+using System.Collections.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace HotChocolate.Types.Analyzers;
+
+[Shared]
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(DataLoaderKeyedServiceAttributeIgnoredCodeFixProvider))]
+public sealed class DataLoaderKeyedServiceAttributeIgnoredCodeFixProvider : CodeFixProvider
+{
+    private const string Title = "Remove keyed service attribute";
+
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } =
+        [ErrorCodes.Analyzers.DataLoaderKeyedServiceAttributeIgnored];
+
+    public override FixAllProvider GetFixAllProvider()
+        => WellKnownFixAllProviders.BatchFixer;
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+        if (root is null)
+        {
+            return;
+        }
+
+        var attribute = root.FindNode(context.Diagnostics[0].Location.SourceSpan)
+            .AncestorsAndSelf()
+            .OfType<AttributeSyntax>()
+            .FirstOrDefault();
+
+        if (attribute is null)
+        {
+            return;
+        }
+
+        context.RegisterCodeFix(
+            CodeAction.Create(
+                Title,
+                c => RemoveAttributeAsync(context.Document, attribute, c),
+                Title),
+            context.Diagnostics);
+    }
+
+    private static async Task<Document> RemoveAttributeAsync(
+        Document document,
+        AttributeSyntax attribute,
+        CancellationToken cancellationToken)
+    {
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+        if (root is null || attribute.Parent is not AttributeListSyntax attributeList)
+        {
+            return document;
+        }
+
+        SyntaxNode? newRoot;
+
+        if (attributeList.Attributes.Count == 1)
+        {
+            newRoot = root.RemoveNode(attributeList, SyntaxRemoveOptions.KeepExteriorTrivia);
+        }
+        else
+        {
+            var newAttributeList = attributeList.RemoveNode(attribute, SyntaxRemoveOptions.KeepExteriorTrivia);
+            newRoot = newAttributeList is null ? null : root.ReplaceNode(attributeList, newAttributeList);
+        }
+
+        return newRoot is null ? document : document.WithSyntaxRoot(newRoot);
+    }
+}

src/HotChocolate/Core/src/Types.Analyzers/DataLoaderKeyedServiceConflictAnalyzer.cs

@@ -0,0 +1,62 @@
+using System.Collections.Immutable;
+using HotChocolate.Types.Analyzers.Helpers;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace HotChocolate.Types.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class DataLoaderKeyedServiceConflictAnalyzer : DiagnosticAnalyzer
+{
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
+        [Errors.DataLoaderKeyedServiceAttributeConflict];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeMethodDeclaration, SyntaxKind.MethodDeclaration);
+    }
+
+    private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
+    {
+        var methodDeclaration = (MethodDeclarationSyntax)context.Node;
+        var attributes = GenericDataLoaderAnalyzerHelper.GetDataLoaderAttributes(
+            context.SemanticModel,
+            methodDeclaration,
+            context.Compilation,
+            context.CancellationToken);
+
+        if (attributes.IsEmpty)
+        {
+            return;
+        }
+
+        foreach (var parameter in methodDeclaration.ParameterList.Parameters)
+        {
+            if (parameter.AttributeLists.Count == 0
+                || context.SemanticModel.GetDeclaredSymbol(parameter, context.CancellationToken)
+                    is not IParameterSymbol parameterSymbol)
+            {
+                continue;
+            }
+
+            var serviceAttributeInfo = parameterSymbol.GetServiceAttributeInfo(context.Compilation);
+
+            if (serviceAttributeInfo.HasServiceAttribute
+                && serviceAttributeInfo.HasFromKeyedServicesAttribute)
+            {
+                context.ReportDiagnostic(Diagnostic.Create(
+                    Errors.DataLoaderKeyedServiceAttributeConflict,
+                    Location.Create(
+                        parameter.SyntaxTree,
+                        TextSpan.FromBounds(
+                            parameter.AttributeLists[0].SpanStart,
+                            parameter.AttributeLists[parameter.AttributeLists.Count - 1].Span.End))));
+            }
+        }
+    }
+}

src/HotChocolate/Core/src/Types.Analyzers/DataLoaderKeyedServiceKeyNotDeterminableAnalyzer.cs

@@ -0,0 +1,79 @@
+using System.Collections.Immutable;
+using HotChocolate.Types.Analyzers.Helpers;
+using HotChocolate.Types.Analyzers.Models;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace HotChocolate.Types.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class DataLoaderKeyedServiceKeyNotDeterminableAnalyzer : DiagnosticAnalyzer
+{
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
+        [Errors.DataLoaderKeyedServiceKeyNotDeterminable];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeMethodDeclaration, SyntaxKind.MethodDeclaration);
+    }
+
+    private static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
+    {
+        var methodDeclaration = (MethodDeclarationSyntax)context.Node;
+        var attributes = GenericDataLoaderAnalyzerHelper.GetDataLoaderAttributes(
+            context.SemanticModel,
+            methodDeclaration,
+            context.Compilation,
+            context.CancellationToken);
+
+        if (attributes.IsEmpty
+            || context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken)
+                is not IMethodSymbol methodSymbol
+            || methodSymbol.Parameters.IsEmpty)
+        {
+            return;
+        }
+
+        var parameters = DataLoaderInfo.CreateParameters(methodSymbol, context.Compilation);
+
+        foreach (var parameter in parameters)
+        {
+            if (parameter.Kind is not DataLoaderParameterKind.Service)
+            {
+                continue;
+            }
+
+            var serviceAttributeInfo = parameter.Parameter.GetServiceAttributeInfo(context.Compilation);
+
+            if (!serviceAttributeInfo.IsServiceKeyUndeterminable)
+            {
+                continue;
+            }
+
+            foreach (var attribute in parameter.Parameter.GetAttributes())
+            {
+                if (attribute.AttributeClass is null
+                    || attribute.AttributeClass.ToDisplayString() == WellKnownAttributes.ServiceAttribute
+                    || !attribute.AttributeClass.IsOrInheritsFrom(WellKnownAttributes.ServiceAttribute)
+                    || attribute.GetDerivedServiceKey(context.Compilation, out _)
+                        is not SymbolExtensions.ServiceKeyExtractionResult.Undeterminable)
+                {
+                    continue;
+                }
+
+                var location = attribute.ApplicationSyntaxReference?.GetSyntax(context.CancellationToken)
+                    .GetLocation()
+                    ?? parameter.Parameter.Locations.FirstOrDefault()
+                    ?? Location.None;
+
+                context.ReportDiagnostic(Diagnostic.Create(
+                    Errors.DataLoaderKeyedServiceKeyNotDeterminable,
+                    location));
+            }
+        }
+    }
+}