Address Copilot review feedback on Lucene1001/Lucene1002 analyzers

- Lucene1001 CS code fix: emit ThrowStatement (not ExpressionStatement) when
  converting an expression-bodied `=> throw ...` member, so the produced code
  is valid C#.
- Lucene1001 CS + VB analyzers: exclude lambdas, anonymous methods, and (CS)
  local functions from the base-call scan. A base call inside an uninvoked
  delegate body should not satisfy the contract.
- Lucene1002 CS + VB code fixes: use ElasticCarriageReturnLineFeed instead of
  hardcoded line endings so the formatter normalizes to the document's
  convention.
- DiagnosticVerifier: harden System.Runtime.dll lookup with a
  TRUSTED_PLATFORM_ASSEMBLIES fallback and a clear error if neither resolves.
- Tests: add VerifyCSharpFix/VerifyBasicFix coverage for Lucene1002, a
  VerifyCSharpFix for the Lucene1001 expression-bodied case plus a new
  throw-expression regression, lambda/local-function exclusion tests for
  Lucene1001 (CS + VB), and the missing VB indirect-Tokenizer-inheritance
  test for Lucene1002.

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

Author: paulirwin

src/dotnet/Lucene.Net.CodeAnalysis.CSharp/Lucene1001_AddBaseMethodCallCSCodeFixProvider.cs

