Add WHAM002 analyzer: warn on non-static GetBoundField lambda

Non-static lambdas in GetBoundField cause delegate allocation on every
property access. The static modifier prevents accidental closure captures
and keeps the hot path allocation-free.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: amis92

AGENTS.md

@@ -177,6 +177,7 @@ Extensions, Concrete.Extensions, Concrete.Extensions.Generators, EditorServices,
   - `[GenerateSymbol(SymbolKind.X)]` — generates `Kind` property + 3 `Accept` overloads
   - `[Bound]` on properties — generates `CheckReferencesCore` accessing all bound properties
   - `WHAM001` analyzer — warns when `GetBoundField` is called without `[Bound]`
+  - `WHAM002` analyzer — warns when `GetBoundField` lambda is not `static`
   - Symbol classes using these must be `partial`
 - **BattleScribe quirks**: some spec default expectations match BattleScribe bugs rather than
   "correct" behavior; wham uses engine-specific overrides for these (documented in

src/WarHub.ArmouryModel.Concrete.Extensions.Generators/BoundAnalyzer.cs

@@ -1,5 +1,7 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
 
@@ -16,8 +18,16 @@ public sealed class BoundAnalyzer : DiagnosticAnalyzer
         defaultSeverity: DiagnosticSeverity.Warning,
         isEnabledByDefault: true);
 
+    public static readonly DiagnosticDescriptor GetBoundFieldNonStaticLambda = new(
+        id: "WHAM002",
+        title: "GetBoundField called with non-static lambda",
+        messageFormat: "GetBoundField lambda should be static to avoid delegate allocation on every access. Add the 'static' modifier.",
+        category: "WarHub.ArmouryModel",
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true);
+
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
-        ImmutableArray.Create(GetBoundFieldWithoutBoundAttribute);
+        ImmutableArray.Create(GetBoundFieldWithoutBoundAttribute, GetBoundFieldNonStaticLambda);
 
     public override void Initialize(AnalysisContext context)
     {
@@ -33,6 +43,12 @@ private static void AnalyzeInvocation(OperationAnalysisContext context)
         if (invocation.TargetMethod.Name != "GetBoundField")
             return;
 
+        CheckBoundAttribute(context, invocation);
+        CheckStaticLambda(context, invocation);
+    }
+
+    private static void CheckBoundAttribute(OperationAnalysisContext context, IInvocationOperation invocation)
+    {
         // Walk up to find the containing property
         var containingSymbol = context.ContainingSymbol;
         if (containingSymbol is not IMethodSymbol { AssociatedSymbol: IPropertySymbol property })
@@ -59,4 +75,37 @@ private static void AnalyzeInvocation(OperationAnalysisContext context)
             context.ReportDiagnostic(diagnostic);
         }
     }
+
+    private static void CheckStaticLambda(OperationAnalysisContext context, IInvocationOperation invocation)
+    {
+        // The last argument to GetBoundField is the binding lambda
+        var args = invocation.Arguments;
+        if (args.Length < 3)
+            return;
+
+        var lambdaArg = args[args.Length - 1];
+        if (lambdaArg.Value is not IDelegateCreationOperation delegateCreation)
+            return;
+
+        if (delegateCreation.Target is not IAnonymousFunctionOperation anonymousFunc)
+            return;
+
+        // Check the syntax node for the 'static' modifier
+        var syntax = anonymousFunc.Syntax;
+        bool isStatic = false;
+        if (syntax is LambdaExpressionSyntax lambda)
+        {
+            isStatic = lambda.Modifiers.Any(SyntaxKind.StaticKeyword);
+        }
+        else if (syntax is AnonymousMethodExpressionSyntax anonymousMethod)
+        {
+            isStatic = anonymousMethod.Modifiers.Any(SyntaxKind.StaticKeyword);
+        }
+
+        if (!isStatic)
+        {
+            context.ReportDiagnostic(
+                Diagnostic.Create(GetBoundFieldNonStaticLambda, syntax.GetLocation()));
+        }
+    }
 }