Address Copilot review on LuceneDev4002

Use a symbol-based attribute check (IMethodSymbol.GetAttributes) instead
of inspecting AttributeSyntax with a SemanticModel from the wrong tree.
The previous code threw "Syntax node is not within syntax tree" whenever
the target method lived in a different file from the call site and had
any attribute. Symbol-based lookup also avoids Compilation.GetSemanticModel
in the analyzer (which trips RS1030).

Also:
- Drop the Contains("NoInlining") string fallback in the syntax-based
  helper; the constant-value path already resolves MethodImplOptions.NoInlining
  and the fallback false-positives on identifiers like "NotNoInlining".
- Replace the namespace walk in FindSourceTypeByName with
  Compilation.GetSymbolsWithName to leverage Roslyn's symbol index.
- Update the analyzer's XML doc — the PR adds a code fix; the previous
  comment claimed there was none.
- Add cross-document tests for both analyzer and code fix; the analyzer
  test reproduces the SemanticModel bug above.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.CodeAnalysis.Dev.CodeFixes/LuceneDev4xxx/LuceneDev4002_StackTraceHelperNoInliningCodeFixProvider.cs

@@ -16,7 +16,6 @@
  * limitations under the License.
  */
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
@@ -106,14 +105,14 @@ private static async Task<Solution> AddNoInliningToTargetAsync(
                 if (member.MethodKind != MethodKind.Ordinary)
                     continue;
 
+                if (NoInliningAttributeHelper.HasNoInliningAttribute(member, methodImplAttrSymbol))
+                    continue;
+
                 foreach (var declRef in member.DeclaringSyntaxReferences)
                 {
                     if (declRef.GetSyntax(cancellationToken) is not MethodDeclarationSyntax methodDecl)
                         continue;
 
-                    var declSemantic = compilation.GetSemanticModel(methodDecl.SyntaxTree);
-                    if (NoInliningAttributeHelper.FindNoInliningAttribute(methodDecl, declSemantic, methodImplAttrSymbol) is not null)
-                        continue;
                     if (NoInliningAttributeHelper.HasEmptyBody(methodDecl))
                         continue;
                     if (NoInliningAttributeHelper.IsInterfaceOrAbstractMethod(methodDecl))
@@ -267,40 +266,17 @@ private static (string? Name, INamedTypeSymbol? TypeFromNameof) ResolveClassRefe
 
         private static INamedTypeSymbol? FindSourceTypeByName(Compilation compilation, string typeName)
         {
-            foreach (var type in EnumerateAllTypes(compilation.Assembly.GlobalNamespace))
-            {
-                if (type.Name == typeName)
-                    return type;
-            }
-            return null;
-        }
-
-        private static IEnumerable<INamedTypeSymbol> EnumerateAllTypes(INamespaceSymbol ns)
-        {
-            foreach (var member in ns.GetMembers())
+            // Use Roslyn's symbol-name index instead of walking every namespace.
+            // Restrict to the source assembly so we don't match metadata types.
+            foreach (var symbol in compilation.GetSymbolsWithName(n => n == typeName, SymbolFilter.Type))
             {
-                if (member is INamedTypeSymbol type)
+                if (symbol is INamedTypeSymbol type
+                    && SymbolEqualityComparer.Default.Equals(type.ContainingAssembly, compilation.Assembly))
                 {
-                    yield return type;
-                    foreach (var nested in EnumerateNestedTypes(type))
-                        yield return nested;
-                }
-                else if (member is INamespaceSymbol child)
-                {
-                    foreach (var t in EnumerateAllTypes(child))
-                        yield return t;
+                    return type;
                 }
             }
-        }
-
-        private static IEnumerable<INamedTypeSymbol> EnumerateNestedTypes(INamedTypeSymbol type)
-        {
-            foreach (var nested in type.GetTypeMembers())
-            {
-                yield return nested;
-                foreach (var deeper in EnumerateNestedTypes(nested))
-                    yield return deeper;
-            }
+            return null;
         }
     }
 }

src/Lucene.Net.CodeAnalysis.Dev/LuceneDev4xxx/LuceneDev4002_StackTraceHelperNoInliningAnalyzer.cs

@@ -16,7 +16,6 @@
  * limitations under the License.
  */
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using Lucene.Net.CodeAnalysis.Dev.Utility;
@@ -32,10 +31,8 @@ namespace Lucene.Net.CodeAnalysis.Dev.LuceneDev4xxx
     /// StackTraceHelper.DoesStackTraceContainMethod(className, methodName) overload
     /// that lack [MethodImpl(MethodImplOptions.NoInlining)]. Without it the JIT may
     /// inline the method out of the stack trace, silently breaking the check.
