gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

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],
@@ -56,6 +63,13 @@ const cobolScopeResolver = {
             return 'compatible';
         return 'incompatible';
     },
+    // PROGRAM-ID declarations bridge to legacy Module graph nodes. COBOL's
+    // procedure-pointer ENTRY values therefore target Module defs, while every
+    // AST-backed provider keeps the shared callable-label default.
+    isCallableValueTarget: (def) => def.type === 'Module',
+    // Structural COBOL CALLS/IMPORTS remain owned by the established regex
+    // processor; this resolver contributes only procedure-pointer CALLS.
+    scopeResolutionEdgeMode: 'callable-flow-only',
     // No inheritance in COBOL — empty MRO map.
     buildMro: () => new Map(),
     // Everything lives under the PROGRAM-ID Module scope.

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,9 +2,10 @@ 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, } from './arity-metadata.js';
+import { classifyCppParameterType, computeCppDeclarationArity, computeCppCallArity, normalizeCppParamType, } from './arity-metadata.js';
 import { markCppAnonymousNamespaceRange, markFileLocal } from './file-local-linkage.js';
 import { markCppDependentBase, markCppDependentPackBase } from './two-phase-lookup.js';
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
@@ -13,6 +14,97 @@ 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']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter_declaration', 'optional_parameter_declaration']),
+    bindingNodeTypes: new Set(['init_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set([
+        'identifier',
+        'field_identifier',
+        'type_identifier',
+        'namespace_identifier',
+    ]),
+    callableSignatureDeclarationNodeTypes: new Set([
+        'declaration',
+        'field_declaration',
+        'parameter_declaration',
+        'optional_parameter_declaration',
+    ]),
+    callableReferenceNodeTypes: new Set(['qualified_identifier']),
+    emitCanonicalInvokeReference: true,
+    memberPointerOperators: new Set(['.*', '->*']),
+    memberPointerParts: (node) => cppRecoveredMemberPointerParts(node),
+    parameterPassingMode: (parameter) => cppOutermostPassingMode(parameter),
+    isTrueReferenceBinding: (_container, destination) => cppContainsNodeType(destination, 'reference_declarator'),
+    expectedSignature: (container, destination) => cppFunctionDeclaratorSignature(destination) ?? cppFunctionDeclaratorSignature(container),
+    normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+};
+/**
+ * Passing mode from the parameter's OUTERMOST declarator chain only. A deep
+ * subtree scan inverted copy vs alias: `void reg(void (*cb)(int& out))` has a
+ * `reference_declarator` inside the nested parameter list, but `cb` itself is
+ * a by-value pointer copy — classifying it 'reference' made the solver
+ * back-propagate formal targets into every caller's argument cell (#2522
+ * review, M5). The chain walk never descends into nested parameter lists.
+ */
+function cppOutermostPassingMode(parameter) {
+    let sawReference = false;
+    let sawPointer = false;
+    let node = parameter.childForFieldName('declarator') ?? null;
+    const visited = new Set();
+    while (node !== null && !visited.has(node.id)) {
+        visited.add(node.id);
+        if (node.type === 'reference_declarator' || node.type === 'abstract_reference_declarator') {
+            // A reference ANYWHERE on the chain aliases the caller's storage —
+            // `void (*&cb)(int)` is a reference to pointer, i.e. an alias.
+            sawReference = true;
+        }
+        else if (node.type === 'pointer_declarator' || node.type === 'abstract_pointer_declarator') {
+            sawPointer = true;
+        }
+        const next = node.childForFieldName('declarator');
+        if (next !== null) {
+            node = next;
+            continue;
+        }
+        if (node.type === 'parenthesized_declarator') {
+            node =
+                node.namedChildren.find((child) => child !== null && child.type.includes('declarator')) ?? null;
+            continue;
+        }
+        break;
+    }
+    return sawReference ? 'reference' : sawPointer ? 'pointer' : 'value';
+}
+function cppRecoveredMemberPointerParts(node) {
+    if (!node.type.includes('parenthesized'))
+        return undefined;
+    const recovered = node.namedChildren.find((child) => child !== null && child.type === 'ERROR');
+    if (recovered === undefined)
+        return undefined;
+    const operator = recovered.children.find((child) => child !== null && child.text === '->*');
+    const sibling = node.namedChildren.find((child) => child !== null && child.id !== recovered.id);
+    const errIdentifier = recovered.namedChildren.find((child) => child !== null);
+    if (operator === undefined || sibling === undefined || errIdentifier === undefined) {
+        return undefined;
+    }
+    // tree-sitter's error recovery groups `(obj->*ptr)` two ways depending on
+    // recovery cost (identifier lengths!): either `[identifier, ERROR "->*m"]`
+    // or `[ERROR "obj->*", identifier]`. Disambiguate by token order INSIDE the
+    // ERROR: an identifier BEFORE `->*` is the receiver (the sibling is the
+    // pointer/member); an identifier AFTER `->*` is the member (the sibling is
+    // the receiver). Assuming one fixed grouping swapped the roles and silently
+    // dropped the call site (#2522 review, H2).
+    if (errIdentifier.startIndex < operator.startIndex) {
+        return { receiver: errIdentifier, member: sibling, operator: operator.text };
+    }
+    return { receiver: sibling, member: errIdentifier, operator: operator.text };
+}
 /**
  * Per-file wall-clock budget for the capture-emit loop (#2432). A worker
  * thread stuck in this loop cannot be terminated safely (terminating a
@@ -36,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);
@@ -380,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 ──
@@ -398,8 +500,125 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     // bases per ISO C++ two-phase lookup.
     detectCppDependentBases(tree.rootNode, filePath);
     captureCppMemberLookupFacts(tree.rootNode, filePath);
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, CPP_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
+function cppFunctionDeclaratorSignature(node) {
+    const declarator = cppFindDescendantOfType(node, 'function_declarator');
+    const parameters = declarator?.childForFieldName('parameters');
+    if (parameters === null || parameters === undefined) {
+        return recoverCppMemberPointerSignature(node.text);
+    }
+    const parameterNodes = parameters.namedChildren.filter((child) => child !== null && child.type.includes('parameter_declaration'));
+    const hasEllipsis = parameters.children.some((child) => child.type === '...' || (!child.isNamed && child.text === '...')) || parameterNodes.some((parameter) => parameter.type === 'variadic_parameter_declaration');
+    const isVoidOnly = parameterNodes.length === 1 &&
+        parameterNodes[0].namedChildCount === 1 &&
+        parameterNodes[0].firstNamedChild?.text === 'void';
+    if (isVoidOnly) {
+        return { parameterCount: 0, parameterTypes: [], parameterTypeClasses: [] };
+    }
+    const parameterTypes = [];
+    const parameterTypeClasses = [];
+    for (const parameter of parameterNodes) {
+        if (parameter.type === 'variadic_parameter_declaration') {
+            parameterTypes.push('...');
+            parameterTypeClasses.push({
+                base: '...',
+                cv: 'unknown',
+                indirection: 'unknown',
+                pointerDepth: 0,
+            });
+            continue;
+        }
+        const rawType = parameter.childForFieldName('type')?.text ?? 'unknown';
+        const declaratorText = parameter.childForFieldName('declarator')?.text;
+        parameterTypes.push(normalizeCppParamType(rawType));
+        parameterTypeClasses.push(classifyCppParameterType(rawType, declaratorText, parameter.text));
+    }
+    if (hasEllipsis && !parameterTypes.includes('...')) {
+        parameterTypes.push('...');
+        parameterTypeClasses.push({
+            base: '...',
+            cv: 'unknown',
+            indirection: 'unknown',
+            pointerDepth: 0,
+        });
+    }
+    return {
+        ...(hasEllipsis ? {} : { parameterCount: parameterNodes.length }),
+        parameterTypes,
+        parameterTypeClasses,
+        isConst: /\)\s*const(?:\s|$)/.test(declarator.text),
+    };
+}
+/**
+ * tree-sitter-cpp parses a non-const pointer-to-member variable such as
+ * `void (Base::*member)()` as nested call expressions (while the cv-qualified
+ * twin is a declaration). Recover the callable shape from the declarator text
+ * so `const`/non-`const` overload sets remain distinguishable.
+ */
+function recoverCppMemberPointerSignature(text) {
+    const match = text.match(/\(\s*[^()]*::\s*\*\s*[A-Za-z_]\w*\s*\)\s*\(([^()]*)\)\s*(const\b)?/);
+    if (match === null)
+        return undefined;
+    const rawParameters = match[1].trim();
+    const parameterCount = rawParameters === '' || rawParameters === 'void'
+        ? 0
+        : splitTopLevelCppParameters(rawParameters).length;
+    return { parameterCount, isConst: match[2] !== undefined };
+}
+function splitTopLevelCppParameters(text) {
+    const out = [];
+    let start = 0;
+    let angleDepth = 0;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    for (let index = 0; index < text.length; index++) {
+        switch (text[index]) {
+            case '<':
+                angleDepth++;
+                break;
+            case '>':
+                angleDepth = Math.max(0, angleDepth - 1);
+                break;
+            case '(':
+                parenDepth++;
+                break;
+            case ')':
+                parenDepth = Math.max(0, parenDepth - 1);
+                break;
+            case '[':
+                bracketDepth++;
+                break;
+            case ']':
+                bracketDepth = Math.max(0, bracketDepth - 1);
+                break;
+            case ',':
+                if (angleDepth === 0 && parenDepth === 0 && bracketDepth === 0) {
+                    out.push(text.slice(start, index).trim());
+                    start = index + 1;
+                }
+                break;
+        }
+    }
+    out.push(text.slice(start).trim());
+    return out.filter((parameter) => parameter.length > 0);
+}
+function cppContainsNodeType(root, type) {
+    return cppFindDescendantOfType(root, type) !== null;
+}
+function cppFindDescendantOfType(root, type) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === type)
+            return node;
+        for (const child of node.namedChildren)
+            if (child !== null)
+                stack.push(child);
+    }
+    return null;
+}
 function extractCppDeclarationReturnType(fnNode) {
     const typeNode = fnNode.childForFieldName('type');
     if (typeNode === null)

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)