.

SimonCropp · SimonCropp · commit 572b8beee0bd · 2026-01-20T15:24:28.000+11:00
diff --git a/src/GraphQL.EntityFramework.Analyzers/DiagnosticDescriptors.cs b/src/GraphQL.EntityFramework.Analyzers/DiagnosticDescriptors.cs
@@ -1,7 +1,3 @@
-using Microsoft.CodeAnalysis;
-
-namespace GraphQL.EntityFramework.Analyzers;
-
 static class DiagnosticDescriptors
 {
     public static readonly DiagnosticDescriptor GQLEF002 = new(
diff --git a/src/GraphQL.EntityFramework.Analyzers/FieldBuilderResolveAnalyzer.cs b/src/GraphQL.EntityFramework.Analyzers/FieldBuilderResolveAnalyzer.cs
@@ -1,19 +1,10 @@
-#nullable enable
-
-using System.Collections.Immutable;
-using System.Linq;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-
 namespace GraphQL.EntityFramework.Analyzers;
 
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class FieldBuilderResolveAnalyzer : DiagnosticAnalyzer
 {
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
-        ImmutableArray.Create(DiagnosticDescriptors.GQLEF002);
+        [DiagnosticDescriptors.GQLEF002];
 
     public override void Initialize(AnalysisContext context)
     {
@@ -22,7 +13,7 @@ public override void Initialize(AnalysisContext context)
         context.RegisterSyntaxNodeAction(AnalyzeInvocation, SyntaxKind.InvocationExpression);
     }
 
-    void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
+    static void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
     {
         var invocation = (InvocationExpressionSyntax)context.Node;
 
@@ -54,16 +45,15 @@ void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
         }
     }
 
-    bool IsFieldBuilderResolveCall(
+    static bool IsFieldBuilderResolveCall(
         InvocationExpressionSyntax invocation,
         SemanticModel semanticModel,
         out LambdaExpressionSyntax? lambdaExpression)
     {
         lambdaExpression = null;
 
         // Check method name is Resolve, ResolveAsync, ResolveList, or ResolveListAsync
-        var memberAccess = invocation.Expression as MemberAccessExpressionSyntax;
-        if (memberAccess == null)
+        if (invocation.Expression is not MemberAccessExpressionSyntax memberAccess)
         {
             return false;
         }
@@ -114,7 +104,7 @@ bool IsFieldBuilderResolveCall(
         return false;
     }
 
-    bool IsProjectionBasedResolve(InvocationExpressionSyntax invocation, SemanticModel semanticModel)
+    static bool IsProjectionBasedResolve(InvocationExpressionSyntax invocation, SemanticModel semanticModel)
     {
         var symbolInfo = semanticModel.GetSymbolInfo(invocation);
         if (symbolInfo.Symbol is not IMethodSymbol methodSymbol)
@@ -128,7 +118,7 @@ bool IsProjectionBasedResolve(InvocationExpressionSyntax invocation, SemanticMod
                methodSymbol.ContainingNamespace?.ToString() == "GraphQL.EntityFramework";
     }
 
-    bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)
+    static bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)
     {
         var classDeclaration = node.FirstAncestorOrSelf<ClassDeclarationSyntax>();
         if (classDeclaration == null)
@@ -147,9 +137,7 @@ bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)
         while (baseType != null)
         {
             var typeName = baseType.Name;
-            if ((typeName == "EfObjectGraphType" ||
-                 typeName == "EfInterfaceGraphType" ||
-                 typeName == "QueryGraphType") &&
+            if (typeName is "EfObjectGraphType" or "EfInterfaceGraphType" or "QueryGraphType" &&
                 baseType.ContainingNamespace?.ToString() == "GraphQL.EntityFramework")
             {
                 return true;
@@ -161,7 +149,7 @@ bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)
         return false;
     }
 
-    bool AccessesNavigationProperties(LambdaExpressionSyntax lambda, SemanticModel semanticModel)
+    static bool AccessesNavigationProperties(LambdaExpressionSyntax lambda, SemanticModel semanticModel)
     {
         var body = lambda.Body;
 
@@ -196,7 +184,7 @@ bool AccessesNavigationProperties(LambdaExpressionSyntax lambda, SemanticModel s
         return false;
     }
 
-    bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out MemberAccessExpressionSyntax? propertyAccess)
+    static bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out MemberAccessExpressionSyntax? propertyAccess)
     {
         propertyAccess = null;
 
@@ -207,8 +195,15 @@ bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out Member
         // Walk up the chain to find context.Source
         while (true)
         {
-            if (current.Expression is MemberAccessExpressionSyntax { Name.Identifier.Text: "Source", Expression: IdentifierNameSyntax identifier } &&
-                (identifier.Identifier.Text == "context" || identifier.Identifier.Text == "ctx"))
+            if (current.Expression is
+                MemberAccessExpressionSyntax
+                {
+                    Name.Identifier.Text: "Source",
+                    Expression: IdentifierNameSyntax
+                    {
+                        Identifier.Text: "context" or "ctx"
+                    }
+                })
             {
                 sourceAccess = current;
                 break;
@@ -240,21 +235,24 @@ bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out Member
 
         // Also check for direct access like: context.Source (without further property access)
         if (memberAccess.Name.Identifier.Text == "Source" &&
-            memberAccess.Expression is IdentifierNameSyntax ctxId &&
-            (ctxId.Identifier.Text == "context" || ctxId.Identifier.Text == "ctx"))
-        {
-            // This is just context.Source itself, check parent node
-            if (memberAccess.Parent is MemberAccessExpressionSyntax parentMember)
+            memberAccess is
             {
-                propertyAccess = parentMember;
-                return true;
-            }
+                Expression: IdentifierNameSyntax
+                {
+                    Identifier.Text: "context" or "ctx"
+                },
+                Parent: MemberAccessExpressionSyntax parentMember
+            })
+            // This is just context.Source itself, check parent node
+        {
+            propertyAccess = parentMember;
+            return true;
         }
 
         return false;
     }
 
-    bool IsSafeProperty(IPropertySymbol propertySymbol)
+    static bool IsSafeProperty(IPropertySymbol propertySymbol)
     {
         // Only primary keys and foreign keys are safe to access
         // because they are always included in EF projections
@@ -344,5 +342,4 @@ static bool IsForeignKeyProperty(IPropertySymbol propertySymbol)
         var typeName = underlyingType.ToString();
         return typeName == "System.Guid";
     }
-
 }
diff --git a/src/GraphQL.EntityFramework.Analyzers/GlobalUsings.cs b/src/GraphQL.EntityFramework.Analyzers/GlobalUsings.cs
@@ -0,0 +1,5 @@
+﻿global using System.Collections.Immutable;
+global using Microsoft.CodeAnalysis;
+global using Microsoft.CodeAnalysis.CSharp;
+global using Microsoft.CodeAnalysis.CSharp.Syntax;
+global using Microsoft.CodeAnalysis.Diagnostics;
diff --git a/src/GraphQL.EntityFramework.Analyzers/GraphQL.EntityFramework.Analyzers.csproj b/src/GraphQL.EntityFramework.Analyzers/GraphQL.EntityFramework.Analyzers.csproj
@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>preview</LangVersion>
     <IsRoslynComponent>true</IsRoslynComponent>
     <DevelopmentDependency>true</DevelopmentDependency>
     <IncludeBuildOutput>false</IncludeBuildOutput>
diff --git a/src/GraphQL.EntityFramework/GraphApi/FieldBuilderExtensions.cs b/src/GraphQL.EntityFramework/GraphApi/FieldBuilderExtensions.cs
@@ -210,7 +210,7 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveList<TDbContext
         var compiledProjection = projection.Compile();
 
         field.Resolver = new FuncFieldResolver<TSource, IEnumerable<TReturn>>(
-            async context =>
+            context =>
             {
                 // Resolve service from request services
                 var executionContext = context.ExecutionContext;
@@ -240,7 +240,7 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveList<TDbContext
                 }
                 catch (Exception exception)
                 {
-                    throw new Exception(
+                    throw new(
                         $"""
                         Failed to execute projection-based list resolve for field `{field.Name}`
                         TSource: {typeof(TSource).FullName}
@@ -252,7 +252,7 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveList<TDbContext
 
                 // Note: For list results, we don't apply filters on the collection itself
                 // Filters would be applied to individual items if needed
-                return result ?? Enumerable.Empty<TReturn>();
+                return result;
             });
 
         return builder;
@@ -321,7 +321,7 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveListAsync<TDbCo
                 }
                 catch (Exception exception)
                 {
-                    throw new Exception(
+                    throw new(
                         $"""
                         Failed to execute projection-based async list resolve for field `{field.Name}`
                         TSource: {typeof(TSource).FullName}
@@ -333,7 +333,7 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveListAsync<TDbCo
 
                 // Note: For list results, we don't apply filters on the collection itself
                 // Filters would be applied to individual items if needed
-                return result ?? Enumerable.Empty<TReturn>();
+                return result;
             });
 
         return builder;
@@ -346,7 +346,7 @@ public static FieldBuilder<TSource, IEnumerable<TReturn>> ResolveListAsync<TDbCo
         // This is a workaround since we can't access it directly
         var serviceType = service.GetType();
         var method = serviceType.GetMethod("ResolveFilter",
-            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+            BindingFlags.NonPublic | BindingFlags.Instance);
 
         if (method is null)
         {

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,3 @@`
`1`		`-using Microsoft.CodeAnalysis;`
`2`		`-`
`3`		`-namespace GraphQL.EntityFramework.Analyzers;`
`4`		`-`
`5`	`1`	`static class DiagnosticDescriptors`
`6`	`2`	`{`
`7`	`3`	`public static readonly DiagnosticDescriptor GQLEF002 = new(`
Original file line number	Diff line number	Diff line change
`@@ -1,19 +1,10 @@`
`1`		`-#nullable enable`
`2`		`-`
`3`		`-using System.Collections.Immutable;`
`4`		`-using System.Linq;`
`5`		`-using Microsoft.CodeAnalysis;`
`6`		`-using Microsoft.CodeAnalysis.CSharp;`
`7`		`-using Microsoft.CodeAnalysis.CSharp.Syntax;`
`8`		`-using Microsoft.CodeAnalysis.Diagnostics;`
`9`		`-`
`10`	`1`	`namespace GraphQL.EntityFramework.Analyzers;`
`11`	`2`
`12`	`3`	`[DiagnosticAnalyzer(LanguageNames.CSharp)]`
`13`	`4`	`public class FieldBuilderResolveAnalyzer : DiagnosticAnalyzer`
`14`	`5`	`{`
`15`	`6`	`public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =`
`16`		`- ImmutableArray.Create(DiagnosticDescriptors.GQLEF002);`
	`7`	`+ [DiagnosticDescriptors.GQLEF002];`
`17`	`8`
`18`	`9`	`public override void Initialize(AnalysisContext context)`
`19`	`10`	`{`
`@@ -22,7 +13,7 @@ public override void Initialize(AnalysisContext context)`
`22`	`13`	`context.RegisterSyntaxNodeAction(AnalyzeInvocation, SyntaxKind.InvocationExpression);`
`23`	`14`	`}`
`24`	`15`
`25`		`- void AnalyzeInvocation(SyntaxNodeAnalysisContext context)`
	`16`	`+ static void AnalyzeInvocation(SyntaxNodeAnalysisContext context)`
`26`	`17`	`{`
`27`	`18`	`var invocation = (InvocationExpressionSyntax)context.Node;`
`28`	`19`
`@@ -54,16 +45,15 @@ void AnalyzeInvocation(SyntaxNodeAnalysisContext context)`
`54`	`45`	`}`
`55`	`46`	`}`
`56`	`47`
`57`		`- bool IsFieldBuilderResolveCall(`
	`48`	`+ static bool IsFieldBuilderResolveCall(`
`58`	`49`	`InvocationExpressionSyntax invocation,`
`59`	`50`	`SemanticModel semanticModel,`
`60`	`51`	`out LambdaExpressionSyntax? lambdaExpression)`
`61`	`52`	`{`
`62`	`53`	`lambdaExpression = null;`
`63`	`54`
`64`	`55`	`// Check method name is Resolve, ResolveAsync, ResolveList, or ResolveListAsync`
`65`		`- var memberAccess = invocation.Expression as MemberAccessExpressionSyntax;`
`66`		`- if (memberAccess == null)`
	`56`	`+ if (invocation.Expression is not MemberAccessExpressionSyntax memberAccess)`
`67`	`57`	`{`
`68`	`58`	`return false;`
`69`	`59`	`}`
`@@ -114,7 +104,7 @@ bool IsFieldBuilderResolveCall(`
`114`	`104`	`return false;`
`115`	`105`	`}`
`116`	`106`
`117`		`- bool IsProjectionBasedResolve(InvocationExpressionSyntax invocation, SemanticModel semanticModel)`
	`107`	`+ static bool IsProjectionBasedResolve(InvocationExpressionSyntax invocation, SemanticModel semanticModel)`
`118`	`108`	`{`
`119`	`109`	`var symbolInfo = semanticModel.GetSymbolInfo(invocation);`
`120`	`110`	`if (symbolInfo.Symbol is not IMethodSymbol methodSymbol)`
`@@ -128,7 +118,7 @@ bool IsProjectionBasedResolve(InvocationExpressionSyntax invocation, SemanticMod`
`128`	`118`	`methodSymbol.ContainingNamespace?.ToString() == "GraphQL.EntityFramework";`
`129`	`119`	`}`
`130`	`120`
`131`		`- bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)`
	`121`	`+ static bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)`
`132`	`122`	`{`
`133`	`123`	`var classDeclaration = node.FirstAncestorOrSelf<ClassDeclarationSyntax>();`
`134`	`124`	`if (classDeclaration == null)`
`@@ -147,9 +137,7 @@ bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)`
`147`	`137`	`while (baseType != null)`
`148`	`138`	`{`
`149`	`139`	`var typeName = baseType.Name;`
`150`		`- if ((typeName == "EfObjectGraphType" \|\|`
`151`		`- typeName == "EfInterfaceGraphType" \|\|`
`152`		`- typeName == "QueryGraphType") &&`
	`140`	`+ if (typeName is "EfObjectGraphType" or "EfInterfaceGraphType" or "QueryGraphType" &&`
`153`	`141`	`baseType.ContainingNamespace?.ToString() == "GraphQL.EntityFramework")`
`154`	`142`	`{`
`155`	`143`	`return true;`
`@@ -161,7 +149,7 @@ bool IsInEfGraphType(SyntaxNode node, SemanticModel semanticModel)`
`161`	`149`	`return false;`
`162`	`150`	`}`
`163`	`151`
`164`		`- bool AccessesNavigationProperties(LambdaExpressionSyntax lambda, SemanticModel semanticModel)`
	`152`	`+ static bool AccessesNavigationProperties(LambdaExpressionSyntax lambda, SemanticModel semanticModel)`
`165`	`153`	`{`
`166`	`154`	`var body = lambda.Body;`
`167`	`155`
`@@ -196,7 +184,7 @@ bool AccessesNavigationProperties(LambdaExpressionSyntax lambda, SemanticModel s`
`196`	`184`	`return false;`
`197`	`185`	`}`
`198`	`186`
`199`		`- bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out MemberAccessExpressionSyntax? propertyAccess)`
	`187`	`+ static bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out MemberAccessExpressionSyntax? propertyAccess)`
`200`	`188`	`{`
`201`	`189`	`propertyAccess = null;`
`202`	`190`
`@@ -207,8 +195,15 @@ bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out Member`
`207`	`195`	`// Walk up the chain to find context.Source`
`208`	`196`	`while (true)`
`209`	`197`	`{`
`210`		`- if (current.Expression is MemberAccessExpressionSyntax { Name.Identifier.Text: "Source", Expression: IdentifierNameSyntax identifier } &&`
`211`		`- (identifier.Identifier.Text == "context" \|\| identifier.Identifier.Text == "ctx"))`
	`198`	`+ if (current.Expression is`
	`199`	`+ MemberAccessExpressionSyntax`
	`200`	`+ {`
	`201`	`+ Name.Identifier.Text: "Source",`
	`202`	`+ Expression: IdentifierNameSyntax`
	`203`	`+ {`
	`204`	`+ Identifier.Text: "context" or "ctx"`
	`205`	`+ }`
	`206`	`+ })`
`212`	`207`	`{`
`213`	`208`	`sourceAccess = current;`
`214`	`209`	`break;`
`@@ -240,21 +235,24 @@ bool IsContextSourceAccess(MemberAccessExpressionSyntax memberAccess, out Member`
`240`	`235`
`241`	`236`	`// Also check for direct access like: context.Source (without further property access)`
`242`	`237`	`if (memberAccess.Name.Identifier.Text == "Source" &&`
`243`		`- memberAccess.Expression is IdentifierNameSyntax ctxId &&`
`244`		`- (ctxId.Identifier.Text == "context" \|\| ctxId.Identifier.Text == "ctx"))`
`245`		`- {`
`246`		`- // This is just context.Source itself, check parent node`
`247`		`- if (memberAccess.Parent is MemberAccessExpressionSyntax parentMember)`
	`238`	`+ memberAccess is`
`248`	`239`	`{`
`249`		`- propertyAccess = parentMember;`
`250`		`- return true;`
`251`		`- }`
	`240`	`+ Expression: IdentifierNameSyntax`
	`241`	`+ {`
	`242`	`+ Identifier.Text: "context" or "ctx"`
	`243`	`+ },`
	`244`	`+ Parent: MemberAccessExpressionSyntax parentMember`
	`245`	`+ })`
	`246`	`+ // This is just context.Source itself, check parent node`
	`247`	`+ {`
	`248`	`+ propertyAccess = parentMember;`
	`249`	`+ return true;`
`252`	`250`	`}`
`253`	`251`
`254`	`252`	`return false;`
`255`	`253`	`}`
`256`	`254`
`257`		`- bool IsSafeProperty(IPropertySymbol propertySymbol)`
	`255`	`+ static bool IsSafeProperty(IPropertySymbol propertySymbol)`
`258`	`256`	`{`
`259`	`257`	`// Only primary keys and foreign keys are safe to access`
`260`	`258`	`// because they are always included in EF projections`
`@@ -344,5 +342,4 @@ static bool IsForeignKeyProperty(IPropertySymbol propertySymbol)`
`344`	`342`	`var typeName = underlyingType.ToString();`
`345`	`343`	`return typeName == "System.Guid";`
`346`	`344`	`}`
`347`		`-`
`348`	`345`	`}`