gitnexus 1.6.10-rc.146 → 1.6.10-rc.147

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

@@ -58,8 +58,8 @@
  *   - `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`
+ *   - `adlIndexByPass` — the lazily-built candidate index, memoized weakly on
+ *     the `parsedFiles` array it was built from (first-`pickCppAdlCandidates`
  *     time; see `ensureAdlIndex`)
  *
  * The class→namespace map uses qualified names (not scope IDs) because

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

@@ -58,8 +58,8 @@
  *   - `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`
+ *   - `adlIndexByPass` — the lazily-built candidate index, memoized weakly on
+ *     the `parsedFiles` array it was built from (first-`pickCppAdlCandidates`
  *     time; see `ensureAdlIndex`)
  *
  * The class→namespace map uses qualified names (not scope IDs) because
@@ -103,8 +103,21 @@ function pushFileSiteKey(idx, filePath, key) {
     }
     keys.push(key);
 }
-let adlIndex;
-let adlIndexSource;
+/**
+ * Per-pass memo: `parsedFiles` array identity → the built index. `WeakMap`-keyed
+ * so the entry lives only as long as the caller's `parsedFiles` array does, and
+ * is reclaimed with the pass — mirrors `qualifiedNsIndexByPass` in
+ * `inline-namespaces.ts` and `moduleScopeIndexByPass` in `file-local-linkage.ts`.
+ *
+ * Weak keying is load-bearing, not stylistic: the index holds
+ * `SymbolDefinition` references reaching into every ParsedFile's scopes, so the
+ * previous module-level strong `let` pair (index + source array) kept the whole
+ * C/C++ ParsedFile set alive past the point `scope-resolution/pipeline/phase.ts`
+ * evicts `files`/`contents`/`preExtractedByPath` and calls `forceGc()` to
+ * reclaim it — C++ is 7th of 16 `SCOPE_RESOLVERS` entries, so the retention
+ * survived nine later language passes plus emit.
+ */
+let adlIndexByPass = new WeakMap();
 function siteKey(filePath, line, col) {
     return `${filePath}:${line}:${col}`;
 }
@@ -292,26 +305,36 @@ export function validateAdlSeqCoverage(idx) {
     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
+ *  every subsequent call site in the same pipeline run. Reset by
  *  `clearCppAdlState`.
  *
+ *  Lifetime: the memoized entry is reachable only while the caller still holds
+ *  the `parsedFiles` array. Once the pipeline drops it, the entry — and the
+ *  `SymbolDefinition` references it holds into those files' scopes — becomes
+ *  collectable; nothing here pins it (see {@link adlIndexByPass}).
+ *
  *  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.) */
+ *  module-level `classToNamespaceQualifiedName` (friend-candidate keys). The
+ *  WeakMap key covers only the first, so the explicit clear is still REQUIRED
+ *  for the other two: a later pass may hand back the same `parsedFiles`
+ *  reference with different `scopes` / class→namespace state, and identity
+ *  alone would serve the stale index. 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 key to also cover `scopes` is
+ *  deferred until one does.) */
 function ensureAdlIndex(scopes, parsedFiles) {
-    if (adlIndex !== undefined && adlIndexSource === parsedFiles)
-        return;
-    adlIndex = buildAdlIndex(scopes, parsedFiles);
-    adlIndexSource = parsedFiles;
+    let index = adlIndexByPass.get(parsedFiles);
+    if (index === undefined) {
+        index = buildAdlIndex(scopes, parsedFiles);
+        adlIndexByPass.set(parsedFiles, index);
+    }
+    return index;
 }
 /** Record per-call-site argument info. Called once per call site from
  *  `emitCppScopeCaptures`. */
