gitnexus 1.6.10-rc.99 → 1.6.10

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

@@ -6,6 +6,7 @@ import { cArityCompatibility, cMergeBindings, resolveCImportTarget } from './ind
 import { scanHeaderFiles } from './header-scan.js';
 import { expandCWildcardNames, isStaticName, clearStaticNames } from './static-linkage.js';
 import { applyCStaticLinkageSideChannel } from './capture-side-channel.js';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 /**
  * Per-pass memo of the augmented `#include`-resolution file set
  * (`allFilePaths` ∪ header `.h` paths), keyed on the two stable source sets.
@@ -16,25 +17,25 @@ import { applyCStaticLinkageSideChannel } from './capture-side-channel.js';
  * handing it a new set identity each time. Both `allFilePaths` (built once in
  * scope-resolution `run.ts`) and the header set (`loadResolutionConfig`
  * result) are stable per pass, so the union is built once and reused.
- * `WeakMap`-keyed → reclaimed with the pass (no cross-pass staleness).
+ * Reclaimed with the pass (no cross-pass staleness).
+ *
+ * Two inputs, so two levels of `perFileSet` composed rather than a second
+ * primitive: the outer memo's value is the inner memo, and a function is an
+ * object, which is all `T extends object` asks for.
+ *
+ * The MEMO stays private to this file even though the C++ resolver's twin is
+ * byte-identical. The augmented set's IDENTITY is load-bearing downstream —
+ * C++ delegates to `resolveCImportTarget`, whose `suffixIndex` memo is keyed on
+ * exactly this set — so one memo shared across the two languages would hand
+ * each the other's index. Same builder-shared/memo-separate rule as
+ * `import-resolvers/pass-cache.ts`.
  */
-const augmentedPathsByPass = new WeakMap();
-function augmentedFilePaths(allFilePaths, headerPaths) {
-    let byHeaders = augmentedPathsByPass.get(allFilePaths);
-    if (byHeaders === undefined) {
-        byHeaders = new WeakMap();
-        augmentedPathsByPass.set(allFilePaths, byHeaders);
-    }
-    let augmented = byHeaders.get(headerPaths);
-    if (augmented === undefined) {
-        const set = new Set(allFilePaths);
-        for (const h of headerPaths)
-            set.add(h);
-        augmented = set;
-        byHeaders.set(headerPaths, augmented);
-    }
-    return augmented;
-}
+const augmentedFilePathsFor = perFileSet((allFilePaths) => perFileSet((headerPaths) => {
+    const set = new Set(allFilePaths);
+    for (const h of headerPaths)
+        set.add(h);
+    return set;
+}));
 /**
  * C `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -78,7 +79,7 @@ export const cScopeResolver = {
         // targets .h files classified as C++ in language detection.
         const headerPaths = resolutionConfig;
         if (headerPaths !== undefined && headerPaths.size > 0) {
-            return resolveCImportTarget(targetRaw, fromFile, augmentedFilePaths(allFilePaths, headerPaths));
+            return resolveCImportTarget(targetRaw, fromFile, augmentedFilePathsFor(allFilePaths)(headerPaths));
         }
         return resolveCImportTarget(targetRaw, fromFile, allFilePaths);
     },

package/dist/core/ingestion/languages/c/static-linkage.js

@@ -1,3 +1,4 @@
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 /**
  * Per-file set of function names declared with `static` storage class.
  * Populated during `emitCScopeCaptures` and consumed by `expandCWildcardNames`
@@ -52,27 +53,22 @@ export function clearStaticNames() {
  * thousands of resolved includes) that is ~10^10+ comparisons on a single
  * thread — the dominant term in the scope-resolution finalize grind.
  *
- * Building the lookup once collapses it to O(R_include + F). `WeakMap`-keyed
- * on the array so the index is reclaimed with the pass — no cross-pass
+ * Building the lookup once collapses it to O(R_include + F). `perFileSet` keys
+ * on the array identity so the index is reclaimed with the pass — no cross-pass
  * staleness (mirrors the {@link clearStaticNames} discipline for server-mode
  * / multi-repo reuse), and a fresh array transparently rebuilds.
  */
