gitnexus 1.6.6-rc.124 → 1.6.6-rc.125

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

@@ -49,13 +49,18 @@
  *
  * ## State lifecycle
  *
- * Three module-level maps populated per pipeline invocation, cleared via
- * `clearCppAdlState()` (called from `clearFileLocalNames`):
+ * Five pieces of module-level state populated per pipeline invocation, all
+ * reset together by `clearCppAdlState()` (called from
+ * `cppScopeResolver.loadResolutionConfig`, alongside `clearFileLocalNames` —
+ * NOT from `clearFileLocalNames` itself), grouped by when they fill:
  *
  *   - `argInfoBySite` — per-call-site argument shape (capture-time)
  *   - `noAdlSites` — call sites with parenthesized function (capture-time)
  *   - `classToNamespaceQualifiedName` — class def → its enclosing namespace
  *     qualified name (`populateCppAssociatedNamespaces` time)
+ *   - `adlIndex` / `adlIndexSource` — the lazily-built candidate index and the
+ *     `parsedFiles` reference it was built from (first-`pickCppAdlCandidates`
+ *     time; see `ensureAdlIndex`)
  *
  * The class→namespace map uses qualified names (not scope IDs) because
  * C++ namespaces are open: `namespace N { ... }` in file A and
@@ -94,14 +99,59 @@ export interface CppAdlArgInfo {
      *  referenced Function/Method def's parameter and return types. */
     readonly functionRefText?: string;
 }
+/**
+ * ADL candidate index — built **once** per pipeline run from
+ * `(scopes, parsedFiles)` and reused by every call site.
+ *
+ * The legacy `pickCppAdlCandidates` re-scanned all parsed files (rebuilding a
+ * per-file `scopesById` map each time), all workspace defs (for the
+ * class-by-simple-name lookup), and used an O(scopes²) child-scope walk for
+ * hidden friends — once **per unresolved call site**. With hundreds of
+ * thousands of unresolved C++ sites that made the scope-resolution emit phase
+ * super-linear (observed ~6.7h on a large repo). This index moves all of that
+ * work to a single pass; per-site cost drops to O(associated namespaces).
+ */
+export interface AdlCandidateIndex {
+    /** simple name → class-like defs (Class/Struct/Interface/Enum), preserving
+     *  `scopes.defs.byId` iteration order so first-match / ambiguous semantics
+     *  match the legacy linear scan. */
+    readonly classDefsBySimple: Map<string, SymbolDefinition[]>;
+    /** namespace QName → simple name → callable defs owned by that namespace,
+     *  with inline-namespace transparency (inline-ns defs are also registered
+     *  under the parent namespace's QName). */
+    readonly nsCandidates: Map<string, Map<string, SymbolDefinition[]>>;
+    /** associated-class enclosing-namespace QName → simple name → hidden-friend
+     *  and class-member callable defs. */
+    readonly friendCandidates: Map<string, Map<string, SymbolDefinition[]>>;
+    /** namespace QName (own) → simple name → Function/Method defs, for the
+     *  qualified function-reference ADL path. */
+    readonly nsFunctionsByQName: Map<string, Map<string, SymbolDefinition[]>>;
+    /** simple name → Function/Method defs across all namespaces, for the
+     *  unqualified function-reference ADL path. */
+    readonly nsFunctionsBySimple: Map<string, SymbolDefinition[]>;
+    /** nodeId → visitation sequence number, used to merge per-namespace buckets
+     *  back into the exact legacy candidate order (file-major; namespace defs
+     *  before friend/member defs within a file). */
+    readonly seqByNodeId: Map<string, number>;
+}
+/**
+ * Return the nodeIds present in the index's candidate buckets
+ * (`nsCandidates` + `friendCandidates`) but missing from `seqByNodeId`, each
+ * reported once. Empty array means the seq-coverage invariant holds — which it
+ * must, since `buildAdlIndex` assigns a seq to every callable def in the same
+ * block that buckets it. Exported for the dev-gated guard in `buildAdlIndex`
+ * and its unit test.
+ */
+export declare function validateAdlSeqCoverage(idx: AdlCandidateIndex): string[];
 /** 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;
 /** Mark a call site as ADL-suppressed (function child wrapped in
  *  `parenthesized_expression`, e.g. `(f)(s)`). */
 export declare function markCppAdlSiteNoAdl(filePath: string, line: number, col: number): void;
