[Analyzer] Source-gen non-static partial root type classes (#9740)

Author: glen-84

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

@@ -63,7 +63,7 @@ public static class Errors
         new(
             id: "HC0091",
             title: "Partial Keyword Missing",
-            messageFormat: "A static root type class should be declared as partial to allow source generation",
+            messageFormat: "A root type class should be declared as partial to allow source generation",
             category: "TypeSystem",
             DiagnosticSeverity.Info,
             isEnabledByDefault: true);

src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/RootTypeFileBuilder.cs

@@ -8,6 +8,27 @@ public sealed class RootTypeFileBuilder(StringBuilder sb) : TypeFileBuilderBase(
 {
     protected override string OutputFieldDescriptorType => WellKnownTypes.ObjectFieldDescriptor;
 
+    public override void WriteBeginClass(IOutputTypeInfo type)
+    {
+        if (type is RootTypeInfo { IsStatic: false } rootType)
+        {
+            Writer.WriteIndentedLine(
+                "{0} partial class {1}",
+                rootType.IsPublic ? "public" : "internal",
+                rootType.Name);
+            Writer.WriteIndentedLine("{");
+            Writer.IncreaseIndent();
+            return;
+        }
+
+        base.WriteBeginClass(type);
+    }
+
+    protected override string GetInstanceReceiver(
+        string fullyQualifiedTypeName,
+        string contextExpression = "context")
+        => $"{contextExpression}.Resolver<{fullyQualifiedTypeName}>()";
+
     public override void WriteInitializeMethod(IOutputTypeInfo type, ILocalTypeLookup typeLookup)
     {
         if (type is not RootTypeInfo rootType)

src/HotChocolate/Core/src/Types.Analyzers/FileBuilders/TypeFileBuilderBase.cs

@@ -48,6 +48,21 @@ public virtual void WriteBeginClass(IOutputTypeInfo type)
         Writer.IncreaseIndent();
     }
 
+    /// <summary>
+    /// Builds the C# expression that yields the receiver for an instance resolver call.
+    /// </summary>
+    /// <param name="fullyQualifiedTypeName">
+    /// The fully qualified type name of the resolver class (already prefixed with <c>global::</c>).
+    /// </param>
+    /// <param name="contextExpression">
+    /// The C# expression that yields the resolver context (e.g. <c>"context"</c> for
+    /// single resolvers, <c>"contexts[0]"</c> for batch resolvers).
+    /// </param>
+    protected virtual string GetInstanceReceiver(
+        string fullyQualifiedTypeName,
+        string contextExpression = "context")
+        => $"{contextExpression}.Parent<{fullyQualifiedTypeName}>()";
+
     public void WriteEndClass()
     {
         Writer.DecreaseIndent();
@@ -920,13 +935,14 @@ private void WriteResolver(
         {
             WriteResolverArguments(resolver, resolverMethod, typeLookup);
 
+            var typeName = resolver.Member.ContainingType.ToFullyQualified();
+            var receiver = resolver.IsStatic ? typeName : GetInstanceReceiver(typeName);
+
             if (async)
             {
                 Writer.WriteIndentedLine(
-                    resolver.IsStatic
-                        ? "var result = await {0}.{1}({2});"
-                        : "var result = await context.Parent<{0}>().{1}({2});",
-                    resolver.Member.ContainingType.ToFullyQualified(),
+                    "var result = await {0}.{1}({2});",
+                    receiver,
                     resolver.Member.Name,
                     GetResolverArgumentAssignments(resolver.Parameters.Length));
 
@@ -935,10 +951,8 @@ private void WriteResolver(
             else
             {
                 Writer.WriteIndentedLine(
-                    resolver.IsStatic
-                        ? "var result = {0}.{1}({2});"
-                        : "var result = context.Parent<{0}>().{1}({2});",
-                    resolver.Member.ContainingType.ToFullyQualified(),
+                    "var result = {0}.{1}({2});",
+                    receiver,
                     resolver.Member.Name,
                     GetResolverArgumentAssignments(resolver.Parameters.Length));
 
@@ -1022,11 +1036,12 @@ private void WritePureResolver(Resolver resolver, IMethodSymbol resolverMethod,
         {
             WriteResolverArguments(resolver, resolverMethod, typeLookup);
 
+            var typeName = resolver.Member.ContainingType.ToFullyQualified();
+            var receiver = resolver.IsStatic ? typeName : GetInstanceReceiver(typeName);
+
             Writer.WriteIndentedLine(
-                resolver.IsStatic
-                    ? "var result = {0}.{1}({2});"
-                    : "var result = context.Parent<{0}>().{1}({2});",
-                resolver.Member.ContainingType.ToFullyQualified(),
+                "var result = {0}.{1}({2});",
+                receiver,
                 resolver.Member.Name,
                 GetResolverArgumentAssignments(resolver.Parameters.Length));
 
@@ -1253,12 +1268,17 @@ or ResolverParameterKind.Argument
 
             Writer.WriteLine();
 
-            // Call the user's batch resolver method
+            // Call the user's batch resolver method.
+            var batchTypeName = resolver.Member.ContainingType.ToFullyQualified();
+            var batchReceiver = resolver.IsStatic
+                ? batchTypeName
+                : GetInstanceReceiver(batchTypeName, "contexts[0]");
+
             if (isAsync)
             {
                 Writer.WriteIndentedLine(
                     "var result = await {0}.{1}({2});",
-                    resolver.Member.ContainingType.ToFullyQualified(),
+                    batchReceiver,
                     resolver.Member.Name,
                     GetResolverArgumentAssignments(resolver.Parameters.Length));
 
@@ -1283,7 +1303,7 @@ or ResolverParameterKind.Argument
             {
                 Writer.WriteIndentedLine(
                     "var result = {0}.{1}({2});",
-                    resolver.Member.ContainingType.ToFullyQualified(),
+                    batchReceiver,
                     resolver.Member.Name,
                     GetResolverArgumentAssignments(resolver.Parameters.Length));
 
@@ -1347,11 +1367,12 @@ private void WritePropertyResolver(Resolver resolver)
         Writer.WriteIndentedLine("{");
         using (Writer.IncreaseIndent())
         {
+            var typeName = resolver.Member.ContainingType.ToFullyQualified();
+            var receiver = resolver.IsStatic ? typeName : GetInstanceReceiver(typeName);
+
             Writer.WriteIndentedLine(
-                resolver.IsStatic
-                    ? "var result = {0}.{1};"
-                    : "var result = context.Parent<{0}>().{1};",
-                resolver.Member.ContainingType.ToFullyQualified(),
+                "var result = {0}.{1};",
+                receiver,
                 resolver.Member.Name);
 
             Writer.WriteIndentedLine("return result;");

src/HotChocolate/Core/src/Types.Analyzers/Inspectors/ObjectTypeInspector.cs

@@ -44,7 +44,9 @@ public bool TryHandle(GeneratorSyntaxContext context, [NotNullWhen(true)] out Sy
                     Location.Create(possibleType.SyntaxTree, possibleType.Span)));
         }
 
-        if (!possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword)))
+        // Root types may be instance classes; the static requirement applies only to object type extensions.
+        if (!isOperationType
+            && !possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword)))
         {
             diagnostics = diagnostics.Add(
                 Diagnostic.Create(

src/HotChocolate/Core/src/Types.Analyzers/Inspectors/TypeAttributeInspector.cs

@@ -60,7 +60,7 @@ public bool TryHandle(
                     {
                         if (fullName.Equals(QueryTypeAttribute))
                         {
-                            if (type.IsStatic && possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
+                            if (possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
                             {
                                 syntaxInfo = null;
                                 return false;
@@ -75,7 +75,7 @@ public bool TryHandle(
 
                         if (fullName.Equals(MutationTypeAttribute))
                         {
-                            if (type.IsStatic && possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
+                            if (possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
                             {
                                 syntaxInfo = null;
                                 return false;
@@ -90,7 +90,7 @@ public bool TryHandle(
 
                         if (fullName.Equals(SubscriptionTypeAttribute))
                         {
-                            if (type.IsStatic && possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
+                            if (possibleType.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
                             {
                                 syntaxInfo = null;
                                 return false;

src/HotChocolate/Core/src/Types.Analyzers/Models/RootTypeInfo.cs

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using HotChocolate.Types.Analyzers.Helpers;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace HotChocolate.Types.Analyzers.Models;
@@ -23,6 +24,7 @@ public RootTypeInfo(
         RegistrationKey = schemaType.ToAssemblyQualified();
         Namespace = schemaType.ContainingNamespace.ToDisplayString();
         IsPublic = schemaType.DeclaredAccessibility == Accessibility.Public;
+        IsStatic = classDeclarationSyntax.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword));
         ClassDeclaration = classDeclarationSyntax;
         Resolvers = resolvers;
         Description = compilation.GetDescription(schemaType);
@@ -45,6 +47,8 @@ public RootTypeInfo(
 
     public bool IsPublic { get; }
 
+    public bool IsStatic { get; }
+
     public OperationType OperationType { get; }
 
     public bool HasSchemaType => true;

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

@@ -27,12 +27,6 @@ private static void AnalyzeClassDeclaration(SyntaxNodeAnalysisContext context)
             return;
         }
 
-        // Check if class is static
-        if (!classDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword)))
-        {
-            return;
-        }
-
         // Check if class is already partial
         if (classDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)))
         {

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

@@ -14,7 +14,7 @@ public sealed class RootTypePartialCodeFixProvider : CodeFixProvider
 {
     private const string Title = "Add partial keyword";
 
-    public override ImmutableArray<string> FixableDiagnosticIds { get; } = ["HC0089"];
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } = ["HC0091"];
 
     public override FixAllProvider GetFixAllProvider()
         => WellKnownFixAllProviders.BatchFixer;

src/HotChocolate/Core/test/Types.Analyzers.Integration.Tests/IntegrationTests.cs

@@ -111,4 +111,25 @@ public async Task Maps_NullOrdering_From_PagingOptions_To_PagingArguments()
         Assert.Empty(operationResult.Errors);
         Assert.Equal(NullOrdering.NativeNullsFirst, Query.PagingArguments.NullOrdering);
     }
+
+    [Fact]
+    public async Task Resolves_Instance_Method_On_NonStatic_QueryType()
+    {
+        // arrange
+        // NonStaticPagedQuery.SomeBooks returns a Book whose title is the resolver
+        // instance's InstanceId (a 32-char hex GUID).
+        var executor = await new ServiceCollection()
+            .AddGraphQLServer()
+            .AddIntegrationTestTypes()
+            .AddPagingArguments()
+            .BuildRequestExecutorAsync();
+
+        // act
+        var result = await executor.ExecuteAsync("{ someBooks { nodes { title } } }");
+
+        // assert
+        var json = result.ToJson();
+        Assert.DoesNotContain("\"errors\"", json);
+        Assert.Matches("\"title\": \"[0-9a-f]{32}\"", json);
+    }
 }

src/HotChocolate/Core/test/Types.Analyzers.Integration.Tests/IssueNonStaticConnection.cs

@@ -0,0 +1,50 @@
+namespace HotChocolate.Types;
+
+public class Author
+{
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+}
+
+[ObjectType<Author>]
+public static partial class AuthorType
+{
+    [UsePaging]
+    public static IQueryable<Book> Books([Parent(nameof(Author.Id))] Author parent)
+        => Enumerable.Empty<Book>().AsQueryable();
+}
+
+public class Publisher
+{
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+}
+
+[ObjectType<Publisher>]
+public static partial class PublisherType
+{
+    [UsePaging]
+    public static IQueryable<Book> Books([Parent(nameof(Publisher.Id))] Publisher parent)
+        => Enumerable.Empty<Book>().AsQueryable();
+}
+
+[QueryType]
+public partial class NonStaticPagedQuery
+{
+    // Per-instance identifier surfaced through SomeBooks so a test can confirm
+    // the resolver method was invoked on a real instance.
+    [GraphQLIgnore]
+    public string InstanceId { get; } = Guid.NewGuid().ToString("N");
+
+    [UsePaging]
+    public IQueryable<Book> SomeBooks() =>
+        new[] { new Book { Id = "1", Title = InstanceId } }.AsQueryable();
+
+    [UsePaging]
+#pragma warning disable CA1822 // Mark members as static
+    public IQueryable<Author> Authors() => Enumerable.Empty<Author>().AsQueryable();
+
+    [UsePaging]
+    public IQueryable<Publisher> Publishers() => Enumerable.Empty<Publisher>().AsQueryable();
+#pragma warning restore CA1822 // Mark members as static
+}