Fix C# static readonly tuple field extraction (#4691)

* Fix C# static readonly tuple fields (#4616)

* Refresh stale C# indexes for tuple fields (#4616)

Author: Widthdom

DEVELOPER_GUIDE.md

@@ -473,7 +473,7 @@ Do not add mutable static caches, shared `StringBuilder` instances, reused `Matc
 | `environment` | Dockerfile `ENV` variable names | Variable/search symbol; participates in Dockerfile variable references |
 | `event` | Event declarations | Search/filter symbol |
 | `expose` | Dockerfile `EXPOSE` ports | Container runtime search symbol |
-| `field` | Field declarations where distinct from properties | Search/filter symbol |
+| `field` | Field declarations where distinct from properties; C# const and static readonly fields share the tuple-aware type grammar used by ordinary fields | Search/filter symbol |
 | `file_module` | File-scoped module/package declarations | Namespace-like context symbol |
 | `function` | Functions, methods, constructors, delegates, tasks, and callable bindings that do not have a narrower kind | Primary callable definition; participates in callers/callees through reference rows |
 | `generator` | JavaScript/TypeScript generator declarations | Callable definition; participates in callers/callees through reference rows |
@@ -3330,7 +3330,7 @@ filter、downstream JSON consumer が同じ値を理解できるようにして
 | `environment` | Dockerfile `ENV` variable name | variable/search symbol。Dockerfile variable reference に参加 |
 | `event` | event declaration | Search/filter symbol |
 | `expose` | Dockerfile `EXPOSE` port | container runtime search symbol |
-| `field` | property と区別される field declaration | Search/filter symbol |
+| `field` | property と区別される field declaration。C# の const / static readonly field は通常 field と tuple-aware な型文法を共有する | Search/filter symbol |
 | `file_module` | file-scoped module / package declaration | Namespace-like context symbol |
 | `function` | 関数、method、constructor、delegate、task、およびより狭い kind がない callable binding | Primary callable definition。reference row 経由で callers/callees に参加 |
 | `generator` | JavaScript / TypeScript generator declaration | Callable definition。reference row 経由で callers/callees に参加 |

TESTING_GUIDE.md

@@ -197,6 +197,7 @@ Use `docs/test-doc-maintenance-plan.md` before moving oversized suites or adding
   C# query-range collision forms for basic selection, directional ordering, keyword-named members, and object initializers share one indexed source when they assert the same empty inspect reference bundle.
   C# inspect brace-range regressions place char-literal, raw-string, and verbatim-string forms in one indexed class and query each following method from that shared fixture.
   C# generic query-range selectors share simple and tuple type arguments in one fixture, while generic type-pattern coverage shares designation and no-designation forms in another fixture.
+  C# field-type grammar coverage shares static readonly tuple, nullable-tuple, generic-tuple-member, const/plain-field controls, and deconstruction negatives in one extractor fixture. The full-scan regression also seeds the previous C# extractor contract against an unchanged file and verifies that incremental indexing restores the tuple field kind and complete return type.
   C# switch-expression pattern-variable coverage keeps recursive, declaration, guard, and comment-trivia forms in one extractor fixture when their contract is the set of genuine enum-member references.
   C# foreach-shadowing coverage shares embedded, same-line, and dangling-else forms in one source and distinguishes the surviving references by container.
   C# lambda-parameter shadowing coverage shares simple, multiline, after-lambda, and same-line boundary forms in one extraction pass.
@@ -912,6 +913,7 @@ dotnet test --filter "FullyQualifiedName~GitHelperTests"
   C# query-range collision の basic selection、directional ordering、keyword 名 member、object initializer は、同じ空の inspect reference bundle を検証する場合は1つの indexed source を共有してください。
   C# inspect の brace-range regression は char literal、raw string、verbatim string を1つの indexed class に併置し、それぞれの後続 method を共有 fixture から query してください。
   C# generic query-range selector は単純型引数と tuple 型引数を1つの fixture で共有し、generic type-pattern coverage は designation 有無を別の1 fixture で共有してください。
+  C# field 型文法 coverage は static readonly tuple、nullable tuple、generic 内 tuple member、const / 通常 field の control、deconstruction の負例を1つの extractor fixture で共有してください。full-scan regression では未変更 file に以前の C# extractor contract を設定し、incremental index が tuple field の kind と完全な return type を復元することも検証してください。
   C# switch-expression pattern-variable coverage は、真の enum-member reference 集合を同じ contract とする recursive、declaration、guard、comment-trivia 形式を1つの extractor fixture で共有してください。
   C# foreach shadowing coverage は embedded、same-line、dangling-else 形式を1つの source で共有し、残る reference を container で区別してください。
   C# lambda parameter shadowing coverage は simple、multiline、after-lambda、same-line boundary 形式を1回の extraction pass で共有してください。

changelog.d/unreleased/4616.fixed.md

@@ -0,0 +1,17 @@
+---
+category: fixed
+issues:
+  - 4616
+affected:
+  - src/CodeIndex/Indexer/Symbols/SymbolExtractor.cs
+  - tests/CodeIndex.Tests/SymbolExtractorCSharpTests.cs
+  - tests/CodeIndex.Tests/IndexCommandRunnerFullScanTests.cs
+---
+
+## English
+
+- **C# static readonly tuple fields retain complete metadata (#4616)** — static readonly fields now use the shared C# type grammar, so tuple, nullable-tuple, and generic-tuple-member types remain `field` symbols with complete return-type metadata without treating deconstruction locals as fields. The C# extractor contract was advanced so normal incremental indexing refreshes unchanged source files created by earlier versions.
+
+## 日本語
+
+- **C# の static readonly tuple field で完全なメタデータを保持するようになりました (#4616)** — static readonly field が共有 C# 型文法を使うようになり、tuple、nullable tuple、generic 内の tuple member 型を deconstruction local と誤認せず、完全な return-type metadata を持つ `field` symbol として維持します。C# extractor contract も更新したため、通常の incremental index で以前の version が作成した未変更 source file を再抽出します。

src/CodeIndex/Indexer/Symbols/SymbolExtractor.cs

@@ -16,7 +16,7 @@ public static partial class SymbolExtractor
     public const int DefaultContractVersion = 1;
     public const int ExpandedLanguageContractVersion = 2;
     public const int PythonContractVersion = 2;
-    public const int CSharpContractVersion = 3;
+    public const int CSharpContractVersion = 4;
     public const int DockerfileContractVersion = 2;
     public const int MakefileContractVersion = 2;
     public const int StyleAndXamlContractVersion = 2;
@@ -1131,12 +1131,17 @@ private enum JavaScriptTypeScriptFunctionHeaderConsumeResult
             // 先頭以外の位置に現れることを許容し、`readonly public static` や `static public readonly`
             // のような旧来の並びでも kind `field` で取り扱う。通常フィールド（kind `property`）の
             // 正規表現に流れ落ちないようにする。Closes #355.
+            // Share CSharpTypePattern with const and plain fields so tuple, nullable-tuple, and
+            // generic-over-tuple types retain stable field kind and complete return-type metadata.
+            // const / 通常フィールドと CSharpTypePattern を共有し、tuple / nullable tuple /
+            // generic-over-tuple 型でも安定した field kind と完全な return-type metadata を保持する。
+            // Closes #4616.
             new("function",  new Regex(
                 $@"^\s*"
               + $@"(?=(?:(?:{CSharpVisibilityPattern}|new|static|readonly)\s+)*static\s+)"
               + $@"(?=(?:(?:{CSharpVisibilityPattern}|new|static|readonly)\s+)*readonly\s+)"
               + $@"(?:(?<visibility>{CSharpVisibilityPattern})\s+|(?:new|static|readonly)\s+)+"
-              + @"(?<returnType>[\w@?.<>\[\],:\s]+?)\s+(?<name>" + CSharpIdentifierPattern + @")\s*[=;]",
+              + $@"(?<returnType>{CSharpTypePattern})\s+(?<name>{CSharpIdentifierPattern})\s*[=;]",
                 RegexOptions.Compiled), BodyStyle.None, "visibility", "returnType"),
             // Plain field (instance, readonly, volatile, plain static, etc.) — kind `property`.
             // Must come AFTER the `const` and `static readonly` patterns (which take priority

tests/CodeIndex.Tests/IndexCommandRunnerFullScanTests.cs

@@ -2204,6 +2204,68 @@ WHERE kind IN ('route', 'implements', 'attribute', 'layout')
         }
     }
 
+    [Fact]
+    public void Run_FullScan_ReindexesUnchangedCSharpTupleReadonlyFieldWhenExtractorVersionChanged_Issue4616()
+    {
+        var projectRoot = CreateTempProject();
+        try
+        {
+            File.WriteAllText(
+                Path.Combine(projectRoot, "tuple-fields.cs"),
+                """
+                public class TupleFields
+                {
+                    public static readonly (int Left, int Right) Pair = (1, 2);
+                }
+                """);
+
+            var initialExitCode = IndexCommandRunner.Run([projectRoot, "--json"], _jsonOptions);
+            Assert.Equal(CommandExitCodes.Success, initialExitCode);
+
+            var dbPath = Path.Combine(projectRoot, ".cdidx", "codeindex.db");
+            using (var conn = OpenNonPoolingConnection(dbPath))
+            {
+                conn.Open();
+                using var cmd = conn.CreateCommand();
+                cmd.CommandText = $"""
+                    DELETE FROM symbols WHERE name = 'Pair';
+                    UPDATE codeindex_meta
+                    SET value = '3'
+                    WHERE key = '{DbContext.GetSymbolExtractorVersionMetaKey("csharp")}';
+                    """;
+                cmd.ExecuteNonQuery();
+            }
+
+            var (exitCode, json) = RunAndCaptureJson([projectRoot, "--json"]);
+
+            Assert.Equal(CommandExitCodes.Success, exitCode);
+            Assert.Equal("success", json.GetProperty("status").GetString());
+            Assert.Equal(0, json.GetProperty("summary").GetProperty("files_skipped").GetInt32());
+
+            using var verify = OpenNonPoolingConnection(dbPath);
+            verify.Open();
+            using var symbolCmd = verify.CreateCommand();
+            symbolCmd.CommandText = "SELECT kind, return_type FROM symbols WHERE name = 'Pair'";
+            using (var reader = symbolCmd.ExecuteReader())
+            {
+                Assert.True(reader.Read());
+                Assert.Equal("field", reader.GetString(0));
+                Assert.Equal("(int Left, int Right)", reader.GetString(1));
+                Assert.False(reader.Read());
+            }
+
+            using var versionCmd = verify.CreateCommand();
+            versionCmd.CommandText = $"SELECT value FROM codeindex_meta WHERE key = '{DbContext.GetSymbolExtractorVersionMetaKey("csharp")}'";
+            Assert.Equal(
+                SymbolExtractor.CSharpContractVersion.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                versionCmd.ExecuteScalar() as string);
+        }
+        finally
+        {
+            DeleteDirectory(projectRoot);
+        }
+    }
+
     [ProductionRuntimeFact]
     public void Run_FullScan_DegradedWarningSummarizesRemainingFoldGap()
     {

tests/CodeIndex.Tests/SymbolExtractorCSharpTests.cs

@@ -3087,6 +3087,39 @@ public class Svc
         Assert.DoesNotContain(symbols, s => s.Kind == "property" && s.Name is "A" or "B" or "C" or "D" or "D2" or "E" or "F");
     }
 
+    [Fact]
+    public void Extract_CSharp_FieldPatterns_ShareTupleTypeGrammar_Issue4616()
+    {
+        var content = """
+            namespace TupleFields;
+
+            public class Holder
+            {
+                public static readonly (int Left, int Right) Pair = (1, 2);
+                public static readonly (int Left, int Right)? MaybePair = null;
+                public static readonly Dictionary<string, (int Left, int Right)> PairByName = new();
+                public const (int Left, int Right) ConstPair = (1, 2);
+                public (int Left, int Right) PlainPair = (1, 2);
+
+                public void DeconstructLocals()
+                {
+                    var (left, right) = Pair;
+                    (int nestedLeft, int nestedRight) = Pair;
+                }
+            }
+            """;
+        var symbols = SymbolExtractor.Extract(1, "csharp", content);
+
+        Assert.Contains(symbols, s => s.Kind == "field" && s.Name == "Pair" && s.ReturnType == "(int Left, int Right)");
+        Assert.Contains(symbols, s => s.Kind == "field" && s.Name == "MaybePair" && s.ReturnType == "(int Left, int Right)?");
+        var pairByName = Assert.Single(symbols.Where(s => s.Name == "PairByName"));
+        Assert.Equal("field", pairByName.Kind);
+        Assert.Equal("Dictionary<string,(int Left,int Right)>", pairByName.ReturnType);
+        Assert.Contains(symbols, s => s.Kind == "field" && s.Name == "ConstPair" && s.ReturnType == "(int Left, int Right)");
+        Assert.Contains(symbols, s => s.Kind == "property" && s.Name == "PlainPair" && s.ReturnType == "(int Left, int Right)");
+        Assert.DoesNotContain(symbols, s => s.Name is "left" or "right" or "nestedLeft" or "nestedRight");
+    }
+
     [Fact]
     public void Extract_CSharp_Method_FreeModifierOrder()
     {