gitnexus 1.6.6-rc.145 → 1.6.6-rc.146

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

@@ -163,6 +163,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`.
@@ -206,8 +226,96 @@ 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

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/qualified-type-names.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tag C# file-level type defs with their enclosing-namespace path on the
+ * sidecar `namespacePrefix` field — WITHOUT touching `qualifiedName` (mutating
+ * it corrupts simple-name heritage / base resolution; #2046 regression).
+ *
+ * `tagNamespacePrefixes` (shared) only reaches defs whose scope chain includes
+ * a Namespace scope. C# file-scoped `namespace X;` gives the Namespace scope a
+ * 1-line range, so top-level types land under the Module scope and are missed.
+ * This pass covers both block- and file-scoped namespaces so the qualified
+ * constructor resolver can break a same-tail collision (`new B.Foo()` with both
+ * `A.Foo` and `B.Foo`) by matching the explicit qualifier against the sidecar.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+export declare function populateCsharpNamespacePrefixes(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/csharp/qualified-type-names.js

@@ -0,0 +1,59 @@
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+function isTypeDef(def) {
+    return isClassLike(def.type) || def.type === 'Enum';
+}
+export function populateCsharpNamespacePrefixes(parsed) {
+    const scopesById = new Map();
+    for (const scope of parsed.scopes)
+        scopesById.set(scope.id, scope);
+    // The file's declared namespace (file-scoped `namespace X;`). First Namespace
+    // scope's own def qualifiedName; undefined when the file is namespace-free.
+    const fileNamespace = (() => {
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Namespace')
+                continue;
+            const nsDef = scope.ownedDefs.find((d) => d.type === 'Namespace');
+            const q = nsDef?.qualifiedName;
+            if (q !== undefined && q.length > 0)
+                return q;
+        }
+        return undefined;
+    })();
+    // Enclosing namespace path for a scope: nearest ancestor Namespace scope's
+    // full qualifiedName, else the file-scoped namespace (Module-parented types).
+    const namespaceOf = (scope) => {
+        let parentId = scope.parent;
+        while (parentId !== null) {
+            const parent = scopesById.get(parentId);
+            if (parent === undefined)
+                break;
+            if (parent.kind === 'Namespace') {
+                const nsDef = parent.ownedDefs.find((d) => d.type === 'Namespace');
+                const q = nsDef?.qualifiedName;
+                if (q !== undefined && q.length > 0)
+                    return q;
+            }
+            if (parent.kind === 'Module')
+                return fileNamespace;
+            parentId = parent.parent;
+        }
+        return fileNamespace;
+    };
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Class')
+            continue;
+        const prefix = namespaceOf(scope);
+        if (prefix === undefined || prefix.length === 0)
+            continue;
+        for (const def of scope.ownedDefs) {
+            if (!isTypeDef(def))
+                continue;
+            if (def.namespacePrefix !== undefined)
+                continue;
+            const q = def.qualifiedName;
+            if (q === prefix || (q !== undefined && q.startsWith(`${prefix}.`)))
+                continue;
+            def.namespacePrefix = prefix;
+        }
+    }
+}

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

@@ -39,6 +39,12 @@ const CSHARP_SCOPE_QUERY = `
 (namespace_declaration) @scope.namespace
 (file_scoped_namespace_declaration) @scope.namespace
 
+(namespace_declaration
+  name: (_) @declaration.name) @declaration.namespace
+
+(file_scoped_namespace_declaration
+  name: (_) @declaration.name) @declaration.namespace
+
 (class_declaration) @scope.class
 (interface_declaration) @scope.class
 (struct_declaration) @scope.class
