gitnexus 1.6.5-rc.43 → 1.6.5-rc.45

package/dist/core/ingestion/languages/c-cpp.js

@@ -270,12 +270,20 @@ const cCppExtractFunctionName = (node) => {
     }
     return { funcName, label };
 };
-/** Check if a C/C++ function_definition is inside a class or struct body.
+/** Check if a C/C++ function_definition is inside a class or struct body
+ *  (and NOT a friend declaration).
  *  Used by cppLabelOverride to skip duplicate function captures
- *  that are already covered by definition.method queries. */
+ *  that are already covered by definition.method queries.
+ *  Friend functions are free functions defined inside class bodies —
+ *  they must NOT be skipped (ISO C++ hidden-friend idiom). */
 function isCppInsideClassOrStruct(functionNode) {
     let ancestor = functionNode?.parent ?? null;
     while (ancestor) {
+        // Friend declarations: the function_definition is wrapped in
+        // `friend_declaration` → `field_declaration_list` → class_specifier.
+        // These are free functions, not methods — don't skip them.
+        if (ancestor.type === 'friend_declaration')
+            return false;
         if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
             return true;
         ancestor = ancestor.parent;

package/dist/core/ingestion/languages/cpp/adl.d.ts

@@ -41,10 +41,8 @@
  * def with that simple name. Locally-declared function-pointer variables
  * (e.g. `void (*g)()`) and function parameters are excluded from this path.
  *
- * The current implementation also short-circuits to ADL only when ordinary lookup is empty
- * (`findCallableBindingInScope` returned undefined). ISO C++ would
- * normally merge ADL candidates with ordinary-lookup candidates and
- * run overload resolution over the union; V1 defers that merge to V2.
+ * ADL candidates are merged with ordinary unqualified-lookup candidates
+ * in the free-call fallback before overload narrowing.
  *
  * ## Parenthesized-name suppression
  *
@@ -103,12 +101,6 @@ export interface CppAdlArgInfo {
      *  containing a matching Function/Method def is contributed. */
     readonly functionRefText?: string;
 }
-/** Sentinel returned by `pickCppAdlCandidates` when ADL surfaces multiple
- *  candidates that share normalized parameter types — the caller MUST
- *  suppress (zero edges) rather than pick arbitrarily. Mirrors the
- *  OVERLOAD_AMBIGUOUS contract from the receiver-bound path. */
-export declare const ADL_AMBIGUOUS: unique symbol;
-export type AdlResult = SymbolDefinition | typeof ADL_AMBIGUOUS | undefined;
 /** Record per-call-site argument info. Called once per call site from
  *  `emitCppScopeCaptures`. */
 export declare function markCppAdlSiteArgs(filePath: string, line: number, col: number, args: readonly CppAdlArgInfo[]): void;
@@ -130,13 +122,10 @@ export declare function clearCppAdlState(): void;
  */
 export declare function populateCppAssociatedNamespaces(parsed: ParsedFile): void;
 /**
- * V1 ADL candidate picker. Returns:
- *   - `SymbolDefinition` — exactly one ADL candidate (or unique survivor
- *     after narrowing); caller emits the CALLS edge.
- *   - `ADL_AMBIGUOUS` — multiple candidates with no disambiguator;
- *     caller MUST suppress (zero edges).
- *   - `undefined` — no ADL candidates; caller falls through to ordinary
- *     `pickUniqueGlobalCallable` fallback.
+ * ADL candidate collector. Returns:
+ *   - `readonly SymbolDefinition[]` — ADL candidates to merge with
+ *     ordinary unqualified lookup candidates.
+ *   - `undefined` — no ADL candidates.
  *
  * Fires only when:
  *   - the call site is not in `noAdlSites` (parenthesized form), AND
@@ -145,10 +134,8 @@ export declare function populateCppAssociatedNamespaces(parsed: ParsedFile): voi
  */
 export declare function pickCppAdlCandidates(site: {
     readonly name: string;
-    readonly arity?: number;
-    readonly argumentTypes?: readonly string[];
     readonly atRange: {
         startLine: number;
         startCol: number;
     };
-}, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]): AdlResult;
+}, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]): readonly SymbolDefinition[] | undefined;

package/dist/core/ingestion/languages/cpp/adl.js

