Address Copilot review: handle non-reduced extension calls

The previous filter checked Parameters[0], which is correct for
instance methods and reduced extension calls (sb.IndexOf("x")) but
not for static-form extension calls
(StringBuilderExtensions.IndexOf(sb, "x")) where Parameters[0] is the
receiver. The two call shapes resolve to the same underlying API but
my filter would silently skip the static form.

Use the same value-parameter-index pattern as LuceneDev6005:
index 1 when IsExtensionMethod && ReducedFrom == null, else 0.

Adds tests for both reduced-form (already worked) and static-form
(was the regression Copilot flagged) calls into a J2N-style
StringBuilderExtensions stub.

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

Author: paulirwin

src/Lucene.Net.CodeAnalysis.Dev/LuceneDev6xxx/LuceneDev6001_6002_StringComparisonAnalyzer.cs

@@ -118,10 +118,17 @@ static bool HasStringComparisonParameter(IMethodSymbol? m, INamedTypeSymbol scTy
             var (hasStringComparisonArg, isValidValue, invalidArgLocation, comparisonValueName) =
                 CheckStringComparisonArgument(invocation, semantic, stringComparisonType);
 
-            // The rule only applies to overloads whose first parameter is a string —
+            // The rule only applies to overloads whose value parameter is a string —
             // overloads like IndexOf(char) / StartsWith(char) have no StringComparison sibling.
-            static bool FirstParameterIsString(IMethodSymbol? m)
-                => m != null && m.Parameters.Length > 0 && m.Parameters[0].Type.SpecialType == SpecialType.System_String;
+            // For non-reduced extension method calls (e.g. StringBuilderExtensions.IndexOf(sb, "x")),
+            // Parameters[0] is the receiver, so skip past it.
+            static bool ValueParameterIsString(IMethodSymbol? m)
+            {
+                if (m == null || m.Parameters.Length == 0) return false;
+                int valueIndex = m.IsExtensionMethod && m.ReducedFrom == null ? 1 : 0;
+                return m.Parameters.Length > valueIndex
+                    && m.Parameters[valueIndex].Type.SpecialType == SpecialType.System_String;
+            }
 
             // If resolved symbol available
             if (methodSymbol != null)
@@ -130,7 +137,7 @@ static bool FirstParameterIsString(IMethodSymbol? m)
                 if (!ContainingTypeIsStringOrJ2N(methodSymbol.ContainingType))
                     return;
 
-                if (!FirstParameterIsString(methodSymbol))
+                if (!ValueParameterIsString(methodSymbol))
                     return;
 
                 // If the method has StringComparison parameter in signature
@@ -170,7 +177,7 @@ static bool FirstParameterIsString(IMethodSymbol? m)
             {
                 // Check if any candidate is from String or J2N types and takes a string first parameter
                 var relevantCandidates = candidateSymbols
-                    .Where(c => ContainingTypeIsStringOrJ2N(c.ContainingType) && FirstParameterIsString(c))
+                    .Where(c => ContainingTypeIsStringOrJ2N(c.ContainingType) && ValueParameterIsString(c))
                     .ToImmutableArray();
 
                 if (relevantCandidates.Length == 0)

tests/Lucene.Net.CodeAnalysis.Dev.Tests/LuceneDev6xxx/TestLuceneDev6001_6002_StringComparisonAnalyzer.cs

@@ -581,5 +581,82 @@ public void M()
 
             await test.RunAsync();
         }
+
+        [Test]
+        public async Task Detects_J2NStringBuilderExtensions_ReducedForm_MissingStringComparison()
+        {
+            var testCode = @"
+using System.Text;
+using J2N.Text;
+
+namespace J2N.Text
+{
+    public static class StringBuilderExtensions
+    {
+        public static int IndexOf(this StringBuilder sb, string value) => 0;
+    }
+}
+
+public class Sample
+{
+    public void M()
+    {
+        var sb = new StringBuilder(""hello"");
+        int index = sb.IndexOf(""he"");
+    }
+}";
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev6001_MissingStringComparison.Id, DiagnosticSeverity.Error)
+                .WithSeverity(DiagnosticSeverity.Error)
+                .WithMessageFormat(Descriptors.LuceneDev6001_MissingStringComparison.MessageFormat)
+                .WithArguments("IndexOf")
+                .WithLocation("/0/Test0.cs", line: 18, column: 24);
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev6001_6002_StringComparisonAnalyzer())
+            {
+                TestCode = testCode,
+                ExpectedDiagnostics = { expected }
+            };
+
+            await test.RunAsync();
+        }
+
+        [Test]
+        public async Task Detects_J2NStringBuilderExtensions_StaticForm_MissingStringComparison()
+        {
+            var testCode = @"
+using System.Text;
+
+namespace J2N.Text
+{
+    public static class StringBuilderExtensions
+    {
+        public static int IndexOf(this StringBuilder sb, string value) => 0;
+    }
+}
+
+public class Sample
+{
+    public void M()
+    {
+        var sb = new StringBuilder(""hello"");
+        int index = J2N.Text.StringBuilderExtensions.IndexOf(sb, ""he"");
+    }
+}";
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev6001_MissingStringComparison.Id, DiagnosticSeverity.Error)
+                .WithSeverity(DiagnosticSeverity.Error)
+                .WithMessageFormat(Descriptors.LuceneDev6001_MissingStringComparison.MessageFormat)
+                .WithArguments("IndexOf")
+                .WithLocation("/0/Test0.cs", line: 17, column: 54);
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev6001_6002_StringComparisonAnalyzer())
+            {
+                TestCode = testCode,
+                ExpectedDiagnostics = { expected }
+            };
+
+            await test.RunAsync();
+        }
     }
 }