@@ -480,6 +486,13 @@ const CSHARP_SCOPE_QUERY = `
 (object_creation_expression
   type: (qualified_name) @reference.call.constructor.qualified) @reference.call.constructor
 
+;; Alias-qualified constructor: \`new MyAlias::Foo()\`, \`new global::Foo()\`. The
+;; top-level type is an alias_qualified_name (a \`global::Ns.Foo\` qualifier nests
+;; under qualified_name instead, covered above). No @reference.name here —
+;; captures.ts derives the simple-name tail via terminalTypeNameNode.
+(object_creation_expression
+  type: (alias_qualified_name) @reference.call.constructor.qualified) @reference.call.constructor
+
 ;; References — field/property writes: \`obj.Name = "x"\` emits a write
 ;; ACCESSES edge from the enclosing method to the field/property on
 ;; obj's class.

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

@@ -8,6 +8,7 @@
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { populateCsharpNamespacePrefixes } from './qualified-type-names.js';
 import { csharpProvider } from '../csharp.js';
 import { csharpArityCompatibility, csharpMergeBindings, resolveCsharpImportTarget, } from './index.js';
 import { populateCsharpNamespaceSiblings } from './namespace-siblings.js';
@@ -38,7 +39,13 @@ const csharpScopeResolver = {
     // contract is (callsite, def).
     arityCompatibility: (callsite, def) => csharpArityCompatibility(def, callsite),
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
-    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    populateOwners: (parsed) => {
+        populateClassOwnedMembers(parsed);
+        // Sidecar-only namespace tagging (does NOT touch qualifiedName) so the
+        // qualified constructor resolver can break same-tail collisions like
+        // `new B.Foo()` by matching the explicit qualifier (#2046).
+        populateCsharpNamespacePrefixes(parsed);
+    },
     // C# uses `base` for super-class dispatch, not `super`. Match as a
     // plain identifier (no `()` call like Python's `super(...)`) — `base`
     // is a keyword-like receiver, not a callable.

package/dist/core/ingestion/scope-resolution/graph-bridge/edges.js

@@ -55,7 +55,7 @@ export function tryEmitEdge(graph, scopes, nodeLookup, site, targetDef, reason,
     // Inheritance edges are emitted directly by `preEmitInheritanceEdges` (which
     // owns the enclosing-class caller and the EXTENDS-vs-IMPLEMENTS type), so this
     // generic bridge derives caller + edge type purely from the site.
-    const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup);
+    const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup, site.atRange);
     const targetGraphId = resolveDefGraphId(targetDef.filePath, targetDef, nodeLookup);
     const edgeType = mapReferenceKindToEdgeType(site.kind);
     if (callerGraphId === undefined)
@@ -99,7 +99,7 @@ export function tryEmitEdge(graph, scopes, nodeLookup, site, targetDef, reason,
  * flag honoring, edge-type mapping, caller-id resolution.
  */
 export function tryEmitEdgeWithExplicitTargetId(graph, scopes, nodeLookup, site, targetGraphId, reason, seen, confidence = 0.85, collapseByCallerTarget = false) {
-    const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup);
+    const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup, site.atRange);
     const edgeType = mapReferenceKindToEdgeType(site.kind);
     if (callerGraphId === undefined)
         return false;

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.d.ts

@@ -59,4 +59,7 @@ export declare function simpleQualifiedName(def: SymbolDefinition): string | und
  * edge source. Matches legacy DAG behavior where module-level CALLS
  * edges originate from the file symbol.
  */
-export declare function resolveCallerGraphId(startScope: ScopeId, scopes: ScopeResolutionIndexes, nodeLookup: GraphNodeLookup): string | undefined;
+export declare function resolveCallerGraphId(startScope: ScopeId, scopes: ScopeResolutionIndexes, nodeLookup: GraphNodeLookup, atRange?: {
+    startLine: number;
+    startCol: number;
+}): string | undefined;

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.js

@@ -18,6 +18,7 @@
  */
 import { generateId } from '../../../../lib/utils.js';
 import { qualifiedKey, simpleKey } from '../graph-bridge/node-lookup.js';
+import { isOverloadableCallable } from '../../utils/callable-labels.js';
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
 import { parameterShapeIdTag } from '../../utils/method-props.js';
 /**
@@ -48,14 +49,30 @@ function isCallerAnchorLabel(label) {
         label === 'Struct' ||
         label === 'Enum');
 }
-/**
- * Callables whose same-name overloads occupy distinct graph nodes keyed by
- * parameter types / shape. Must mirror `isOverloadableCallable` in
- * `node-lookup.ts` so registration and lookup agree (Constructor included —
- * #1928 F38).
- */
-function isOverloadableCallable(label) {
-    return label === 'Function' || label === 'Method' || label === 'Constructor';
+function rangeContainsPoint(range, at) {
+    if (at.startLine < range.startLine || at.startLine > range.endLine)
+        return false;
+    if (at.startLine === range.startLine && at.startCol < range.startCol)
+        return false;
+    if (at.startLine === range.endLine && at.startCol > range.endCol)
+        return false;
+    return true;
+}
+/** Pick the callable that owns `atRange` when multiple overloads share a class scope. */
+function pickCallerCallableDef(scope, scopes, atRange) {
+    if (atRange !== undefined) {
+        for (const childId of scopes.scopeTree.getChildren(scope.id)) {
+            const child = scopes.scopeTree.getScope(childId);
+            if (child === undefined || child.kind !== 'Function')
+                continue;
+            if (!rangeContainsPoint(child.range, atRange))
+                continue;
+            const childCallable = child.ownedDefs.find((d) => d.type === 'Function' || d.type === 'Method' || d.type === 'Constructor');
+            if (childCallable !== undefined)
+                return childCallable;
+        }
+    }
+    return scope.ownedDefs.find((d) => d.type === 'Function' || d.type === 'Method' || d.type === 'Constructor');
 }
 /**
  * Look up a `SymbolDefinition` in the graph node lookup.
@@ -106,9 +123,10 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
         // Overload disambiguation: when the def carries parameter types,
         // try the parameter-typed key first so same-name same-arity
         // overloads route to their distinct graph nodes. Constructors are
-        // included so a `this(int)`/`super(int)` chain or `new Foo(int)`
-        // resolves to the matching ctor overload instead of first-wins
-        // collapsing onto another `Foo` ctor (a self-loop) — #1928 F38.
+        // included so a C# `: this(int)` / `: base(int)` chain, a Java
+        // `this(int)`/`super(int)` chain, or `new Foo(int)` resolves to the
+        // matching ctor overload instead of first-wins collapsing onto
+        // another `Foo` ctor (a self-loop) — #1928 F38 / #2046.
         if (isOverloadableCallable(def.type) &&
             def.parameterTypes !== undefined &&
             def.parameterTypes.length > 0) {
@@ -167,7 +185,7 @@ export function simpleQualifiedName(def) {
  * edge source. Matches legacy DAG behavior where module-level CALLS
  * edges originate from the file symbol.
  */
-export function resolveCallerGraphId(startScope, scopes, nodeLookup) {
+export function resolveCallerGraphId(startScope, scopes, nodeLookup, atRange) {
     let current = startScope;
     const visited = new Set();
     let lastFilePath;
@@ -182,9 +200,9 @@ export function resolveCallerGraphId(startScope, scopes, nodeLookup) {
         // Prefer Function/Method/Constructor anchors; fall back to
         // Class/Interface/Struct/Enum. Variable/Property are NOT valid
         // caller anchors — see `isCallerAnchorLabel` for why.
-        const fnDef = scope.ownedDefs.find((d) => d.type === 'Function' || d.type === 'Method' || d.type === 'Constructor');
+        const fnDef = pickCallerCallableDef(scope, scopes, atRange);
         if (fnDef !== undefined) {
-            const id = resolveDefGraphId(scope.filePath, fnDef, nodeLookup);
+            const id = resolveDefGraphId(fnDef.filePath, fnDef, nodeLookup);
             if (id !== undefined)
                 return id;
         }

package/dist/core/ingestion/scope-resolution/graph-bridge/node-lookup.js

@@ -17,6 +17,7 @@
  * `SymbolDefinition.nodeId` values into the legacy graph-node ID
  * format that downstream consumers (queries, edges, MCP) expect.
  */
+import { isOverloadableCallable } from '../../utils/callable-labels.js';
 import { templateConstraintsIdTag } from '../../utils/template-arguments.js';
 import { parameterShapeIdTag } from '../../utils/method-props.js';
 /**
@@ -134,17 +135,6 @@ export function buildGraphNodeLookup(graph) {
     }
     return lookup;
 }
-/**
- * Callables whose same-name overloads must route to distinct graph nodes via
- * the parameter-types / shape key. Constructors belong here too: a class with
- * `Foo()` and `Foo(int)` mints distinct `#0`/`#1` Constructor nodes, and a
- * `this(...)`/`super(...)` edge (or any `new Foo(args)`) must reach the right
- * one. Without the overload key both ctor nodes collapse onto the first-wins
- * qualified/simple key, turning a `this()` chain into a self-loop (#1928 F38).
- */
-function isOverloadableCallable(label) {
-    return label === 'Function' || label === 'Method' || label === 'Constructor';
-}
 export function isLinkableLabel(label) {
     return (label === 'Function' ||
         label === 'Method' ||

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -17,7 +17,7 @@
  * generalization plan.
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
-import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findClassBindingInScope, } from '../scope/walkers.js';
+import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, resolveInheritanceBaseInScope, } from '../scope/walkers.js';
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from './overload-narrowing.js';
 export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _referenceIndex, handledSites, model, workspaceIndex, options = {}) {
     let emitted = 0;
@@ -44,8 +44,8 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // the same two targets; see test expectations.
             let fnDef;
             if (site.callForm === 'constructor') {
-                const classDef = findClassBindingInScope(site.inScope, site.name, scopes);
-                if (classDef !== undefined) {
+                const classDef = resolveInheritanceBaseInScope(site.inScope, site.name, scopes, site.rawQualifiedName);
+                if (classDef !== undefined && classDef.type !== 'Interface') {
                     // Most languages link `Type(...)` to the explicit Constructor def
                     // when one exists (else the Class). Languages that model the call
                     // as a reference to the type itself opt into
@@ -53,7 +53,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     fnDef =
                         options.constructorCallTargetsClass === true
                             ? classDef
-                            : pickConstructorOrClass(classDef, workspaceIndex, scopes);
+                            : pickConstructorOrClass(classDef, workspaceIndex, scopes, site.arity);
                 }
                 else if (options.allowGlobalFallback === true) {
                     // The constructed type may live in a sibling/imported file that is
@@ -64,9 +64,11 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     const globalClass = pickUniqueGlobalClass(site.name, globalClassesBySimpleName);
                     if (globalClass !== undefined) {
                         fnDef =
-                            options.constructorCallTargetsClass === true
-                                ? globalClass
-                                : pickConstructorOrClass(globalClass, workspaceIndex, scopes);
+                            globalClass.type === 'Interface'
+                                ? undefined
+                                : options.constructorCallTargetsClass === true
+                                    ? globalClass
+                                    : pickConstructorOrClass(globalClass, workspaceIndex, scopes, site.arity);
                     }
                 }
             }
@@ -290,7 +292,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                 handledSites.add(siteKey(parsed.filePath, site));
                 continue;
             }
-            const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup);
+            const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup, site.atRange);
             if (callerGraphId === undefined)
                 continue;
             const tgtGraphId = resolveDefGraphId(fnDef.filePath, fnDef, nodeLookup);
