cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/csharp/import-decomposer.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Decompose a C# `using_directive` into a `CaptureMatch` carrying the
+ * synthesized markers `@import.kind` / `@import.source` / `@import.name`
+ * / `@import.alias` that `interpretCsharpImport` consumes.
+ *
+ * Unlike Python's decomposer this is 1:1 — each `using` produces exactly
+ * one import. The split layer exists to expose the kind (namespace vs
+ * alias vs static) without pushing raw-text parsing into `interpret.ts`.
+ *
+ *   using System;                           → namespace
+ *   using System.Collections.Generic;       → namespace
+ *   using Foo = System.Bar;                 → alias
+ *   using static System.Math;               → static
+ *   global using System.IO;                 → namespace (treated as file-scoped)
+ *   using global::System.IO;                → namespace (global:: alias stripped)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitUsingDirective = splitUsingDirective;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+function splitUsingDirective(stmtNode) {
+    if (stmtNode.type !== 'using_directive')
+        return null;
+    const spec = parseUsingDirective(stmtNode);
+    if (spec === null)
+        return null;
+    return buildImportMatch(stmtNode, spec);
+}
+function parseUsingDirective(node) {
+    // tree-sitter-c-sharp's using_directive exposes named children
+    // corresponding to the parts of the directive but omits keyword tokens
+    // (`using`, `static`, `global`) from the named-child list. We inspect
+    // the raw source text to detect the flavor — the grammar doesn't give
+    // us a cleaner signal.
+    const raw = node.text;
+    // Named child layout:
+    //   namespace form:  [pathNode]
+    //   alias form:      [aliasIdNode, pathNode]         (name field = aliasId)
+    //   static form:     [pathNode]                      (same as namespace)
+    //   global using:    [pathNode]                      (same as namespace)
+    const aliasField = node.childForFieldName('name');
+    const children = node.namedChildren;
+    if (children.length === 0)
+        return null;
+    // Alias form — the `name:` field is the alias identifier; the
+    // remaining named child is the type/namespace path.
+    if (aliasField !== null) {
+        const pathNode = children.find((c) => c !== null && c.startIndex !== aliasField.startIndex);
+        if (pathNode === undefined)
+            return null;
+        return {
+            kind: 'alias',
+            source: stripGenericArgs(unwrapGlobalAlias(pathNode.text)),
+            name: aliasField.text,
+            alias: aliasField.text,
+            atNode: node,
+        };
+    }
+    const pathNode = children[0];
+    if (pathNode === null)
+        return null;
+    const source = stripGenericArgs(unwrapGlobalAlias(pathNode.text));
+    if (source === '')
+        return null;
+    const lastSegment = source.split('.').pop() ?? source;
+    // `using static X.Y;` — detect by scanning the raw text before the path.
+    // `global using` behaves semantically as a file-scoped using for our
+    // purposes, so it isn't a separate kind here.
+    if (/^\s*(?:global\s+)?using\s+static\s/.test(raw)) {
+        return { kind: 'static', source, name: '*', atNode: node };
+    }
+    return { kind: 'namespace', source, name: lastSegment, atNode: node };
+}
+/** Strip `global::` prefix — `global::System.IO` → `System.IO`. */
+function unwrapGlobalAlias(text) {
+    return text.replace(/^global::/, '');
+}
+/** Strip generic type arguments — `Dictionary<string, int>` → `Dictionary`. */
+function stripGenericArgs(text) {
+    const lt = text.indexOf('<');
+    if (lt === -1)
+        return text;
+    return text.slice(0, lt);
+}
+function buildImportMatch(stmtNode, spec) {
+    const m = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', stmtNode),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', spec.atNode, spec.kind),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', spec.atNode, spec.source),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', spec.atNode, spec.name),
+    };
+    if (spec.alias !== undefined) {
+        m['@import.alias'] = (0, ast_helpers_js_1.syntheticCapture)('@import.alias', spec.atNode, spec.alias);
+    }
+    return m;
+}

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

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Adapter from `(ParsedImport, WorkspaceIndex)` → concrete file path.
+ *
+ * Unit 2 shape: suffix-match against the repo's `.cs` files. Each
+ * `using System.Collections.Generic;` could legally expand to multiple
+ * files (every `.cs` that declares `namespace System.Collections.Generic`
+ * — partial classes, assembly-wide namespaces). The scope-resolver
+ * contract returns a single primary target, so we pick the first
+ * match. Cross-file partial-class aggregation runs at graph-bridge
+ * time (Unit 6) via `populateOwners`.
+ *
+ * When `.csproj` configs are available, consults the legacy
+ * namespace-directory resolver first. Both that resolver's suffix
+ * fallback and the progressive prefix stripping below are gated on
+ * declared in-repo namespaces so BCL usings like `System.Threading.Tasks`
+ * cannot spuriously match a local `Tasks.cs` (#1881).
+ *
+ * Returning `null` lets the finalize algorithm mark the edge as
+ * `linkStatus: 'unresolved'`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCsharpImportTarget = resolveCsharpImportTarget;
+const csharp_js_1 = require("../../import-resolvers/csharp.js");
+const utils_js_1 = require("../../import-resolvers/utils.js");
+const csharp_namespace_gate_js_1 = require("../../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: (0, utils_js_1.buildSuffixIndex)(normalized, all) };
+    workspaceFileIndexCache.set(allFilePaths, built);
+    return built;
+}
+function resolveCsharpImportTarget(parsedImport, workspaceIndex) {
+    const ctx = narrowContext(workspaceIndex);
+    if (ctx === null)
+        return null;
+    if (parsedImport.kind === 'dynamic-unresolved')
+        return null;
+    if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
+        return null;
+    const targetRaw = parsedImport.targetRaw;
+    const evidence = ctx.namespaces;
+    const csharpConfigs = ctx.csharpConfigs ?? [];
+    if (csharpConfigs.length > 0) {
+        const { normalized, all, index } = getWorkspaceFileIndex(ctx.allFilePaths);
+        const fromCsproj = (0, csharp_js_1.resolveCSharpImportInternal)(targetRaw, [...csharpConfigs], normalized, all, index, evidence);
+        if (fromCsproj.length > 0)
+            return fromCsproj[0];
+        // csproj configs are authoritative: mirror legacy `configs/csharp.ts`,
+        // which returns an empty result to STOP the chain. Falling through to the
+        // ungated `resolveDirectMatch` would re-introduce the BCL→local match the
+        // internal resolver's gate just suppressed (#1881 parity, #2).
+        return null;
+    }
+    // Namespace path: `System.Collections.Generic` → `System/Collections/Generic`.
+    const pathLike = targetRaw.replace(/\./g, '/');
+    // Gate the WHOLE no-csproj path on declared in-repo namespaces — the direct
+    // path/suffix match INCLUDED — so a BCL using can't resolve to a
+    // coincidentally path-aligned local file (e.g. `Legacy/System/Threading/
+    // Tasks.cs` satisfying `using System.Threading.Tasks;`). Running the gate
+    // before `resolveDirectMatch` mirrors the legacy leg's gate-first ordering
+    // (`import-resolvers/configs/csharp.ts`), so the two legs are equivalent
+    // (#1881 parity, Codex F2). The gate keeps its fail-open for
+    // undefined/truncated evidence, so legitimate edges in unscanned repos are
+    // unaffected.
+    if (!(0, csharp_namespace_gate_js_1.csharpSuffixFallbackAllowed)(targetRaw, evidence)) {
+        return null;
+    }
+    // Exact file / nested-suffix / namespace-dir direct-child match.
+    const direct = resolveDirectMatch(ctx.allFilePaths, pathLike);
+    if (direct !== null)
+        return direct;
+    // Progressive prefix stripping — mirrors csproj's root-namespace mapping
+    // without the csproj.
+    return resolveByProgressiveStripping(ctx.allFilePaths, pathLike);
+}
+/**
+ * `WorkspaceIndex` is an opaque `unknown` placeholder in the shared contract;
+ * the orchestrator hands us a `CsharpResolveContext`-shaped object. Narrow
+ * structurally rather than via a cast chain so unexpected shapes fail cleanly.
+ */
+function narrowContext(workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    return ctx;
+}
+/**
+ * First-pass resolution against the full namespace path:
+ * exact whole-path file > nested suffix file > first `.cs` directly inside
+ * the namespace directory.
+ */
+function resolveDirectMatch(allFilePaths, 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)
+        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;
+}
+/**
+ * Try each suffix of the namespace path against `.cs` files and directories,
+ * stripping leading segments one at a time. Models `using CrossFile.Models;`
+ * 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) {
+    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)
+            return tailFileMatch;
+        const child = findDirectChild(allFilePaths, tail);
+        if (child !== null)
+            return child;
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/csharp/index.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * C# scope-resolution hooks (RFC #909 Ring 3, RFC §5).
+ *
+ * Public API barrel. Consumers should import from this file rather than
+ * the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`               — tree-sitter query + lazy parser/query singletons
+ *   - `captures.ts`            — `emitCsharpScopeCaptures` orchestrator
+ *   - `import-decomposer.ts`   — each `using` → ParsedImport-shaped captures
+ *   - `interpret.ts`           — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `simple-hooks.ts`        — small/no-op hooks made explicit
+ *   - `receiver-binding.ts`    — synthesize `this`/`base` type-bindings on
+ *                                instance-method entry
+ *   - `merge-bindings.ts`      — C# `using` precedence
+ *   - `arity.ts`               — C# arity compatibility (`params`, default values)
+ *   - `arity-metadata.ts`      — synthesize arity metadata from declarations
+ *   - `accessor-unwrap.ts`     — `.Values` / `.Keys` receiver-type unwrap for
+ *                                `Dictionary<K,V>` chains
+ *   - `namespace-siblings.ts`  — AST-driven cross-file implicit-namespace
+ *                                visibility (file/namespace attribution, no
+ *                                regex; reuses orchestrator's treeCache)
+ *   - `import-target.ts`       — `(ParsedImport, WorkspaceIndex) → file path` adapter
+ *   - `scope-resolver.ts`      — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`         — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ *
+ * ## Known limitations
+ *
+ * The C# registry-primary path intentionally does NOT resolve the
+ * following. Each is a conscious trade-off at migration time.
+ *
+ *   1. **csproj-driven namespace resolution** — the legacy path
+ *      consults `csharpConfigs` (the parsed .csproj workspace) to map
+ *      `using X.Y;` back to the exact files declaring `namespace X.Y`.
+ *      The scope-resolver contract passes only `allFilePaths`, so we
+ *      fall back to suffix matching on `.cs` files. Unit 7's parity
+ *      gate flags any divergence.
+ *   2. **Multi-file namespace expansion** — a single `using X.Y;` in
+ *      the legacy path can emit multiple IMPORTS edges (every file
+ *      declaring that namespace). The scope-resolver contract returns
+ *      a single target, so we pick the first match; partial-class
+ *      aggregation runs at graph-bridge time.
+ *   3. **Overload resolution by parameter type** — arity narrowing is
+ *      wired (`arity.ts` + `arity-metadata.ts`), but type-based
+ *      disambiguation (`F(int)` vs `F(string)` at a call with a typed
+ *      argument) is left to the registry's type-binding layer.
+ *   4. **Generic type parameter resolution** — `List<User>` binds the
+ *      bound name to `User` via the single-arg-generic stripper;
+ *      nested generics (`Dictionary<K, List<V>>`) fall through the
+ *      receiver-type heuristic.
+ *   5. **`dynamic` typed expressions** — runtime dispatch through
+ *      `dynamic` is not followed.
+ *   6. **Preprocessor-conditional code** — `#if DEBUG` blocks parse
+ *      as usual; branch selection is ignored, so both arms contribute
+ *      bindings.
+ *   7. **Global using propagation across files** — treated as a
+ *      file-scoped using for the declaring file. Unit 7 parity gate
+ *      will flag cases where this matters.
+ *   8. **Expression-bodied `=>` members** — handled by the method
+ *      extractor, but receiver synthesis for `=> this.Field` shortcuts
+ *      follows the same path as block-bodied methods.
+ *   9. **Multi-namespace file attribution** — when a single file
+ *      declares two namespaces (rare), all top-level classes are
+ *      attributed to the first declared namespace via a `first-wins`
+ *      rule in `namespace-siblings.ts`. Namespace detection itself is
+ *      AST-driven (tree-sitter), so `global using static`, aliased
+ *      `using static X = Y.Z;`, attributes, and preprocessor-gated
+ *      declarations are all recognized correctly.
+ *
+ * The `test/integration/resolvers/csharp.test.ts` resolver suite is the
+ * authoritative signal for which of these matter in practice; it runs in
+ * the standard CI test workflow, so a regression blocks the merge.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpReceiverBinding = exports.csharpImportOwningScope = exports.csharpBindingScopeFor = exports.resolveCsharpImportTarget = exports.csharpArityCompatibility = exports.csharpMergeBindings = exports.interpretCsharpTypeBinding = exports.interpretCsharpImport = exports.resetCsharpCaptureCacheStats = exports.getCsharpCaptureCacheStats = exports.emitCsharpScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitCsharpScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitCsharpScopeCaptures; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getCsharpCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getCsharpCaptureCacheStats; } });
+Object.defineProperty(exports, "resetCsharpCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetCsharpCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretCsharpImport", { enumerable: true, get: function () { return interpret_js_1.interpretCsharpImport; } });
+Object.defineProperty(exports, "interpretCsharpTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretCsharpTypeBinding; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "csharpMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.csharpMergeBindings; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "csharpArityCompatibility", { enumerable: true, get: function () { return arity_js_1.csharpArityCompatibility; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveCsharpImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveCsharpImportTarget; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "csharpBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.csharpBindingScopeFor; } });
+Object.defineProperty(exports, "csharpImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.csharpImportOwningScope; } });
+Object.defineProperty(exports, "csharpReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.csharpReceiverBinding; } });

package/dist/core/code/engine/core/ingestion/languages/csharp/interpret.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Capture-match → semantic-shape interpreters for C#.
+ *
+ *   - `interpretCsharpImport`     → `ParsedImport`
+ *   - `interpretCsharpTypeBinding` → `ParsedTypeBinding`
+ *
+ * The using-directive matches arrive pre-decomposed by
+ * `emitCsharpScopeCaptures` (one import per match, with synthesized
+ * `@import.kind/source/name/alias` markers). Type-binding matches arrive
+ * from the raw query captures — each `@type-binding.*` anchor carries
+ * `@type-binding.name` + `@type-binding.type`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretCsharpImport = interpretCsharpImport;
+exports.interpretCsharpTypeBinding = interpretCsharpTypeBinding;
+// ─── interpretImport ──────────────────────────────────────────────────────
+function interpretCsharpImport(captures) {
+    const kindCap = captures['@import.kind'];
+    const sourceCap = captures['@import.source'];
+    const nameCap = captures['@import.name'];
+    const aliasCap = captures['@import.alias'];
+    const kind = kindCap?.text;
+    if (kind === undefined || sourceCap === undefined)
+        return null;
+    switch (kind) {
+        case 'namespace': {
+            // `using System;` / `using System.Collections.Generic;`
+            // Bind the last segment as the local name so `Generic.Foo`-style
+            // qualifier references resolve. Full path is the resolution target.
+            return {
+                kind: 'namespace',
+                localName: nameCap?.text ?? sourceCap.text.split('.').pop() ?? sourceCap.text,
+                importedName: sourceCap.text,
+                targetRaw: sourceCap.text,
+            };
+        }
+        case 'alias': {
+            // `using Dict = System.Collections.Generic.Dictionary<string, int>;`
+            // The decomposer already stripped generic args from source.
+            if (aliasCap === undefined)
+                return null;
+            const importedName = sourceCap.text.split('.').pop() ?? sourceCap.text;
+            return {
+                kind: 'alias',
+                localName: aliasCap.text,
+                importedName,
+                alias: aliasCap.text,
+                targetRaw: sourceCap.text,
+            };
+        }
+        case 'static': {
+            // `using static System.Math;` — brings static members of Math into
+            // unqualified scope. Semantically closest to a wildcard, but we
+            // map to `namespace` here so finalize emits the File→File IMPORTS
+            // edge without requiring `expandsWildcardTo` (which would list
+            // every exported member). Static-member unqualified-access is a
+            // deferred limitation; the usual cross-file lookup via
+            // namespace-siblings covers `Target.Member` calls.
+            const lastSegment = sourceCap.text.split('.').pop() ?? sourceCap.text;
+            return {
+                kind: 'namespace',
+                localName: lastSegment,
+                importedName: sourceCap.text,
+                targetRaw: sourceCap.text,
+            };
+        }
+        default:
+            return null;
+    }
+}
+// ─── interpretTypeBinding ─────────────────────────────────────────────────
+function interpretCsharpTypeBinding(captures) {
+    const nameCap = captures['@type-binding.name'];
+    const typeCap = captures['@type-binding.type'];
+    if (nameCap === undefined || typeCap === undefined)
+        return null;
+    // Strip nullable suffix (`User?` → `User`), single-arg generic wrapper
+    // (`List<User>` → `User`), and qualifier (`System.User` → `User`) so
+    // receiver-typed resolution treats these identically.
+    const rawType = stripQualifier(stripGeneric(stripNullable(typeCap.text.trim())));
+    // Anchor captures distinguish the source of the binding. Order
+    // matters: more-specific anchors take precedence.
+    let source = 'parameter-annotation';
+    if (captures['@type-binding.self'] !== undefined)
+        source = 'self';
+    else if (captures['@type-binding.constructor'] !== undefined)
+        source = 'constructor-inferred';
+    else if (captures['@type-binding.annotation'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.alias'] !== undefined)
+        source = 'assignment-inferred';
+    else if (captures['@type-binding.return'] !== undefined)
+        source = 'return-annotation';
+    return { boundName: nameCap.text, rawTypeName: rawType, source };
+}
+/** Member accesses we want to preserve through qualifier stripping.
+ *  Dictionary/collection views (`data.Values`, `data.Keys`) survive
+ *  so the compound-receiver pass can unwrap the receiver's generic
+ *  type (Dictionary<K,V>) based on the suffix. */
+const COLLECTION_ACCESSOR_SUFFIXES = new Set(['Values', 'Keys']);
+/** `User?` → `User`. */
+function stripNullable(text) {
+    if (text.endsWith('?'))
+        return text.slice(0, -1).trim();
+    return text;
+}
+/**
+ * Unwrap a single-arg generic collection wrapper — `List<User>`,
+ * `IEnumerable<User>`, `Task<User>` — to its element type. Mirrors
+ * Python's `stripGeneric` behavior so for-loop and chain propagation
+ * work on the element type.
+ *
+ * Multi-arg generics (`Dictionary<string, User>`, `Func<int, User>`)
+ * are left alone — element semantics aren't unambiguous.
+ */
+function stripGeneric(text) {
+    const single = text.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:List|IList|IEnumerable|ICollection|IReadOnlyList|IReadOnlyCollection|HashSet|ISet|Task|ValueTask|Nullable|IAsyncEnumerable)<([^,<>]+)>$/);
+    if (single !== null)
+        return single[1].trim();
+    return text;
+}
+/** `System.Collections.User` → `User`. Preserves dotted paths whose
+ *  final segment is a known Dictionary/collection accessor (`.Values`,
+ *  `.Keys`, `.Count`, etc.) so downstream resolvers can unwrap the
+ *  receiver's generic type based on the suffix — `data.Values` →
+ *  element type of `data`'s Dictionary<K,V>. */
+function stripQualifier(text) {
+    // Strip only the outermost qualifier: the last `.` at generic nesting depth 0.
+    // This preserves F41 (never cut inside `Dictionary<string, Ns.User>`) AND
+    // nested types through a generic outer (`Ns.Outer<int>.Inner` → `Inner`, not
+    // `Outer<int>.Inner` — #2046 P3).
+    let depth = 0;
+    let lastDotAtDepth0 = -1;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '<')
+            depth++;
+        else if (c === '>')
+            depth = Math.max(0, depth - 1);
+        else if (c === '.' && depth === 0)
+            lastDotAtDepth0 = i;
+    }
+    if (lastDotAtDepth0 === -1)
+        return text;
+    const tail = text.slice(lastDotAtDepth0 + 1);
+    if (COLLECTION_ACCESSOR_SUFFIXES.has(tail))
+        return text;
+    return tail;
+}

