Skip char overloads in LuceneDev6001/6002

The analyzer's literal-only guard only suppressed 6001/6002 when the
first argument was a `'x'` char literal or `"x"` single-character
string literal. Calls like `text.IndexOf(c)` where `c` is a char
variable bound to `string.IndexOf(char)` — which has no
StringComparison sibling — falsely tripped 6001 (#1211).

Filter both the resolved-symbol and ambiguous-candidate paths to
overloads whose first parameter is `System.String`, so char overloads
are excluded from the rule entirely instead of relying on syntactic
literal recognition.

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,13 +118,21 @@ 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 —
+            // 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;
+
             // If resolved symbol available
             if (methodSymbol != null)
             {
                 // Only apply rule to System.String or J2N.StringBuilderExtensions containing type
                 if (!ContainingTypeIsStringOrJ2N(methodSymbol.ContainingType))
                     return;
 
+                if (!FirstParameterIsString(methodSymbol))
+                    return;
+
                 // If the method has StringComparison parameter in signature
                 bool methodHasComparisonParam = HasStringComparisonParameter(methodSymbol, stringComparisonType);
 
@@ -160,9 +168,9 @@ static bool HasStringComparisonParameter(IMethodSymbol? m, INamedTypeSymbol scTy
             // Handle ambiguous candidates
             if (candidateSymbols.Length > 0)
             {
-                // Check if any candidate is from String or J2N types
+                // Check if any candidate is from String or J2N types and takes a string first parameter
                 var relevantCandidates = candidateSymbols
-                    .Where(c => ContainingTypeIsStringOrJ2N(c.ContainingType))
+                    .Where(c => ContainingTypeIsStringOrJ2N(c.ContainingType) && FirstParameterIsString(c))
                     .ToImmutableArray();
 
                 if (relevantCandidates.Length == 0)

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

@@ -78,6 +78,80 @@ public void M()
             await test.RunAsync();
         }
 
+        [Test]
+        public async Task Skips_IndexOf_CharLiteral()
+        {
+            var testCode = @"
+using System;
+
+public class Sample
+{
+    public void M()
+    {
+        string text = ""Hello"";
+        int index = text.IndexOf('H');
+    }
+}";
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev6001_6002_StringComparisonAnalyzer())
+            {
+                TestCode = testCode,
+                ExpectedDiagnostics = { } // IndexOf(char) has no StringComparison overload; no diagnostic
+            };
+
+            await test.RunAsync();
+        }
+
+        [Test]
+        public async Task Skips_IndexOf_CharVariable()
+        {
+            var testCode = @"
+using System;
+
+public class Sample
+{
+    public void M()
+    {
+        string text = ""Hello"";
+        char c = 'H';
+        int index = text.IndexOf(c);
+    }
+}";
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev6001_6002_StringComparisonAnalyzer())
+            {
+                TestCode = testCode,
+                ExpectedDiagnostics = { } // IndexOf(char) has no StringComparison overload; no diagnostic
+            };
+
+            await test.RunAsync();
+        }
+
+        [Test]
+        public async Task Skips_StartsWith_CharVariable()
+        {
+            var testCode = @"
+using System;
+
+public class Sample
+{
+    public void M()
+    {
+        string text = ""Hello"";
+        char c = 'H';
+        bool starts = text.StartsWith(c);
+    }
+}";
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev6001_6002_StringComparisonAnalyzer())
+            {
+                TestCode = testCode,
+                ExpectedDiagnostics = { } // StartsWith(char) has no StringComparison overload; no diagnostic
+            };
+
+            await test.RunAsync();
+        }
+
         [Test]
         public async Task Detects_IndexOf_MissingStringComparison()
         {