-const moduleScopeIndexByPass = new WeakMap();
-function moduleScopeIndex(parsedFiles) {
-    let index = moduleScopeIndexByPass.get(parsedFiles);
-    if (index === undefined) {
-        index = new Map();
-        // First-wins to preserve `Array.find` semantics (returns the first match).
-        // `moduleScope` is unique per file in practice, so collisions are absent;
-        // the guard only formalises identical behaviour to the prior `.find`.
-        for (const p of parsedFiles) {
-            if (!index.has(p.moduleScope))
-                index.set(p.moduleScope, p);
-        }
-        moduleScopeIndexByPass.set(parsedFiles, index);
+const moduleScopeIndex = perFileSet((parsedFiles) => {
+    const index = new Map();
+    // First-wins to preserve `Array.find` semantics (returns the first match).
+    // `moduleScope` is unique per file in practice, so collisions are absent;
+    // the guard only formalises identical behaviour to the prior `.find`.
+    for (const p of parsedFiles) {
+        if (!index.has(p.moduleScope))
+            index.set(p.moduleScope, p);
     }
     return index;
-}
+});
 /**
  * Return the names visible through a C wildcard import (`#include`).
  * All module-scope defs from the target file are visible EXCEPT those

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

@@ -369,6 +369,13 @@ export const cProvider = defineLanguage({
     // than a DataCloneError at the worker boundary (#2143).
     collectCaptureSideChannel: (filePath) => assertCloneable(collectCStaticLinkageSideChannel(filePath)),
     interpretImport: interpretCImport,
+    // `#include` is a preprocessor directive, not a statement that runs. The
+    // header text is spliced in before the program starts, wherever the directive
+    // sits — and C allows it inside a function body. Without this the central
+    // Pass-3 position rule would mark such an include `runsOnlyWhenCalled` and
+    // `check --cycles` would silently drop an include cycle that is entirely
+    // real. See `LanguageProvider.importsExecuteWhereWritten`.
+    importsExecuteWhereWritten: false,
     interpretTypeBinding: interpretCTypeBinding,
     bindingScopeFor: cBindingScopeFor,
     importOwningScope: cImportOwningScope,
@@ -447,6 +454,12 @@ export const cppProvider = defineLanguage({
     // re-parse (#1983). See `cpp/capture-side-channel.ts`.
     collectCaptureSideChannel: (filePath) => assertCloneable(collectCppCaptureSideChannel(filePath)),
     interpretImport: interpretCppImport,
+    // Same as C — `cpp/query.ts` emits `@import.statement` for `preproc_include`
+    // too. It holds for C++'s whole import surface: the only other form Pass 3
+    // sees is `@import.using-decl` (`using ns::name` / `using namespace ns`),
+    // which is a compile-time name-lookup declaration and executes no more than
+    // an `#include` does. See the note on `cProvider`.
+    importsExecuteWhereWritten: false,
     interpretTypeBinding: interpretCppTypeBinding,
     bindingScopeFor: cppBindingScopeFor,
     importOwningScope: cppImportOwningScope,

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

@@ -10,10 +10,34 @@
  */
 import path from 'node:path';
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
 import { cobolProvider } from '../cobol.js';
 // Copybook file extensions for COPY name resolution
 const COPYBOOK_EXTENSIONS = new Set(['.cpy', '.copybook']);
+// COBOL source files, searched only after every copybook has missed.
+const COBOL_SOURCE_EXTENSIONS = new Set(['.cbl', '.cob', '.cobol']);
+const getCobolCopyIndex = perFileSet((allFilePaths) => {
+    const copybooks = new Map();
+    const sources = new Map();
+    // One pass builds both tiers: the two scans walked the same files and
+    // classified each by the same extension test.
+    for (const fp of allFilePaths) {
+        const ext = path.extname(fp).toLowerCase();
+        const tier = COPYBOOK_EXTENSIONS.has(ext)
+            ? copybooks
+            : COBOL_SOURCE_EXTENSIONS.has(ext)
+                ? sources
+                : undefined;
+        if (tier === undefined)
+            continue;
+        const basename = path.basename(fp, ext).toUpperCase();
+        // First in Set-iteration order wins, as the scans' first-match `return` did.
+        if (!tier.has(basename))
+            tier.set(basename, fp);
+    }
+    return { copybooks, sources };
+});
 const cobolScopeResolver = {
     language: SupportedLanguages.Cobol,
     languageProvider: cobolProvider,
@@ -21,26 +45,9 @@ const cobolScopeResolver = {
     // ── Resolve COPY bookname to file path ─────────────────────────────
     resolveImportTarget: (targetRaw, _fromFile, allFilePaths) => {
         const upper = targetRaw.toUpperCase();
-        // Check copybook files first
-        for (const fp of allFilePaths) {
-            const ext = path.extname(fp).toLowerCase();
-            if (!COPYBOOK_EXTENSIONS.has(ext))
-                continue;
-            const basename = path.basename(fp, ext).toUpperCase();
-            if (basename === upper)
-                return fp;
-        }
-        // Also search COBOL source files (.cbl, .cob, .cobol)
-        const COBOL_SOURCE_EXTS = new Set(['.cbl', '.cob', '.cobol']);
-        for (const fp of allFilePaths) {
-            const ext = path.extname(fp).toLowerCase();
-            if (!COBOL_SOURCE_EXTS.has(ext))
-                continue;
-            const basename = path.basename(fp, ext).toUpperCase();
-            if (basename === upper)
-                return fp;
-        }
-        return null;
+        const index = getCobolCopyIndex(allFilePaths);
+        // Copybooks first, then COBOL sources — the tier order IS the tie-break.
+        return index.copybooks.get(upper) ?? index.sources.get(upper) ?? null;
     },
     // COBOL has no binding-merge rules beyond the default (local-first-then-imports).
     mergeBindings: (existing) => [...existing],

package/dist/core/ingestion/languages/cobol.js

@@ -34,6 +34,19 @@ export const cobolProvider = defineLanguage({
     // ── Scope-resolution hooks ───────────────────────────────────────
     emitScopeCaptures: emitCobolScopeCaptures,
     interpretImport: interpretCobolImport,
+    // `COPY` is a pure textual splice by the copybook preprocessor — the
+    // `#include` case exactly, and COBOL's only import form. It is spliced before
+    // anything runs, so a copybook cycle built from `COPY` statements is real and
+    // must not be tagged `runsOnlyWhenCalled` by the central Pass-3 position rule.
+    //
+    // LATENT today, declared anyway. `cobol/captures.ts` ranges every
+    // `@scope.function` (PROCEDURE DIVISION sections and paragraphs) over a
+    // SINGLE line — `rangeOf(line, 0, line, endCol)` — so a `COPY` on any later
+    // line never resolves inside a Function scope and Pass 3 has nothing to mark.
+    // The flag is here so that giving those anchors their true multi-line ranges
+    // is a scope-resolution fix and not, silently, a cycle-suppression bug.
+    // See `LanguageProvider.importsExecuteWhereWritten`.
+    importsExecuteWhereWritten: false,
     importOwningScope: cobolImportOwningScope,
     receiverBinding: cobolReceiverBinding,
 });

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/captures.js

@@ -2,6 +2,7 @@ import { nodeIfType, nodeToCapture, syntheticCapture, } from '../../utils/ast-he
 import { getCppParser, getCppScopeQuery } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { stripUeMacros } from '../../cpp-ue-preprocessor.js';
 import { normalizeQualifiedName } from '../../utils/qualified-name.js';
 import { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
 import { classifyCppParameterType, computeCppDeclarationArity, computeCppCallArity, normalizeCppParamType, } from './arity-metadata.js';
@@ -13,6 +14,7 @@ import { extractCppTemplateConstraints } from './constraint-extractor.js';
 import { captureCppMemberLookupFacts } from './member-lookup.js';
 import { CPP_BRACED_INIT_TYPE_PREFIX } from './conversion-rank.js';
 import { logger } from '../../../logger.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { synthesizeCallableFlowCaptures, } from '../../utils/callable-flow-captures.js';
 const CPP_CALLABLE_CAPTURE_OPTIONS = {
     functionNodeTypes: new Set(['function_definition', 'lambda_expression']),
@@ -126,8 +128,12 @@ function cppCaptureBudgetMs() {
 export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = parseSourceSafe(getCppParser(), sourceText, undefined, {
-            bufferSize: getTreeSitterBufferSize(sourceText),
+        // Idempotent re-application: `extractParsedFile` already preprocesses, but
+        // direct emitter callers (benchmarks, capture goldens) must see the same
+        // program the pipeline does.
+        const parseText = stripUeMacros(sourceText);
+        tree = parseSourceSafe(getCppParser(), parseText, undefined, {
+            bufferSize: getTreeSitterBufferSize(parseText),
         });
     }
     const rawMatches = getCppScopeQuery().matches(tree.rootNode);
@@ -470,6 +476,12 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 }
             }
         }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
         out.push(grouped);
     }
     // ── Emit inheritance references for scope-resolution MRO / EXTENDS ──

package/dist/core/ingestion/languages/cpp/file-local-linkage.js

@@ -1,3 +1,4 @@
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 import { isCppInlineNamespaceScope } from './inline-namespaces.js';
 /**
  * Per-file set of symbol names with file-local linkage.
@@ -235,24 +236,19 @@ export function isCppDefGloballyVisible(filePath, nodeId) {
  * `parsedFiles` reference; the old `parsedFiles.find(...)` was therefore O(F)
  * per edge → O(R·F) overall (at kernel scale the ~25–30k `.h` headers are
  * classified C++, so this fires hard — the C twin in `c/static-linkage.ts`).
- * Building the lookup once collapses it to O(R+F). `WeakMap`-keyed so it is
- * reclaimed with the pass (no cross-pass staleness; mirrors
- * {@link clearFileLocalNames}).
+ * Building the lookup once collapses it to O(R+F). `perFileSet` keys on the
+ * array identity so it is reclaimed with the pass (no cross-pass staleness;
+ * mirrors {@link clearFileLocalNames}).
  */
-const moduleScopeIndexByPass = new WeakMap();
-function moduleScopeIndex(parsedFiles) {
-    let index = moduleScopeIndexByPass.get(parsedFiles);
-    if (index === undefined) {
-        index = new Map();
-        // First-wins to preserve `Array.find` semantics (returns the first match).
-        for (const p of parsedFiles) {
-            if (!index.has(p.moduleScope))
-                index.set(p.moduleScope, p);
-        }
-        moduleScopeIndexByPass.set(parsedFiles, index);
+const moduleScopeIndex = perFileSet((parsedFiles) => {
+    const index = new Map();
+    // First-wins to preserve `Array.find` semantics (returns the first match).
+    for (const p of parsedFiles) {
+        if (!index.has(p.moduleScope))
+            index.set(p.moduleScope, p);
     }
     return index;
-}
+});
 export function expandCppWildcardNames(targetModuleScope, parsedFiles) {
     const target = moduleScopeIndex(parsedFiles).get(targetModuleScope);
     if (target === undefined)

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 {};