-    ///
-    /// This analyzer has no code fix: the diagnostic is reported on the referenced
-    /// method declaration but is triggered by a separate invocation, which Roslyn
-    /// treats as a non-local diagnostic and does not allow code fixes for.
+    /// The diagnostic is reported on the invocation so the IDE surfaces it as a
+    /// local diagnostic and a code fix can apply the attribute to the target method.
     /// </summary>
     [DiagnosticAnalyzer(LanguageNames.CSharp)]
     public sealed class LuceneDev4002_StackTraceHelperNoInliningAnalyzer : DiagnosticAnalyzer
@@ -110,14 +107,14 @@ private static void AnalyzeInvocation(SyntaxNodeAnalysisContext ctx, INamedTypeS
                 if (member.MethodKind != MethodKind.Ordinary)
                     continue;
 
+                if (NoInliningAttributeHelper.HasNoInliningAttribute(member, methodImplAttrSymbol))
+                    continue;
+
                 foreach (var declRef in member.DeclaringSyntaxReferences)
                 {
                     if (declRef.GetSyntax(ctx.CancellationToken) is not MethodDeclarationSyntax methodDecl)
                         continue;
 
-                    if (NoInliningAttributeHelper.FindNoInliningAttribute(methodDecl, ctx.SemanticModel, methodImplAttrSymbol) is not null)
-                        continue;
-
                     if (NoInliningAttributeHelper.HasEmptyBody(methodDecl))
                         continue;
 
@@ -192,40 +189,17 @@ private static (string? Name, INamedTypeSymbol? TypeFromNameof) ResolveClassRefe
 
         private static INamedTypeSymbol? FindSourceTypeByName(Compilation compilation, string typeName)
         {
-            foreach (var type in EnumerateAllTypes(compilation.Assembly.GlobalNamespace))
-            {
-                if (type.Name == typeName)
-                    return type;
-            }
-            return null;
-        }
-
-        private static IEnumerable<INamedTypeSymbol> EnumerateAllTypes(INamespaceSymbol ns)
-        {
-            foreach (var member in ns.GetMembers())
+            // Use Roslyn's symbol-name index instead of walking every namespace.
+            // Restrict to the source assembly so we don't match metadata types.
+            foreach (var symbol in compilation.GetSymbolsWithName(n => n == typeName, SymbolFilter.Type))
             {
-                if (member is INamedTypeSymbol type)
-                {
-                    yield return type;
-                    foreach (var nested in EnumerateNestedTypes(type))
-                        yield return nested;
-                }
-                else if (member is INamespaceSymbol child)
+                if (symbol is INamedTypeSymbol type
+                    && SymbolEqualityComparer.Default.Equals(type.ContainingAssembly, compilation.Assembly))
                 {
-                    foreach (var t in EnumerateAllTypes(child))
-                        yield return t;
+                    return type;
                 }
             }
-        }
-
-        private static IEnumerable<INamedTypeSymbol> EnumerateNestedTypes(INamedTypeSymbol type)
-        {
-            foreach (var nested in type.GetTypeMembers())
-            {
-                yield return nested;
-                foreach (var deeper in EnumerateNestedTypes(nested))
-                    yield return deeper;
-            }
+            return null;
         }
     }
 }

src/Lucene.Net.CodeAnalysis.Dev/LuceneDev4xxx/NoInliningAttributeHelper.cs

