gitnexus 1.6.6-rc.99 → 1.6.6

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,25 +73,338 @@ import { isCppInlineNamespaceScope } from './inline-namespaces.js';
 const argInfoBySite = new Map();
 const noAdlSites = new Set();
 const classToNamespaceQualifiedName = new Map();
+/**
+ * Per-`filePath` index of the site keys this file contributed to
+ * `argInfoBySite` / `noAdlSites`, kept in **strict lockstep** with those two
+ * maps (#1983 perf). Without it, `collectCppAdlSideChannel(filePath)` had to
+ * scan the ENTIRE module-level maps (every site of every file the worker
+ * parsed in the current sub-batch) and `parseSiteKey` each entry just to pick
+ * out one file's slice — O(F²) per sub-batch (~100M `parseSiteKey` calls
+ * across the Linux kernel). These indexes turn collect into
+ * O(entries-for-this-file).
+ *
+ * Lockstep invariant: a key is pushed here at most once, exactly when it is
+ * first inserted into the corresponding map, and both indexes are cleared
+ * wherever `argInfoBySite` / `noAdlSites` are cleared (`clearCppAdlState` and
+ * the per-file restore in `applyCppAdlSideChannel`). The "first insert only"
+ * guard mirrors the maps' own de-dup (`Map.set` / `Set.add` are idempotent on
+ * the key), so iterating an index yields each of this file's keys exactly once
+ * — byte-identical to the old filtered full scan.
+ */
+const argInfoSiteKeysByFile = new Map();
+const noAdlSiteKeysByFile = new Map();
+/** Push `key` into the per-file index `idx[filePath]` (creating the bucket on
+ *  first use). Callers guard against duplicate keys so each key appears once. */
+function pushFileSiteKey(idx, filePath, key) {
+    let keys = idx.get(filePath);
+    if (keys === undefined) {
+        keys = [];
+        idx.set(filePath, keys);
+    }
+    keys.push(key);
+}
+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) {
-    argInfoBySite.set(siteKey(filePath, line, col), args);
+    const key = siteKey(filePath, line, col);
+    // Lockstep with `argInfoSiteKeysByFile`: index the key only on first insert
+    // (a re-mark overwrites the value but must NOT duplicate the index entry).
+    if (!argInfoBySite.has(key))
+        pushFileSiteKey(argInfoSiteKeysByFile, filePath, key);
+    argInfoBySite.set(key, args);
 }
 /** Mark a call site as ADL-suppressed (function child wrapped in
  *  `parenthesized_expression`, e.g. `(f)(s)`). */
 export function markCppAdlSiteNoAdl(filePath, line, col) {
-    noAdlSites.add(siteKey(filePath, line, col));
+    const key = siteKey(filePath, line, col);
+    // Lockstep with `noAdlSiteKeysByFile`: index the key only on first insert.
+    if (!noAdlSites.has(key))
+        pushFileSiteKey(noAdlSiteKeysByFile, filePath, key);
+    noAdlSites.add(key);
+}
+const SITE_KEY_RE = /^(.*):(\d+):(\d+)$/;
+/** Split a `filePath:line:col` site key, tolerating colons in the path. */
+function parseSiteKey(key) {
+    const m = SITE_KEY_RE.exec(key);
+    if (m === null)
+        return undefined;
+    return { filePath: m[1], line: Number(m[2]), col: Number(m[3]) };
 }