@@ -403,8 +426,14 @@ export function clearCppAdlState() {
     argInfoSiteKeysByFile.clear();
     noAdlSiteKeysByFile.clear();
     classToNamespaceQualifiedName.clear();
-    adlIndex = undefined;
-    adlIndexSource = undefined;
+    // The candidate index is dropped by REASSIGNING a fresh `WeakMap`: `WeakMap`
+    // has no `.clear()`, and swapping the instance discards every memoized entry
+    // at once — the exact invalidation the previous `adlIndex = undefined` pair
+    // provided. Required even though the map is keyed on `parsedFiles` identity,
+    // because the index also depends on `scopes` and
+    // `classToNamespaceQualifiedName`, which the key cannot observe (see
+    // {@link ensureAdlIndex}).
+    adlIndexByPass = new WeakMap();
 }
 /**
  * Walk `parsed.scopes` to record each Class def's enclosing namespace
@@ -467,14 +496,14 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     if (args === undefined || args.length === 0)
         return undefined;
     // Build the workspace-wide ADL candidate index once; reuse for every site.
-    ensureAdlIndex(scopes, parsedFiles);
+    const idx = 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);
+        collectAssociatedNamespacesForAdlArg(arg, scopes, idx, associatedNamespaces);
         if (arg.functionRefText !== undefined) {
-            collectFunctionTypeAssociatedNamespaces(arg.functionRefText, scopes, associatedNamespaces);
+            collectFunctionTypeAssociatedNamespaces(arg.functionRefText, scopes, idx, associatedNamespaces);
         }
     }
     if (associatedNamespaces.size === 0)
@@ -487,9 +516,6 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     //     (`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();
     const collectFrom = (buckets) => {
@@ -515,11 +541,11 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
         return undefined;
     return [...bySeq.entries()].sort((a, b) => a[0] - b[0]).map(([, def]) => def);
 }
-function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces) {
+function collectAssociatedNamespacesForAdlArg(arg, scopes, idx, associatedNamespaces) {
     // For template args this may be the template name itself (e.g. `vector`);
     // simple-name lookup can match project classes with the same name (known
     // V1/V2 simplification).
-    addAssociatedNamespaceForClassName(arg.simpleClassName, scopes, associatedNamespaces);
+    addAssociatedNamespaceForClassName(arg.simpleClassName, scopes, idx, associatedNamespaces);
     // Includes template-owner namespaces (e.g. `std` in std::vector<T>). If
     // that surfaces extra candidates, merged-candidate overload narrowing in
     // free-call-fallback suppresses arbitrary edge emission.
@@ -530,13 +556,13 @@ function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces)
             associatedNamespaces.add(ns);
     }
     for (const className of arg.templateArgClassNames) {
-        addAssociatedNamespaceForClassName(className, scopes, associatedNamespaces);
+        addAssociatedNamespaceForClassName(className, scopes, idx, associatedNamespaces);
     }
 }
-function addAssociatedNamespaceForClassName(simpleClassName, scopes, associatedNamespaces) {
+function addAssociatedNamespaceForClassName(simpleClassName, scopes, idx, associatedNamespaces) {
     if (simpleClassName.length === 0)
         return;
-    const classLookup = findCppClassDefBySimpleName(simpleClassName);
+    const classLookup = findCppClassDefBySimpleName(idx, simpleClassName);
     if (classLookup === undefined)
         return;
     const { classDef, ambiguous } = classLookup;
@@ -629,10 +655,10 @@ 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) {
+function findCppClassDefBySimpleName(idx, 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);
+    const matches = idx.classDefsBySimple.get(simpleName);
     if (matches === undefined)
         return undefined;
     const first = matches[0];
@@ -644,10 +670,7 @@ function findCppClassDefBySimpleName(simpleName) {
  * Contribute associated namespaces for a function-reference argument by walking
  * the referenced overload set's parameter and return types.
  */