-/** Clear ADL state. Called from `clearFileLocalNames` so all C++ resolver
- *  per-pipeline state is reset together. */
+/** Clear ADL state. Called from `cppScopeResolver.loadResolutionConfig`
+ *  (alongside `clearFileLocalNames`) so all C++ resolver per-pipeline state is
+ *  reset together at the start of each resolution pass. */
 export declare function clearCppAdlState(): void;
 /**
  * Walk `parsed.scopes` to record each Class def's enclosing namespace

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

@@ -49,13 +49,18 @@
  *
  * ## State lifecycle
  *
- * Three module-level maps populated per pipeline invocation, cleared via
- * `clearCppAdlState()` (called from `clearFileLocalNames`):
+ * Five pieces of module-level state populated per pipeline invocation, all
+ * reset together by `clearCppAdlState()` (called from
+ * `cppScopeResolver.loadResolutionConfig`, alongside `clearFileLocalNames` —
+ * NOT from `clearFileLocalNames` itself), grouped by when they fill:
  *
  *   - `argInfoBySite` — per-call-site argument shape (capture-time)
  *   - `noAdlSites` — call sites with parenthesized function (capture-time)
  *   - `classToNamespaceQualifiedName` — class def → its enclosing namespace
  *     qualified name (`populateCppAssociatedNamespaces` time)
+ *   - `adlIndex` / `adlIndexSource` — the lazily-built candidate index and the
+ *     `parsedFiles` reference it was built from (first-`pickCppAdlCandidates`
+ *     time; see `ensureAdlIndex`)
  *
  * The class→namespace map uses qualified names (not scope IDs) because
  * C++ namespaces are open: `namespace N { ... }` in file A and
@@ -68,9 +73,216 @@ import { isCppInlineNamespaceScope } from './inline-namespaces.js';
 const argInfoBySite = new Map();
 const noAdlSites = new Set();
 const classToNamespaceQualifiedName = new Map();
+let adlIndex;
+let adlIndexSource;
 function siteKey(filePath, line, col) {
     return `${filePath}:${line}:${col}`;
 }
+/** Last segment of a dotted qualified name (matches legacy inline expression). */
+function adlSimpleName(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}
+function isAdlCallableType(type) {
+    return type === 'Function' || type === 'Method' || type === 'Constructor';
+}
+function pushNested(map, outerKey, innerKey, def) {
+    let inner = map.get(outerKey);
+    if (inner === undefined) {
+        inner = new Map();
+        map.set(outerKey, inner);
+    }
+    let arr = inner.get(innerKey);
+    if (arr === undefined) {
+        arr = [];
+        inner.set(innerKey, arr);
+    }
+    arr.push(def);
+}
+function pushFlat(map, key, def) {
+    let arr = map.get(key);
+    if (arr === undefined) {
+        arr = [];
+        map.set(key, arr);
+    }
+    arr.push(def);
+}
+/** Build the ADL candidate index in a single pass over the workspace. The
+ *  visitation order (file-major; per file, all namespace scopes before all
+ *  class scopes; ownedDefs in declaration order) mirrors the legacy push
+ *  order so `seqByNodeId` reconstructs identical candidate ordering. */
+function buildAdlIndex(scopes, parsedFiles) {
+    const idx = {
+        classDefsBySimple: new Map(),
+        nsCandidates: new Map(),
+        friendCandidates: new Map(),
+        nsFunctionsByQName: new Map(),
+        nsFunctionsBySimple: new Map(),
+        seqByNodeId: new Map(),
+    };
+    // (1) class-like defs by simple name — preserve byId order so arr[0] is the
+    //     legacy `firstMatch` and `arr.length > 1` is the legacy `ambiguous`.
+    for (const def of scopes.defs.byId.values()) {
+        if (def.type !== 'Class' &&
+            def.type !== 'Struct' &&
+            def.type !== 'Interface' &&
+            def.type !== 'Enum')
+            continue;
+        pushFlat(idx.classDefsBySimple, adlSimpleName(def), def);
+    }
+    let seq = 0;
+    for (const parsed of parsedFiles) {
+        const scopesById = new Map();
+        for (const sc of parsed.scopes)
+            scopesById.set(sc.id, sc);
+        // parent → children, built once (replaces the legacy O(scopes²) walk).
+        const childrenByParent = new Map();
+        for (const sc of parsed.scopes) {
+            if (sc.parent === null)
+                continue;
+            let kids = childrenByParent.get(sc.parent);
+            if (kids === undefined) {
+                kids = [];
+                childrenByParent.set(sc.parent, kids);
+            }
+            kids.push(sc);
+        }
+        // PASS A — namespace-owned candidates (+ function-reference indexes).
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Namespace')
+                continue;
+            const qName = computeNamespaceQName(scope, scopesById);
+            // Registration keys reproduce the legacy membership test: own QName
+            // always; for an inline namespace child of a Namespace, also the parent
+            // QName (ISO C++ inline-namespace transparency for ADL).
+            const keys = [];
+            if (qName !== '')
+                keys.push(qName);
+            if (isCppInlineNamespaceScope(scope.id)) {
+                const parentScope = scope.parent !== null ? scopesById.get(scope.parent) : undefined;
+                if (parentScope !== undefined && parentScope.kind === 'Namespace') {
+                    const parentQName = computeNamespaceQName(parentScope, scopesById);
+                    if (parentQName !== '' && parentQName !== qName)
+                        keys.push(parentQName);
+                }
+            }
+            for (const def of scope.ownedDefs) {
+                if (def.type === 'Function' || def.type === 'Method') {
+                    const sn = adlSimpleName(def);
+                    pushFlat(idx.nsFunctionsBySimple, sn, def);
+                    if (qName !== '')
+                        pushNested(idx.nsFunctionsByQName, qName, sn, def);
+                }
+                if (!isAdlCallableType(def.type))
+                    continue;
+                const s = seq++;
+                idx.seqByNodeId.set(def.nodeId, s);
+                const sn = adlSimpleName(def);
+                for (const key of keys)
+                    pushNested(idx.nsCandidates, key, sn, def);
+            }
+        }
+        // PASS B — hidden-friend + class-member candidates for associated classes.
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Class')
+                continue;
+            // Enclosing-namespace QName(s) of the class def(s) in this scope.
+            const classNsKeys = new Set();
+            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)
+                    classNsKeys.add(nsQName);
+            }
+            if (classNsKeys.size === 0)
+                continue;
+            // Friend functions: callable defs in child Function scopes.
+            for (const childScope of childrenByParent.get(scope.id) ?? []) {
+                if (childScope.kind !== 'Function')
+                    continue;
+                for (const def of childScope.ownedDefs) {
+                    if (!isAdlCallableType(def.type))
+                        continue;
+                    const s = seq++;
+                    idx.seqByNodeId.set(def.nodeId, s);
+                    const sn = adlSimpleName(def);
+                    for (const key of classNsKeys)
+                        pushNested(idx.friendCandidates, key, sn, def);
+                }
+            }
+            // Class-member callables.
+            for (const def of scope.ownedDefs) {
+                if (!isAdlCallableType(def.type))
+                    continue;
+                const s = seq++;
+                idx.seqByNodeId.set(def.nodeId, s);
+                const sn = adlSimpleName(def);
+                for (const key of classNsKeys)
+                    pushNested(idx.friendCandidates, key, sn, def);
+            }
+        }
+    }
+    // Dev/test-only invariant guard: every def bucketed into nsCandidates/
+    // friendCandidates must have a seqByNodeId entry, otherwise the `?? 0`
+    // fallback in pickCppAdlCandidates could collapse two seq-0 candidates and
+    // silently drop a CALLS edge. Gated like the rest of the resolver's opt-in
+    // validation (see contract/scope-resolver.ts and reconcile-ownership.ts):
+    // active in dev/test, off in production and when VALIDATE_SEMANTIC_MODEL=0.
+    if (process.env.NODE_ENV !== 'production' && process.env.VALIDATE_SEMANTIC_MODEL !== '0') {
+        const missing = validateAdlSeqCoverage(idx);
+        if (missing.length > 0) {
+            throw new Error(`[cpp-adl] seq-coverage invariant violated: ${missing.length} candidate def(s) ` +
+                `bucketed without a seqByNodeId entry (e.g. ${missing.slice(0, 5).join(', ')}). ` +
+                `Every def pushed into nsCandidates/friendCandidates must be seq-assigned in the ` +
+                `same build block — see pickCppAdlCandidates' \`?? 0\` fallback.`);
+        }
+    }
+    return idx;
+}
+/**
+ * Return the nodeIds present in the index's candidate buckets
+ * (`nsCandidates` + `friendCandidates`) but missing from `seqByNodeId`, each
+ * reported once. Empty array means the seq-coverage invariant holds — which it
+ * must, since `buildAdlIndex` assigns a seq to every callable def in the same
+ * block that buckets it. Exported for the dev-gated guard in `buildAdlIndex`
+ * and its unit test.
+ */
+export function validateAdlSeqCoverage(idx) {
+    const missing = new Set();
+    for (const buckets of [idx.nsCandidates, idx.friendCandidates]) {
+        for (const bySimple of buckets.values()) {
+            for (const defs of bySimple.values()) {
+                for (const def of defs) {
+                    if (!idx.seqByNodeId.has(def.nodeId))
+                        missing.add(def.nodeId);
+                }
+            }
+        }
+    }
+    return [...missing];
+}
+/** Build the ADL index on first use of a given `parsedFiles` set; reuse it for
+ *  all subsequent call sites in the same pipeline run. Reset by
+ *  `clearCppAdlState`.
+ *
+ *  Staleness is keyed on `parsedFiles` reference identity ONLY, but the index
+ *  is a function of THREE inputs: `parsedFiles` (namespace/friend candidates),
+ *  `scopes` (`classDefsBySimple`, read from `scopes.defs.byId`), and the
+ *  module-level `classToNamespaceQualifiedName` (friend-candidate keys). This
+ *  is sound for the current pipeline because all three are built together once
+ *  per `runScopeResolution` pass and `clearCppAdlState` runs in
+ *  `loadResolutionConfig` at the start of every pass. Callers MUST call
+ *  `clearCppAdlState` between any two passes that change `scopes` or
+ *  `classToNamespaceQualifiedName` while reusing the same `parsedFiles` array
+ *  reference — otherwise a stale index would be served. (No such caller exists
+ *  today; widening the guard to also key on `scopes` is deferred until one
+ *  does.) */
+function ensureAdlIndex(scopes, parsedFiles) {
+    if (adlIndex !== undefined && adlIndexSource === parsedFiles)
+        return;
+    adlIndex = buildAdlIndex(scopes, parsedFiles);
+    adlIndexSource = parsedFiles;
+}
 /** Record per-call-site argument info. Called once per call site from
  *  `emitCppScopeCaptures`. */
 export function markCppAdlSiteArgs(filePath, line, col, args) {
@@ -81,12 +293,15 @@ export function markCppAdlSiteArgs(filePath, line, col, args) {
 export function markCppAdlSiteNoAdl(filePath, line, col) {
     noAdlSites.add(siteKey(filePath, line, col));
 }
-/** Clear ADL state. Called from `clearFileLocalNames` so all C++ resolver
- *  per-pipeline state is reset together. */
+/** Clear ADL state. Called from `cppScopeResolver.loadResolutionConfig`
+ *  (alongside `clearFileLocalNames`) so all C++ resolver per-pipeline state is
+ *  reset together at the start of each resolution pass. */
 export function clearCppAdlState() {
     argInfoBySite.clear();
     noAdlSites.clear();
     classToNamespaceQualifiedName.clear();
+    adlIndex = undefined;
+    adlIndexSource = undefined;
 }
 /**
  * Walk `parsed.scopes` to record each Class def's enclosing namespace
@@ -148,123 +363,54 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     const args = argInfoBySite.get(key);
     if (args === undefined || args.length === 0)
         return undefined;
+    // Build the workspace-wide ADL candidate index once; reuse for every site.
+    ensureAdlIndex(scopes, parsedFiles);
     // Collect associated namespace QNames from every participating class-typed arg
     // and from function-reference args.
     const associatedNamespaces = new Set();
     for (const arg of args) {
         collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces);
         if (arg.functionRefText !== undefined) {
-            collectFunctionTypeAssociatedNamespaces(arg.functionRefText, scopes, parsedFiles, associatedNamespaces);
+            collectFunctionTypeAssociatedNamespaces(arg.functionRefText, scopes, associatedNamespaces);
         }
     }
     if (associatedNamespaces.size === 0)
         return undefined;
-    // 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 = [];
+    // Gather candidates from the prebuilt index instead of re-scanning every
+    // parsed file. For each associated namespace, pull:
+    //   - namespace-owned callables (`nsCandidates`, includes inline-namespace
+    //     transparency), AND
+    //   - hidden-friend / class-member callables of associated classes
+    //     (`friendCandidates`, ISO C++ `[basic.lookup.argdep]` §2).
+    // Dedup by nodeId and sort by visitation sequence so the candidate list is
+    // byte-for-byte identical to the legacy file-major scan order.
+    const idx = adlIndex;
+    if (idx === undefined)
+        return undefined;
+    const bySeq = new Map();
     const seenKey = new Set();
-    for (const parsed of parsedFiles) {
-        const scopesById = new Map();
-        for (const sc of parsed.scopes)
-            scopesById.set(sc.id, sc);
-        for (const scope of parsed.scopes) {
-            if (scope.kind !== 'Namespace')
+    const collectFrom = (buckets) => {
+        for (const ns of associatedNamespaces) {
+            const matches = buckets.get(ns)?.get(site.name);
+            if (matches === undefined)
                 continue;
-            const qName = computeNamespaceQName(scope, scopesById);
-            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;
-                }
-                const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
-                if (simple !== site.name)
-                    continue;
-                // Dedup by nodeId — using normalized parameter-types as the key
-                // would collapse `process(int)`/`process(long)`-style overloads
-                // (both normalize to `['int']`) before
-                // `isOverloadAmbiguousAfterNormalization` can detect them.
-                if (seenKey.has(def.nodeId))
-                    continue;
-                seenKey.add(def.nodeId);
-                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;
+            for (const def of matches) {
                 if (seenKey.has(def.nodeId))
                     continue;
                 seenKey.add(def.nodeId);
-                candidates.push(def);
+                // `?? 0` is unreachable: every bucketed def is seq-assigned in the same
+                // block that buckets it in buildAdlIndex (PASS A / PASS B). The dev-gated
+                // validateAdlSeqCoverage guard in buildAdlIndex fails loudly if that ever
+                // breaks, rather than letting two seq-0 defs collide and drop a candidate.
+                bySeq.set(idx.seqByNodeId.get(def.nodeId) ?? 0, def);
             }
         }
-    }
-    if (candidates.length === 0)
+    };
+    collectFrom(idx.nsCandidates);
+    collectFrom(idx.friendCandidates);
+    if (bySeq.size === 0)
         return undefined;
-    return candidates;
+    return [...bySeq.entries()].sort((a, b) => a[0] - b[0]).map(([, def]) => def);
 }
 function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces) {
     // For template args this may be the template name itself (e.g. `vector`);
@@ -287,7 +433,7 @@ function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces)
 function addAssociatedNamespaceForClassName(simpleClassName, scopes, associatedNamespaces) {
     if (simpleClassName.length === 0)
         return;
-    const classLookup = findCppClassDefBySimpleName(simpleClassName, scopes);
+    const classLookup = findCppClassDefBySimpleName(simpleClassName);
     if (classLookup === undefined)
         return;
     const { classDef, ambiguous } = classLookup;
@@ -380,32 +526,25 @@ function findNamespaceDefInScope(scope) {
  *
  *  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' &&
-            def.type !== 'Enum')
-            continue;
-        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
-        if (simple !== simpleName)
-            continue;
-        if (firstMatch === undefined) {
-            firstMatch = def;
-            continue;
-        }
-        return { classDef: firstMatch, ambiguous: true };
-    }
-    if (firstMatch === undefined)
+function findCppClassDefBySimpleName(simpleName) {
+    // `classDefsBySimple` preserves `scopes.defs.byId` order, so `[0]` is the
+    // legacy first-match and `length > 1` is the legacy `ambiguous` flag.
+    const matches = adlIndex?.classDefsBySimple.get(simpleName);
+    if (matches === undefined)
+        return undefined;
+    const first = matches[0];
+    if (first === undefined)
         return undefined;
-    return { classDef: firstMatch, ambiguous: false };
+    return { classDef: first, ambiguous: matches.length > 1 };
 }
 /**
  * Contribute associated namespaces for a function-reference argument by walking
  * the referenced overload set's parameter and return types.
  */
-function collectFunctionTypeAssociatedNamespaces(refText, scopes, parsedFiles, out) {
+function collectFunctionTypeAssociatedNamespaces(refText, scopes, out) {
+    const idx = adlIndex;
+    if (idx === undefined)
+        return;
     const colonIdx = refText.lastIndexOf('::');
     if (colonIdx !== -1) {
         // Qualified ref: extract namespace prefix and normalise :: → dot notation.
@@ -413,27 +552,14 @@ function collectFunctionTypeAssociatedNamespaces(refText, scopes, parsedFiles, o
         if (nsText === '')
             return;
         const simpleName = refText.slice(colonIdx + 2);
-        // Verify that a Function/Method named `simpleName` exists in `nsText`.
-        // Without this guard every `a::b` qualified_identifier arg (variable,
-        // enum value, static member, type alias) would blindly contribute `a`
-        // to the associated set and risk a false-positive CALLS edge.
-        for (const parsed of parsedFiles) {
-            const scopesById = new Map();
-            for (const sc of parsed.scopes)
-                scopesById.set(sc.id, sc);
-            for (const scope of parsed.scopes) {
-                if (scope.kind !== 'Namespace')
-                    continue;
-                if (computeNamespaceQName(scope, scopesById) !== nsText)
-                    continue;
-                for (const def of scope.ownedDefs) {
-                    if (def.type !== 'Function' && def.type !== 'Method')
-                        continue;
-                    const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
-                    if (simple === simpleName)
-                        collectAssociatedNamespacesForFunctionDef(def, scopes, out);
-                }
-            }
+        // Only Function/Method defs named `simpleName` in `nsText` contribute
+        // (the index already restricts to those types); this guards against an
+        // `a::b` arg that names a variable / enum value / type alias blindly
+        // contributing `a` to the associated set (false-positive CALLS edge).
+        const matches = idx.nsFunctionsByQName.get(nsText)?.get(simpleName);
+        if (matches !== undefined) {
+            for (const def of matches)
+                collectAssociatedNamespacesForFunctionDef(def, scopes, out);
         }
         return;
     }
@@ -441,19 +567,10 @@ function collectFunctionTypeAssociatedNamespaces(refText, scopes, parsedFiles, o
     // the previous V1 lookup scope. The stricter part of this PR is what each
     // overload contributes: only namespaces from parameter/return types, never
     // the function's own enclosing namespace.
-    for (const parsed of parsedFiles) {
-        for (const scope of parsed.scopes) {
-            if (scope.kind !== 'Namespace')
-                continue;
-            for (const def of scope.ownedDefs) {
-                if (def.type !== 'Function' && def.type !== 'Method')
-                    continue;
-                const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
-                if (simple !== refText)
-                    continue;
-                collectAssociatedNamespacesForFunctionDef(def, scopes, out);
-            }
-        }
+    const matches = idx.nsFunctionsBySimple.get(refText);
+    if (matches !== undefined) {
+        for (const def of matches)
+            collectAssociatedNamespacesForFunctionDef(def, scopes, out);
     }
 }
 function collectAssociatedNamespacesForFunctionDef(def, scopes, out) {

package/package.json

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