Address Copilot review feedback on PR #27

- Code fix: only offer TryGetValue rewrite when receiver type exposes
  an accessible public instance TryGetValue(TKey, out TValue) method,
  to avoid generating non-compiling code when the method is only
  available via explicit interface implementation.
- Add unit test verifying PickLocalName collision-avoidance produces
  a unique name (value1) when 'value' is already in scope.
- Fix misleading comment in DictionaryTypeHelper.IsGenericDictionaryIndexer
  to match actual behavior.

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

Author: paulirwin

src/Lucene.Net.CodeAnalysis.Dev.CodeFixes/LuceneDev1xxx/LuceneDev1007_1008_DictionaryIndexerCodeFixProvider.cs

@@ -49,6 +49,9 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
             if (root == null) return;
 
+            var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
+            if (semanticModel == null) return;
+
             foreach (var diagnostic in context.Diagnostics)
             {
                 var elementAccess = root.FindToken(diagnostic.Location.SourceSpan.Start)
@@ -66,6 +69,11 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                     continue;
                 }
 
+                // If the receiver type doesn't expose an accessible TryGetValue method
+                // (e.g. only via explicit interface implementation), skip — the rewrite would not compile.
+                if (!HasAccessibleTryGetValue(semanticModel, elementAccess))
+                    continue;
+
                 context.RegisterCodeFix(
                     CodeAction.Create(
                         title: TitleReturn,
@@ -75,6 +83,30 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             }
         }
 
+        private static bool HasAccessibleTryGetValue(SemanticModel semanticModel, ElementAccessExpressionSyntax elementAccess)
+        {
+            var receiverType = semanticModel.GetTypeInfo(elementAccess.Expression).Type;
+            if (receiverType == null)
+                return false;
+
+            foreach (var member in receiverType.GetMembers("TryGetValue"))
+            {
+                if (member is not IMethodSymbol method)
+                    continue;
+                if (method.IsStatic)
+                    continue;
+                if (method.DeclaredAccessibility != Accessibility.Public)
+                    continue;
+                if (method.Parameters.Length != 2)
+                    continue;
+                if (method.Parameters[1].RefKind != RefKind.Out)
+                    continue;
+                return true;
+            }
+
+            return false;
+        }
+
         private static async Task<Document> ConvertReturnAsync(
             Document document,
             ReturnStatementSyntax returnStmt,

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

@@ -36,7 +36,7 @@ public static bool IsGenericDictionaryIndexer(IPropertySymbol indexer, INamedTyp
         {
             valueType = null;
 
-            // Must take a single non-object key parameter. (The IDictionary.this[object] variant is handled elsewhere.)
+            // Must take a single key parameter. (The non-generic IDictionary.this[object] variant is handled elsewhere.)
             if (indexer.Parameters.Length != 1)
                 return false;
 

tests/Lucene.Net.CodeAnalysis.Dev.CodeFixes.Tests/LuceneDev1xxx/TestLuceneDev1007_1008_DictionaryIndexerCodeFixProvider.cs

@@ -112,5 +112,58 @@ public int M(IDictionary<string, int> dict, string key)
 
             await test.RunAsync();
         }
+
+        [Test]
+        public async Task TestFix_Return_PicksUniqueLocalName_WhenValueIsInScope()
+        {
+            var testCode = @"
+using System.Collections.Generic;
+
+public class Sample
+{
+    public int M(IDictionary<string, int> dict, string key)
+    {
+        int value = 42;
+        if (value > 0)
+        {
+            return dict[key];
+        }
+        return value;
+    }
+}";
+
+            var fixedCode = @"
+using System.Collections.Generic;
+
+public class Sample
+{
+    public int M(IDictionary<string, int> dict, string key)
+    {
+        int value = 42;
+        if (value > 0)
+        {
+            return dict.TryGetValue(key, out var value1) ? value1 : default;
+        }
+        return value;
+    }
+}";
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev1007_GenericDictionaryIndexerValueType)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessageFormat(Descriptors.LuceneDev1007_GenericDictionaryIndexerValueType.MessageFormat)
+                .WithArguments("dict[key]")
+                .WithLocation("/0/Test0.cs", line: 11, column: 20);
+
+            var test = new InjectableCodeFixTest(
+                () => new LuceneDev1007_1008_DictionaryIndexerAnalyzer(),
+                () => new LuceneDev1007_1008_DictionaryIndexerCodeFixProvider())
+            {
+                TestCode = testCode,
+                FixedCode = fixedCode,
+                ExpectedDiagnostics = { expected }
+            };
+
+            await test.RunAsync();
+        }
     }
 }