package/dist/core/code/engine/core/ingestion/languages/csharp/merge-bindings.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * C# shadowing precedence for the `mergeBindings` hook.
+ *
+ * Tier ranking (lower wins in shadowing):
+ *
+ *   - 0: `local` — a class member, method, local variable, or parameter
+ *        declared in this scope.
+ *   - 1: `import` / `namespace` / `reexport` — `using System;`,
+ *        `using System.Collections.Generic;`, `using Alias = Foo;`.
+ *        All three using flavors that introduce a name at this scope
+ *        tier together; the compiler resolves ambiguity by requiring
+ *        an explicit qualifier when two `using`s collide, but for
+ *        receiver-typed dispatch we treat them as equivalent tiers.
+ *   - 2: `wildcard` — `using static System.Math;` brings static
+ *        members in; any local or `using` with the same simple name
+ *        shadows.
+ *
+ * Explicit interface implementations (`void IFoo.Bar() { }`) bind under
+ * the qualified name in the extractor layer, so they never collide with
+ * a plain `Bar` at this layer.
+ *
+ * Within a surviving tier we de-dup by `DefId`, last-write-wins so a
+ * `using` re-declared further down the file cleanly replaces the
+ * earlier binding.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpMergeBindings = csharpMergeBindings;
+const TIER_LOCAL = 0;
+const TIER_IMPORT = 1;
+const TIER_WILDCARD = 2;
+const TIER_UNKNOWN = 3;
+function tierOf(b) {
+    switch (b.origin) {
+        case 'local':
+            return TIER_LOCAL;
+        case 'reexport':
+        case 'import':
+        case 'namespace':
+            return TIER_IMPORT;
+        case 'wildcard':
+            return TIER_WILDCARD;
+        default:
+            return TIER_UNKNOWN;
+    }
+}
+function csharpMergeBindings(bindings) {
+    if (bindings.length === 0)
+        return bindings;
+    let bestTier = Number.POSITIVE_INFINITY;
+    for (const b of bindings)
+        bestTier = Math.min(bestTier, tierOf(b));
+    const survivors = bindings.filter((b) => tierOf(b) === bestTier);
+    const seen = new Map();
+    for (const b of survivors)
+        seen.set(b.def.nodeId, b);
+    return [...seen.values()];
+}