@@ -25,6 +25,8 @@ namespace Lucene.Net.CodeAnalysis.Dev.LuceneDev4xxx
 {
     public static class NoInliningAttributeHelper
     {
+        private const int NoInlining = 0x0008;
+
         public static AttributeSyntax? FindNoInliningAttribute(
             MethodDeclarationSyntax methodDecl,
             SemanticModel semantic,
@@ -46,6 +48,27 @@ public static class NoInliningAttributeHelper
             return null;
         }
 
+        // Symbol-based variant: works across syntax trees and avoids
+        // Compilation.GetSemanticModel (which would trip RS1030 in an analyzer).
+        public static bool HasNoInliningAttribute(
+            IMethodSymbol method,
+            INamedTypeSymbol methodImplAttrSymbol)
+        {
+            foreach (var attr in method.GetAttributes())
+            {
+                if (!SymbolEqualityComparer.Default.Equals(attr.AttributeClass, methodImplAttrSymbol))
+                    continue;
+
+                if (attr.ConstructorArguments.Length == 0)
+                    continue;
+
+                var first = attr.ConstructorArguments[0];
+                if (first.Value is int intValue && (intValue & NoInlining) == NoInlining)
+                    return true;
+            }
+            return false;
+        }
+
         private static bool AttributeSpecifiesNoInlining(AttributeSyntax attr, SemanticModel semantic)
         {
             if (attr.ArgumentList is null || attr.ArgumentList.Arguments.Count == 0)
@@ -61,11 +84,10 @@ private static bool AttributeSpecifiesNoInlining(AttributeSyntax attr, SemanticM
             var constant = semantic.GetConstantValue(firstPositional.Expression);
             if (constant.HasValue && constant.Value is int intValue)
             {
-                const int NoInlining = 0x0008;
                 return (intValue & NoInlining) == NoInlining;
             }
 
-            return firstPositional.Expression.ToString().Contains("NoInlining");
+            return false;
         }
 
         public static bool IsInterfaceOrAbstractMethod(MethodDeclarationSyntax methodDecl)

tests/Lucene.Net.CodeAnalysis.Dev.CodeFixes.Tests/LuceneDev4xxx/TestLuceneDev4002_StackTraceHelperNoInliningCodeFixProvider.cs

@@ -165,6 +165,64 @@ public void Check()
             await test.RunAsync();
         }
 
+        [Test]
+        public async Task Fix_AddsAttributeAndUsing_InTargetDocument_WhenTargetIsInDifferentFile()
+        {
+            // Target lives in /0/Test0.cs, Caller in /0/Test1.cs. The code fix must
+            // edit the target's document (adding the attribute and the using) rather
+            // than the caller's.
+            var targetSource = @"
+public class Target
+{
+    public void Merge()
+    {
+        var x = 1;
+    }
+}
+";
+
+            var callerSource = @"
+public class Caller
+{
+    public void Check()
+    {
+        if (Lucene.Net.Support.ExceptionHandling.StackTraceHelper.DoesStackTraceContainMethod(nameof(Target), nameof(Target.Merge)))
+        {
+        }
+    }
+}" + StackTraceHelperStub;
+
+            var fixedTargetSource = @"using System.Runtime.CompilerServices;
+
+public class Target
+{
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public void Merge()
+    {
+        var x = 1;
+    }
+}
+";
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev4002_MissingNoInlining)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithLocation("/0/Test1.cs", line: 6, column: 13)
+                .WithArguments("Target.Merge");
+
+            var test = new InjectableCodeFixTest(
+                () => new LuceneDev4002_StackTraceHelperNoInliningAnalyzer(),
+                () => new LuceneDev4002_StackTraceHelperNoInliningCodeFixProvider())
+            {
+                ExpectedDiagnostics = { expected }
+            };
+            test.TestState.Sources.Add(targetSource);
+            test.TestState.Sources.Add(callerSource);
+            test.FixedState.Sources.Add(fixedTargetSource);
+            test.FixedState.Sources.Add(callerSource);
+
+            await test.RunAsync();
+        }
+
         [Test]
         public async Task Fix_PreservesExistingAttributeOnTarget()
         {

tests/Lucene.Net.CodeAnalysis.Dev.Tests/LuceneDev4xxx/TestLuceneDev4002_StackTraceHelperNoInliningAnalyzer.cs

@@ -145,6 +145,56 @@ public void Check()
             await test.RunAsync();
         }
 
+        [Test]
+        public async Task LuceneDev4002_Reports_When_TargetMethod_Is_In_Different_Document()
+        {
+            // The Target type and the Caller live in separate source files. The analyzer
+            // must build a SemanticModel against the Target's syntax tree before
+            // inspecting attributes — using the caller's SemanticModel against a node
+            // from a different tree throws ArgumentException. Target carries an
+            // unrelated attribute so the attribute-walk path actually executes.
+            var targetSource = @"
+using System;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class FooAttribute : Attribute { }
+
+public class Target
+{
+    [Foo]
+    public void Merge()
+    {
+        var x = 1;
+    }
+}
+";
+
+            var callerSource = @"
+public class Caller
+{
+    public void Check()
+    {
+        if (Lucene.Net.Support.ExceptionHandling.StackTraceHelper.DoesStackTraceContainMethod(nameof(Target), nameof(Target.Merge)))
+        {
+        }
+    }
+}" + StackTraceHelperStub;
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev4002_MissingNoInlining)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithLocation("/0/Test1.cs", line: 6, column: 13)
+                .WithArguments("Target.Merge");
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev4002_StackTraceHelperNoInliningAnalyzer())
+            {
+                ExpectedDiagnostics = { expected }
+            };
+            test.TestState.Sources.Add(targetSource);
+            test.TestState.Sources.Add(callerSource);
+
+            await test.RunAsync();
+        }
+
         [Test]
         public async Task LuceneDev4002_NoDiagnostic_For_SingleArgOverload()
         {