gitnexus 1.6.3-rc.8 → 1.6.3

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

@@ -0,0 +1,82 @@
+/**
+ * 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.
+ *
+ * Shadow-harness corpus parity is the authoritative signal for which
+ * of these matter in practice. The CI parity gate blocks any PR that
+ * regresses either the legacy or registry-primary run of
+ * `test/integration/resolvers/csharp.test.ts`.
+ */
+export { emitCsharpScopeCaptures } from './captures.js';
+export { getCsharpCaptureCacheStats, resetCsharpCaptureCacheStats } from './cache-stats.js';
+export { interpretCsharpImport, interpretCsharpTypeBinding } from './interpret.js';
+export { csharpMergeBindings } from './merge-bindings.js';
+export { csharpArityCompatibility } from './arity.js';
+export { resolveCsharpImportTarget } from './import-target.js';
+export { csharpBindingScopeFor, csharpImportOwningScope, csharpReceiverBinding, } from './simple-hooks.js';

package/dist/core/ingestion/languages/csharp/interpret.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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`.
+ */
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
+export declare function interpretCsharpImport(captures: CaptureMatch): ParsedImport | null;
+export declare function interpretCsharpTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;

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

@@ -0,0 +1,132 @@
+/**
+ * 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`.
+ */
+// ─── interpretImport ──────────────────────────────────────────────────────
+export 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 ─────────────────────────────────────────────────
+export 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) {
+    const lastDot = text.lastIndexOf('.');
+    if (lastDot === -1)
+        return text;
+    const tail = text.slice(lastDot + 1);
+    if (COLLECTION_ACCESSOR_SUFFIXES.has(tail))
+        return text;
+    return tail;
+}

package/dist/core/ingestion/languages/csharp/merge-bindings.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+import type { BindingRef } from '../../../../_shared/index.js';
+export declare function csharpMergeBindings(bindings: readonly BindingRef[]): readonly BindingRef[];

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

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+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;
+    }
+}
+export 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()];
+}

package/dist/core/ingestion/languages/csharp/namespace-siblings.d.ts

@@ -0,0 +1,50 @@
+/**
+ * C# same-namespace cross-file visibility.
+ *
+ * C# makes every type declared in `namespace X` visible to every other
+ * file that also declares `namespace X`, without any explicit `using`
+ * directive. Python has no equivalent — every cross-file reference
+ * needs an explicit import — so this is a C#-specific pass.
+ *
+ * Without this: `Service.cs` (namespace `FieldTypes`) can't see
+ * `User` declared in `Models.cs` (same namespace), so `user.Address`
+ * field-chain resolution fails at `findClassBindingInScope('User')`
+ * in the Service.cs scope chain.
+ *
+ * Implementation: after the finalize pass populates `indexes.bindings`
+ * (from explicit `using` directives), walk each file's tree-sitter
+ * AST for `namespace_declaration` / `file_scoped_namespace_declaration`
+ * and `using_directive` nodes. The orchestrator hands us its
+ * `treeCache` so files already parsed by `extractParsedFile` are
+ * re-used instead of re-parsed — `ParsedFile`'s underlying tree is
+ * the single source of truth. Group classes by namespace, and inject
+ * cross-file sibling classes into each Namespace scope's finalized
+ * bindings with `origin: 'namespace'` — a tier below `local` so a
+ * local declaration still shadows a cross-file sibling with the same
+ * name.
+ *
+ * The tree-sitter walk is authoritative: it sees `global using static`,
+ * aliased `using static X = Y.Z;`, attributed namespace declarations,
+ * and preprocessor-guarded declarations correctly because the
+ * tree-sitter grammar parses them as real nodes (not textual
+ * coincidences).
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+/** Content + (optional) pre-parsed tree-sitter trees keyed by filePath.
+ *  The orchestrator builds `fileContents` from the pipeline's file list;
+ *  `treeCache` is the same `scopeTreeCache` already populated by the
+ *  parse phase, so cache hits avoid a second `parser.parse()`. */
+export interface CsharpSiblingInputs {
+    readonly fileContents: ReadonlyMap<string, string>;
+    readonly treeCache?: {
+        get(filePath: string): unknown;
+    };
+}
+/**
+ * Mutate `indexes.bindings` in-place, adding cross-file sibling class
+ * defs to each Namespace scope. Class-like defs (Class / Interface /
+ * Struct / Record / Enum) are visible cross-file; method / field
+ * members are not.
+ */
+export declare function populateCsharpNamespaceSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, inputs: CsharpSiblingInputs): void;