@@ -529,13 +531,14 @@ function logicalCallableKey(def) {
  *  Class def itself when no explicit Constructor exists. Matches
  *  legacy behavior — tests assert targetLabel === 'Class' for implicit
  *  ctors and targetLabel === 'Constructor' for explicit ones. */
-function pickConstructorOrClass(classDef, workspaceIndex, scopes) {
+function pickConstructorOrClass(classDef, workspaceIndex, scopes, callArity) {
     const classScope = workspaceIndex.classScopeByDefId.get(classDef.nodeId);
     if (classScope === undefined)
         return classDef;
+    const ctors = [];
     for (const def of classScope.ownedDefs) {
         if (def.type === 'Constructor')
-            return def;
+            ctors.push(def);
     }
     if (scopes !== undefined) {
         for (const childId of scopes.scopeTree.getChildren(classScope.id)) {
@@ -544,11 +547,18 @@ function pickConstructorOrClass(classDef, workspaceIndex, scopes) {
                 continue;
             for (const def of childScope.ownedDefs) {
                 if (def.type === 'Constructor')
-                    return def;
+                    ctors.push(def);
             }
         }
     }
-    return classDef;
+    if (ctors.length === 0)
+        return classDef;
+    if (callArity !== undefined) {
+        const narrowed = narrowByArity(ctors, callArity);
+        if (narrowed !== undefined)
+            return narrowed;
+    }
+    return ctors[0];
 }
 /** Find a unique workspace-wide class-like def by simple name, for a
  *  constructor-form call `Type(...)` whose type lives outside the call

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -19,7 +19,7 @@
  * "resolve member on owner with MRO" pattern. All four are reusable
  * as-is for TypeScript, Java, Kotlin, Ruby, etc.
  */
-import { normalizeQualifiedName } from '../../utils/qualified-name.js';
+import { normalizeQualifiedName, splitQualifiedName, stripTrailingTypeArguments, } from '../../utils/qualified-name.js';
 const EMPTY_BINDINGS = Object.freeze([]);
 /**
  * Look up binding refs at `scopeId` for `name`, consulting both the
@@ -321,7 +321,7 @@ export function resolveInheritanceBaseInScope(startScope, baseName, scopes, rawQ
  * wrong EXTENDS edge silently corrupts impact analysis).
  */
 function resolveQualifiedInheritanceBase(startScope, rawQualifiedName, scopes, enclosingClassDef) {
-    const normalized = normalizeQualifiedName(rawQualifiedName);
+    const normalized = stripTrailingTypeArguments(normalizeQualifiedName(rawQualifiedName));
     // No qualifier after normalization → nothing the simple-tail walk doesn't do.
     if (normalized.length === 0 || !normalized.includes('.'))
         return undefined;
@@ -333,12 +333,25 @@ function resolveQualifiedInheritanceBase(startScope, rawQualifiedName, scopes, e
     const enclosing = isRootAnchored
         ? []
         : enclosingScopeSegments(startScope, scopes, enclosingClassDef);
-    // Candidate keys: longest enclosing prefix first, then the root-anchored form.
+    // Candidate keys: longest enclosing prefix first for *relative* qualified
+    // bases (`Outer.Inner` inside `NS.Outer.Derived` → `NS.Outer.Inner`). When the
+    // qualifier names a *different* namespace than the enclosing scope (`new B.Foo()`
+    // inside `namespace A` → `B.Foo`, not `A.Foo`), try the raw normalized key
+    // FIRST so same-tail local bindings don't win (#2046 / #1991).
+    const normParts = splitQualifiedName(normalized);
+    const isRelativeToEnclosing = enclosing.length > 0 &&
+        normParts.length > 0 &&
+        normParts[0] === enclosing[enclosing.length - 1];
     const keys = [];
+    if (!isRelativeToEnclosing) {
+        keys.push(normalized);
+    }
     for (let i = enclosing.length; i >= 1; i--) {
         keys.push([...enclosing.slice(0, i), normalized].join('.'));
     }
-    keys.push(normalized);
+    if (!keys.includes(normalized)) {
+        keys.push(normalized);
+    }
     for (const key of keys) {
         const ids = scopes.qualifiedNames.get(key);
         if (ids.length === 0)
@@ -377,6 +390,33 @@ function resolveQualifiedInheritanceBase(startScope, rawQualifiedName, scopes, e
             return undefined; // genuine tie → refuse, don't guess
         }
     }
+    // Qualifier-vs-sidecar fallback (#2046). Languages whose class `qualifiedName`
+    // is the SIMPLE name (C#) never populate a qualified key in the index, so the
+    // keyed loop above can't see `B.Foo`. Resolve the simple TAIL and break the
+    // same-tail collision by matching the explicit qualifier (`B`) against each
+    // candidate's `namespacePrefix` sidecar. Commit only on a unique match — a
+    // still-ambiguous qualifier refuses (never guesses a wrong EXTENDS/CALLS edge).
+    const tail = normParts[normParts.length - 1];
+    const qualifier = normParts.slice(0, -1).join('.');
+    if (tail !== undefined && qualifier.length > 0) {
+        const tailIds = scopes.qualifiedNames.get(tail);
+        let qUnique;
+        let qCount = 0;
+        for (const id of tailIds) {
+            const def = scopes.defs.get(id);
+            if (def === undefined || !isClassLike(def.type))
+                continue;
+            const np = def.namespacePrefix;
+            if (np === undefined || np.length === 0)
+                continue;
+            if (np === qualifier || np.endsWith(`.${qualifier}`)) {
+                qUnique = def;
+                qCount++;
+            }
+        }
+        if (qCount === 1)
+            return qUnique;
+    }
     return undefined;
 }
 /**

package/dist/core/ingestion/utils/callable-labels.d.ts

@@ -0,0 +1,13 @@
+import type { NodeLabel } from '../../../_shared/index.js';
+/**
+ * Callables whose same-name overloads occupy distinct graph nodes keyed by
+ * parameter types / shape. Shared by graph-bridge registration (`node-lookup.ts`)
+ * and resolution (`ids.ts`) so overload keys stay aligned.
+ *
+ * Constructors belong here: a class with `Foo()` and `Foo(int)` mints distinct
+ * `#0`/`#1` Constructor nodes, and a `: this(...)` / `: base(...)` (C#),
+ * `this(...)`/`super(...)` (Java), or `new Foo(args)` edge must reach the
+ * right overload — otherwise both ctor nodes collapse onto the first-wins
+ * qualified/simple key and a ctor chain becomes a self-loop (#1928 F38 / #2046).
+ */
+export declare function isOverloadableCallable(label: NodeLabel | undefined): boolean;

package/dist/core/ingestion/utils/callable-labels.js

@@ -0,0 +1,14 @@
+/**
+ * Callables whose same-name overloads occupy distinct graph nodes keyed by
+ * parameter types / shape. Shared by graph-bridge registration (`node-lookup.ts`)
+ * and resolution (`ids.ts`) so overload keys stay aligned.
+ *
+ * Constructors belong here: a class with `Foo()` and `Foo(int)` mints distinct
+ * `#0`/`#1` Constructor nodes, and a `: this(...)` / `: base(...)` (C#),
+ * `this(...)`/`super(...)` (Java), or `new Foo(args)` edge must reach the
+ * right overload — otherwise both ctor nodes collapse onto the first-wins
+ * qualified/simple key and a ctor chain becomes a self-loop (#1928 F38 / #2046).
+ */
+export function isOverloadableCallable(label) {
+    return label === 'Function' || label === 'Method' || label === 'Constructor';
+}

package/dist/core/ingestion/utils/qualified-name.d.ts

@@ -29,3 +29,9 @@ export declare const normalizeQualifiedName: (value: string) => string;
  * separator-only input.
  */
 export declare const splitQualifiedName: (value: string) => string[];
+/**
+ * Strip a trailing generic argument list at angle-bracket depth 0
+ * (`Models.Box<int>` → `Models.Box`). Constructor and inheritance sites
+ * often carry type arguments that are not part of the indexed def key.
+ */
+export declare function stripTrailingTypeArguments(value: string): string;

package/dist/core/ingestion/utils/qualified-name.js

@@ -38,3 +38,30 @@ export const splitQualifiedName = (value) => {
     const normalized = normalizeQualifiedName(value);
     return normalized ? normalized.split('.').filter(Boolean) : [];
 };
+/**
+ * Strip a trailing generic argument list at angle-bracket depth 0
+ * (`Models.Box<int>` → `Models.Box`). Constructor and inheritance sites
+ * often carry type arguments that are not part of the indexed def key.
+ */
+export function stripTrailingTypeArguments(value) {
+    let depth = 0;
+    let ltAt0 = -1;
+    for (let i = 0; i < value.length; i++) {
+        const c = value[i];
+        if (c === '<') {
+            if (depth === 0)
+                ltAt0 = i;
+            depth++;
+        }
+        else if (c === '>') {
+            depth = Math.max(0, depth - 1);
+            if (depth === 0 && ltAt0 >= 0) {
+                const after = value.slice(i + 1).trim();
+                if (after.length === 0)
+                    return value.slice(0, ltAt0);
+                ltAt0 = -1;
+            }
+        }
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.145",
+  "version": "1.6.6-rc.146",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",