@@ -41,10 +41,8 @@
  * def with that simple name. Locally-declared function-pointer variables
  * (e.g. `void (*g)()`) and function parameters are excluded from this path.
  *
- * The current implementation also short-circuits to ADL only when ordinary lookup is empty
- * (`findCallableBindingInScope` returned undefined). ISO C++ would
- * normally merge ADL candidates with ordinary-lookup candidates and
- * run overload resolution over the union; V1 defers that merge to V2.
+ * ADL candidates are merged with ordinary unqualified-lookup candidates
+ * in the free-call fallback before overload narrowing.
  *
  * ## Parenthesized-name suppression
  *
@@ -69,15 +67,10 @@
  * but logically share the same namespace. ADL must consider candidates
  * declared in either file.
  */
-import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
+import { isCppInlineNamespaceScope } from './inline-namespaces.js';
 const argInfoBySite = new Map();
 const noAdlSites = new Set();
 const classToNamespaceQualifiedName = new Map();
-/** Sentinel returned by `pickCppAdlCandidates` when ADL surfaces multiple
- *  candidates that share normalized parameter types — the caller MUST
- *  suppress (zero edges) rather than pick arbitrarily. Mirrors the
- *  OVERLOAD_AMBIGUOUS contract from the receiver-bound path. */
-export const ADL_AMBIGUOUS = Symbol('ADL_AMBIGUOUS');
 function siteKey(filePath, line, col) {
     return `${filePath}:${line}:${col}`;
 }
@@ -124,15 +117,27 @@ export function populateCppAssociatedNamespaces(parsed) {
             classToNamespaceQualifiedName.set(def.nodeId, nsQName);
         }
     }