-function collectFunctionTypeAssociatedNamespaces(refText, scopes, out) {
-    const idx = adlIndex;
-    if (idx === undefined)
-        return;
+function collectFunctionTypeAssociatedNamespaces(refText, scopes, idx, out) {
     const colonIdx = refText.lastIndexOf('::');
     if (colonIdx !== -1) {
         // Qualified ref: extract namespace prefix and normalise :: → dot notation.
@@ -662,7 +685,7 @@ function collectFunctionTypeAssociatedNamespaces(refText, scopes, out) {
         const matches = idx.nsFunctionsByQName.get(nsText)?.get(simpleName);
         if (matches !== undefined) {
             for (const def of matches)
-                collectAssociatedNamespacesForFunctionDef(def, scopes, out);
+                collectAssociatedNamespacesForFunctionDef(def, scopes, idx, out);
         }
         return;
     }
@@ -673,23 +696,23 @@ function collectFunctionTypeAssociatedNamespaces(refText, scopes, out) {
     const matches = idx.nsFunctionsBySimple.get(refText);
     if (matches !== undefined) {
         for (const def of matches)
-            collectAssociatedNamespacesForFunctionDef(def, scopes, out);
+            collectAssociatedNamespacesForFunctionDef(def, scopes, idx, out);
     }
 }
-function collectAssociatedNamespacesForFunctionDef(def, scopes, out) {
+function collectAssociatedNamespacesForFunctionDef(def, scopes, idx, out) {
     const parameterTypes = def.parameterTypeClasses?.map((typeClass) => typeClass.base);
     for (const paramType of parameterTypes ?? def.parameterTypes ?? []) {
-        collectAssociatedNamespacesForFunctionTypeText(paramType, scopes, out);
+        collectAssociatedNamespacesForFunctionTypeText(paramType, scopes, idx, out);
     }
     if (def.returnType !== undefined) {
-        collectAssociatedNamespacesForFunctionTypeText(def.returnType, scopes, out);
+        collectAssociatedNamespacesForFunctionTypeText(def.returnType, scopes, idx, out);
     }
 }
-function collectAssociatedNamespacesForFunctionTypeText(typeText, scopes, out) {
+function collectAssociatedNamespacesForFunctionTypeText(typeText, scopes, idx, out) {
     for (const token of extractCppTypeNameTokens(typeText)) {
         if (isIgnoredCppAdlNamespace(token.namespaceName))
             continue;
-        addAssociatedNamespaceForClassName(token.simpleName, scopes, out);
+        addAssociatedNamespaceForClassName(token.simpleName, scopes, idx, out);
         if (token.namespaceName !== '')
             out.add(token.namespaceName);
     }

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

@@ -14,12 +14,14 @@
  *   2. **Transitive qualified visibility.** `outer::foo()` resolves to
  *      `outer::v1::foo()` when `v1` is inline. The qualified-namespace
  *      receiver resolver (`resolveCppQualifiedNamespaceMember`) walks
- *      inline-namespace children transitively when collecting candidates.
+ *      inline-namespace children transitively when collecting candidates —
+ *      once per pipeline run, into {@link QualifiedNsMemberIndex} (#2788).
  *
  * State lifecycle: capture-time `markCppInlineNamespaceRange` records each
  * inline namespace's source range; `populateCppInlineNamespaceScopes`
  * resolves ranges to `ScopeId`s during `populateOwners`. Cleared via
- * `clearCppInlineNamespaces`, called from `clearFileLocalNames`.
+ * `clearCppInlineNamespaces`, called from
+ * `cppScopeResolver.loadResolutionConfig` at the start of every pass.
  *
  * STL idiom this enables: `std::__1::vector` (libc++) and `std::__cxx11`
  * (libstdc++) are inline namespaces of `std`. With this support,
@@ -46,7 +48,14 @@ export declare function markCppInlineNamespaceRange(filePath: string, range: Ran
 export declare function collectCppInlineNamespaceSideChannel(filePath: string): readonly string[];
 /** Restore this file's captured inline-namespace ranges from the side-channel. */
 export declare function applyCppInlineNamespaceSideChannel(filePath: string, ranges: readonly string[]): void;
-/** Clear all inline-namespace state. Called from `clearFileLocalNames`. */
+/** Clear all inline-namespace state. Called from
+ *  `cppScopeResolver.loadResolutionConfig` at the start of every pass.
+ *
+ *  The qualified-namespace index is dropped by REASSIGNING a fresh `WeakMap`
+ *  (`WeakMap` has no `.clear()`) so its entries — and the `SymbolDefinition`
+ *  references they hold — are released here rather than waiting on the key.
+ *  Correctness does not rest on that: {@link inlineNamespaceEpoch} invalidates
+ *  any surviving entry. */
 export declare function clearCppInlineNamespaces(): void;
 /** Resolve captured ranges to actual ScopeIds by matching scope ranges
  *  against the inline-namespace ranges recorded for this file. Run from
@@ -59,17 +68,28 @@ export declare function populateCppInlineNamespaceScopes(parsed: ParsedFile): vo
  *  namespace's level). */
 export declare function isCppInlineNamespaceScope(scopeId: ScopeId): boolean;
 /**
- * Walk every parsed file looking for a Namespace scope whose qualified
- * name matches `receiverName`, collect its callable ownedDefs matching
- * `memberName`, transitively descending into any inline-namespace
- * children (since they're members of the enclosing namespace under ISO
- * C++).
+ * Find the Namespace scopes whose simple name matches `receiverName` and
+ * return their callable members matching `memberName`, transitively
+ * including inline-namespace children (since they're members of the
+ * enclosing namespace under ISO C++). Served from a per-pipeline index
+ * ({@link QualifiedNsMemberIndex}), not a per-call-site workspace scan.
  *
  * 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; returns `'ambiguous'` so the caller
  * suppresses edge emission rather than picking arbitrarily (#1564).
+ *
+ * Two production call sites, both in `scope-resolver.ts`:
+ *   - `resolveQualifiedReceiverMember` — the `outer::foo()` qualified-receiver
+ *     hook. Passes `callsite`, so a multi-candidate set can be narrowed by
+ *     arity and argument types.
+ *   - `resolveAdlCandidates` — resolving a `using ns::name;` named import back
+ *     to its namespace member, for template-class method bodies where the
+ *     lexical walk misses that visibility. Passes NO `callsite`, which makes
+ *     the narrowing filters below pass-throughs: on that path any receiver
+ *     whose member has more than one candidate returns `'ambiguous'` (and the
+ *     caller then skips it) rather than being disambiguated.
  */
 export declare function resolveCppQualifiedNamespaceMember(receiverName: string, memberName: string, parsedFiles: readonly ParsedFile[], _scopes: ScopeResolutionIndexes, callsite?: Callsite): SymbolDefinition | 'ambiguous' | undefined;
 export {};

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

@@ -14,12 +14,14 @@
  *   2. **Transitive qualified visibility.** `outer::foo()` resolves to
  *      `outer::v1::foo()` when `v1` is inline. The qualified-namespace
  *      receiver resolver (`resolveCppQualifiedNamespaceMember`) walks
- *      inline-namespace children transitively when collecting candidates.
+ *      inline-namespace children transitively when collecting candidates —
+ *      once per pipeline run, into {@link QualifiedNsMemberIndex} (#2788).
  *
  * State lifecycle: capture-time `markCppInlineNamespaceRange` records each
  * inline namespace's source range; `populateCppInlineNamespaceScopes`
  * resolves ranges to `ScopeId`s during `populateOwners`. Cleared via
- * `clearCppInlineNamespaces`, called from `clearFileLocalNames`.
+ * `clearCppInlineNamespaces`, called from
+ * `cppScopeResolver.loadResolutionConfig` at the start of every pass.
  *
  * STL idiom this enables: `std::__1::vector` (libc++) and `std::__cxx11`
  * (libstdc++) are inline namespaces of `std`. With this support,
@@ -27,9 +29,16 @@
  * declaration transparently.
  */
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
+import { isOverloadableCallable } from '../../utils/callable-labels.js';
+import { isSemanticModelValidatorEnabled } from '../../utils/env.js';
 import { CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES, cppConversionRank } from './conversion-rank.js';
 const inlineNamespaceRangesByFile = new Map();
 const inlineNamespaceScopeIds = new Set();
+/** Bumped by every writer of {@link inlineNamespaceScopeIds}. The qualified-ns
+ *  index is a function of both `parsedFiles` and that Set; its WeakMap key sees
+ *  only the first, so the memo stamps this epoch and a missed
+ *  {@link clearCppInlineNamespaces} degrades to a rebuild, not a stale answer. */
+let inlineNamespaceEpoch = 0;
 function rangeKey(r) {
     return `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
 }
@@ -65,10 +74,19 @@ export function applyCppInlineNamespaceSideChannel(filePath, ranges) {
     for (const r of ranges)
         set.add(r);
 }
-/** Clear all inline-namespace state. Called from `clearFileLocalNames`. */
+/** Clear all inline-namespace state. Called from
+ *  `cppScopeResolver.loadResolutionConfig` at the start of every pass.
+ *
+ *  The qualified-namespace index is dropped by REASSIGNING a fresh `WeakMap`
+ *  (`WeakMap` has no `.clear()`) so its entries — and the `SymbolDefinition`
+ *  references they hold — are released here rather than waiting on the key.
+ *  Correctness does not rest on that: {@link inlineNamespaceEpoch} invalidates
+ *  any surviving entry. */
 export function clearCppInlineNamespaces() {
     inlineNamespaceRangesByFile.clear();
     inlineNamespaceScopeIds.clear();
+    inlineNamespaceEpoch++;
+    qualifiedNsIndexByPass = new WeakMap();
 }
 /** Resolve captured ranges to actual ScopeIds by matching scope ranges
  *  against the inline-namespace ranges recorded for this file. Run from
@@ -78,6 +96,7 @@ export function populateCppInlineNamespaceScopes(parsed) {
     const ranges = inlineNamespaceRangesByFile.get(parsed.filePath);
     if (ranges === undefined || ranges.size === 0)
         return;
+    inlineNamespaceEpoch++;
     for (const scope of parsed.scopes) {
         if (scope.kind !== 'Namespace')
             continue;
@@ -94,45 +113,234 @@ export function isCppInlineNamespaceScope(scopeId) {
     return inlineNamespaceScopeIds.has(scopeId);
 }
 /**
- * Walk every parsed file looking for a Namespace scope whose qualified
- * name matches `receiverName`, collect its callable ownedDefs matching
- * `memberName`, transitively descending into any inline-namespace
- * children (since they're members of the enclosing namespace under ISO
- * C++).
+ * Dev/test-only mutation tripwire on the arrays this module shares across call
+ * sites ({@link NO_DEFS} and every `membersByReceiver` memo entry): an in-place
+ * `.sort()`/`.splice()` ever added to `overload-narrowing.ts` would corrupt
+ * every LATER resolution of the same pair, not just its own call, and freezing
+ * makes that a loud `TypeError` instead. DEV-ONLY because the types already
+ * reject it — the memo and `narrowOverloadCandidates`' parameter are both
+ * `readonly SymbolDefinition[]`, so only a cast gets past — while the freeze is
+ * not free: V8 moves a frozen array to `PACKED_FROZEN_ELEMENTS`, off the
+ * builtin fast path for the `.filter`/`.map`/`.some` narrowing runs over it at
+ * every multi-candidate call site (measured 4.6×; large bench arm 100.3 → 70.6ms
+ * with it off). Gated on `isSemanticModelValidatorEnabled()` — the OPT-IN form,
+ * not `adl.ts`'s opt-out `NODE_ENV !== 'production'`: `NODE_ENV` is unset in a
+ * CLI `analyze`, so the opt-out form would keep paying the freeze exactly where
+ * the cost lands. Read once at load because this one is per-call-site.
+ */
+const FREEZE_SHARED_CANDIDATES = isSemanticModelValidatorEnabled();
+/** Shared empties: most namespace scopes declare no callables, and most
+ *  qualified receivers name no namespace at all. `NO_DEFS` is process-wide, so
+ *  it gets the same dev-only freeze the memoized arrays do. */
+const NO_MEMBERS = new Map();
+const NO_DEFS = FREEZE_SHARED_CANDIDATES ? Object.freeze([]) : [];
+/** Simple (last-segment) name of a def, matching the legacy scan exactly —
+ *  including the empty-string fallback for a def with no `qualifiedName`, and
+ *  the empty last segment of a trailing-dot name. `lastIndexOf` + `slice`
+ *  rather than `split('.').pop()`: same result, no intermediate array, and this
+ *  runs per callable def and per namespace scope at build. */
+function simpleNameOf(def) {
+    const qualified = def.qualifiedName;
+    if (qualified == null)
+        return '';
+    const lastDot = qualified.lastIndexOf('.');
+    return lastDot === -1 ? qualified : qualified.slice(lastDot + 1);
+}
+/**
+ * Per-pass memo: `parsedFiles` array identity → the built index. `WeakMap`-keyed
+ * so the entry lives only as long as the caller's `parsedFiles` array does, and
+ * is reclaimed with the pass — mirrors `moduleScopeIndexByPass` in
+ * `file-local-linkage.ts`.
  *
- * 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; returns `'ambiguous'` so the caller
- * suppresses edge emission rather than picking arbitrarily (#1564).
+ * Weak keying is load-bearing, not stylistic: the index holds
+ * `SymbolDefinition` references reaching into every ParsedFile's scopes, so a
+ * module-level strong `let` pair (index + source array) kept the whole C/C++
+ * ParsedFile set alive past the point `scope-resolution/pipeline/phase.ts`
+ * evicts `files`/`contents`/`preExtractedByPath` and calls `forceGc()` to
+ * reclaim it — C++ is 7th of 16 `SCOPE_RESOLVERS` entries, so the retention
+ * survived nine later language passes plus emit (104.2 MB measured).
  */
-export function resolveCppQualifiedNamespaceMember(receiverName, memberName, parsedFiles, _scopes, callsite) {
-    const allHits = [];
-    const seenNodeId = new Set();
+let qualifiedNsIndexByPass = new WeakMap();
+/** Build the index in two linear passes per file: one to make a node per
+ *  `Namespace` scope, one to link inline children and register receivers.
+ *  Linking needs both endpoints to exist and `parsed.scopes` does not promise
+ *  parents precede children, hence two passes rather than one — but only the
+ *  first pass filters `parsed.scopes`; it hands the second the `[scope, node]`
+ *  pairs it already found. */
+function buildQualifiedNsMemberIndex(parsedFiles) {
+    const rootsByReceiver = new Map();
     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 nodesByScope = new Map();
+        const namespaces = [];
+        for (const sc of parsed.scopes) {
+            if (sc.kind !== 'Namespace')
                 continue;
-            const nsDef = findNamespaceDefInScope(scope);
+            const node = { ownMembers: bucketOwnMembers(sc), inlineChildren: [] };
+            nodesByScope.set(sc.id, node);
+            namespaces.push([sc, node]);
+        }
+        for (const [sc, node] of namespaces) {
+            // A non-`Namespace` parent (a Module scope, say) has no node, so the
+            // inline child links to nothing — hence the `?.` below.
+            if (sc.parent !== null && inlineNamespaceScopeIds.has(sc.id)) {
+                nodesByScope.get(sc.parent)?.inlineChildren.push(node);
+            }
+            const nsDef = findNamespaceDefInScope(sc);
             if (nsDef === undefined)
                 continue;
-            const nsName = nsDef.qualifiedName?.split('.').pop() ?? nsDef.qualifiedName ?? '';
-            if (nsName !== receiverName)
-                continue;
-            // 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);
+            const nsName = simpleNameOf(nsDef);
+            let roots = rootsByReceiver.get(nsName);
+            if (roots === undefined) {
+                roots = [];
+                rootsByReceiver.set(nsName, roots);
             }
+            roots.push(node);
+        }
+    }
+    return { rootsByReceiver, membersByReceiver: new Map() };
+}
+/** Bucket a namespace scope's own callable `ownedDefs` by member simple name.
+ *  No descent: inline children are separate nodes reached by the walk. */
+function bucketOwnMembers(scope) {
+    let members;
+    for (const def of scope.ownedDefs) {
+        if (!isOverloadableCallable(def.type))
+            continue;
+        const simple = simpleNameOf(def);
+        members ??= new Map();
+        let arr = members.get(simple);
+        if (arr === undefined) {
+            arr = [];
+            members.set(simple, arr);
+        }
+        arr.push(def);
+    }
+    return members ?? NO_MEMBERS;
+}
+/** Candidates for `receiver::member`, memoized on the index per pair so a
+ *  repeated call site costs two Map lookups. */
+function qualifiedNsMembers(index, receiverName, memberName) {
+    const roots = index.rootsByReceiver.get(receiverName);
+    // No namespace by that name — the most common outcome in real source. Left
+    // unmemoized deliberately: it is already O(1), and memoizing would grow the
+    // index by an entry per unresolved receiver name in the workspace.
+    if (roots === undefined)
+        return NO_DEFS;
+    let byMember = index.membersByReceiver.get(receiverName);
+    if (byMember === undefined) {
+        byMember = new Map();
+        index.membersByReceiver.set(receiverName, byMember);
+    }
+    let hits = byMember.get(memberName);
+    if (hits === undefined) {
+        // Memoization makes this array shared by every call site in the pass rather
+        // than rebuilt per call, so it carries the dev-only mutation tripwire (see
+        // {@link FREEZE_SHARED_CANDIDATES}).
+        hits = gatherQualifiedNsMember(roots, memberName);
+        if (FREEZE_SHARED_CANDIDATES)
+            hits = Object.freeze(hits);
+        byMember.set(memberName, hits);
+    }
+    return hits;
+}
+/** Pre-order depth-first walk of every scope named `receiverName` and its
+ *  transitive inline-namespace children, collecting callables named
+ *  `memberName` — the index twin of the legacy
+ *  `findMemberInNamespaceTransitive`.
+ *
+ *  Iterative, not recursive: nesting depth is whatever the input file says, and
+ *  a recursive descent threw `RangeError` past ~8k levels (see
+ *  {@link QualifiedNsMemberIndex}). */
+function gatherQualifiedNsMember(roots, memberName) {
+    const hits = [];
+    const stack = [];
+    // `visited` spans ALL roots, reproducing the legacy per-receiver `seenNodeId`
+    // dedup: `namespace ns { inline namespace ns { … } }` registers both scopes
+    // under receiver `ns`, and the outer walk already collected the inner's defs.
+    // Node identity is equivalent to the legacy nodeId key because a node always
+    // contributes the same defs. It doubles as the guard that a malformed parent
+    // cycle terminates instead of spinning — the one regression an explicit stack
+    // could otherwise introduce over recursion's `RangeError`.
+    const visited = new Set();
+    for (const root of roots) {
+        stack.push(root);
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (visited.has(node))
+                continue;
+            visited.add(node);
+            const own = node.ownMembers.get(memberName);
+            if (own !== undefined)
+                for (const def of own)
+                    hits.push(def);
+            // Reverse push so children pop in declaration order — the legacy walk's
+            // pre-order depth-first candidate order (see
+            // {@link QualifiedNsMemberIndex.rootsByReceiver}).
+            const kids = node.inlineChildren;
+            for (let i = kids.length - 1; i >= 0; i--)
+                stack.push(kids[i]);
         }
     }
+    return hits.length === 0 ? NO_DEFS : hits;
+}
+/** Build the index on first use of a given `parsedFiles` set; reuse it for
+ *  every subsequent call site that passes the same array reference AND the same
+ *  {@link inlineNamespaceEpoch}.
+ *
+ *  Both keys are needed because the index is a function of TWO inputs:
+ *  `parsedFiles` and the module-level `inlineNamespaceScopeIds` (which inline
+ *  children get descended into). A later pass may hand back the same
+ *  `parsedFiles` reference with different inline-namespace state, so identity
+ *  alone would serve a stale index — the epoch is what makes that a checked
+ *  rebuild instead of a documented obligation on the clear site.
+ *
+ *  Lifetime: the entry is reachable only while the caller still holds the
+ *  `parsedFiles` array; nothing here pins it (see {@link qualifiedNsIndexByPass}).
+ *
+ *  Same STALENESS contract as `ensureAdlIndex` in `adl.ts`, minus that
+ *  sibling's dev-gated `validateAdlSeqCoverage` guard: this index has no `?? 0`
+ *  defaulting read to silently collide on, so there is nothing for such a guard
+ *  to catch. */
+function qualifiedNsMemberIndex(parsedFiles) {
+    const memo = qualifiedNsIndexByPass.get(parsedFiles);
+    if (memo !== undefined && memo.epoch === inlineNamespaceEpoch)
+        return memo.index;
+    const index = buildQualifiedNsMemberIndex(parsedFiles);
+    qualifiedNsIndexByPass.set(parsedFiles, { epoch: inlineNamespaceEpoch, index });
+    return index;
+}
+/** Constant narrowing hooks for the C++ qualified-receiver path — hoisted so
+ *  the literal is not reallocated at every multi-candidate call site. */
+const CPP_NARROWING_HOOKS = {
+    conversionRankFn: cppConversionRank,
+    conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
+};
+/**
+ * Find the Namespace scopes whose simple name matches `receiverName` and
+ * return their callable members matching `memberName`, transitively
+ * including inline-namespace children (since they're members of the
+ * enclosing namespace under ISO C++). Served from a per-pipeline index
+ * ({@link QualifiedNsMemberIndex}), not a per-call-site workspace scan.
+ *
+ * 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; returns `'ambiguous'` so the caller
+ * suppresses edge emission rather than picking arbitrarily (#1564).
+ *
+ * Two production call sites, both in `scope-resolver.ts`:
+ *   - `resolveQualifiedReceiverMember` — the `outer::foo()` qualified-receiver
+ *     hook. Passes `callsite`, so a multi-candidate set can be narrowed by
+ *     arity and argument types.
+ *   - `resolveAdlCandidates` — resolving a `using ns::name;` named import back
+ *     to its namespace member, for template-class method bodies where the
+ *     lexical walk misses that visibility. Passes NO `callsite`, which makes
+ *     the narrowing filters below pass-throughs: on that path any receiver
+ *     whose member has more than one candidate returns `'ambiguous'` (and the
+ *     caller then skips it) rather than being disambiguated.
+ */
+export function resolveCppQualifiedNamespaceMember(receiverName, memberName, parsedFiles, _scopes, callsite) {
+    const allHits = qualifiedNsMembers(qualifiedNsMemberIndex(parsedFiles), receiverName, memberName);
     if (allHits.length === 0)
         return undefined;
     if (allHits.length === 1)
@@ -142,12 +350,7 @@ export function resolveCppQualifiedNamespaceMember(receiverName, memberName, par
     // can disambiguate via exact-type match and, when available, conversion-rank
     // scoring (`cppConversionRank`). Same-signature ambiguity is still detected
     // by `isOverloadAmbiguousAfterNormalization` below.
-    const narrowed = narrowOverloadCandidates(allHits, callsite?.arity, callsite?.argumentTypes, callsite !== undefined
-        ? {
-            conversionRankFn: cppConversionRank,
-            conversionOnlyArgTypePrefixes: CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
-        }
-        : undefined);
+    const narrowed = narrowOverloadCandidates(allHits, callsite?.arity, callsite?.argumentTypes, callsite !== undefined ? CPP_NARROWING_HOOKS : undefined);
     if (narrowed.length === 1)
         return narrowed[0];
     if (narrowed.length === 0)
@@ -158,35 +361,6 @@ export function resolveCppQualifiedNamespaceMember(receiverName, memberName, par
     // suppress because we lack call-site info to disambiguate.
     return 'ambiguous';
 }
-/** Recursively search a namespace scope and any inline-namespace
- *  descendants for callable defs with the given simple name. Non-inline
- *  nested namespaces are NOT traversed — they require explicit
- *  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)
-            results.push(def);
-    }
-    // Descend into inline-namespace children.
-    for (const childScope of scopesById.values()) {
-        if (childScope.parent !== scope.id)
-            continue;
-        if (childScope.kind !== 'Namespace')
-            continue;
-        if (!inlineNamespaceScopeIds.has(childScope.id))
-            continue;
-        const childHits = findMemberInNamespaceTransitive(childScope, scopesById, memberName);
-        for (const hit of childHits)
-            results.push(hit);
-    }
-    return results;
-}
 function findNamespaceDefInScope(scope) {
     for (const def of scope.ownedDefs) {
         if (def.type === 'Namespace')

package/package.json

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