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

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/dist/core/ingestion/languages/cpp/interpret.d.ts

@@ -23,6 +23,8 @@ export declare function interpretCppImport(captures: CaptureMatch): ParsedImport
  *   - `'alias'`               — `auto x = existingVar`
  */
 export declare function interpretCppTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;
+/** Remove C++ declaration specifiers from `text` and trim the result. */
+export declare function stripCppSpecifiers(text: string): string;
 /**
  * Normalize a C++ type name: strip pointer/array/reference syntax,
  * qualifiers, while preserving template arguments for specialization-aware

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

@@ -78,7 +78,131 @@ export function interpretCppTypeBinding(captures) {
     else if (captures['@type-binding.annotation'] !== undefined) {
         source = 'annotation';
     }
-    return { boundName: name, rawTypeName: normalizeCppTypeName(type), source };
+    // A member field's type is captured AS WRITTEN, qualifier and all
+    // (`ns::Repo<User>`), because the query matches the outer
+    // `qualified_identifier` — one depth-agnostic pattern per declarator shape
+    // instead of one per qualifier depth. The qualifier is dropped HERE; see the
+    // "Field type, QUALIFIED" block in query.ts for why the qualified spelling
+    // resolves to nothing and the tail resolves like the bare one.
+    //
+    // FIELDS ONLY. `@type-binding.parameter` and `@type-binding.assignment` also
+    // capture qualified spellings (their patterns use `type: (_)`), and reducing
+    // THOSE would newly bind every qualified local and parameter in the workspace
+    // — a far wider change than the member-field miss this closes, and not one
+    // anything here has measured.
+    const effectiveType = captures['@type-binding.field'] === undefined ? type : cppQualifiedTail(type);
+    // The reduced spelling is also the AS-WRITTEN one, and saying so is load
+    // bearing. `collectTypeBindings` derives `TypeRef.declaredSpelling` from
+    // `@type-binding.type` whenever that text differs from `rawTypeName`, and it
+    // now does for every qualified member. `declaredSpelling` exists to keep a
+    // CONTAINER distinguishable from a class of the same name after capture
+    // reduced it; a qualifier is not a container — `ns::Address` and `Address`
+    // have the identical member set — so recording one here would answer
+    // "container, as written" for a plain member and hand `elementTypeOf` a
+    // spelling it never sees for the bare form.
+    const declaredSpelling = cppPointerSpelling(captures, effectiveType, name) ??
+        (effectiveType === type ? undefined : effectiveType);
+    return declaredSpelling === undefined
+        ? { boundName: name, rawTypeName: normalizeCppTypeName(effectiveType), source }
+        : {
+            boundName: name,
+            rawTypeName: normalizeCppTypeName(effectiveType),
+            declaredSpelling,
+            source,
+        };
+}
+/**
+ * The tail of a `::`-qualified type spelling — `a::b::Repo<User>` → `Repo<User>`,
+ * `ns::Address` → `Address`, an unqualified spelling unchanged.
+ *
+ * Only TOP-LEVEL separators count, so a qualified TYPE ARGUMENT survives:
+ * `std::vector<std::string>` reduces to `vector<std::string>`, not to `string`.
+ * That is the same string the old per-depth rules produced by capturing the
+ * inner node, so the reduction is textual where it used to be structural and
+ * the result is identical for every depth they covered.
+ */
+function cppQualifiedTail(text) {
+    let angleDepth = 0;
+    let lastSeparator = -1;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === '<')
+            angleDepth++;
+        else if (ch === '>') {
+            if (angleDepth > 0)
+                angleDepth--;
+        }
+        else if (angleDepth === 0 && ch === ':' && text[i + 1] === ':') {
+            lastSeparator = i;
+            i++;
+        }
+    }
+    if (lastSeparator === -1)
+        return text;
+    const tail = text.slice(lastSeparator + 2).trim();
+    // A spelling that ends in `::` has no tail to reduce to. Cannot arise from a
+    // parsed `qualified_identifier`, but returning an empty type name would make
+    // the binding claim a type of `""`, so the written spelling is kept instead.
+    return tail.length === 0 ? text : tail;
+}
+/** Anchors whose capture spans a whole declaration, so the declarator — and
+ *  with it the pointer — is inside the captured text. */
+const CPP_WHOLE_DECLARATION_ANCHORS = [
+    '@type-binding.parameter',
+    '@type-binding.annotation',
+    '@type-binding.assignment',
+];
+const squeezeWhitespace = (text) => text.replace(/\s+/g, '');
+/**
+ * `User* repos` — the written spelling, when tree-sitter-cpp hangs the pointer
+ * off the DECLARATOR rather than the type.
+ *
+ * `@type-binding.type` is a bare `User` there, so the binding records `User` and
+ * nothing downstream can tell `repos[0]` (pointer subscript, element `User`)
+ * from `grid[0]` on a class with `operator[]` (element: whatever the operator
+ * returns). The index step needs that distinction and declines without it, so
+ * the pointer is reconstructed here — at the capture layer, from the anchor,
+ * which spans the whole declaration.
+ *
+ * EXACT SHAPE ONLY: the declaration must be precisely `<type> * <name>` once
+ * whitespace is removed. `const T*`, `T**`, an array declarator, a reference,
+ * a function pointer — none match, and none get a spelling, so the index step
+ * declines for them. A loose match would hand back container evidence that is
+ * not there and re-mint the confidently wrong edge this exists to prevent.
+ */
+function cppPointerSpelling(captures, typeText, nameText) {
+    // The target below always contains a literal `*`, so an anchor whose text has
+    // none can never equal it. Testing that FIRST is the whole optimisation: this
+    // runs on every C++ type binding and the overwhelming majority declare no
+    // pointer, so the squeezes (three `replace` passes over the declaration, the
+    // type and the name) are skipped entirely for them. `target` is built lazily
+    // on the first star-bearing anchor for the same reason.
+    let target;
+    for (const anchor of CPP_WHOLE_DECLARATION_ANCHORS) {
+        const text = captures[anchor]?.text;
+        if (text === undefined || !text.includes('*'))
+            continue;
+        if (target === undefined) {
+            const type = squeezeWhitespace(typeText);
+            const name = squeezeWhitespace(nameText);
+            if (type.length === 0 || name.length === 0)
+                return undefined;
+            target = `${type}*${name}`;
+        }
+        if (squeezeWhitespace(text) === target)
+            return `${typeText.trim()}*`;
+    }
+    return undefined;
+}
+/** Declaration specifiers that carry no type identity. Held in ONE place so
+ *  every consumer agrees on the keyword list — the resolver's element-type
+ *  hook strips exactly the same set before deciding whether a spelling is a
+ *  pointer, and a silently diverging copy there would make the two disagree
+ *  about what `const T*` is. */
+const CPP_SPECIFIER_RE = /\b(const|volatile|restrict|static|extern|inline|mutable|constexpr|consteval)\b/g;
+/** Remove C++ declaration specifiers from `text` and trim the result. */
+export function stripCppSpecifiers(text) {
+    return text.replace(CPP_SPECIFIER_RE, '').trim();
 }
 /**
  * Normalize a C++ type name: strip pointer/array/reference syntax,
@@ -90,11 +214,7 @@ export function interpretCppTypeBinding(captures) {
  * by base-name fallback in resolveClassBindingForName.
  */
 export function normalizeCppTypeName(text) {
-    let t = text.trim();
-    // Strip const, volatile, restrict, static, extern, inline, mutable, constexpr
-    t = t
-        .replace(/\b(const|volatile|restrict|static|extern|inline|mutable|constexpr|consteval)\b/g, '')
-        .trim();
+    let t = stripCppSpecifiers(text);
     // Strip pointer stars
     while (t.endsWith('*'))
         t = t.slice(0, -1).trim();