From cd7ee603fa5072ad998c2265db6553700bd268ee Mon Sep 17 00:00:00 2001
From: Widthdom <widthdom@gmail.com>
Date: Mon, 27 Jul 2026 12:03:33 +0900
Subject: [PATCH 1/3] Fix C# parameter modifier type references (#4832)

---
 DEVELOPER_GUIDE.md                            |  4 +
 TESTING_GUIDE.md                              |  2 +
 changelog.d/unreleased/4832.fixed.md          | 19 ++++
 .../ReferenceExtractor.DeclarationTypes.cs    |  5 +-
 tests/CodeIndex.Tests/DbReaderTests.cs        | 92 +++++++++++++++++++
 .../ReferenceExtractorCSharpTests.cs          | 82 +++++++++++++++++
 6 files changed, 203 insertions(+), 1 deletion(-)
 create mode 100644 changelog.d/unreleased/4832.fixed.md

diff --git a/DEVELOPER_GUIDE.md b/DEVELOPER_GUIDE.md
index efe043126..1df627fd7 100644
--- a/DEVELOPER_GUIDE.md
+++ b/DEVELOPER_GUIDE.md
@@ -1435,6 +1435,8 @@ Supported symbol kinds by language:
 | Zig / PowerShell / CSS-SCSS / Batch / Assembly / HTML | language-specific functions, labels, selectors, stages, Web Components, properties, imports | language-specific references where implemented | mixed |
 | XML | bounded element/attribute paths plus NuGet.config security-policy values | XAML references where implemented | mixed |
 
+C# parameter and argument-list modifier tokens (`out`, `ref`, `in`, `params`, `this`, and `scoped`) are excluded only when parsed in modifier positions. A following concrete or generic type retains its `type_reference`, while `out var` emits neither the modifier nor the implicit `var` as a type. Do not implement this as a global keyword blacklist because contextual keywords can remain legal identifiers outside modifier positions.
+
 Shell and PowerShell files also expose a synthetic `<script>` function symbol spanning the file. Top-level call references use this scope as their graph container, while references inside declared functions retain the declared function container.
 
 Type aliases are indexed as `import` symbols in Rust, TypeScript, Swift, Go, F# and Scala. In F#, record declarations map to `struct`, discriminated unions map to `enum`, and constructor-style `type` declarations remain `class`.
@@ -4579,6 +4581,8 @@ SQL 固有の symbol extraction:
 | Zig / PowerShell / CSS-SCSS / Batch / Assembly / HTML | 言語別 function、label、selector、stage、Web Component、property、import | 実装済みの言語別 reference | mixed |
 | XML | 上限付き element / attribute path と NuGet.config security-policy value | 実装済みの XAML reference | mixed |
 
+C# の parameter / argument-list modifier token（`out`、`ref`、`in`、`params`、`this`、`scoped`）は、modifier 位置として解析された場合だけ除外します。後続の concrete type / generic type の `type_reference` は維持し、`out var` では modifier も暗黙の `var` も型として出力しません。contextual keyword は modifier 位置以外では合法な identifier になり得るため、global keyword blacklist にしてはいけません。
+
 Shell と PowerShell のファイルには、ファイル全体を覆う合成 `<script>` 関数シンボルも作成される。トップレベルの call reference はこのスコープを graph container として使い、宣言済み関数内の reference はその関数 container を維持する。
 
 Rust / TypeScript / Swift / Go / F# / Scala の type alias は `import` シンボルとして index される。F# では record は `struct`、discriminated union は `enum`、constructor 形式の `type` は `class` として扱う。
diff --git a/TESTING_GUIDE.md b/TESTING_GUIDE.md
index 018c8040d..3af8d0233 100644
--- a/TESTING_GUIDE.md
+++ b/TESTING_GUIDE.md
@@ -433,6 +433,7 @@ Use `docs/test-doc-maintenance-plan.md` before moving oversized suites or adding
 - Nested generic attribute forms extend that shared fixture instead of running a second parser pass solely for deeper angle-bracket nesting.
 - No-argument parameter attributes on methods, delegates, and lambdas share one C# fixture because all three exercise the same section-local parenthesis-depth rule.
 - Argument-bearing parameter attributes share one method fixture for inline and line-broken declaration layouts.
+- C# parameter and argument-list modifier coverage keeps multiline declaration and call sites for `out` / `ref` / `in` / `params` / `this` / `scoped`, `out var`, following generic types, ref returns, and ref structs in one extractor fixture. The indexed reader fixture separately proves raw `type_reference` queries exclude modifiers while resolved following-type edges remain graph-queryable.
 - Direct and `global::` static type qualifiers share one C# fixture while retaining per-container reference assertions.
 - Static qualifiers in using statements and field access share one consumer fixture and extraction pass.
 - Namespace-qualified and Pascal-cased instance-member chains share one qualifier fixture with a rightmost static type reference, so positive and negative qualifier outcomes are checked after one parse.
@@ -1317,6 +1318,7 @@ dotnet test --filter "FullyQualifiedName~GitHelperTests"
 - nested generic attribute 形式も同じ共有 fixture に含め、山括弧の深い入れ子だけのために2回目の parser pass を実行しません。
 - method、delegate、lambda の no-argument parameter attribute は、同じ section-local parenthesis-depth 規則を通るため1つの C# fixture を共有します。
 - 引数付き parameter attribute は、inline と改行された declaration layout で1つの method fixture を共有します。
