gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/languages/cpp/query.js

@@ -54,12 +54,26 @@ const CPP_SCOPE_QUERY = `
   declarator: (type_identifier) @declaration.name) @declaration.struct
 
 ;; ─── Declarations — class / struct inside template_declaration ───────
+;; \`parameters:\` is the DECLARED parameter list (\`template <class T>\`), which
+;; lives on the template_declaration and not on the specifier — the opposite
+;; nesting from \`@declaration.template-arguments\` above, which is part of the
+;; specifier's own NAME. A partial specialization carries both, and that pairing
+;; is the only thing separating it from a full specialization written against
+;; the identical arguments.
+;;
+;; These four patterns are TWINS of the four standalone specifier patterns
+;; above: a templated struct matches both, minting two defs with one id, and
+;; only this half can see the parameter list. The duplicate-declaration backfill
+;; in scope-extractor.ts is what stops match order from deciding which twin
+;; keeps the parameters.
 (template_declaration
+  parameters: (template_parameter_list) @declaration.type-parameters
   (class_specifier
     name: (type_identifier) @declaration.name
     body: (field_declaration_list)) @declaration.class)
 
 (template_declaration
+  parameters: (template_parameter_list) @declaration.type-parameters
   (class_specifier
     name: (template_type
       (type_identifier) @declaration.name
@@ -67,11 +81,13 @@ const CPP_SCOPE_QUERY = `
     body: (field_declaration_list)) @declaration.class)
 
 (template_declaration
+  parameters: (template_parameter_list) @declaration.type-parameters
   (struct_specifier
     name: (type_identifier) @declaration.name
     body: (field_declaration_list)) @declaration.struct)
 
 (template_declaration
+  parameters: (template_parameter_list) @declaration.type-parameters
   (struct_specifier
     name: (template_type
       (type_identifier) @declaration.name
@@ -97,6 +113,16 @@ const CPP_SCOPE_QUERY = `
   declarator: (function_declarator
     declarator: (identifier) @declaration.name)) @declaration.function
 
+;; Lambda bindings (\`auto f = [](int x){ … };\`). The \`@declaration.function\`
+;; anchor sits on the INNER lambda_expression so its range aligns with
+;; \`(lambda_expression) @scope.function\` above; otherwise the def is owned by
+;; the enclosing scope and calls inside the lambda lose caller attribution.
+;; Mirrors the TypeScript arrow patterns (#2687).
+(declaration
+  declarator: (init_declarator
+    declarator: (identifier) @declaration.name
+    value: (lambda_expression) @declaration.function))
+
 ;; ─── Declarations — function definition with pointer return ─────────
 (function_definition
   declarator: (pointer_declarator
@@ -526,6 +552,86 @@ const CPP_SCOPE_QUERY = `
   declarator: (reference_declarator
     (field_identifier) @type-binding.name)) @type-binding.field
 
+;; Generic field type: Repo<User> repo; (#2833)
+;; The three rules above all require type: (type_identifier), so a member whose
+;; type carries template arguments is a template_type and matched NONE of them —
+;; the field got no type binding at all, and every call through it lost its edge
+;; in BOTH spellings (repo.save() and this->repo.save()), while the same type in
+;; a LOCAL resolved fine because the local declaration rules gained their
+;; template_type variant long ago (see "Covers: List<User> users;" above).
+;; These three mirror the three above, one per declarator shape. Written as
+;; separate patterns rather than one alternation: a node-type alternation in a
+;; field position is the tree-sitter 0.21 hazard this repo has been bitten by
+;; before.
+(field_declaration
+  type: (template_type) @type-binding.type
+  declarator: (field_identifier) @type-binding.name) @type-binding.field
+
+;; Generic field, pointer: Repo<User>* repo;
+(field_declaration
+  type: (template_type) @type-binding.type
+  declarator: (pointer_declarator
+    declarator: (field_identifier) @type-binding.name)) @type-binding.field
+
+;; Generic field, reference: Repo<User>& repo;
+(field_declaration
+  type: (template_type) @type-binding.type
+  declarator: (reference_declarator
+    (field_identifier) @type-binding.name)) @type-binding.field
+
+;; ─── Field type, QUALIFIED: ns::Address addr; std::vector<Item> items; ─
+;; The six rules above require the type node to BE a type_identifier or a
+;; template_type, and a qualified member type is NEITHER: tree-sitter-cpp parses
+;; ns::Address as a qualified_identifier WRAPPING the type_identifier, and
+;; std::vector<Item> as one wrapping the template_type. So every qualified
+;; member — generic or not — matched none of the six and bound nothing, which
+;; covers the commonest member spellings in real C++ (std::string, std::mutex,
+;; std::vector<T>, ns::Config).
+;;
+;; ONE PATTERN PER DECLARATOR SHAPE, MATCHING THE OUTER qualified_identifier,
+;; and that is the whole design. A tree-sitter query cannot match a node at
+;; arbitrary nesting depth, and a::b::c::Repo<User> nests one
+;; qualified_identifier per qualifier — so enumerating the inner node instead
+;; costs 3 patterns per depth per genericity and STILL ends at whatever depth
+;; the last author enumerated (that boundary was real: depth 3 was uncaptured).
+;; Matching the outer node is depth-agnostic and genericity-agnostic, and it is
+;; a single node type in the field position, not an alternation — the
+;; tree-sitter 0.21 hazard this repo has been bitten by before.
+;;
+;; The QUALIFIER IS THEN DROPPED, by cppQualifiedTail in interpret.ts, not
+;; here — and dropping it was measured rather than assumed. Recording
+;; ns::Repo<User> resolves to NOTHING: findClassBindingInScope's dotted-tail
+;; fallback splits on "." and C++ writes "::", and resolveClassBindingForName's
+;; generic branch then looks up the base ns::Repo, which is not a key either
+;; because C++ emits no @declaration.qualified_name and indexes ns::Repo under
+;; Repo. Reducing to the tail lands on exactly the path the BARE spelling
+;; already takes — one class-like match or decline — so a qualified member field
+;; behaves like the bare one instead of like nothing. A tail that names no
+;; workspace class (std::string with no "class string" in the repo) binds
+;; nothing and emits nothing, which is why this is a miss-closing change rather
+;; than an edge-fabricating one.
+;;
+;; Like the six above, each requires the declarator to reach the field_identifier
+;; DIRECTLY, so a method whose return type is qualified (ns::Thing method();)
+;; still captures no field — a function_declarator sits in between and none of
+;; these match it. Same for a function-pointer member, a using/typedef alias, a
+;; friend declaration and an operator declaration.
+(field_declaration
+  type: (qualified_identifier) @type-binding.type
+  declarator: (field_identifier) @type-binding.name) @type-binding.field
+
+;; Qualified field, pointer: ns::Address* addr; std::unique_ptr<Repo>* repo;
+(field_declaration
+  type: (qualified_identifier) @type-binding.type
+  declarator: (pointer_declarator
+    declarator: (field_identifier) @type-binding.name)) @type-binding.field
+
+;; Qualified field, reference: ns::Address& addr; std::vector<Item>& items;
+(field_declaration
+  type: (qualified_identifier) @type-binding.type
+  declarator: (reference_declarator
+    (field_identifier) @type-binding.name)) @type-binding.field
+
 ;; ─── References — constructor calls (new Foo()) ─────────────────────
 (new_expression
   type: (type_identifier) @reference.name) @reference.call.constructor

package/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -1,6 +1,7 @@
 import { findClassBindingInScope, findEnclosingClassDef, } from '../../scope-resolution/scope/walkers.js';
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { populateClassOwnedMembers, tagNamespacePrefixes, } from '../../scope-resolution/scope/walkers.js';
+import { extractElementTypeFromString } from '../../type-extractors/shared.js';
 import { cppProvider } from '../c-cpp.js';
 import { cppArityCompatibility } from './arity.js';
 import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
@@ -16,6 +17,12 @@ import { populateCppRangeBindings } from './range-bindings.js';
 import { cppConstraintCompatibility } from './constraint-filter.js';
 import { clearCppUserDefinedConversions, populateCppUserDefinedConversions, } from './user-defined-conversions.js';
 import { buildCppMemberLookupMro, clearCppMemberLookupState, resolveCppReceiverMember, } from './member-lookup.js';
+import { stripCppSpecifiers } from './interpret.js';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
+/** A pointee worth binding: a bare identifier, not `T**`, `T[]`, `A::B` or a
+ *  template spelling. Hoisted — a literal here would mint a fresh RegExp on
+ *  every subscript the resolver folds. */
+const CPP_SIMPLE_POINTEE_RE = /^[A-Za-z_]\w*$/;
 /**
  * Per-pass memo of the augmented `#include`-resolution file set
  * (`allFilePaths` ∪ header paths), keyed on the two stable source sets.
@@ -23,26 +30,24 @@ import { buildCppMemberLookupMro, clearCppMemberLookupState, resolveCppReceiverM
  * a fresh ~F-entry `Set` on every call AND defeated the shared
  * `resolveCImportTarget` suffix-index memo (in `c/import-target.ts`) by handing
  * it a new set identity each time. Both inputs are stable per pass, so the
- * union is built once and reused. `WeakMap`-keyed → reclaimed with the pass.
- * (Twin of the C resolver's `augmentedFilePaths`.)
+ * union is built once and reused. Reclaimed with the pass.
+ *
+ * Two inputs, so two levels of `perFileSet` composed rather than a second
+ * primitive: the outer memo's value is the inner memo, and a function is an
+ * object, which is all `T extends object` asks for.
+ *
+ * (Twin of the C resolver's `augmentedFilePathsFor`.) The two memos stay
+ * SEPARATE deliberately. C++ delegates to `resolveCImportTarget`, whose
+ * `suffixIndex` memo is keyed on the augmented set, so a single memo shared
+ * with C would hand each language the other's index — same
+ * builder-shared/memo-separate rule as `import-resolvers/pass-cache.ts`.
  */
-const augmentedPathsByPass = new WeakMap();
-function augmentedFilePaths(allFilePaths, headerPaths) {
-    let byHeaders = augmentedPathsByPass.get(allFilePaths);
-    if (byHeaders === undefined) {
-        byHeaders = new WeakMap();
-        augmentedPathsByPass.set(allFilePaths, byHeaders);
-    }
-    let augmented = byHeaders.get(headerPaths);
-    if (augmented === undefined) {
-        const set = new Set(allFilePaths);
-        for (const h of headerPaths)
-            set.add(h);
-        augmented = set;
-        byHeaders.set(headerPaths, augmented);
-    }
-    return augmented;
-}
+const augmentedFilePathsFor = perFileSet((allFilePaths) => perFileSet((headerPaths) => {
+    const set = new Set(allFilePaths);
+    for (const h of headerPaths)
+        set.add(h);
+    return set;
+}));
 /**
  * C++ `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -78,7 +83,7 @@ export const cppScopeResolver = {
         // detection but are importable from .cpp files via #include.
         const headerPaths = resolutionConfig;
         if (headerPaths !== undefined && headerPaths.size > 0) {
-            return resolveCppImportTarget(targetRaw, fromFile, augmentedFilePaths(allFilePaths, headerPaths));
+            return resolveCppImportTarget(targetRaw, fromFile, augmentedFilePathsFor(allFilePaths)(headerPaths));
         }
         return resolveCppImportTarget(targetRaw, fromFile, allFilePaths);
     },
@@ -195,6 +200,29 @@ export const cppScopeResolver = {
         const mro = scopes.methodDispatch.mroFor(enclosing.nodeId);
         return mro.includes(lhsDef.nodeId);
     },
+    // Subscript route only — C++ collection views are method calls.
+    //
+    // Two container spellings reach a subscript. A POINTER is one of them: `p[i]`
+    // on a `User*` is pointer arithmetic yielding a `User`, so the trailing `*` is
+    // peeled here rather than by `stripTypePreservingDecoration` (C++ declares
+    // none) — and peeling it at a bare class lookup instead would be wrong, since
+    // that is the route by which `p->m()` must keep seeing `User`'s own members.
+    // The other is a template container (`std::vector<User>`), left to the shared
+    // extractor.
+    //
+    // Fed the annotation AS WRITTEN, since `normalizeCppTypeName` strips both the
+    // star and the array brackets at capture. `undefined` = "not a container", so
+    // an `operator[]`-bearing class does not fold `grid[0]` onto `Grid`.
+    elementTypeOf: (containerType, via) => {
+        if (via.kind !== 'index')
+            return undefined;
+        const t = stripCppSpecifiers(containerType);
+        if (t.endsWith('*')) {
+            const pointee = t.slice(0, -1).trim();
+            return CPP_SIMPLE_POINTEE_RE.test(pointee) ? pointee : undefined;
+        }
+        return extractElementTypeFromString(t);
+    },
     // C++ is statically typed — disable field fallback heuristic
     fieldFallbackOnMethodLookup: false,
     // C++ needs return type propagation across #include boundaries

package/dist/core/ingestion/languages/csharp/accessor-unwrap.d.ts

@@ -1,21 +1,8 @@
-/**
- * C# collection-accessor unwrapping.
- *
- * When the compound-receiver resolver encounters a trailing
- * `.Values` / `.Keys` on a dotted member-access chain, it calls the
- * provider's `unwrapCollectionAccessor` hook to find the element
- * type. This module supplies the C# implementation — recognizing
- * Dictionary-family generics and returning the value or key type.
- *
- * Other languages (Python, Java, TypeScript) use method-call syntax
- * for the same access (`.values()` / `.keys()`), which the compound-
- * receiver's call-expression branch already handles; they leave this
- * hook undefined.
- */
+import type { ElementAccessRoute } from '../../scope-resolution/contract/scope-resolver.js';
 /**
  * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
  * to its element-type simple name. Returns `undefined` for any
  * receiver / accessor combination we don't recognize, letting the
  * compound-receiver pass fall through to the regular field walk.
  */
-export declare function unwrapCsharpCollectionAccessor(receiverType: string, accessor: string): string | undefined;
+export declare function unwrapCsharpElementType(containerType: string, via: ElementAccessRoute): string | undefined;

package/dist/core/ingestion/languages/csharp/accessor-unwrap.js

@@ -1,16 +1,16 @@
+import { extractElementTypeFromString } from '../../type-extractors/shared.js';
 /**
- * C# collection-accessor unwrapping.
+ * C# container element-type unwrapping.
  *
  * When the compound-receiver resolver encounters a trailing
  * `.Values` / `.Keys` on a dotted member-access chain, it calls the
- * provider's `unwrapCollectionAccessor` hook to find the element
+ * provider's `elementTypeOf` hook to find the element
  * type. This module supplies the C# implementation — recognizing
  * Dictionary-family generics and returning the value or key type.
  *
- * Other languages (Python, Java, TypeScript) use method-call syntax
- * for the same access (`.values()` / `.keys()`), which the compound-
- * receiver's call-expression branch already handles; they leave this
- * hook undefined.
+ * Other languages (Python, Java, TypeScript) use method-call syntax for the
+ * same access (`.values()` / `.keys()`), which the compound-receiver's
+ * call-expression branch already handles; they answer only the `index` route.
  */
 /** Extract (K, V) from `Dictionary<K, V>` / `IDictionary<K, V>` /
  *  `IReadOnlyDictionary<K, V>` / `SortedDictionary<K, V>` /
@@ -46,11 +46,19 @@ function extractDictionaryArgs(rawName) {
  * receiver / accessor combination we don't recognize, letting the
  * compound-receiver pass fall through to the regular field walk.
  */
-export function unwrapCsharpCollectionAccessor(receiverType, accessor) {
-    if (accessor !== 'Values' && accessor !== 'Keys')
+export function unwrapCsharpElementType(containerType, via) {
+    const args = extractDictionaryArgs(containerType);
+    // Subscript on a dictionary yields the VALUE type — `dict["k"]` is a V, never
+    // a K. Previously this route returned nothing at all for C#, because the
+    // dictionary parse below was reachable only from the accessor hook.
+    if (via.kind === 'index') {
+        if (args !== undefined)
+            return args.value;
+        return extractElementTypeFromString(containerType);
+    }
+    if (via.name !== 'Values' && via.name !== 'Keys')
         return undefined;
-    const args = extractDictionaryArgs(receiverType);
     if (args === undefined)
         return undefined;
-    return accessor === 'Values' ? args.value : args.key;
+    return via.name === 'Values' ? args.value : args.key;
 }

package/dist/core/ingestion/languages/csharp/captures.js

@@ -24,6 +24,7 @@ import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = [
     '@declaration.method',
@@ -143,6 +144,12 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
             }
             // Defensive fallback: emit the raw match so the extractor at
             // least sees an anchor, even without markers.
+            // Structural receiver chain for a call whose receiver is itself an
+            // expression, so resolution can type it by folding over structure
+            // instead of re-parsing the receiver's source text. Self-gating: a
+            // non-call match, an absent receiver, or a chain with no nameable base
+            // all leave `grouped` untouched.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             continue;
         }
@@ -159,6 +166,12 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         // the AST in code. Mirrors Python's `self`/`cls` synthesis on
         // `@scope.function` matches.
         if (grouped['@scope.function'] !== undefined) {
+            // Structural receiver chain for a call whose receiver is itself an
+            // expression, so resolution can type it by folding over structure
+            // instead of re-parsing the receiver's source text. Self-gating: a
+            // non-call match, an absent receiver, or a chain with no nameable base
+            // all leave `grouped` untouched.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             const fnNode = nodeIfType(nodeMap['@scope.function'], ...FUNCTION_NODE_TYPES);
             if (fnNode !== null) {
@@ -231,6 +244,12 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(argTypes));
             }
         }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
         out.push(grouped);
         // Synthesize primary-constructor declarations on class/record
         // declarations that carry a `parameter_list` child (C# 12 syntax

package/dist/core/ingestion/languages/csharp/import-target.js

@@ -19,22 +19,17 @@
  * `linkStatus: 'unresolved'`.
  */
 import { resolveCSharpImportInternal } from '../../import-resolvers/csharp.js';
-import { buildSuffixIndex } from '../../import-resolvers/utils.js';
+import { getWorkspaceFileIndex, } from '../../import-resolvers/workspace-file-index.js';
+import { buildPackageDirIndex, firstFileDirectlyInPkgDir, } from '../../import-resolvers/package-dir-index.js';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 import { csharpSuffixFallbackAllowed } from '../../csharp-namespace-gate.js';
-// Memoize on Set identity: the orchestrator passes the SAME `allFilePaths`
-// Set through every `resolveImportTarget` call in a pass, so this rebuilds
-// the normalized list + suffix index once instead of once per import (#1881 #2).
-const workspaceFileIndexCache = new WeakMap();
-function getWorkspaceFileIndex(allFilePaths) {
-    const cached = workspaceFileIndexCache.get(allFilePaths);
-    if (cached)
-        return cached;
-    const all = [...allFilePaths];
-    const normalized = all.map((f) => f.replace(/\\/g, '/'));
-    const built = { normalized, all, index: buildSuffixIndex(normalized, all) };
-    workspaceFileIndexCache.set(allFilePaths, built);
-    return built;
-}
+/**
+ * Namespace-directory index over the `.cs` files, memoized on the Set's
+ * identity. Feeds `firstFileDirectlyInPkgDir` (in
+ * `import-resolvers/package-dir-index.ts`), which the no-csproj path calls once
+ * for the direct match and then up to once per stripped namespace prefix.
+ */
+const getCsharpDirIndex = perFileSet((allFilePaths) => buildPackageDirIndex(allFilePaths, (normalized) => normalized.endsWith('.cs')));
 export function resolveCsharpImportTarget(parsedImport, workspaceIndex) {
     const ctx = narrowContext(workspaceIndex);
     if (ctx === null)
@@ -47,8 +42,8 @@ export function resolveCsharpImportTarget(parsedImport, workspaceIndex) {
     const evidence = ctx.namespaces;
     const csharpConfigs = ctx.csharpConfigs ?? [];
     if (csharpConfigs.length > 0) {
-        const { normalized, all, index } = getWorkspaceFileIndex(ctx.allFilePaths);
-        const fromCsproj = resolveCSharpImportInternal(targetRaw, [...csharpConfigs], normalized, all, index, evidence);
+        const { index } = getWorkspaceFileIndex(ctx.allFilePaths);
+        const fromCsproj = resolveCSharpImportInternal(targetRaw, [...csharpConfigs], ctx.allFilePaths, index, evidence);
         if (fromCsproj.length > 0)
             return fromCsproj[0];
         // csproj configs are authoritative: mirror legacy `configs/csharp.ts`,
@@ -72,12 +67,19 @@ export function resolveCsharpImportTarget(parsedImport, workspaceIndex) {
         return null;
     }
     // Exact file / nested-suffix / namespace-dir direct-child match.
-    const direct = resolveDirectMatch(ctx.allFilePaths, pathLike);
+    //
+    // The no-csproj path used to take the raw Set and re-scan it — up to eight
+    // full workspace passes for a four-segment `using` — past the memoized index
+    // sitting right there for the csproj branch (#2878). Both legs now read the
+    // same per-run indexes.
+    const ws = getWorkspaceFileIndex(ctx.allFilePaths);
+    const dirs = getCsharpDirIndex(ctx.allFilePaths);
+    const direct = resolveDirectMatch(ws, dirs, pathLike);
     if (direct !== null)
         return direct;
     // Progressive prefix stripping — mirrors csproj's root-namespace mapping
     // without the csproj.
-    return resolveByProgressiveStripping(ctx.allFilePaths, pathLike);
+    return resolveByProgressiveStripping(ws, dirs, pathLike);
 }
 /**
  * `WorkspaceIndex` is an opaque `unknown` placeholder in the shared contract;
@@ -98,46 +100,26 @@ function narrowContext(workspaceIndex) {
  * exact whole-path file > nested suffix file > first `.cs` directly inside
  * the namespace directory.
  */
-function resolveDirectMatch(allFilePaths, pathLike) {
+function resolveDirectMatch(ws, dirs, pathLike) {
     const exactName = `${pathLike}.cs`;
-    const nestedSuffix = `/${exactName}`;
-    let suffixFile = null;
-    for (const raw of allFilePaths) {
-        const f = raw.replace(/\\/g, '/');
-        if (!f.endsWith('.cs'))
-            continue;
-        if (f === exactName)
-            return raw; // exact whole-path match wins
-        if (suffixFile === null && f.endsWith(nestedSuffix))
-            suffixFile = raw;
-    }
-    if (suffixFile !== null)
+    // An exact whole-path match wins even when a `…/<exactName>` suffix match
+    // appeared EARLIER in iteration order, so the two lookups stay separate:
+    // `index.get` conflates them and would return the earlier suffix hit.
+    const exact = ws.normToRaw.get(exactName);
+    if (exact !== undefined)
+        return exact;
+    // No whole-path file exists, so every segment-suffix hit is a `/<exactName>`
+    // match and `index.get` yields the first one in iteration order — exactly the
+    // `suffixFile` the scan kept. Only a `.cs` file can carry a `.cs` suffix key,
+    // so the old `endsWith('.cs')` filter is implied.
+    const suffixFile = ws.index.get(exactName);
+    if (suffixFile !== undefined)
         return suffixFile;
-    return findDirectChild(allFilePaths, pathLike);
-}
-/**
- * First `.cs` file that lives directly inside the namespace directory
- * `dirSegment` (at repo root or nested under a project prefix), not deeper.
- * The legacy resolver emits all of them; the scope-resolver contract is
- * single-target so we take one.
- */
-function findDirectChild(allFilePaths, dirSegment) {
-    const dirPrefix = `${dirSegment}/`;
-    const nestedDirPrefix = `/${dirPrefix}`;
-    for (const raw of allFilePaths) {
-        const f = raw.replace(/\\/g, '/');
-        if (!f.endsWith('.cs'))
-            continue;
-        const atRoot = f.startsWith(dirPrefix);
-        const atNested = f.includes(nestedDirPrefix);
-        if (!atRoot && !atNested)
-            continue;
-        const idx = atRoot ? 0 : f.indexOf(nestedDirPrefix) + 1;
-        const after = f.slice(idx + dirPrefix.length);
-        if (after.length > 0 && !after.includes('/'))
-            return raw;
-    }
-    return null;
+    // First `.cs` file living directly inside the namespace directory `pathLike`
+    // (at repo root or nested under a project prefix), not deeper. The legacy
+    // resolver emits all of them; the scope-resolver contract is single-target so
+    // we take one.
+    return firstFileDirectlyInPkgDir(dirs, pathLike);
 }
 /**
  * Try each suffix of the namespace path against `.cs` files and directories,
@@ -145,27 +127,19 @@ function findDirectChild(allFilePaths, dirSegment) {
  * resolving to `Models/User.cs` in a repo laid out without the `CrossFile/`
  * prefix (the scope-resolver layer has no csproj to consult).
  */
-function resolveByProgressiveStripping(allFilePaths, pathLike) {
+function resolveByProgressiveStripping(ws, dirs, pathLike) {
     const segments = pathLike.split('/').filter(Boolean);
     for (let skip = 1; skip < segments.length; skip++) {
         const tail = segments.slice(skip).join('/');
         if (tail === '')
             continue;
-        const tailFile = `${tail}.cs`;
-        const tailSuffix = `/${tailFile}`;
-        let tailFileMatch = null;
-        for (const raw of allFilePaths) {
-            const f = raw.replace(/\\/g, '/');
-            if (!f.endsWith('.cs'))
-                continue;
-            if (f === tailFile || f.endsWith(tailSuffix)) {
-                tailFileMatch = raw;
-                break;
-            }
-        }
-        if (tailFileMatch !== null)
+        // `f === tailFile || f.endsWith('/' + tailFile)`, first in iteration order —
+        // no exact-wins rule here, unlike `resolveDirectMatch`, so the conflated
+        // suffix lookup is the right one.
+        const tailFileMatch = ws.index.get(`${tail}.cs`);
+        if (tailFileMatch !== undefined)
             return tailFileMatch;
-        const child = findDirectChild(allFilePaths, tail);
+        const child = firstFileDirectlyInPkgDir(dirs, tail);
         if (child !== null)
             return child;
     }

package/dist/core/ingestion/languages/csharp/namespace-siblings.js

@@ -545,7 +545,11 @@ export function populateCsharpNamespaceSiblings(parsedFiles, indexes, inputs) {
                 if (seen.has(memberDef.nodeId))
                     continue;
                 seen.add(memberDef.nodeId);
-                bucketArr.push({ def: memberDef, origin: 'import' });
+                bucketArr.push({
+                    def: memberDef,
+                    origin: 'import',
+                    visibility: 'static-member-import',
+                });
             }
         }
     }

package/dist/core/ingestion/languages/csharp/query.js

@@ -61,24 +61,44 @@ const CSHARP_SCOPE_QUERY = `
 ;; Anonymous methods / lambdas are not scoped — out of scope per plan.
 
 ;; Declarations — types
+;; The parameter list is matched as an UNNAMED optional child, not through a
+;; \`type_parameters:\` field: the C# grammar gives \`interface_declaration\` that
+;; field but \`class_declaration\` / \`struct_declaration\` / \`record_declaration\`
+;; only a bare \`type_parameter_list\` child, so the field form would silently
+;; capture nothing on exactly the three most common declarations. The unnamed
+;; form matches all four.
+;;
+;; A \`where T : IRepo\` constraint is a SEPARATE sibling clause
+;; (\`type_parameter_constraints_clause\`) and is deliberately not read here — the
+;; bound stays absent for C#, which reads as "unknown", the safe direction.
 (class_declaration
-  name: (identifier) @declaration.name) @declaration.class
+  name: (identifier) @declaration.name
+  (type_parameter_list)? @declaration.type-parameters) @declaration.class
 
 (interface_declaration
-  name: (identifier) @declaration.name) @declaration.interface
+  name: (identifier) @declaration.name
+  (type_parameter_list)? @declaration.type-parameters) @declaration.interface
 
 (struct_declaration
-  name: (identifier) @declaration.name) @declaration.struct
+  name: (identifier) @declaration.name
+  (type_parameter_list)? @declaration.type-parameters) @declaration.struct
 
 (record_declaration
-  name: (identifier) @declaration.name) @declaration.record
+  name: (identifier) @declaration.name
+  (type_parameter_list)? @declaration.type-parameters) @declaration.record
 
 (enum_declaration
   name: (identifier) @declaration.name) @declaration.enum
 
 ;; Declarations — methods / constructors / properties
+;;
+;; A generic METHOD's parameters are read for the same reason a generic type's
+;; are (#2912 review): \`void Run<T>(IValidator<T> v)\` writes a receiver whose
+;; argument is a type VARIABLE, and a pass that cannot tell that from a concrete
+;; type prunes every implementor of \`IValidator\` from the call's fan-out.
 (method_declaration
-  name: (identifier) @declaration.name) @declaration.method
+  name: (identifier) @declaration.name
+  (type_parameter_list)? @declaration.type-parameters) @declaration.method
 
 (constructor_declaration
   name: (identifier) @declaration.name) @declaration.constructor