Address Copilot review: TryFormat, null-provider, comment

Three fixes from PR #28 review:

1. LuceneDev2001 missed `int.TryFormat(buffer, out _)` because the
   resolved overload declares an *optional* IFormatProvider parameter,
   and the analyzer bailed whenever the signature had one. Switch to
   checking whether the invocation actually supplies a provider arg.

2. NumericTypeHelper.GetFormatProviderArgument returned null for `null`
   literal arguments because GetTypeInfo(...).Type is null for them,
   so calls like `i.ToString((string)null, null)` slipped past the
   2007/2008 explicit-culture analyzer. Fall back to ConvertedType so
   overload-resolution-chosen parameter types are picked up.

3. Stale comment in LuceneDev2003 claimed using-static forms aren't
   handled, but the implementation already supports IdentifierNameSyntax
   and verifies the containing type is System.String. Comment updated.

Adds three regression tests covering each fix.

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

Author: paulirwin

src/Lucene.Net.CodeAnalysis.Dev/LuceneDev2xxx/LuceneDev2001_BclNumericToStringAnalyzer.cs

@@ -64,7 +64,9 @@ private static void AnalyzeInvocation(SyntaxNodeAnalysisContext ctx)
             if (!NumericTypeHelper.IsBclNumericSpecialType(containing))
                 return;
 
-            if (NumericTypeHelper.HasFormatProviderParameter(method, semantic.Compilation))
+            // Bail only when the call site actually supplies a provider argument; methods like
+            // TryFormat declare an *optional* IFormatProvider parameter that callers often omit.
+            if (NumericTypeHelper.GetFormatProviderArgument(invocation, semantic) is not null)
                 return;
 
             // Exempt parameterless ToString() inside a class's ToString() override —

src/Lucene.Net.CodeAnalysis.Dev/LuceneDev2xxx/LuceneDev2003_StringFormatNumericAnalyzer.cs

@@ -43,8 +43,9 @@ private static void AnalyzeInvocation(SyntaxNodeAnalysisContext ctx)
         {
             var invocation = (InvocationExpressionSyntax)ctx.Node;
 
-            // Match Format(...) on System.String. Don't bother with using-static or alias forms;
-            // the canonical Lucene.NET style is string.Format(...).
+            // Match Format(...) called as either `string.Format(...)` (member access) or `Format(...)`
+            // (identifier — e.g. via `using static System.String;`). Containing-type check below
+            // confirms the resolved method really is on System.String.
             string? methodName = invocation.Expression switch
             {
                 MemberAccessExpressionSyntax m => m.Name.Identifier.ValueText,

src/Lucene.Net.CodeAnalysis.Dev/Utility/NumericTypeHelper.cs

@@ -134,7 +134,10 @@ public static bool HasFormatProviderParameter(IMethodSymbol? method, Compilation
 
             foreach (var arg in invocation.ArgumentList.Arguments)
             {
-                var argType = semanticModel.GetTypeInfo(arg.Expression).Type;
+                // For literals like `null` or `default`, GetTypeInfo(...).Type is null but
+                // ConvertedType reflects the parameter type chosen by overload resolution.
+                var typeInfo = semanticModel.GetTypeInfo(arg.Expression);
+                var argType = typeInfo.Type ?? typeInfo.ConvertedType;
                 if (argType is null) continue;
                 if (SymbolEqualityComparer.Default.Equals(argType, fpType))
                     return arg.Expression;

tests/Lucene.Net.CodeAnalysis.Dev.Tests/LuceneDev2xxx/TestLuceneDev2001_BclNumericToStringAnalyzer.cs

@@ -74,6 +74,51 @@ public class Sample
             await test.RunAsync();
         }
 
+        [Test]
+        public async Task IntTryFormat_WithoutProvider_ReportsDiagnostic()
+        {
+            var testCode = @"
+using System;
+
+public class Sample
+{
+    public bool M(int i, Span<char> buffer) => i.TryFormat(buffer, out _);
+}";
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev2001_BclNumericToStringMissingFormatProvider)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessageFormat(Descriptors.LuceneDev2001_BclNumericToStringMissingFormatProvider.MessageFormat)
+                .WithArguments("TryFormat", "Int32")
+                .WithLocation("/0/Test0.cs", line: 6, column: 50);
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev2001_BclNumericToStringAnalyzer())
+            {
+                TestCode = testCode,
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net80,
+                ExpectedDiagnostics = { expected }
+            };
+            await test.RunAsync();
+        }
+
+        [Test]
+        public async Task IntTryFormat_WithProvider_NoDiagnostic()
+        {
+            var testCode = @"
+using System;
+using System.Globalization;
+
+public class Sample
+{
+    public bool M(int i, Span<char> buffer) => i.TryFormat(buffer, out _, provider: CultureInfo.InvariantCulture);
+}";
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev2001_BclNumericToStringAnalyzer())
+            {
+                TestCode = testCode,
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net80
+            };
+            await test.RunAsync();
+        }
+
         [Test]
         public async Task IntToString_WithProvider_NoDiagnostic()
         {

tests/Lucene.Net.CodeAnalysis.Dev.Tests/LuceneDev2xxx/TestLuceneDev2007_2008_NumericExplicitCultureAnalyzer.cs

@@ -81,6 +81,32 @@ public class Sample
             await test.RunAsync();
         }
 
+        [Test]
+        public async Task NullProviderLiteral_Reports2007()
+        {
+            // Regression: passing `null` for IFormatProvider should be treated as a non-invariant
+            // explicit provider (it's effectively current-culture). The argument's TypeInfo.Type
+            // is null for the `null` literal, so detection must fall back to ConvertedType.
+            var testCode = @"
+public class Sample
+{
+    public string M(int i) => i.ToString((string)null, null);
+}";
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev2007_NumericNonInvariantFormatProvider)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessageFormat(Descriptors.LuceneDev2007_NumericNonInvariantFormatProvider.MessageFormat)
+                .WithArguments("ToString")
+                .WithLocation("/0/Test0.cs", line: 4, column: 33);
+
+            var test = new InjectableCSharpAnalyzerTest(() => new LuceneDev2007_2008_NumericExplicitCultureAnalyzer())
+            {
+                TestCode = testCode,
+                ExpectedDiagnostics = { expected }
+            };
+            await test.RunAsync();
+        }
+
         [Test]
         public async Task IsEnabledByDefault_2007True_2008False()
         {