+    // Enum defs live in Namespace scopes directly (not inside Class scopes).
+    // Map each Enum def to its enclosing namespace so ADL on enum-typed
+    // arguments contributes the correct associated namespace.
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Namespace')
+            continue;
+        const nsQName = computeNamespaceQName(scope, scopesById);
+        if (nsQName === '')
+            continue;
+        for (const def of scope.ownedDefs) {
+            if (def.type !== 'Enum')
+                continue;
+            classToNamespaceQualifiedName.set(def.nodeId, nsQName);
+        }
+    }
 }
 /**
- * V1 ADL candidate picker. Returns:
- *   - `SymbolDefinition` — exactly one ADL candidate (or unique survivor
- *     after narrowing); caller emits the CALLS edge.
- *   - `ADL_AMBIGUOUS` — multiple candidates with no disambiguator;
- *     caller MUST suppress (zero edges).
- *   - `undefined` — no ADL candidates; caller falls through to ordinary
- *     `pickUniqueGlobalCallable` fallback.
+ * ADL candidate collector. Returns:
+ *   - `readonly SymbolDefinition[]` — ADL candidates to merge with
+ *     ordinary unqualified lookup candidates.
+ *   - `undefined` — no ADL candidates.
  *
  * Fires only when:
  *   - the call site is not in `noAdlSites` (parenthesized form), AND
@@ -160,6 +165,8 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     // Walk every namespace scope in every parsed file; collect callable
     // ownedDefs whose enclosing namespace matches one of the associated
     // QNames AND whose simple name matches the call's name.
+    // ISO C++: inline namespaces are transparent — candidates in inline
+    // children of an associated namespace are also ADL-reachable.
     const candidates = [];
     const seenKey = new Set();
     for (const parsed of parsedFiles) {
@@ -170,8 +177,20 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
             if (scope.kind !== 'Namespace')
                 continue;
             const qName = computeNamespaceQName(scope, scopesById);
-            if (!associatedNamespaces.has(qName))
-                continue;
+            if (!associatedNamespaces.has(qName)) {
+                // Check if this is an inline-namespace child of an associated NS.
+                // ISO C++ inline namespaces are transparent for ADL: if the outer
+                // namespace is in the associated set, candidates in the inline child
+                // are also reachable.
+                if (!isCppInlineNamespaceScope(scope.id))
+                    continue;
+                const parentScope = scope.parent !== null ? scopesById.get(scope.parent) : undefined;
+                if (parentScope === undefined || parentScope.kind !== 'Namespace')
+                    continue;
+                const parentQName = computeNamespaceQName(parentScope, scopesById);
+                if (!associatedNamespaces.has(parentQName))
+                    continue;
+            }
             for (const def of scope.ownedDefs) {
                 if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor') {
                     continue;
@@ -189,26 +208,66 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
                 candidates.push(def);
             }
         }
+        // ISO C++ `[basic.lookup.argdep]` §2: hidden friend functions declared
+        // inside a class body are visible via ADL when the class is an associated
+        // class. Scan Class scopes whose enclosing namespace is in the associated
+        // set for callable ownedDefs matching the call name. This enables the
+        // canonical "hidden friend" idiom:
+        //   struct Foo { friend void swap(Foo&, Foo&) {} };
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Class')
+                continue;
+            // Check if ANY class def in this scope has an associated namespace.
+            let isAssociatedClass = false;
+            for (const def of scope.ownedDefs) {
+                if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                    continue;
+                const nsQName = classToNamespaceQualifiedName.get(def.nodeId);
+                if (nsQName !== undefined && associatedNamespaces.has(nsQName)) {
+                    isAssociatedClass = true;
+                    break;
+                }
+            }
+            if (!isAssociatedClass)
+                continue;
+            // Also scan Function scopes that are direct children of this class
+            // scope — friend function definitions create their own Function scope
+            // underneath the Class scope.
+            for (const childScope of parsed.scopes) {
+                if (childScope.parent !== scope.id)
+                    continue;
+                if (childScope.kind !== 'Function')
+                    continue;
+                for (const def of childScope.ownedDefs) {
+                    if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor') {
+                        continue;
+                    }
+                    const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                    if (simple !== site.name)
+                        continue;
+                    if (seenKey.has(def.nodeId))
+                        continue;
+                    seenKey.add(def.nodeId);
+                    candidates.push(def);
+                }
+            }
+            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 !== site.name)
+                    continue;
+                if (seenKey.has(def.nodeId))
+                    continue;
+                seenKey.add(def.nodeId);
+                candidates.push(def);
+            }
+        }
     }
     if (candidates.length === 0)
         return undefined;
-    if (candidates.length === 1)
-        return candidates[0];
-    // Multi-candidate: narrow then check ambiguity. Reuses the OVERLOAD_AMBIGUOUS
-    // sentinel contract from `overload-narrowing.ts` so int/long-collision-style
-    // ambiguity also suppresses on the ADL path.
-    const narrowed = narrowOverloadCandidates(candidates, site.arity, site.argumentTypes);
-    if (narrowed.length === 1)
-        return narrowed[0];
-    if (narrowed.length === 0)
-        return undefined;
-    if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity))
-        return ADL_AMBIGUOUS;
-    // Multiple surviving candidates that aren't normalization-ambiguous —
-    // ISO C++ would run overload resolution; V1 lacks conversion ranking so
-    // suppress rather than pick arbitrarily. Mirrors `pickImplicitThisOverload`'s
-    // unique-survivor requirement (see `pick-implicit-this-overload.test.ts`).
-    return ADL_AMBIGUOUS;
+    return candidates;
 }
 function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces) {
     // For template args this may be the template name itself (e.g. `vector`);
@@ -216,8 +275,8 @@ function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces)
     // V1/V2 simplification).
     addAssociatedNamespaceForClassName(arg.simpleClassName, scopes, associatedNamespaces);
     // Includes template-owner namespaces (e.g. `std` in std::vector<T>). If
-    // that surfaces extra candidates, ADL_AMBIGUOUS suppression below prevents
-    // arbitrary edge emission.
+    // that surfaces extra candidates, merged-candidate overload narrowing in
+    // free-call-fallback suppresses arbitrary edge emission.
     if (arg.templateNamespace.length > 0)
         associatedNamespaces.add(arg.templateNamespace);
     for (const ns of arg.templateArgNamespaces) {
@@ -316,15 +375,21 @@ function findNamespaceDefInScope(scope) {
     }
     return undefined;
 }
-/** Find a class-like def by simple name across the workspace. V1
- *  still arbitrary-picks the first class on collisions (multiple classes
+/** Find a class-like or enum def by simple name across the workspace.
+ *  V1 still arbitrary-picks the first match on collisions (multiple defs
  *  share the simple name), but reports the collision so callers can avoid
  *  amplifying that uncertainty (for example by skipping MRO expansion).
- *  C++ ADL strictness would require full type-driven lookup. */
+ *  C++ ADL strictness would require full type-driven lookup.
+ *
+ *  ISO C++ `[basic.lookup.argdep]` §2: enumerations contribute their
+ *  enclosing namespace to the associated set, just like class types. */
 function findCppClassDefBySimpleName(simpleName, scopes) {
     let firstMatch;
     for (const def of scopes.defs.byId.values()) {
-        if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+        if (def.type !== 'Class' &&
+            def.type !== 'Struct' &&
+            def.type !== 'Interface' &&
+            def.type !== 'Enum')
             continue;
         const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
         if (simple !== simpleName)

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

@@ -9,10 +9,9 @@ import { resolveCppImportTarget } from './import-target.js';
 import { scanCppHeaderFiles } from './header-scan.js';
 import { expandCppWildcardNames, isFileLocal, clearFileLocalNames, populateCppAnonymousNamespaceScopes, populateCppNonGloballyVisible, isCppDefGloballyVisible, } from './file-local-linkage.js';
 import { populateCppDependentBases, clearCppDependentBases, isCppDependentBaseMember, } from './two-phase-lookup.js';
-import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates, ADL_AMBIGUOUS, } from './adl.js';
+import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates } from './adl.js';
 import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQualifiedNamespaceMember, } from './inline-namespaces.js';
 import { populateCppRangeBindings } from './range-bindings.js';