+- C# の parameter / argument-list modifier coverage は、`out` / `ref` / `in` / `params` / `this` / `scoped`、`out var`、後続の generic type、ref return、ref struct の multiline declaration / call site を1つの extractor fixture で共有します。indexed reader fixture では、modifier が raw `type_reference` query に出ず、解決済みの後続型 edge が graph query 可能なままであることを別途固定します。
 - direct と `global::` の static type qualifier は、container ごとの reference assertion を維持しながら1つの C# fixture を共有します。
 - using statement と field access の static qualifier は、1つの consumer fixture と抽出 pass を共有します。
 - namespace qualifier と PascalCase の instance-member chain は rightmost static type reference と1つの qualifier fixture を共有し、1回の parse 後に正例と call 除外を検証します。
diff --git a/changelog.d/unreleased/4832.fixed.md b/changelog.d/unreleased/4832.fixed.md
new file mode 100644
index 000000000..b6d6b8ef9
--- /dev/null
+++ b/changelog.d/unreleased/4832.fixed.md
@@ -0,0 +1,19 @@
+---
+category: fixed
+issues:
+  - 4832
+affected:
+  - src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
+  - tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
+  - tests/CodeIndex.Tests/DbReaderTests.cs
+  - DEVELOPER_GUIDE.md
+  - TESTING_GUIDE.md
+---
+
+## English
+
+- **C# parameter modifiers no longer appear as type references (#4832)** — Modifier-position `out`, `ref`, `in`, `params`, `this`, and `scoped` tokens are excluded while following concrete and generic types retain their resolved type references, including in multiline declarations and calls; `out var` no longer creates a pseudo-type reference.
+
+## 日本語
+
+- **C# のパラメーター修飾子を型参照として出力しないようにしました (#4832)** — 修飾子位置の `out`、`ref`、`in`、`params`、`this`、`scoped` を除外しつつ、複数行の宣言や呼び出しでも後続の具体型・ジェネリック型は解決済みの型参照として維持し、`out var` は疑似的な型参照を生成しないようにしました。
diff --git a/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs b/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
index 0e3b7491a..80015b7d6 100644
--- a/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
+++ b/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
@@ -701,7 +701,10 @@ private static bool TryGetSimpleDeclarationTypeSpan(string line, string language
         while (first < tokens.Count)
         {
             var token = head.Substring(tokens[first].Start, tokens[first].Length);
-            if (token.StartsWith("[", StringComparison.Ordinal) || token.StartsWith("@", StringComparison.Ordinal) || IsDeclarationModifier(language, token))
+            if (token.StartsWith("[", StringComparison.Ordinal)
+                || token.StartsWith("@", StringComparison.Ordinal)
+                || IsDeclarationModifier(language, token)
+                || IsParameterModifier(language, token))
             {
                 first++;
                 continue;
diff --git a/tests/CodeIndex.Tests/DbReaderTests.cs b/tests/CodeIndex.Tests/DbReaderTests.cs
index 0ae605355..8c05f5255 100644
--- a/tests/CodeIndex.Tests/DbReaderTests.cs
+++ b/tests/CodeIndex.Tests/DbReaderTests.cs
@@ -401,6 +401,98 @@ private bool TryReadAllPositionLines(string path, out IReadOnlyList<string?> sou
         Assert.Equal(1, callee.ReferenceCount);
     }
 
+    [Fact]
+    public void CSharpParameterAndArgumentModifiersStayOutOfTypeReferenceQueries_Issue4832()
+    {
+        const string path = "src/csharp_modifier_type_references.cs";
+        InsertIndexedFile(
+            path,
+            "csharp",
+            """
+            struct Payload {}
+            class Wrapper<T> {}
+
+            static class ModifierFixture
+            {
+                static void Params(params Wrapper<Payload>[] items) {}
+
+                static void Consume(
+                    out Payload output,
+                    ref Wrapper<Payload> byRef,
+                    in Payload input,
+                    Payload tail)
+                {
+                    output = input;
+                }
+
+                static void Extend(
+                    this scoped ref Payload target,
+                    scoped in Payload input)
+                {
+                }
+
+                static void Run(Wrapper<Payload> byRef, Payload input)
+                {
+                    Consume(
+                        out Payload declared,
+                        ref byRef,
+                        in input,
+                        input);
+                    Consume(
+                        out var inferred,
+                        ref byRef,
+                        in input,
+                        input);
+                }
+            }
+            """);
+
+        foreach (var modifier in new[] { "out", "ref", "in", "params", "this", "scoped" })
+        {
+            Assert.Empty(_reader.SearchReferences(
+                modifier,
+                lang: "csharp",
+                referenceKind: "type_reference",
+                exact: true,
+                pathPatterns: [path]));
+        }
+
+        var payloadReferences = _reader.SearchReferences(
+            "Payload",
+            lang: "csharp",
+            referenceKind: "type_reference",
+            exact: true,
+            pathPatterns: [path]);
+        Assert.Contains(payloadReferences, reference =>
+            reference.Context.Contains("out Payload output", StringComparison.Ordinal));
+        Assert.Contains(payloadReferences, reference =>
+            reference.Context.Contains("this scoped ref Payload target", StringComparison.Ordinal));
+        Assert.All(payloadReferences, reference => Assert.Equal("resolved", reference.ResolutionState));
+
+        var wrapperReferences = _reader.SearchReferences(
+            "Wrapper",
+            lang: "csharp",
+            referenceKind: "type_reference",
+            exact: true,
+            pathPatterns: [path]);
+        Assert.Contains(wrapperReferences, reference =>
+            reference.Context.Contains("ref Wrapper<Payload> byRef", StringComparison.Ordinal));
+        Assert.All(wrapperReferences, reference => Assert.Equal("resolved", reference.ResolutionState));
+
+        var callers = _reader.GetCallers(
+            "Payload",
+            lang: "csharp",
+            referenceKind: "type_reference",
+            exact: true,
+            pathPatterns: [path]);
+        Assert.NotEmpty(callers);
+        Assert.All(callers, caller =>
+        {
+            Assert.Equal("Payload", caller.CalleeName);
+            Assert.Equal("type_reference", caller.ReferenceKind);
+        });
+    }
+
     [Fact]
     public void GetCallers_SolutionProjectReference_RequiresExplicitKind_Issue3662()
     {
diff --git a/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs b/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
index ccc12c0a5..886f6ca1c 100644
--- a/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
+++ b/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
@@ -54,6 +54,88 @@ void Process<T>(T item) {}
             && reference.ContainerName == "Run");
     }
 
+    [Fact]
+    public void Extract_CsharpParameterAndArgumentModifiers_KeepFollowingTypeReferences_Issue4832()
+    {
+        const string content = """
+            struct Payload {}
+            class Wrapper<T> {}
+            ref struct RefPacket {}
+
+            static class ModifierFixture
+            {
+                static ref Payload RefReturn(ref Payload value) => ref value;
+                static void Params(params Wrapper<Payload>[] items) {}
+
+                static void Consume(
+                    out Payload output,
+                    ref Wrapper<Payload> byRef,
+                    in Payload input,
+                    Payload tail)
+                {
+                    output = input;
+                }
+
+                static void Extend(
+                    this scoped ref Payload target,
+                    scoped in Payload input)
+                {
+                }
+
+                static void Run(Wrapper<Payload> byRef, Payload input)
+                {
+                    Consume(
+                        out Payload declared,
+                        ref byRef,
+                        in input,
+                        input);
+                    Consume(
+                        out var inferred,
+                        ref byRef,
+                        in input,
+                        input);
+                    _ = declared;
+                    _ = inferred;
+                }
+            }
+            """;
+
+        var (symbols, references) = ExtractSymbolsAndReferences("csharp", content);
+        var modifierNames = new HashSet<string>(StringComparer.Ordinal)
+        {
+            "out",
+            "ref",
+            "in",
+            "params",
+            "this",
+            "scoped",
+        };
+
+        Assert.DoesNotContain(references, reference =>
+            reference.ReferenceKind == "type_reference"
+            && modifierNames.Contains(reference.SymbolName));
+        Assert.DoesNotContain(references, reference =>
+            reference.ReferenceKind == "type_reference"
+            && reference.SymbolName == "var");
+        Assert.Contains(references, reference =>
+            reference.SymbolName == "Payload"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("out Payload output", StringComparison.Ordinal));
+        Assert.Contains(references, reference =>
+            reference.SymbolName == "Wrapper"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("ref Wrapper<Payload> byRef", StringComparison.Ordinal));
+        Assert.Contains(references, reference =>
+            reference.SymbolName == "Payload"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("this scoped ref Payload target", StringComparison.Ordinal));
+        Assert.Contains(references, reference =>
+            reference.SymbolName == "Payload"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("static ref Payload RefReturn", StringComparison.Ordinal));
+        Assert.Contains(symbols, symbol => symbol.Name == "RefPacket" && symbol.Kind == "struct");
+    }
+
     [Fact]
     public void Extract_CSharpQualifiedDataReaderCall_DoesNotEmitCommonMemberReference_Issue4121()
     {

From 6ed157f9a45eacd380dd4b3241211562ebc663c3 Mon Sep 17 00:00:00 2001
From: Widthdom <widthdom@gmail.com>
Date: Mon, 27 Jul 2026 12:39:52 +0900
Subject: [PATCH 2/3] Handle C# modifier continuation fragments (#4832)

---
 TESTING_GUIDE.md                              |  4 +-
 .../ReferenceExtractor.DeclarationTypes.cs    | 67 +++++++++++++++++++
 tests/CodeIndex.Tests/DbReaderTests.cs        | 11 +++
 .../ReferenceExtractorCSharpTests.cs          | 15 +++++
 4 files changed, 95 insertions(+), 2 deletions(-)

diff --git a/TESTING_GUIDE.md b/TESTING_GUIDE.md
index 3af8d0233..7e1e0ffa4 100644
--- a/TESTING_GUIDE.md
+++ b/TESTING_GUIDE.md
@@ -433,7 +433,7 @@ Use `docs/test-doc-maintenance-plan.md` before moving oversized suites or adding
 - Nested generic attribute forms extend that shared fixture instead of running a second parser pass solely for deeper angle-bracket nesting.
 - No-argument parameter attributes on methods, delegates, and lambdas share one C# fixture because all three exercise the same section-local parenthesis-depth rule.
 - Argument-bearing parameter attributes share one method fixture for inline and line-broken declaration layouts.
-- C# parameter and argument-list modifier coverage keeps multiline declaration and call sites for `out` / `ref` / `in` / `params` / `this` / `scoped`, `out var`, following generic types, ref returns, and ref structs in one extractor fixture. The indexed reader fixture separately proves raw `type_reference` queries exclude modifiers while resolved following-type edges remain graph-queryable.
+- C# parameter and argument-list modifier coverage keeps multiline declaration and call sites for `out` / `ref` / `in` / `params` / `this` / `scoped`, multiple modifier fragments on one continuation line, `out var`, following generic types, ref returns, and ref structs in one extractor fixture. The indexed reader fixture separately proves raw `type_reference` queries exclude modifiers while resolved following-type edges remain graph-queryable.
 - Direct and `global::` static type qualifiers share one C# fixture while retaining per-container reference assertions.
 - Static qualifiers in using statements and field access share one consumer fixture and extraction pass.
 - Namespace-qualified and Pascal-cased instance-member chains share one qualifier fixture with a rightmost static type reference, so positive and negative qualifier outcomes are checked after one parse.
@@ -1318,7 +1318,7 @@ dotnet test --filter "FullyQualifiedName~GitHelperTests"
 - nested generic attribute 形式も同じ共有 fixture に含め、山括弧の深い入れ子だけのために2回目の parser pass を実行しません。
 - method、delegate、lambda の no-argument parameter attribute は、同じ section-local parenthesis-depth 規則を通るため1つの C# fixture を共有します。
 - 引数付き parameter attribute は、inline と改行された declaration layout で1つの method fixture を共有します。
-- C# の parameter / argument-list modifier coverage は、`out` / `ref` / `in` / `params` / `this` / `scoped`、`out var`、後続の generic type、ref return、ref struct の multiline declaration / call site を1つの extractor fixture で共有します。indexed reader fixture では、modifier が raw `type_reference` query に出ず、解決済みの後続型 edge が graph query 可能なままであることを別途固定します。
+- C# の parameter / argument-list modifier coverage は、`out` / `ref` / `in` / `params` / `this` / `scoped`、1つの continuation line 上にある複数の modifier fragment、`out var`、後続の generic type、ref return、ref struct の multiline declaration / call site を1つの extractor fixture で共有します。indexed reader fixture では、modifier が raw `type_reference` query に出ず、解決済みの後続型 edge が graph query 可能なままであることを別途固定します。
 - direct と `global::` の static type qualifier は、container ごとの reference assertion を維持しながら1つの C# fixture を共有します。
 - using statement と field access の static qualifier は、1つの consumer fixture と抽出 pass を共有します。
 - namespace qualifier と PascalCase の instance-member chain は rightmost static type reference と1つの qualifier fixture を共有し、1回の parse 後に正例と call 除外を検証します。
diff --git a/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs b/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
index 80015b7d6..79560bdf3 100644
--- a/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
+++ b/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
@@ -63,6 +63,17 @@ internal static void EmitDeclarationTypeReferences(
                 resolveContainerForColumn(declarationTypeStart),
                 ignoredSegments);
         }
+
+        EmitCSharpModifierContinuationTypeReferences(
+            language,
+            line,
+            references,
+            seen,
+            fileId,
+            context,
+            lineNumber,
+            resolveContainerForColumn,
+            ignoredSegments);
     }
 
     internal static void EmitTypeScriptDeclarationTypeReferences(
@@ -669,6 +680,62 @@ private static bool TryGetParameterTypeRelativeSpan(string parameterFragment, st
         return true;
     }
 
+    private static void EmitCSharpModifierContinuationTypeReferences(
+        string language,
+        string line,
+        List<ReferenceRecord> references,
+        ReferenceDedupeSet seen,
+        long fileId,
+        string context,
+        int lineNumber,
+        Func<int, SymbolRecord?> resolveContainerForColumn,
+        IReadOnlySet<string>? ignoredSegments)
+    {
+        if (language != "csharp")
+            return;
+
+        var fragments = SplitTopLevelCommaSpans(line);
+        if (fragments.Count <= 1)
+            return;
+
+        foreach (var (fragmentStart, fragmentLength) in fragments)
+        {
+            var fragment = line.Substring(fragmentStart, fragmentLength);
+            var tokens = GetTopLevelTokenSpans(fragment);
+            int first = 0;
+            while (first < tokens.Count)
+            {
+                var token = fragment.Substring(tokens[first].Start, tokens[first].Length);
+                if (!token.StartsWith("[", StringComparison.Ordinal))
+                    break;
+                first++;
+            }
+
+            if (first >= tokens.Count)
+                continue;
+
+            var firstToken = fragment.Substring(tokens[first].Start, tokens[first].Length);
+            if (!IsParameterModifier(language, firstToken)
+                || !TryGetParameterTypeRelativeSpan(fragment, language, out var typeRelativeStart, out var typeRelativeLength))
+            {
+                continue;
+            }
+
+            int absoluteStart = fragmentStart + typeRelativeStart;
+            AddTypeExpressionSegmentsForLanguage(
+                language,
+                references,
+                seen,
+                fileId,
+                fragment.Substring(typeRelativeStart, typeRelativeLength),
+                absoluteStart,
+                context,
+                lineNumber,
+                resolveContainerForColumn(absoluteStart),
+                ignoredSegments);
+        }
+    }
+
     private static bool TryGetSimpleDeclarationTypeSpan(string line, string language, out int typeStart, out int typeLength)
     {
         typeStart = -1;
diff --git a/tests/CodeIndex.Tests/DbReaderTests.cs b/tests/CodeIndex.Tests/DbReaderTests.cs
index 8c05f5255..6f8e0a1a3 100644
--- a/tests/CodeIndex.Tests/DbReaderTests.cs
+++ b/tests/CodeIndex.Tests/DbReaderTests.cs
@@ -416,6 +416,13 @@ static class ModifierFixture
             {
                 static void Params(params Wrapper<Payload>[] items) {}
 
+                static void Multi(
+                    out Payload first, out Wrapper<Payload> second)
+                {
+                    first = default;
+                    second = default;
+                }
+
                 static void Consume(
                     out Payload output,
                     ref Wrapper<Payload> byRef,
@@ -443,6 +450,8 @@ static void Run(Wrapper<Payload> byRef, Payload input)
                         ref byRef,
                         in input,
                         input);
+                    Multi(
+                        out Payload first, out Wrapper<Payload> second);
                 }
             }
             """);
@@ -477,6 +486,8 @@ static void Run(Wrapper<Payload> byRef, Payload input)
             pathPatterns: [path]);
         Assert.Contains(wrapperReferences, reference =>
             reference.Context.Contains("ref Wrapper<Payload> byRef", StringComparison.Ordinal));
+        Assert.Equal(2, wrapperReferences.Count(reference =>
+            reference.Context.Contains("out Payload first, out Wrapper<Payload> second", StringComparison.Ordinal)));
         Assert.All(wrapperReferences, reference => Assert.Equal("resolved", reference.ResolutionState));
 
         var callers = _reader.GetCallers(
diff --git a/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs b/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
index 886f6ca1c..c495a32a3 100644
--- a/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
+++ b/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
@@ -67,6 +67,13 @@ static class ModifierFixture
                 static ref Payload RefReturn(ref Payload value) => ref value;
                 static void Params(params Wrapper<Payload>[] items) {}
 
+                static void Multi(
+                    out Payload first, out Wrapper<Payload> second)
+                {
+                    first = default;
+                    second = default;
+                }
+
                 static void Consume(
                     out Payload output,
                     ref Wrapper<Payload> byRef,
@@ -94,8 +101,12 @@ static void Run(Wrapper<Payload> byRef, Payload input)
                         ref byRef,
                         in input,
                         input);
+                    Multi(
+                        out Payload first, out Wrapper<Payload> second);
                     _ = declared;
                     _ = inferred;
+                    _ = first;
+                    _ = second;
                 }
             }
             """;
@@ -125,6 +136,10 @@ static void Run(Wrapper<Payload> byRef, Payload input)
             reference.SymbolName == "Wrapper"
             && reference.ReferenceKind == "type_reference"
             && reference.Context.Contains("ref Wrapper<Payload> byRef", StringComparison.Ordinal));
+        Assert.Equal(2, references.Count(reference =>
+            reference.SymbolName == "Wrapper"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("out Payload first, out Wrapper<Payload> second", StringComparison.Ordinal)));
         Assert.Contains(references, reference =>
             reference.SymbolName == "Payload"
             && reference.ReferenceKind == "type_reference"

From e5236b24552920facf20a1848b0cd8669e130816 Mon Sep 17 00:00:00 2001
From: Widthdom <widthdom@gmail.com>
Date: Mon, 27 Jul 2026 13:56:48 +0900
Subject: [PATCH 3/3] Handle nested C# parameter modifiers (#4832)

---
 TESTING_GUIDE.md                              |   4 +-
 changelog.d/unreleased/4832.fixed.md          |   5 +-
 .../ReferenceExtractor.DeclarationTypes.cs    | 110 +++++++++++++-----
 ...ferenceExtractor.TypeExpressionSegments.cs |  43 +++++++
 tests/CodeIndex.Tests/DbReaderTests.cs        |  26 +++++
 .../ReferenceExtractorCSharpTests.cs          |  35 ++++++
 6 files changed, 187 insertions(+), 36 deletions(-)

diff --git a/TESTING_GUIDE.md b/TESTING_GUIDE.md
index 7e1e0ffa4..1c23a6552 100644
--- a/TESTING_GUIDE.md
+++ b/TESTING_GUIDE.md
@@ -433,7 +433,7 @@ Use `docs/test-doc-maintenance-plan.md` before moving oversized suites or adding
 - Nested generic attribute forms extend that shared fixture instead of running a second parser pass solely for deeper angle-bracket nesting.
 - No-argument parameter attributes on methods, delegates, and lambdas share one C# fixture because all three exercise the same section-local parenthesis-depth rule.
 - Argument-bearing parameter attributes share one method fixture for inline and line-broken declaration layouts.
-- C# parameter and argument-list modifier coverage keeps multiline declaration and call sites for `out` / `ref` / `in` / `params` / `this` / `scoped`, multiple modifier fragments on one continuation line, `out var`, following generic types, ref returns, and ref structs in one extractor fixture. The indexed reader fixture separately proves raw `type_reference` queries exclude modifiers while resolved following-type edges remain graph-queryable.
+- C# parameter and argument-list modifier coverage keeps multiline declaration and call sites for `out` / `ref` / `in` / `params` / `this` / `scoped`, multiple modifier fragments on one continuation line, final `)`-closing fragments, nested lambda arguments, `out var`, following generic types, ref returns, and ref structs in one extractor fixture. The indexed reader fixture separately proves raw `type_reference` queries exclude modifiers while resolved following-type edges remain graph-queryable.
 - Direct and `global::` static type qualifiers share one C# fixture while retaining per-container reference assertions.
 - Static qualifiers in using statements and field access share one consumer fixture and extraction pass.
 - Namespace-qualified and Pascal-cased instance-member chains share one qualifier fixture with a rightmost static type reference, so positive and negative qualifier outcomes are checked after one parse.
@@ -1318,7 +1318,7 @@ dotnet test --filter "FullyQualifiedName~GitHelperTests"
 - nested generic attribute 形式も同じ共有 fixture に含め、山括弧の深い入れ子だけのために2回目の parser pass を実行しません。
 - method、delegate、lambda の no-argument parameter attribute は、同じ section-local parenthesis-depth 規則を通るため1つの C# fixture を共有します。
 - 引数付き parameter attribute は、inline と改行された declaration layout で1つの method fixture を共有します。
-- C# の parameter / argument-list modifier coverage は、`out` / `ref` / `in` / `params` / `this` / `scoped`、1つの continuation line 上にある複数の modifier fragment、`out var`、後続の generic type、ref return、ref struct の multiline declaration / call site を1つの extractor fixture で共有します。indexed reader fixture では、modifier が raw `type_reference` query に出ず、解決済みの後続型 edge が graph query 可能なままであることを別途固定します。
+- C# の parameter / argument-list modifier coverage は、`out` / `ref` / `in` / `params` / `this` / `scoped`、1つの continuation line 上にある複数の modifier fragment、末尾が `)` で閉じる fragment、nested lambda argument、`out var`、後続の generic type、ref return、ref struct の multiline declaration / call site を1つの extractor fixture で共有します。indexed reader fixture では、modifier が raw `type_reference` query に出ず、解決済みの後続型 edge が graph query 可能なままであることを別途固定します。
 - direct と `global::` の static type qualifier は、container ごとの reference assertion を維持しながら1つの C# fixture を共有します。
 - using statement と field access の static qualifier は、1つの consumer fixture と抽出 pass を共有します。
 - namespace qualifier と PascalCase の instance-member chain は rightmost static type reference と1つの qualifier fixture を共有し、1回の parse 後に正例と call 除外を検証します。
diff --git a/changelog.d/unreleased/4832.fixed.md b/changelog.d/unreleased/4832.fixed.md
index b6d6b8ef9..f5cdb474e 100644
--- a/changelog.d/unreleased/4832.fixed.md
+++ b/changelog.d/unreleased/4832.fixed.md
@@ -4,6 +4,7 @@ issues:
   - 4832
 affected:
   - src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
+  - src/CodeIndex/Indexer/References/ReferenceExtractor.TypeExpressionSegments.cs
   - tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
   - tests/CodeIndex.Tests/DbReaderTests.cs
   - DEVELOPER_GUIDE.md
@@ -12,8 +13,8 @@ affected:
 
 ## English
 
-- **C# parameter modifiers no longer appear as type references (#4832)** — Modifier-position `out`, `ref`, `in`, `params`, `this`, and `scoped` tokens are excluded while following concrete and generic types retain their resolved type references, including in multiline declarations and calls; `out var` no longer creates a pseudo-type reference.
+- **C# parameter modifiers no longer appear as type references (#4832)** — Modifier-position `out`, `ref`, `in`, `params`, `this`, and `scoped` tokens are excluded while following concrete and generic types retain their resolved type references, including in multiline declarations, calls, and nested lambda arguments; `out var` no longer creates a pseudo-type reference.
 
 ## 日本語
 
-- **C# のパラメーター修飾子を型参照として出力しないようにしました (#4832)** — 修飾子位置の `out`、`ref`、`in`、`params`、`this`、`scoped` を除外しつつ、複数行の宣言や呼び出しでも後続の具体型・ジェネリック型は解決済みの型参照として維持し、`out var` は疑似的な型参照を生成しないようにしました。
+- **C# のパラメーター修飾子を型参照として出力しないようにしました (#4832)** — 修飾子位置の `out`、`ref`、`in`、`params`、`this`、`scoped` を除外しつつ、複数行の宣言・呼び出しや nested lambda argument でも後続の具体型・ジェネリック型は解決済みの型参照として維持し、`out var` は疑似的な型参照を生成しないようにしました。
diff --git a/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs b/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
index 79560bdf3..35d401da7 100644
--- a/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
+++ b/src/CodeIndex/Indexer/References/ReferenceExtractor.DeclarationTypes.cs
@@ -64,7 +64,7 @@ internal static void EmitDeclarationTypeReferences(
                 ignoredSegments);
         }
 
-        EmitCSharpModifierContinuationTypeReferences(
+        EmitCSharpModifierTypeReferences(
             language,
             line,
             references,
@@ -680,7 +680,7 @@ private static bool TryGetParameterTypeRelativeSpan(string parameterFragment, st
         return true;
     }
 
-    private static void EmitCSharpModifierContinuationTypeReferences(
+    private static void EmitCSharpModifierTypeReferences(
         string language,
         string line,
         List<ReferenceRecord> references,
@@ -694,46 +694,92 @@ private static void EmitCSharpModifierContinuationTypeReferences(
         if (language != "csharp")
             return;
 
-        var fragments = SplitTopLevelCommaSpans(line);
-        if (fragments.Count <= 1)
-            return;
-
-        foreach (var (fragmentStart, fragmentLength) in fragments)
+        for (int tokenStart = 0; tokenStart < line.Length;)
         {
-            var fragment = line.Substring(fragmentStart, fragmentLength);
-            var tokens = GetTopLevelTokenSpans(fragment);
-            int first = 0;
-            while (first < tokens.Count)
+            if (!IsTypeExpressionIdentifierStart(language, line[tokenStart]))
             {
-                var token = fragment.Substring(tokens[first].Start, tokens[first].Length);
-                if (!token.StartsWith("[", StringComparison.Ordinal))
-                    break;
-                first++;
+                tokenStart++;
+                continue;
             }
 
-            if (first >= tokens.Count)
+            int tokenEnd = tokenStart + 1;
+            while (tokenEnd < line.Length && IsTypeExpressionIdentifierPart(language, line[tokenEnd]))
+                tokenEnd++;
+            var token = line.Substring(tokenStart, tokenEnd - tokenStart);
+            if (!IsCSharpParameterModifierPosition(line, tokenStart, tokenEnd, token))
+            {
+                tokenStart = tokenEnd;
                 continue;
+            }
 
-            var firstToken = fragment.Substring(tokens[first].Start, tokens[first].Length);
-            if (!IsParameterModifier(language, firstToken)
-                || !TryGetParameterTypeRelativeSpan(fragment, language, out var typeRelativeStart, out var typeRelativeLength))
+            int fragmentEnd = FindCSharpModifierFragmentEnd(line, tokenEnd);
+            var fragment = line.Substring(tokenStart, fragmentEnd - tokenStart);
+            if (TryGetParameterTypeRelativeSpan(fragment, language, out var typeRelativeStart, out var typeRelativeLength))
             {
-                continue;
+                int absoluteStart = tokenStart + typeRelativeStart;
+                AddTypeExpressionSegmentsForLanguage(
+                    language,
+                    references,
+                    seen,
+                    fileId,
+                    fragment.Substring(typeRelativeStart, typeRelativeLength),
+                    absoluteStart,
+                    context,
+                    lineNumber,
+                    resolveContainerForColumn(absoluteStart),
+                    ignoredSegments);
             }
 
-            int absoluteStart = fragmentStart + typeRelativeStart;
-            AddTypeExpressionSegmentsForLanguage(
-                language,
-                references,
-                seen,
-                fileId,
-                fragment.Substring(typeRelativeStart, typeRelativeLength),
-                absoluteStart,
-                context,
-                lineNumber,
-                resolveContainerForColumn(absoluteStart),
-                ignoredSegments);
+            tokenStart = tokenEnd;
+        }
+    }
+
+    private static int FindCSharpModifierFragmentEnd(string line, int startIndex)
+    {
+        int angleDepth = 0;
+        int parenDepth = 0;
+        int squareDepth = 0;
+        int braceDepth = 0;
+
+        for (int i = startIndex; i < line.Length; i++)
+        {
+            char c = line[i];
+            if (angleDepth == 0 && parenDepth == 0 && squareDepth == 0 && braceDepth == 0)
+            {
+                if (c is ',' or ')' or ';')
+                    return i;
+            }
+
+            switch (c)
+            {
+                case '<':
+                    angleDepth++;
+                    break;
+                case '>':
+                    if (angleDepth > 0) angleDepth--;
+                    break;
+                case '(':
+                    parenDepth++;
+                    break;
+                case ')':
+                    if (parenDepth > 0) parenDepth--;
+                    break;
+                case '[':
+                    squareDepth++;
+                    break;
+                case ']':
+                    if (squareDepth > 0) squareDepth--;
+                    break;
+                case '{':
+                    braceDepth++;
+                    break;
+                case '}':
+                    if (braceDepth > 0) braceDepth--;
+                    break;
+            }
         }
+
+        return line.Length;
     }
 
     private static bool TryGetSimpleDeclarationTypeSpan(string line, string language, out int typeStart, out int typeLength)
diff --git a/src/CodeIndex/Indexer/References/ReferenceExtractor.TypeExpressionSegments.cs b/src/CodeIndex/Indexer/References/ReferenceExtractor.TypeExpressionSegments.cs
index ef841eb3a..b82ad5ce5 100644
--- a/src/CodeIndex/Indexer/References/ReferenceExtractor.TypeExpressionSegments.cs
+++ b/src/CodeIndex/Indexer/References/ReferenceExtractor.TypeExpressionSegments.cs
@@ -149,6 +149,14 @@ internal static void AddTypeExpressionSegments(
             if (language == "csharp")
                 segment = NormalizeCSharpIdentifier(rawSegment);
 
+            if (language == "csharp"
+                && !isEscapedCSharpIdentifier
+                && IsCSharpParameterModifierPosition(expression, segmentStart, i, segment))
+            {
+                i--;
+                continue;
+            }
+
             if (language == "kotlin" && KotlinTypeProjectionModifierNames.Contains(segment))
             {
                 i--;
@@ -178,5 +186,40 @@ internal static void AddTypeExpressionSegments(
         }
     }
 
+    private static bool IsCSharpParameterModifierPosition(
+        string expression,
+        int segmentStart,
+        int segmentEnd,
+        string segment)
+    {
+        if (!IsParameterModifier("csharp", segment))
+            return false;
+
+        int next = SkipWhitespace(expression, segmentEnd);
+        if (next >= expression.Length
+            || (expression[next] != '(' && !IsTypeExpressionIdentifierStart("csharp", expression[next])))
+        {
+            return false;
+        }
+
+        int previous = segmentStart - 1;
+        while (previous >= 0 && char.IsWhiteSpace(expression[previous]))
+            previous--;
+        if (previous < 0 || expression[previous] is '(' or ',')
+            return true;
+        if (!IsTypeExpressionIdentifierPart("csharp", expression[previous]))
+            return false;
+
+        int previousEnd = previous + 1;
+        while (previous >= 0 && IsTypeExpressionIdentifierPart("csharp", expression[previous]))
+            previous--;
+        int previousStart = previous + 1;
+        var previousSegment = expression.Substring(previousStart, previousEnd - previousStart);
+        return IsCSharpParameterModifierPosition(
+            expression,
+            previousStart,
+            previousEnd,
+            previousSegment);
+    }
 
 }
diff --git a/tests/CodeIndex.Tests/DbReaderTests.cs b/tests/CodeIndex.Tests/DbReaderTests.cs
index 6f8e0a1a3..dc2d94044 100644
--- a/tests/CodeIndex.Tests/DbReaderTests.cs
+++ b/tests/CodeIndex.Tests/DbReaderTests.cs
@@ -409,6 +409,8 @@ public void CSharpParameterAndArgumentModifiersStayOutOfTypeReferenceQueries_Iss
             path,
             "csharp",
             """
+            using System.Linq;
+
             struct Payload {}
             class Wrapper<T> {}
 
@@ -423,6 +425,19 @@ static void Multi(
                     second = default;
                 }
 
+                static void Final(
+                    Payload first,
+                    out Wrapper<Payload> last)
+                {
+                    last = default;
+                }
+
+                static bool TryPayload(out Payload value)
+                {
+                    value = default;
+                    return true;
+                }
+
                 static void Consume(
                     out Payload output,
                     ref Wrapper<Payload> byRef,
@@ -452,6 +467,11 @@ static void Run(Wrapper<Payload> byRef, Payload input)
                         input);
                     Multi(
                         out Payload first, out Wrapper<Payload> second);
+                    Final(
+                        input,
+                        out Wrapper<Payload> final);
+                    var inferredMatch = new[] { input }.Any(item => TryPayload(out var nested) && nested.Equals(item));
+                    var explicitMatch = new[] { input }.Any(item => TryPayload(out Payload nested) && nested.Equals(item));
                 }
             }
             """);
@@ -476,6 +496,8 @@ static void Run(Wrapper<Payload> byRef, Payload input)
             reference.Context.Contains("out Payload output", StringComparison.Ordinal));
         Assert.Contains(payloadReferences, reference =>
             reference.Context.Contains("this scoped ref Payload target", StringComparison.Ordinal));
+        Assert.Contains(payloadReferences, reference =>
+            reference.Context.Contains("TryPayload(out Payload nested)", StringComparison.Ordinal));
         Assert.All(payloadReferences, reference => Assert.Equal("resolved", reference.ResolutionState));
 
         var wrapperReferences = _reader.SearchReferences(
@@ -488,6 +510,10 @@ static void Run(Wrapper<Payload> byRef, Payload input)
             reference.Context.Contains("ref Wrapper<Payload> byRef", StringComparison.Ordinal));
         Assert.Equal(2, wrapperReferences.Count(reference =>
             reference.Context.Contains("out Payload first, out Wrapper<Payload> second", StringComparison.Ordinal)));
+        Assert.Contains(wrapperReferences, reference =>
+            reference.Context.Contains("out Wrapper<Payload> last)", StringComparison.Ordinal));
+        Assert.Contains(wrapperReferences, reference =>
+            reference.Context.Contains("out Wrapper<Payload> final)", StringComparison.Ordinal));
         Assert.All(wrapperReferences, reference => Assert.Equal("resolved", reference.ResolutionState));
 
         var callers = _reader.GetCallers(
diff --git a/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs b/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
index c495a32a3..ce05c9f6b 100644
--- a/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
+++ b/tests/CodeIndex.Tests/ReferenceExtractorCSharpTests.cs
@@ -58,6 +58,8 @@ void Process<T>(T item) {}
     public void Extract_CsharpParameterAndArgumentModifiers_KeepFollowingTypeReferences_Issue4832()
     {
         const string content = """
+            using System.Linq;
+
             struct Payload {}
             class Wrapper<T> {}
             ref struct RefPacket {}
@@ -74,6 +76,19 @@ static void Multi(
                     second = default;
                 }
 
+                static void Final(
+                    Payload first,
+                    out Wrapper<Payload> last)
+                {
+                    last = default;
+                }
+
+                static bool TryPayload(out Payload value)
+                {
+                    value = default;
+                    return true;
+                }
+
                 static void Consume(
                     out Payload output,
                     ref Wrapper<Payload> byRef,
@@ -103,10 +118,18 @@ static void Run(Wrapper<Payload> byRef, Payload input)
                         input);
                     Multi(
                         out Payload first, out Wrapper<Payload> second);
+                    Final(
+                        input,
+                        out Wrapper<Payload> final);
+                    var inferredMatch = new[] { input }.Any(item => TryPayload(out var nested) && nested.Equals(item));
+                    var explicitMatch = new[] { input }.Any(item => TryPayload(out Payload nested) && nested.Equals(item));
                     _ = declared;
                     _ = inferred;
                     _ = first;
                     _ = second;
+                    _ = final;
+                    _ = inferredMatch;
+                    _ = explicitMatch;
                 }
             }
             """;
@@ -144,6 +167,18 @@ static void Run(Wrapper<Payload> byRef, Payload input)
             reference.SymbolName == "Payload"
             && reference.ReferenceKind == "type_reference"
             && reference.Context.Contains("this scoped ref Payload target", StringComparison.Ordinal));
+        Assert.Contains(references, reference =>
+            reference.SymbolName == "Payload"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("TryPayload(out Payload nested)", StringComparison.Ordinal));
+        Assert.Contains(references, reference =>
+            reference.SymbolName == "Wrapper"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("out Wrapper<Payload> last)", StringComparison.Ordinal));
+        Assert.Contains(references, reference =>
+            reference.SymbolName == "Wrapper"
+            && reference.ReferenceKind == "type_reference"
+            && reference.Context.Contains("out Wrapper<Payload> final)", StringComparison.Ordinal));
         Assert.Contains(references, reference =>
             reference.SymbolName == "Payload"
             && reference.ReferenceKind == "type_reference"