@@ -88,8 +88,10 @@ private static async Task<Document> AddBaseCallAsync(Document document, MethodDe
             {
                 // Convert expression body => to a block containing base.X(); followed by the original expression as a statement.
                 var existingExpression = methodDeclaration.ExpressionBody.Expression;
-                var existingStatement = SyntaxFactory.ExpressionStatement(existingExpression)
-                    .WithAdditionalAnnotations(Formatter.Annotation);
+                StatementSyntax existingStatement = existingExpression is ThrowExpressionSyntax throwExpression
+                    ? SyntaxFactory.ThrowStatement(throwExpression.Expression)
+                    : SyntaxFactory.ExpressionStatement(existingExpression);
+                existingStatement = existingStatement.WithAdditionalAnnotations(Formatter.Annotation);
                 var newBody = SyntaxFactory.Block(baseStatement, existingStatement)
                     .WithAdditionalAnnotations(Formatter.Annotation);
                 newMethodDeclaration = methodDeclaration

src/dotnet/Lucene.Net.CodeAnalysis.CSharp/Lucene1001_TokenStreamOverrideMustCallBaseMethodCSAnalyzer.cs

@@ -103,13 +103,16 @@ private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
         private static bool ContainsBaseCall(MethodDeclarationSyntax methodDeclaration, string methodName)
         {
             // Inspect either a block body or an expression-bodied member.
+            SyntaxNode body;
             IEnumerable<SyntaxNode> nodes;
             if (methodDeclaration.Body is not null)
             {
+                body = methodDeclaration.Body;
                 nodes = methodDeclaration.Body.DescendantNodes();
             }
             else if (methodDeclaration.ExpressionBody is not null)
             {
+                body = methodDeclaration.ExpressionBody;
                 nodes = methodDeclaration.ExpressionBody.DescendantNodesAndSelf();
             }
             else
@@ -123,7 +126,25 @@ private static bool ContainsBaseCall(MethodDeclarationSyntax methodDeclaration,
                 if (node is InvocationExpressionSyntax invocation &&
                     invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
                     memberAccess.Expression.IsKind(SyntaxKind.BaseExpression) &&
-                    memberAccess.Name.Identifier.ValueText == methodName)
+                    memberAccess.Name.Identifier.ValueText == methodName &&
+                    !IsInsideNestedFunction(invocation, body))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        // A base call inside a lambda, anonymous method, or local function does not necessarily
+        // execute when the enclosing method runs (the delegate may never be invoked). Treat such
+        // occurrences as not satisfying the contract.
+        private static bool IsInsideNestedFunction(SyntaxNode node, SyntaxNode body)
+        {
+            for (var ancestor = node.Parent; ancestor is not null && ancestor != body; ancestor = ancestor.Parent)
+            {
+                if (ancestor is LambdaExpressionSyntax ||
+                    ancestor is AnonymousMethodExpressionSyntax ||
+                    ancestor is LocalFunctionStatementSyntax)
                 {
                     return true;
                 }

src/dotnet/Lucene.Net.CodeAnalysis.CSharp/Lucene1002_AddEndOverrideCSCodeFixProvider.cs

@@ -78,7 +78,7 @@ private static async Task<Document> AddEndOverrideAsync(Document document, Class
 
             var todoComment = SyntaxFactory.Comment("// TODO: set the final offset and finish up other end-of-stream attributes");
             var closeBrace = SyntaxFactory.Token(SyntaxKind.CloseBraceToken)
-                .WithLeadingTrivia(SyntaxFactory.TriviaList(todoComment, SyntaxFactory.EndOfLine("\n")));
+                .WithLeadingTrivia(SyntaxFactory.TriviaList(todoComment, SyntaxFactory.ElasticCarriageReturnLineFeed));
 
             var body = SyntaxFactory.Block(
                 SyntaxFactory.Token(SyntaxKind.OpenBraceToken),

src/dotnet/Lucene.Net.CodeAnalysis.VisualBasic/Lucene1001_TokenStreamOverrideMustCallBaseMethodVBAnalyzer.cs

@@ -102,7 +102,22 @@ private static bool ContainsBaseCall(MethodBlockSyntax methodBlock, string metho
                 if (node is InvocationExpressionSyntax invocation &&
                     invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
                     memberAccess.Expression.IsKind(SyntaxKind.MyBaseExpression) &&
-                    memberAccess.Name.Identifier.ValueText == methodName)
+                    memberAccess.Name.Identifier.ValueText == methodName &&
+                    !IsInsideLambda(invocation, methodBlock))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        // A base call inside a lambda does not necessarily execute when the enclosing method runs
+        // (the delegate may never be invoked). Treat such occurrences as not satisfying the contract.
+        private static bool IsInsideLambda(SyntaxNode node, SyntaxNode body)
+        {
+            for (var ancestor = node.Parent; ancestor is not null && ancestor != body; ancestor = ancestor.Parent)
+            {
+                if (ancestor is LambdaExpressionSyntax)
                 {
                     return true;
                 }

src/dotnet/Lucene.Net.CodeAnalysis.VisualBasic/Lucene1002_AddEndOverrideVBCodeFixProvider.cs

@@ -90,7 +90,7 @@ private static async Task<Document> AddEndOverrideAsync(Document document, Class
                     SyntaxFactory.ArgumentList()));
 
             var endSubStatement = SyntaxFactory.EndSubStatement()
-                .WithLeadingTrivia(SyntaxFactory.CommentTrivia("' TODO: set the final offset and finish up other end-of-stream attributes"), SyntaxFactory.EndOfLine("\r\n"));
+                .WithLeadingTrivia(SyntaxFactory.CommentTrivia("' TODO: set the final offset and finish up other end-of-stream attributes"), SyntaxFactory.ElasticCarriageReturnLineFeed);
 
             var methodBlock = SyntaxFactory.SubBlock(
                 subStatement,

src/dotnet/Lucene.Net.Tests.CodeAnalysis/Helpers/DiagnosticVerifier.Helper.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.IO;
 using System.Linq;
 
 namespace TestHelper
@@ -35,8 +36,38 @@ public abstract partial class DiagnosticVerifier
         private static readonly MetadataReference CorlibReference = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
         // LUCENENET: typeof(object) lives in System.Private.CoreLib and BCL types are forwarded through
         // System.Runtime; analyzer tests that reference base methods returning void (e.g. base.Reset())
-        // need the runtime reference to resolve System.Void.
-        private static readonly MetadataReference SystemRuntimeReference = MetadataReference.CreateFromFile(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(typeof(object).Assembly.Location), "System.Runtime.dll"));
+        // need the runtime reference to resolve System.Void. Try the directory next to corlib first;
+        // fall back to scanning TRUSTED_PLATFORM_ASSEMBLIES for hosts where the file isn't co-located.
+        private static readonly MetadataReference SystemRuntimeReference = ResolveSystemRuntimeReference();
+
+        private static MetadataReference ResolveSystemRuntimeReference()
+        {
+            var corlibDir = Path.GetDirectoryName(typeof(object).Assembly.Location);
+            if (!string.IsNullOrEmpty(corlibDir))
+            {
+                var candidate = Path.Combine(corlibDir, "System.Runtime.dll");
+                if (File.Exists(candidate))
+                {
+                    return MetadataReference.CreateFromFile(candidate);
+                }
+            }
+
+            if (AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") is string tpa)
+            {
+                foreach (var path in tpa.Split(Path.PathSeparator))
+                {
+                    if (Path.GetFileName(path).Equals("System.Runtime.dll", StringComparison.OrdinalIgnoreCase) &&
+                        File.Exists(path))
+                    {
+                        return MetadataReference.CreateFromFile(path);
+                    }
+                }
+            }
+
+            throw new FileNotFoundException(
+                "Unable to locate System.Runtime.dll. Looked next to corlib and in TRUSTED_PLATFORM_ASSEMBLIES.");
+        }
+
         private static readonly MetadataReference SystemCoreReference = MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location);
         private static readonly MetadataReference CSharpSymbolsReference = MetadataReference.CreateFromFile(typeof(CSharpCompilation).Assembly.Location);
         private static readonly MetadataReference CodeAnalysisReference = MetadataReference.CreateFromFile(typeof(Compilation).Assembly.Location);

src/dotnet/Lucene.Net.Tests.CodeAnalysis/TestLucene1001_AddBaseMethodCallCSCodeFixProvider.cs

@@ -214,6 +214,73 @@ sealed class TypeName : TokenStream
             };
 
             VerifyCSharpDiagnostic(test, expected);
+
+            var fixtest = @"
+using Lucene.Net.Analysis;
+
+namespace MyNamespace
+{
+    sealed class TypeName : TokenStream
+    {
+        public override bool IncrementToken() => false;
+
+        public override void Reset()
+        {
+            base.Reset();
+            System.Diagnostics.Debug.WriteLine(""hi"");
+        }
+    }
+}";
+            VerifyCSharpFix(test, fixtest);
+        }
+
+        [Test]
+        public void TestExpressionBodiedThrow_Diagnostic_CodeFix()
+        {
+            // Regression: an expression-bodied void method whose body is `=> throw ...;`
+            // must be converted to a block whose trailing statement is a ThrowStatement,
+            // not an ExpressionStatement (which would be invalid C#).
+            var test = @"
+using Lucene.Net.Analysis;
+using System;
+
+namespace MyNamespace
+{
+    sealed class TypeName : TokenStream
+    {
+        public override bool IncrementToken() => false;
+
+        public override void Reset() => throw new NotSupportedException();
+    }
+}";
+            var expected = new DiagnosticResult
+            {
+                Id = Lucene1001_TokenStreamOverrideMustCallBaseMethodCSAnalyzer.DiagnosticId,
+                Message = "Override of 'Reset()' on type 'TypeName' must call base.Reset().",
+                Severity = DiagnosticSeverity.Warning,
+                Locations = new[] { new DiagnosticResultLocation("Test0.cs", 11, 30) }
+            };
+
+            VerifyCSharpDiagnostic(test, expected);
+
+            var fixtest = @"
+using Lucene.Net.Analysis;
+using System;
+
+namespace MyNamespace
+{
+    sealed class TypeName : TokenStream
+    {
+        public override bool IncrementToken() => false;
+
+        public override void Reset()
+        {
+            base.Reset();
+            throw new NotSupportedException();
+        }
+    }
+}";
+            VerifyCSharpFix(test, fixtest);
         }
 
         [Test]
@@ -286,5 +353,66 @@ public override void Reset()
 
             VerifyCSharpDiagnostic(test, expected);
         }
+
+        [Test]
+        public void TestBaseCallInsideLambda_Diagnostic()
+        {
+            // A base call inside an uninvoked lambda does not satisfy the contract.
+            var test = @"
+using Lucene.Net.Analysis;
+using System;
+
+namespace MyNamespace
+{
+    sealed class TypeName : TokenStream
+    {
+        public override bool IncrementToken() => false;
+
+        public override void Reset()
+        {
+            Action a = () => base.Reset();
+        }
+    }
+}";
+            var expected = new DiagnosticResult
+            {
+                Id = Lucene1001_TokenStreamOverrideMustCallBaseMethodCSAnalyzer.DiagnosticId,
+                Message = "Override of 'Reset()' on type 'TypeName' must call base.Reset().",
+                Severity = DiagnosticSeverity.Warning,
+                Locations = new[] { new DiagnosticResultLocation("Test0.cs", 11, 30) }
+            };
+
+            VerifyCSharpDiagnostic(test, expected);
+        }
+
+        [Test]
+        public void TestBaseCallInsideLocalFunction_Diagnostic()
+        {
+            // A base call inside an uninvoked local function does not satisfy the contract.
+            var test = @"
+using Lucene.Net.Analysis;
+
+namespace MyNamespace
+{
+    sealed class TypeName : TokenStream
+    {
+        public override bool IncrementToken() => false;
+
+        public override void Reset()
+        {
+            void Local() => base.Reset();
+        }
+    }
+}";
+            var expected = new DiagnosticResult
+            {
+                Id = Lucene1001_TokenStreamOverrideMustCallBaseMethodCSAnalyzer.DiagnosticId,
+                Message = "Override of 'Reset()' on type 'TypeName' must call base.Reset().",
+                Severity = DiagnosticSeverity.Warning,
+                Locations = new[] { new DiagnosticResultLocation("Test0.cs", 10, 30) }
+            };
+
+            VerifyCSharpDiagnostic(test, expected);
+        }
     }
 }

src/dotnet/Lucene.Net.Tests.CodeAnalysis/TestLucene1001_AddBaseMethodCallVBCodeFixProvider.cs

@@ -141,5 +141,37 @@ End Class
 
             VerifyBasicDiagnostic(test, expected);
         }
+
+        [Test]
+        public void TestBaseCallInsideLambda_Diagnostic()
+        {
+            // A base call inside an uninvoked lambda does not satisfy the contract.
+            var test = @"
+Imports Lucene.Net.Analysis
+Imports System
+
+Namespace MyNamespace
+    NotInheritable Class TypeName
+        Inherits TokenStream
+
+        Public Overrides Function IncrementToken() As Boolean
+            Return False
+        End Function
+
+        Public Overrides Sub Reset()
+            Dim a As Action = Sub() MyBase.Reset()
+        End Sub
+    End Class
+End Namespace";
+            var expected = new DiagnosticResult
+            {
+                Id = Lucene1001_TokenStreamOverrideMustCallBaseMethodVBAnalyzer.DiagnosticId,
+                Message = "Override of 'Reset()' on type 'TypeName' must call MyBase.Reset().",
+                Severity = DiagnosticSeverity.Warning,
+                Locations = new[] { new DiagnosticResultLocation("Test0.vb", 13, 30) }
+            };
+
+            VerifyBasicDiagnostic(test, expected);
+        }
     }
 }

src/dotnet/Lucene.Net.Tests.CodeAnalysis/TestLucene1002_AddEndOverrideCSCodeFixProvider.cs

@@ -145,6 +145,44 @@ sealed class TypeName : TokenStream
             VerifyCSharpDiagnostic(test);
         }
 
+        [Test]
+        public void TestTokenizerMissingEndOverride_CodeFix()
+        {
+            var test = @"
+using Lucene.Net.Analysis;
+using System.IO;
+
+namespace MyNamespace
+{
+    sealed class TypeName : Tokenizer
+    {
+        public TypeName(TextReader input) : base(input) { }
+
+        public override bool IncrementToken() => false;
+    }
+}";
+            var fixtest = @"
+using Lucene.Net.Analysis;
+using System.IO;
+
+namespace MyNamespace
+{
+    sealed class TypeName : Tokenizer
+    {
+        public TypeName(TextReader input) : base(input) { }
+
+        public override bool IncrementToken() => false;
+
+        public override void End()
+        {
+            base.End();
+            // TODO: set the final offset and finish up other end-of-stream attributes
+        }
+    }
+}";
+            VerifyCSharpFix(test, fixtest);
+        }
+
         [Test]
         public void TestIndirectTokenizerInheritance_Diagnostic()
         {