-/** Clear ADL state. Called from `clearFileLocalNames` so all C++ resolver
- *  per-pipeline state is reset together. */
+/**
+ * Snapshot this file's ADL capture state for the worker→main side-channel.
+ *
+ * Uses the per-file `argInfoSiteKeysByFile` / `noAdlSiteKeysByFile` indexes to
+ * touch only THIS file's entries — O(entries-for-this-file) — instead of the
+ * old O(all-entries) full scan over `argInfoBySite` / `noAdlSites` (#1983).
+ * The output order, and therefore the serialized JSON shape, is byte-identical
+ * to the old filtered scan: the index records keys in the same insertion order
+ * the maps' own iteration would have yielded for this file, and each key is
+ * indexed exactly once (mark guards on first insert), so the same per-file
+ * subsequence is produced.
+ *
+ * `parseSiteKey` is still used to recover `line:col` from each key, but now
+ * only for this file's keys (a bounded handful), never for the whole batch.
+ */
+export function collectCppAdlSideChannel(filePath) {
+    const args = [];
+    for (const key of argInfoSiteKeysByFile.get(filePath) ?? []) {
+        const value = argInfoBySite.get(key);
+        const parsed = parseSiteKey(key);
+        if (value !== undefined && parsed !== undefined) {
+            args.push([parsed.line, parsed.col, value]);
+        }
+    }
+    const noAdl = [];
+    for (const key of noAdlSiteKeysByFile.get(filePath) ?? []) {
+        const parsed = parseSiteKey(key);
+        if (parsed !== undefined) {
+            noAdl.push([parsed.line, parsed.col]);
+        }
+    }
+    return { argInfoBySite: args, noAdlSites: noAdl };
+}
+/** Restore this file's ADL capture state from the side-channel (no parse).
+ *  Keeps the per-file site-key indexes in lockstep with `argInfoBySite` /
+ *  `noAdlSites` (first-insert-only) so a later `collectCppAdlSideChannel` on
+ *  the same process would still produce a correct, duplicate-free snapshot. */
+export function applyCppAdlSideChannel(filePath, data) {
+    for (const [line, col, value] of data.argInfoBySite) {
+        const key = siteKey(filePath, line, col);
+        if (!argInfoBySite.has(key))
+            pushFileSiteKey(argInfoSiteKeysByFile, filePath, key);
+        argInfoBySite.set(key, value);
+    }
+    for (const [line, col] of data.noAdlSites) {
+        const key = siteKey(filePath, line, col);
+        if (!noAdlSites.has(key))
+            pushFileSiteKey(noAdlSiteKeysByFile, filePath, key);
+        noAdlSites.add(key);
+    }
+}
+/** 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();
+    // Lockstep: the per-file site-key indexes mirror argInfoBySite/noAdlSites and
+    // MUST be cleared together — a stale index would resurrect a prior pass's
+    // (or prior file's, after a re-key) keys into the next snapshot.
+    argInfoSiteKeysByFile.clear();
+    noAdlSiteKeysByFile.clear();
     classToNamespaceQualifiedName.clear();
+    adlIndex = undefined;
+    adlIndexSource = undefined;
 }
 /**
  * Walk `parsed.scopes` to record each Class def's enclosing namespace
@@ -148,123 +466,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.
+            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);
             }
         }
-        // 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)
+    };
+    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 +536,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 +629,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 +655,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 +670,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/dist/core/ingestion/languages/cpp/arity-metadata.js

@@ -23,7 +23,6 @@ export function computeCppDeclarationArity(node) {
             continue;
         if (child.type === 'parameter_declaration' ||
             child.type === 'optional_parameter_declaration' ||
-            child.type === 'variadic_parameter' ||
             child.type === 'variadic_parameter_declaration') {
             params.push(child);
         }
@@ -47,8 +46,7 @@ export function computeCppDeclarationArity(node) {
     // token in tree-sitter-cpp, detected via `hasEllipsis` above.
     // C++ parameter packs: `template<typename... Ts> void foo(Ts... args)` —
     // detected as `variadic_parameter_declaration`.
-    const isVariadic = hasEllipsis ||
-        params.some((p) => p.type === 'variadic_parameter' || p.type === 'variadic_parameter_declaration');
+    const isVariadic = hasEllipsis || params.some((p) => p.type === 'variadic_parameter_declaration');
     const optionalCount = params.filter((p) => p.type === 'optional_parameter_declaration').length;
     const requiredCount = params.filter((p) => p.type === 'parameter_declaration' ||
         // variadic_parameter_declaration with a name is a parameter pack — counts as one
@@ -57,11 +55,7 @@ export function computeCppDeclarationArity(node) {
     const types = [];
     const typeClasses = [];
     for (const p of params) {
-        if (p.type === 'variadic_parameter') {
-            types.push('...');
-            typeClasses.push(unknownTypeClass('...'));
-        }
-        else if (p.type === 'variadic_parameter_declaration') {
+        if (p.type === 'variadic_parameter_declaration') {
             // Parameter pack: treated as variadic
             types.push('...');
             typeClasses.push(unknownTypeClass('...'));