-import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
 /**
  * C++ `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -187,12 +186,12 @@ export const cppScopeResolver = {
         return !isCppDependentBaseMember(callerScope, candidate, scopes);
     },
     // C++ argument-dependent / Koenig lookup (U2 of plan 2026-05-13-001).
-    // Fires after `findCallableBindingInScope` returns undefined; surfaces
-    // candidates from the associated namespaces of class-typed arguments.
+    // Contributes candidates from associated namespaces of class-typed
+    // arguments; caller merges with ordinary unqualified lookup candidates.
     // Current boundary: class-typed value/pointer/reference args and template
     // specializations with explicit type arguments contribute associated
-    // namespaces. Function-pointer args, base-class associated namespaces,
-    // and full ordinary+ADL merge remain excluded.
+    // namespaces. Function-pointer args and full conversion-ranking remain
+    // excluded.
     resolveAdlCandidates: (site, callerParsed, scopes, parsedFiles) => {
         // `using ns::name;` introduces `name` into ordinary unqualified lookup.
         // For template-class method bodies, lexical scope walks can miss this
@@ -206,26 +205,31 @@ 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;
             seenUsing.add(member.nodeId);
             usingNamedHits.push(member);
         }
-        if (usingNamedHits.length > 0) {
-            const narrowed = narrowOverloadCandidates(usingNamedHits, site.arity, site.argumentTypes);
-            if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity))
-                return 'ambiguous';
-            if (narrowed.length === 1)
-                return narrowed[0];
-            if (narrowed.length > 1)
-                return 'ambiguous';
+        const adlHits = pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles);
+        if (usingNamedHits.length === 0)
+            return adlHits;
+        if (adlHits === undefined || adlHits.length === 0)
+            return usingNamedHits;
+        const merged = [];
+        const seen = new Set();
+        for (const hit of usingNamedHits) {
+            seen.add(hit.nodeId);
+            merged.push(hit);
         }
-        const result = pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles);
-        if (result === ADL_AMBIGUOUS)
-            return 'ambiguous';
-        return result;
+        for (const hit of adlHits) {
+            if (seen.has(hit.nodeId))
+                continue;
+            seen.add(hit.nodeId);
+            merged.push(hit);
+        }
+        return merged;
     },
     // C++ qualified namespace-member resolution (U5 of plan 2026-05-13-001).
     // Handles `outer::foo()` where `outer` is a namespace (not a class).

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

@@ -506,16 +506,15 @@ export interface ScopeResolver {
      * Optional argument-dependent-lookup (ADL / Koenig lookup) hook for
      * languages with C++-style associated-namespace candidate addition.
      *
-     * Runs in the free-call fallback AFTER `findCallableBindingInScope`
-     * returns `undefined` and BEFORE `pickUniqueGlobalCallable`. The hook
-     * inspects the call site's argument types, computes the associated
-     * namespace set, and returns either:
-     *   - a unique `SymbolDefinition` — emit the CALLS edge to it.
-     *   - `'ambiguous'` — multiple candidates share normalized parameter
-     *     types; the caller MUST suppress (zero edges). Mirrors the
-     *     OVERLOAD_AMBIGUOUS sentinel from `overload-narrowing.ts`.
-     *   - `undefined` — no ADL candidates; caller falls through to the
-     *     global free-call fallback (`pickUniqueGlobalCallable`).
+     * Runs in the free-call fallback alongside ordinary unqualified lookup.
+     * The fallback merges ordinary candidates with ADL candidates and applies
+     * overload narrowing over the union.
+     *
+     * The hook inspects the call site's argument types, computes the
+     * associated namespace set, and returns either:
+     *   - an array of candidate `SymbolDefinition`s to add to the
+     *     ordinary-lookup candidate pool.
+     *   - `undefined` when ADL contributes no candidates.
      *
      * Languages without C++-style ADL leave this undefined. The
      * cross-language contract is "additive tier" — defining the hook never
@@ -529,7 +528,7 @@ export interface ScopeResolver {
             readonly startLine: number;
             readonly startCol: number;
         };
-    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | 'ambiguous' | undefined;
+    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
     /**
      * Optional resolver for qualified-receiver member calls where the
      * receiver is a namespace (not a class) and ordinary scope-chain /
@@ -543,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/free-call-fallback.d.ts

@@ -41,7 +41,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
             readonly startLine: number;
             readonly startCol: number;
         };
-    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | 'ambiguous' | undefined;
+    }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
 }): number;
 /** Walk up from the call-site scope to the enclosing class scope,
  *  pick a method member by name with overload narrowing on arity +

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

@@ -17,8 +17,8 @@
  * generalization plan.
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
-import { findCallableBindingInScope, findClassBindingInScope } from '../scope/walkers.js';
-import { narrowOverloadCandidates } from './overload-narrowing.js';
+import { findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findClassBindingInScope, } 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;
     const seen = new Set();
@@ -48,36 +48,74 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                 fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model);
             }
             if (fnDef === undefined) {
-                fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
-            }
-            // V1 ADL tier (C++ Koenig lookup, opt-in via provider.resolveAdlCandidates).
-            // Fires only when ordinary lookup is empty — V1 limitation per
-            // plan 2026-05-13-001 U2; ISO C++ would merge ADL with ordinary lookup
-            // and run overload resolution over the union.
-            //
-            // Sentinel 'ambiguous': ADL surfaced multiple candidates with
-            // identical normalized parameter types (mirrors OVERLOAD_AMBIGUOUS).
-            // We mark the site handled so `emit-references` does not retry, and
-            // continue to the next site without emitting an edge.
-            if (fnDef === undefined && options.resolveAdlCandidates !== undefined) {
-                const adlResult = options.resolveAdlCandidates({
-                    name: site.name,
-                    arity: site.arity,
-                    argumentTypes: site.argumentTypes,
-                    atRange: { startLine: site.atRange.startLine, startCol: site.atRange.startCol },
-                }, parsed, scopes, parsedFiles);
-                if (adlResult === 'ambiguous') {
-                    handledSites.add(`${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`);
-                    continue;
+                if (options.resolveAdlCandidates === undefined) {
+                    fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
                 }
-                if (adlResult !== undefined) {
-                    fnDef = adlResult;
+                else {
+                    // ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when
+                    // ordinary lookup finds a non-function name (variable, class, enum)
+                    // or a block-scope function declaration (not via using-declaration)
+                    // at the nearest scope where the name exists.
+                    const { callables: ordinary, nonCallableFound, blockScopeDeclFound, } = findCallableBindingsAndAdlBlocker(site.inScope, site.name, scopes);
+                    const adlSuppressed = nonCallableFound || blockScopeDeclFound;
+                    const adl = adlSuppressed
+                        ? undefined
+                        : options.resolveAdlCandidates({
+                            name: site.name,
+                            arity: site.arity,
+                            argumentTypes: site.argumentTypes,
+                            atRange: { startLine: site.atRange.startLine, startCol: site.atRange.startCol },
+                        }, parsed, scopes, parsedFiles);
+                    // Preserve existing ordinary-lookup behavior when ADL contributed
+                    // no candidates.
+                    if (adl === undefined || adl.length === 0) {
+                        fnDef = ordinary[0];
+                    }
+                    else {
+                        const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
+                        const merged = [];
+                        const seen = new Set();
+                        const push = (defs) => {
+                            for (const d of defs) {
+                                if (seen.has(d.nodeId))
+                                    continue;
+                                seen.add(d.nodeId);
+                                merged.push(d);
+                            }
+                        };
+                        push(ordinary);
+                        push(adl);
+                        const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes);
+                        if (narrowed.length === 1) {
+                            fnDef = narrowed[0];
+                        }
+                        else if (narrowed.length === 0) {
+                            // ADL contributed candidates, but none survived arity/type
+                            // narrowing. Treat as handled to avoid global-name fallback
+                            // binding to the same mismatched symbol by simple-name
+                            // uniqueness.
+                            handledSites.add(siteKey);
+                            continue;
+                        }
+                        else if (narrowed.length > 1) {
+                            // Suppress ambiguous overload calls (emit zero edges) when
+                            // merged ordinary+ADL candidate sets cannot be disambiguated.
+                            if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
+                                handledSites.add(siteKey);
+                                continue;
+                            }
+                            // Multiple survivors remain but no conversion-ranking step
+                            // exists yet; suppress instead of picking arbitrarily.
+                            handledSites.add(siteKey);
+                            continue;
+                        }
+                    }
                 }
             }
             // V1: pickUniqueGlobalCallable ignores import context — resolves to any
             // globally-unique callable. False cross-package edges are possible when
             // the caller does not import the target package. Same-package calls are
-            // caught by findCallableBindingInScope above before reaching here.
+            // usually caught by nearest-scope lookup before reaching here.
             if (fnDef === undefined && options.allowGlobalFallback === true) {
                 fnDef = pickUniqueGlobalCallable(site.name, model, scopes, parsed.filePath, options.isFileLocalDef, site.arity, options.isCallableVisibleFromCaller !== undefined
                     ? (candidate) => options.isCallableVisibleFromCaller({

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/dist/core/ingestion/scope-resolution/scope/walkers.d.ts

@@ -102,6 +102,36 @@ export declare function findClassBindingInScope(startScope: ScopeId, receiverNam
  * def-type predicate differs.
  */
 export declare function findCallableBindingInScope(startScope: ScopeId, callableName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+/**
+ * Look up all callable bindings (Function/Method/Constructor) by name
+ * from the nearest scope in the chain that binds `callableName`.
+ *
+ * Preserves the original scope-walk boundary used by
+ * `findCallableBindingInScope`: once any callable binding is found in a
+ * scope, outer scopes are not consulted.
+ */
+export declare function findAllCallableBindingsInScope(startScope: ScopeId, callableName: string, scopes: ScopeResolutionIndexes): readonly SymbolDefinition[];
+/**
+ * ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when ordinary
+ * unqualified lookup finds:
+ *   - a name that is NOT a function or function template, OR
+ *   - a block-scope function declaration that is NOT a using-declaration.
+ *
+ * Combined walker that stops at the **nearest scope** where `name` has any
+ * binding (callable or non-callable) and returns:
+ *   - `callables`: Function/Method/Constructor defs found at that scope
+ *   - `nonCallableFound`: a non-function binding was present (variable, class, etc.)
+ *   - `blockScopeDeclFound`: a callable was found at a Function or Block scope
+ *     (block-scope function declaration that blocks ADL)
+ *
+ * One pass, one stop — no divergence between callable collection and blocker
+ * detection.
+ */
+export declare function findCallableBindingsAndAdlBlocker(startScope: ScopeId, name: string, scopes: ScopeResolutionIndexes): {
+    callables: readonly SymbolDefinition[];
+    nonCallableFound: boolean;
+    blockScopeDeclFound: boolean;
+};
 /**
  * Populate `ownerId` on every def structurally owned by a Class
  * scope — methods (defs in Function scopes whose parent is Class)

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

@@ -209,32 +209,114 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
  * def-type predicate differs.
  */
 export function findCallableBindingInScope(startScope, callableName, scopes) {
+    return findAllCallableBindingsInScope(startScope, callableName, scopes)[0];
+}
+/**
+ * Look up all callable bindings (Function/Method/Constructor) by name
+ * from the nearest scope in the chain that binds `callableName`.
+ *
+ * Preserves the original scope-walk boundary used by
+ * `findCallableBindingInScope`: once any callable binding is found in a
+ * scope, outer scopes are not consulted.
+ */
+export function findAllCallableBindingsInScope(startScope, callableName, scopes) {
     let currentId = startScope;
     const visited = new Set();
     while (currentId !== null) {
         if (visited.has(currentId))
-            return undefined;
+            return [];
         visited.add(currentId);
         const scope = scopes.scopeTree.getScope(currentId);
         if (scope === undefined)
-            return undefined;
+            return [];
+        const out = [];
+        const seen = new Set();
+        const pushCallable = (def) => {
+            if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
+                return;
+            if (seen.has(def.nodeId))
+                return;
+            seen.add(def.nodeId);
+            out.push(def);
+        };
         const localBindings = scope.bindings.get(callableName);
         if (localBindings !== undefined) {
             for (const b of localBindings) {
-                if (b.def.type === 'Function' || b.def.type === 'Method' || b.def.type === 'Constructor') {
-                    return b.def;
-                }
+                pushCallable(b.def);
             }
         }
         const importedBindings = lookupBindingsAt(currentId, callableName, scopes);
         for (const b of importedBindings) {
-            if (b.def.type === 'Function' || b.def.type === 'Method' || b.def.type === 'Constructor') {
-                return b.def;
+            pushCallable(b.def);
+        }
+        if (out.length > 0)
+            return out;
+        currentId = scope.parent;
+    }
+    return [];
+}
+/**
+ * ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when ordinary
+ * unqualified lookup finds:
+ *   - a name that is NOT a function or function template, OR
+ *   - a block-scope function declaration that is NOT a using-declaration.
+ *
+ * Combined walker that stops at the **nearest scope** where `name` has any
+ * binding (callable or non-callable) and returns:
+ *   - `callables`: Function/Method/Constructor defs found at that scope
+ *   - `nonCallableFound`: a non-function binding was present (variable, class, etc.)
+ *   - `blockScopeDeclFound`: a callable was found at a Function or Block scope
+ *     (block-scope function declaration that blocks ADL)
+ *
+ * One pass, one stop — no divergence between callable collection and blocker
+ * detection.
+ */
+export function findCallableBindingsAndAdlBlocker(startScope, name, scopes) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return { callables: [], nonCallableFound: false, blockScopeDeclFound: false };
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return { callables: [], nonCallableFound: false, blockScopeDeclFound: false };
+        const callables = [];
+        const seen = new Set();
+        let nonCallableFound = false;
+        let anyBinding = false;
+        const process = (def) => {
+            anyBinding = true;
+            if (def.type === 'Function' || def.type === 'Method' || def.type === 'Constructor') {
+                if (!seen.has(def.nodeId)) {
+                    seen.add(def.nodeId);
+                    callables.push(def);
+                }
+            }
+            else {
+                nonCallableFound = true;
+            }
+        };
+        const localBindings = scope.bindings.get(name);
+        if (localBindings !== undefined) {
+            for (const b of localBindings) {
+                process(b.def);
             }
         }
+        const importedBindings = lookupBindingsAt(currentId, name, scopes);
+        for (const b of importedBindings) {
+            process(b.def);
+        }
+        if (anyBinding) {
+            // ISO C++: a block-scope function declaration (Function or Block scope)
+            // that is NOT a using-declaration blocks ADL. If we found callables at
+            // a function/block scope, ADL must be suppressed.
+            const blockScopeDeclFound = callables.length > 0 && (scope.kind === 'Function' || scope.kind === 'Block');
+            return { callables, nonCallableFound, blockScopeDeclFound };
+        }
         currentId = scope.parent;
     }
-    return undefined;
+    return { callables: [], nonCallableFound: false, blockScopeDeclFound: false };
 }
 /**
  * Populate `ownerId` on every def structurally owned by a Class

package/package.json

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