gitnexus 1.6.5-rc.44 → 1.6.5-rc.45

package/dist/core/ingestion/languages/cpp/inline-namespaces.d.ts

@@ -60,8 +60,8 @@ export declare function isCppInlineNamespaceScope(scopeId: ScopeId): boolean;
  * Returns the most specific (innermost) match — for `outer::foo()`
  * where `inline namespace v1` declares `foo`, returns `v1::foo`. When
  * multiple inline-namespace children declare the same name, ISO C++
- * leaves the call ambiguous; V1 returns the first match in source
- * order (stable across runs).
+ * leaves the call ambiguous; returns `'ambiguous'` so the caller
+ * suppresses edge emission rather than picking arbitrarily (#1564).
  */
-export declare function resolveCppQualifiedNamespaceMember(receiverName: string, memberName: string, parsedFiles: readonly ParsedFile[], _scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+export declare function resolveCppQualifiedNamespaceMember(receiverName: string, memberName: string, parsedFiles: readonly ParsedFile[], _scopes: ScopeResolutionIndexes): SymbolDefinition | 'ambiguous' | undefined;
 export {};

package/dist/core/ingestion/languages/cpp/inline-namespaces.js

@@ -26,6 +26,7 @@
  * `std::vector` qualified calls resolve to the inline-namespace
  * declaration transparently.
  */
+import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
 const inlineNamespaceRangesByFile = new Map();
 const inlineNamespaceScopeIds = new Set();
 function rangeKey(r) {
@@ -80,10 +81,12 @@ export function isCppInlineNamespaceScope(scopeId) {
  * Returns the most specific (innermost) match — for `outer::foo()`
  * where `inline namespace v1` declares `foo`, returns `v1::foo`. When
  * multiple inline-namespace children declare the same name, ISO C++
- * leaves the call ambiguous; V1 returns the first match in source
- * order (stable across runs).
+ * leaves the call ambiguous; returns `'ambiguous'` so the caller
+ * suppresses edge emission rather than picking arbitrarily (#1564).
  */
 export function resolveCppQualifiedNamespaceMember(receiverName, memberName, parsedFiles, _scopes) {
+    const allHits = [];
+    const seenNodeId = new Set();
     for (const parsed of parsedFiles) {
         const scopesById = new Map();
         for (const sc of parsed.scopes)
@@ -97,27 +100,58 @@ export function resolveCppQualifiedNamespaceMember(receiverName, memberName, par
             const nsName = nsDef.qualifiedName?.split('.').pop() ?? nsDef.qualifiedName ?? '';
             if (nsName !== receiverName)
                 continue;
-            // Found a matching namespace scope in this file. Collect the
-            // member transitively through any inline-namespace children.
-            const hit = findMemberInNamespaceTransitive(scope, scopesById, memberName);
-            if (hit !== undefined)
-                return hit;
+            // Found a matching namespace scope in this file. Collect ALL
+            // members transitively through any inline-namespace children.
+            const hits = findMemberInNamespaceTransitive(scope, scopesById, memberName);
+            for (const hit of hits) {
+                if (seenNodeId.has(hit.nodeId))
+                    continue;
+                seenNodeId.add(hit.nodeId);
+                allHits.push(hit);
+            }
         }
     }
-    return undefined;
+    if (allHits.length === 0)
+        return undefined;
+    if (allHits.length === 1)
+        return allHits[0];
+    // Multi-candidate: the `resolveQualifiedReceiverMember` hook has no
+    // access to call-site arity or argument types, so
+    // `narrowOverloadCandidates` cannot actually narrow here — the call
+    // with `(allHits, undefined, undefined)` is effectively a pass-through.
+    // We retain it so that `isOverloadAmbiguousAfterNormalization` can
+    // still detect int/long-style normalization collisions on this path,
+    // but for any multi-hit case where candidates have genuinely distinct
+    // signatures (e.g. `foo(int)` vs `foo(double)` in different inline
+    // children), we conservatively suppress rather than pick arbitrarily.
+    // A future enhancement could thread call-site argument info through
+    // the `resolveQualifiedReceiverMember` contract to enable real
+    // narrowing here.
+    const narrowed = narrowOverloadCandidates(allHits, undefined, undefined);
+    if (narrowed.length === 1)
+        return narrowed[0];
+    if (narrowed.length === 0)
+        return undefined;
+    if (isOverloadAmbiguousAfterNormalization(narrowed, undefined))
+        return 'ambiguous';
+    // Multiple surviving candidates (distinct signatures) — conservative
+    // suppress because we lack call-site info to disambiguate.
+    return 'ambiguous';
 }
 /** Recursively search a namespace scope and any inline-namespace
- *  descendants for a callable def with the given simple name. Non-inline
+ *  descendants for callable defs with the given simple name. Non-inline
  *  nested namespaces are NOT traversed — they require explicit
- *  qualification (`outer::nested::foo`). */
+ *  qualification (`outer::nested::foo`). Returns ALL matches so the
+ *  caller can detect same-name ambiguity across inline children (#1564). */
 function findMemberInNamespaceTransitive(scope, scopesById, memberName) {
+    const results = [];
     // Check this scope's own ownedDefs first.
     for (const def of scope.ownedDefs) {
         if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
             continue;
         const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
         if (simple === memberName)
-            return def;
+            results.push(def);
     }
     // Descend into inline-namespace children.
     for (const childScope of scopesById.values()) {
@@ -127,11 +161,11 @@ function findMemberInNamespaceTransitive(scope, scopesById, memberName) {
             continue;
         if (!inlineNamespaceScopeIds.has(childScope.id))
             continue;
-        const hit = findMemberInNamespaceTransitive(childScope, scopesById, memberName);
-        if (hit !== undefined)
-            return hit;
+        const childHits = findMemberInNamespaceTransitive(childScope, scopesById, memberName);
+        for (const hit of childHits)
+            results.push(hit);
     }
-    return undefined;
+    return results;
 }
 function findNamespaceDefInScope(scope) {
     for (const def of scope.ownedDefs) {

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

@@ -205,7 +205,7 @@ export const cppScopeResolver = {
             if (imp.localName !== site.name)
                 continue;
             const member = resolveCppQualifiedNamespaceMember(imp.targetRaw, imp.importedName, parsedFiles, scopes);
-            if (member === undefined)
+            if (member === undefined || member === 'ambiguous')
                 continue;
             if (seenUsing.has(member.nodeId))
                 continue;

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -542,10 +542,11 @@ export interface ScopeResolver {
      *
      * Receiver-bound-calls invokes this hook AFTER Case 1 (namespace
      * imports) and AFTER Case 2 (class-name receiver) fail to resolve.
-     * Returns the target def, or `undefined` to fall through to the
-     * remaining cases.
+     * Returns the target def, `'ambiguous'` when multiple inline-namespace
+     * children declare the same name (suppresses edge emission), or
+     * `undefined` to fall through to the remaining cases.
      */
-    readonly resolveQualifiedReceiverMember?: (receiverName: string, memberName: string, callerScope: ScopeId, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | undefined;
+    readonly resolveQualifiedReceiverMember?: (receiverName: string, memberName: string, callerScope: ScopeId, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | 'ambiguous' | undefined;
     /**
      * Enable the receiver-bound Case 0.5 fallback for explicit `this`
      * receivers (`this->m()` / `this.m()`) that resolves against the

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -324,6 +324,12 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             // class with the same simple name.
             if (provider.resolveQualifiedReceiverMember !== undefined) {
                 const memberDef = provider.resolveQualifiedReceiverMember(receiverName, memberName, site.inScope, scopes, parsedFiles);
+                if (memberDef === 'ambiguous') {
+                    // Same-name ambiguity across inline-namespace children (#1564):
+                    // suppress edge emission, mark site handled.
+                    handledSites.add(siteKey);
+                    continue;
+                }
                 if (memberDef !== undefined) {
                     const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                     if (ok)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5-rc.44",
+  "version": "1.6.5-rc.45",
   "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",