gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -15,7 +15,7 @@
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */
-import { findNodeAtRange, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { nodeIfType, nodeToCapture, syntheticCapture, walkNamedTree, } from '../../utils/ast-helpers.js';
 import { splitUsingDirective } from './import-decomposer.js';
 import { computeCsharpArityMetadata } from './arity-metadata.js';
 import { synthesizeCsharpReceiverBinding } from './receiver-binding.js';
@@ -70,10 +70,11 @@ function shouldEmitReadMember(memberNode) {
     }
 }
 export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
-    // Skip the parse when the caller (parse phase's scopeTreeCache)
-    // already produced a Tree for this source. Cache miss = re-parse,
-    // same as before. The cachedTree parameter is typed as `unknown` at
-    // the LanguageProvider contract layer; cast here at the use site.
+    // Reuse a pre-parsed Tree when the caller passes one via `cachedTree`; a
+    // miss re-parses. (The cache is currently always empty — its only producer,
+    // the sequential parser, was removed — so this re-parses in practice.) The
+    // cachedTree parameter is typed `unknown` at the LanguageProvider contract
+    // layer; cast here at the use site.
     let tree = cachedTree;
     if (tree === undefined) {
         tree = parseSourceSafe(getCsharpParser(), sourceText, undefined, {
@@ -91,9 +92,16 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         // `@`; we put it back so the central extractor's prefix lookups
         // (`@scope.`, `@declaration.`, …) work.
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map: the query hands us each matched
+        // node as c.node, so anchors resolve via a type-guarded lookup (nodeIfType)
+        // instead of re-deriving them with findNodeAtRange(tree.rootNode, ...) per
+        // match — the O(matches x rootChildren) root-walk fixed for go #1915 /
+        // python #1918, mirrored here.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
@@ -101,8 +109,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         // the kind/source/name/alias markers it consumes. Raw query match
         // only carries the @import.statement anchor.
         if (grouped['@import.statement'] !== undefined) {
-            const stmtCapture = grouped['@import.statement'];
-            const stmtNode = findNodeAtRange(tree.rootNode, stmtCapture.range, 'using_directive');
+            const stmtNode = nodeIfType(nodeMap['@import.statement'], 'using_directive');
             if (stmtNode !== null) {
                 const decomposed = splitUsingDirective(stmtNode);
                 if (decomposed !== null) {
@@ -116,8 +123,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
             continue;
         }
         if (grouped['@reference.read.member'] !== undefined) {
-            const anchor = grouped['@reference.read.member'];
-            const memberNode = findNodeAtRange(tree.rootNode, anchor.range, 'member_access_expression');
+            const memberNode = nodeIfType(nodeMap['@reference.read.member'], 'member_access_expression');
             if (memberNode === null || !shouldEmitReadMember(memberNode)) {
                 continue;
             }
@@ -130,8 +136,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         // `@scope.function` matches.
         if (grouped['@scope.function'] !== undefined) {
             out.push(grouped);
-            const anchor = grouped['@scope.function'];
-            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            const fnNode = nodeIfType(nodeMap['@scope.function'], ...FUNCTION_NODE_TYPES);
             if (fnNode !== null) {
                 for (const synth of synthesizeCsharpReceiverBinding(fnNode)) {
                     out.push(synth);
@@ -145,8 +150,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         // the first tag that matches.
         const declTag = FUNCTION_DECL_TAGS.find((t) => grouped[t] !== undefined);
         if (declTag !== undefined) {
-            const anchor = grouped[declTag];
-            const fnNode = findFunctionNode(tree.rootNode, anchor.range);
+            const fnNode = nodeIfType(nodeMap[declTag], ...FUNCTION_NODE_TYPES);
             if (fnNode !== null) {
                 const arity = computeCsharpArityMetadata(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -160,6 +164,26 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
                 }
             }
         }
+        // Qualified constructor calls — `new Ns.Foo()`, `new A.B.Foo()`,
+        // `new Ns.Box<int>()` — bind only `@reference.call.constructor.qualified`
+        // with NO `@reference.name`, so the central extractor falls back to the
+        // whole-expression anchor and the reference name becomes the raw
+        // `new Ns.Foo()` text (never resolves). Derive the bare simple-name tail via
+        // the same `terminalTypeNameNode` helper the inheritance synth uses — it
+        // handles qualified_name, a generic tail (`Ns.Box<int>` → `Box`), and
+        // alias_qualified_name (`global::Ns.Foo`). Mirrors Java F35 (#1928).
+        if (grouped['@reference.call.constructor.qualified'] !== undefined &&
+            grouped['@reference.name'] === undefined) {
+            const qNode = nodeMap['@reference.call.constructor.qualified'];
+            const nameNode = qNode === undefined ? null : terminalTypeNameNode(qNode);
+            if (nameNode !== null) {
+                grouped['@reference.name'] = nodeToCapture('@reference.name', nameNode);
+                const qText = qNode.text.trim();
+                if (qText.length > 0 && qText !== nameNode.text) {
+                    grouped['@reference.qualified-name'] = syntheticCapture('@reference.qualified-name', qNode, qText);
+                }
+            }
+        }
         // Synthesize `@reference.arity` on every callsite so the
         // registry's arity filter can narrow overloads. Count the
         // `argument` named children of the backing `argument_list`.
@@ -168,9 +192,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         // resolution.
         const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((t) => grouped[t] !== undefined);
         if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
-            const anchor = grouped[callTag];
-            const callNode = findNodeAtRange(tree.rootNode, anchor.range, 'invocation_expression') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'object_creation_expression');
+            const callNode = nodeIfType(nodeMap[callTag], 'invocation_expression', 'object_creation_expression');
             if (callNode !== null) {
                 const argList = callNode.childForFieldName('arguments');
                 const args = argList === null
@@ -195,9 +217,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         // `new User(...)` resolves to a Constructor def in memberByOwner.
         if (grouped['@declaration.class'] !== undefined ||
             grouped['@declaration.record'] !== undefined) {
-            const anchor = grouped['@declaration.class'] ?? grouped['@declaration.record'];
-            const typeNode = findNodeAtRange(tree.rootNode, anchor.range, 'class_declaration') ??
-                findNodeAtRange(tree.rootNode, anchor.range, 'record_declaration');
+            const typeNode = nodeIfType(nodeMap['@declaration.class'] ?? nodeMap['@declaration.record'], 'class_declaration', 'record_declaration');
             if (typeNode !== null) {
                 const synth = synthesizePrimaryConstructor(typeNode);
                 if (synth !== null)
@@ -206,13 +226,153 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
         }
     }
     out.push(...synthesizeGenericTypeArgumentReferences(tree.rootNode));
+    out.push(...synthesizeCsharpInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCsharpConstructorInitializerReferences(tree.rootNode));
+    return out;
+}
+/**
+ * Synthesize `@reference.call.constructor` captures for C# constructor
+ * initializers — `: base(...)` and `: this(...)` (F38 analog of Java #1928).
+ * tree-sitter-c-sharp models these as `constructor_initializer` nodes the scope
+ * query never matched, so the chained-constructor CALLS edges (derived ctor →
+ * base ctor; ctor → sibling overload) were silently dropped.
+ *
+ * The initializer carries no constructor name (the `base`/`this` child is a bare
+ * keyword token), so the target is resolved structurally:
+ *   - `this(...)` → the enclosing type's own simple name.
+ *   - `base(...)` → the enclosing class/record's base type, reduced to its bare
+ *     simple name via `terminalTypeNameNode`. C# requires the base class first in
+ *     a mixed list (`class C : Base, IFoo`); interface-only lists (`class C : IFoo`)
+ *     imply implicit `System.Object` — no `@reference` is emitted when the first
+ *     non-builtin base would be an interface-only target (resolution also drops
+ *     Interface-typed constructor targets in `free-call-fallback`).
+ * Arity is attached for overload disambiguation, mirroring `new X(...)`.
+ */
+function synthesizeCsharpConstructorInitializerReferences(root) {
+    const out = [];
+    walkNamedTree(root, (node) => {
+        if (node.type !== 'constructor_initializer')
+            return;
+        let kind = null;
+        for (let i = 0; i < node.childCount; i++) {
+            const t = node.child(i)?.type;
+            if (t === 'base' || t === 'this') {
+                kind = t;
+                break;
+            }
+        }
+        if (kind === null)
+            return;
+        const enclosingType = findEnclosingTypeDeclaration(node);
+        if (enclosingType === null)
+            return;
+        let targetNameNode = null;
+        if (kind === 'this') {
+            targetNameNode = enclosingType.childForFieldName('name');
+        }
+        else {
+            const baseList = findNamedChild(enclosingType, 'base_list');
+            if (baseList === null)
+                return;
+            // Prefer the first non-builtin entry (idiomatically the base class). When
+            // the list is interface-only (`class C : IFoo`), do not synthesize a
+            // `base(...)` ref — valid C# chains to implicit Object, not IFoo (#2046).
+            let sawNonBuiltin = false;
+            for (const base of baseList.namedChildren) {
+                if (base === null)
+                    continue;
+                const n = terminalTypeNameNode(base);
+                if (n === null || BUILTIN_TYPE_NAMES.has(n.text))
+                    continue;
+                sawNonBuiltin = true;
+                targetNameNode = n;
+                break;
+            }
+            if (!sawNonBuiltin)
+                return;
+        }
+        if (targetNameNode === null)
+            return;
+        const argList = findNamedChild(node, 'argument_list');
+        const arity = argList === null
+            ? 0
+            : argList.namedChildren.filter((c) => c !== null && c.type === 'argument').length;
+        out.push({
+            '@reference.call.constructor': nodeToCapture('@reference.call.constructor', node),
+            '@reference.name': nodeToCapture('@reference.name', targetNameNode),
+            '@reference.arity': syntheticCapture('@reference.arity', node, String(arity)),
+        });
+    });
+    return out;
+}
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (cur.type === 'class_declaration' ||
+            cur.type === 'struct_declaration' ||
+            cur.type === 'record_declaration') {
+            return cur;
+        }
+        cur = cur.parent;
+    }
+    return null;
+}
+/**
+ * Synthesize `@reference.inherits` captures from C# base lists so the
+ * registry-primary scope-resolution path emits EXTENDS / IMPLEMENTS edges
+ * (mirrors C++ `emitCppInheritanceCaptures`). Without this, C# inheritance
+ * edges came only from the legacy heritage-capture leg (removed in #942),
+ * which is dropped for registry-primary languages in the worker pipeline
+ * (issue #1951).
+ *
+ * Scope covers every `base_list`-bearing declaration the legacy heritage
+ * leg matched: `class_declaration`, `interface_declaration`,
+ * `record_declaration`, and `struct_declaration`. Records and structs were
+ * dropped before (#1951): a `record R(...) : Base(args), IFoo` or
+ * `struct S : IFoo, ns.IBar` produced no registry-primary inheritance edge
+ * even though the legacy heritage query covered them. The
+ * EXTENDS-vs-IMPLEMENTS split is decided downstream from the resolved target's
+ * symbol kind (`preEmitInheritanceEdges`), so all bases are emitted with the
+ * same `inherits` kind here; the base lookup name is normalized to its bare
+ * simple identifier (`IRepository<T>` → `IRepository`, `A.B.IFace` → `IFace`,
+ * `Base(args)` primary-ctor base → `Base`, `MyAlias::Foo` → `Foo`) to match
+ * the V1 simple-name `findClassBindingInScope` contract — exactly the bare
+ * text `normalizeSupertypeName` (supertype-alternation.ts) reduces each shape
+ * to on the legacy leg.
+ */
+function synthesizeCsharpInheritanceReferences(root) {
+    const out = [];
+    walkNamedTree(root, (node) => {
+        if (node.type !== 'class_declaration' &&
+            node.type !== 'interface_declaration' &&
+            node.type !== 'record_declaration' &&
+            node.type !== 'struct_declaration') {
+            return;
+        }
+        const baseList = findNamedChild(node, 'base_list');
+        if (baseList === null)
+            return;
+        for (const base of baseList.namedChildren) {
+            if (base === null)
+                continue;
+            const nameNode = terminalTypeNameNode(base);
+            if (nameNode === null)
+                continue;
+            if (BUILTIN_TYPE_NAMES.has(nameNode.text))
+                continue;
+            out.push({
+                '@reference.inherits': nodeToCapture('@reference.inherits', base),
+                '@reference.name': nodeToCapture('@reference.name', nameNode),
+            });
+        }
+    });
     return out;
 }
 function synthesizeGenericTypeArgumentReferences(root) {
     const out = [];
     // Treat all generic type arguments as static type references, including
     // declaration signatures and call-site generic instantiations.
-    visit(root, (node) => {
+    walkNamedTree(root, (node) => {
         if (node.type !== 'generic_name')
             return;
         const args = findNamedChild(node, 'type_argument_list');
@@ -240,10 +400,32 @@ function terminalTypeNameNode(node) {
             return node;
         case 'nullable_type':
             return node.firstNamedChild === null ? null : terminalTypeNameNode(node.firstNamedChild);
-        case 'qualified_name':
-            return node.lastNamedChild;
+        case 'qualified_name': {
+            // `A.B.Base` -> tail identifier `Base`; `A.B.Base<T>` -> the tail is a
+            // `generic_name`, so recurse to drop the type arguments and reach the
+            // bare base identifier (#1951).
+            const tail = node.lastNamedChild;
+            return tail === null ? null : terminalTypeNameNode(tail);
+        }
+        case 'alias_qualified_name': {
+            // `MyAlias::Foo` / `global::IDisposable` -> the `name` field is the bare
+            // identifier (the `alias` is the qualifier). Mirrors
+            // normalizeSupertypeName's `name`-field reduction for this shape (#1951).
+            const name = node.childForFieldName('name');
+            return name === null ? null : terminalTypeNameNode(name);
+        }
+        case 'primary_constructor_base_type': {
+            // record base with a constructor call: `Base(args)` / `pkg.Base(id)` /
+            // `Box<int>(id)`. The `type` field holds the supertype (identifier /
+            // qualified_name / generic_name); the trailing argument_list is dropped.
+            // Mirrors normalizeSupertypeName's `type`-field reduction (#1951).
+            const type = node.childForFieldName('type');
+            return type === null ? null : terminalTypeNameNode(type);
+        }
         case 'generic_name':
-            return node.childForFieldName('name') ?? node.firstNamedChild;
+            // generic_name has no `name` field (verified by real parse, #1920); the
+            // base identifier is the first named child.
+            return node.firstNamedChild;
         default:
             return null;
     }
@@ -255,13 +437,6 @@ function findNamedChild(node, type) {
     }
     return null;
 }
-function visit(node, cb) {
-    cb(node);
-    for (const child of node.namedChildren) {
-        if (child !== null)
-            visit(child, cb);
-    }
-}
 /** C# 12 primary constructor: `class X(a, b) { }` / `record X(a, b)`.
  *  The parameters are a bare `parameter_list` named child of the type
  *  declaration (no `constructor_declaration` node). Emit a synthetic
@@ -333,14 +508,3 @@ function inferArgType(argNode) {
             return '';
     }
 }
-/** Find the first C# function-like node at the given range. The
- *  declaration anchor range covers the whole method/constructor/etc.
- *  node, but the tag alone doesn't tell us which node type. */
-function findFunctionNode(rootNode, range) {
-    for (const nodeType of FUNCTION_NODE_TYPES) {
-        const n = findNodeAtRange(rootNode, range, nodeType);
-        if (n !== null)
-            return n;
-    }
-    return null;
-}

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

@@ -68,10 +68,9 @@
  *      `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`.
+ * 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.
  */
 export { emitCsharpScopeCaptures } from './captures.js';
 export { getCsharpCaptureCacheStats, resetCsharpCaptureCacheStats } from './cache-stats.js';

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

@@ -68,10 +68,9 @@
  *      `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`.
+ * 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.
  */
 export { emitCsharpScopeCaptures } from './captures.js';
 export { getCsharpCaptureCacheStats, resetCsharpCaptureCacheStats } from './cache-stats.js';

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

@@ -122,10 +122,24 @@ function stripGeneric(text) {
  *  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)
+    // 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(lastDot + 1);
+    const tail = text.slice(lastDotAtDepth0 + 1);
     if (COLLECTION_ACCESSOR_SUFFIXES.has(tail))
         return text;
     return tail;

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

@@ -18,11 +18,20 @@
  * 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 append cross-file sibling classes
- * into each Namespace scope's `bindingAugmentations` bucket with
- * `origin: 'namespace'`. Finalized bindings remain first in
- * `lookupBindingsAt`, and local lexical `Scope.bindings` remains the
- * first-tier shadowing channel.
+ * Group classes by namespace, then route cross-file sibling classes
+ * (and method return-type bindings) through SHARED, per-namespace
+ * channels — `namespaceFqnBindings` / `namespaceTypeBindings`, keyed by
+ * namespace name — populated ONCE per bucket with `origin: 'namespace'`,
+ * rather than copied into every sibling's per-scope `bindingAugmentations`
+ * / `Scope.typeBindings`. That per-file copy was O(files²) for a
+ * concentrated namespace and OOM'd large solutions (#1871; the global
+ * twin was fixed in #1905/#1954). The walkers consult these channels
+ * gated by `accessibleNamespacesByScope` (a file's own namespace +
+ * `using` targets), so visibility is unchanged — only the storage is
+ * shared. Finalized bindings remain first in `lookupBindingsAt`, and
+ * local lexical `Scope.bindings` remains the first-tier shadowing
+ * channel. (`using static` member exposure still uses the per-scope
+ * augmentation channel — it is per-import and not part of the blow-up.)
  *
  * The tree-sitter walk is authoritative: it sees `global using static`,
  * aliased `using static X = Y.Z;`, attributed namespace declarations,
@@ -84,8 +93,9 @@ export declare function createCsharpStructureScanner(): CsharpStructureLineScann
 export declare function extractCsharpStructureViaScanner(content: string): CsharpFileStructure;
 /** 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()`. */
+ *  `treeCache` is currently always empty (its only producer, the sequential
+ *  parser, was removed), so the providers re-parse. Kept as an extension
+ *  point that would let cache hits avoid a second `parser.parse()`. */
 export interface CsharpSiblingInputs {
     readonly fileContents: ReadonlyMap<string, string>;
     readonly treeCache?: {