gitnexus 1.6.6-rc.124 → 1.6.6-rc.126

package/dist/_shared/scope-resolution/reference-site.d.ts

@@ -44,6 +44,18 @@ export type CallForm = 'free' | 'member' | 'constructor' | 'index';
 export interface ReferenceSite {
     /** The name being referenced (e.g., `'save'`, `'User'`, `'count'`). */
     readonly name: string;
+    /**
+     * Optional raw, qualified form of the referenced name when the source wrote
+     * a qualified path (e.g. a C++ base `struct D : Other::Inner` yields
+     * `'Other::Inner'`). `name` keeps the simple tail (`'Inner'`) for the existing
+     * scope-chain contract; resolution normalizes this via `normalizeQualifiedName`
+     * and resolves it against the full-path `QualifiedNameIndex` BEFORE the
+     * simple-tail walk, so a same-tail nested base resolves to the correct
+     * sibling instead of the first-inserted one (issue #1982). Populated only by
+     * per-language captures that emit `@reference.qualified-name`; absent
+     * otherwise, in which case resolution is unchanged.
+     */
+    readonly rawQualifiedName?: string;
     /** Source-text range of this reference. */
     readonly atRange: Range;
     /**

package/dist/_shared/scope-resolution/reference-site.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,GAKZ,OAAO,CAAC;AAEZ;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC9D"}
+{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,GAKZ,OAAO,CAAC;AAEZ;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC9D"}

package/dist/core/ingestion/call-processor.js

@@ -792,8 +792,15 @@ compiledQueryCache) => {
             const routed = callRouter(callNameNode.text, captureMap['call']);
             if (!routed || routed.kind !== 'properties')
                 return;
-            const propEnclosingInfo = findEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
-            const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
+            // #1978: thread the qualifier so a routed property's owner edge points at
+            // the *qualified* nested-class node (Shapes.Circle) instead of a now-nonexistent
+            // simple `Class:file:Circle` id. Gated on the flag → byte-identical when off.
+            // MUST stay in lockstep with the worker `kind === 'properties'` block.
+            const propGetQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
+                ? (node, simpleName) => provider.classExtractor.extractQualifiedName(node, simpleName)
+                : undefined;
+            const propEnclosingInfo = findEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner, propGetQualifiedOwnerName);
+            const propEnclosingClassId = propEnclosingInfo?.qualifiedClassId ?? propEnclosingInfo?.classId ?? null;
             // Enrich routed properties with FieldExtractor metadata so types
             // discovered from constructor assignments (e.g. `@address = Address.new`)
             // are propagated even when the routing payload itself lacks declaredType.

package/dist/core/ingestion/class-extractors/configs/c-cpp.js

@@ -30,6 +30,9 @@ export const cppClassConfig = {
     language: SupportedLanguages.CPlusPlus,
     typeDeclarationNodes: ['class_specifier', 'struct_specifier', 'enum_specifier'],
     ancestorScopeNodeTypes: ['namespace_definition', 'class_specifier', 'struct_specifier'],
+    // #1978: key nested-type nodes by their fully-qualified path (Outer.Inner) so
+    // same-tail nested types in one TU stay distinct instead of silently merging.
+    qualifiedNodeId: true,
     extractName: (node) => {
         const nameNode = node.childForFieldName?.('name');
         if (!nameNode)

package/dist/core/ingestion/class-extractors/configs/ruby.js

@@ -4,4 +4,7 @@ export const rubyClassConfig = {
     language: SupportedLanguages.Ruby,
     typeDeclarationNodes: ['class'],
     ancestorScopeNodeTypes: ['module', 'class'],
+    // #1978: key nested-type nodes by their fully-qualified path (Outer.Inner) so
+    // same-tail classes nested under different modules stay distinct.
+    qualifiedNodeId: true,
 };

package/dist/core/ingestion/class-extractors/generic.js

@@ -1,3 +1,4 @@
+import { splitQualifiedName } from '../utils/qualified-name.js';
 const DEFAULT_SCOPE_NAME_NODE_TYPES = new Set([
     'nested_namespace_specifier',
     'scoped_identifier',
@@ -45,17 +46,6 @@ const CLASS_LIKE_LABELS = new Set([
     'Enum',
     'Record',
 ]);
-const normalizeQualifiedName = (value) => value
-    .replace(/\s+/g, '')
-    .replace(/^::/, '')
-    .replace(/::/g, '.')
-    .replace(/\\/g, '.')
-    .replace(/\.+/g, '.')
-    .replace(/^\.+|\.+$/g, '');
-const splitQualifiedName = (value) => {
-    const normalized = normalizeQualifiedName(value);
-    return normalized ? normalized.split('.').filter(Boolean) : [];
-};
 const extractScopeSegmentsFromNode = (scopeNode, scopeNameNodeTypes) => {
     const nameNode = scopeNode.childForFieldName?.('name') ??
         scopeNode.namedChildren?.find((child) => scopeNameNodeTypes.has(child.type));
@@ -126,6 +116,7 @@ export function createClassExtractor(config) {
     };
     return {
         language: config.language,
+        qualifiedNodeId: config.qualifiedNodeId ?? false,
         isTypeDeclaration(node) {
             return typeDeclarationSet.has(node.type);
         },

package/dist/core/ingestion/class-types.d.ts

@@ -21,6 +21,13 @@ export interface ClassCaptureContext {
  */
 export interface ClassExtractor {
     language: SupportedLanguages;
+    /**
+     * When true, this language's nested-type graph nodes are keyed by their
+     * fully-qualified path (e.g. `Class:file:Outer.Inner`) instead of the simple
+     * tail name, so same-tail nested types in one file stay distinct (#1978).
+     * Surfaced from `ClassExtractionConfig.qualifiedNodeId`.
+     */
+    readonly qualifiedNodeId: boolean;
     isTypeDeclaration(node: SyntaxNode): boolean;
     extract(node: SyntaxNode, fallback?: {
         name?: string;
@@ -37,6 +44,14 @@ export interface ClassExtractionConfig {
     typeDeclarationNodes: string[];
     fileScopeNodeTypes?: string[];
     ancestorScopeNodeTypes?: string[];
+    /**
+     * Opt-in (#1978): key this language's nested-type graph nodes (and their
+     * member-owner edges) by the fully-qualified path instead of the simple tail
+     * name, so same-tail nested types in one file stop colliding. Default false.
+     * Requires `ancestorScopeNodeTypes` to be set so `buildQualifiedName` can walk
+     * the scope chain.
+     */
+    qualifiedNodeId?: boolean;
     scopeNameNodeTypes?: string[];
     extractName?: (node: SyntaxNode) => string | undefined;
     extractType?: (node: SyntaxNode) => ClassLikeNodeLabel | undefined;

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

@@ -49,13 +49,18 @@
  *
  * ## State lifecycle
  *
- * Three module-level maps populated per pipeline invocation, cleared via
- * `clearCppAdlState()` (called from `clearFileLocalNames`):
+ * Five pieces of module-level state populated per pipeline invocation, all
+ * reset together by `clearCppAdlState()` (called from
+ * `cppScopeResolver.loadResolutionConfig`, alongside `clearFileLocalNames` —
+ * NOT from `clearFileLocalNames` itself), grouped by when they fill:
  *
  *   - `argInfoBySite` — per-call-site argument shape (capture-time)
  *   - `noAdlSites` — call sites with parenthesized function (capture-time)
  *   - `classToNamespaceQualifiedName` — class def → its enclosing namespace
  *     qualified name (`populateCppAssociatedNamespaces` time)
+ *   - `adlIndex` / `adlIndexSource` — the lazily-built candidate index and the
+ *     `parsedFiles` reference it was built from (first-`pickCppAdlCandidates`
+ *     time; see `ensureAdlIndex`)
  *
  * The class→namespace map uses qualified names (not scope IDs) because
  * C++ namespaces are open: `namespace N { ... }` in file A and
@@ -94,14 +99,59 @@ export interface CppAdlArgInfo {
      *  referenced Function/Method def's parameter and return types. */
     readonly functionRefText?: string;
 }
+/**
+ * ADL candidate index — built **once** per pipeline run from
+ * `(scopes, parsedFiles)` and reused by every call site.
+ *
+ * The legacy `pickCppAdlCandidates` re-scanned all parsed files (rebuilding a
+ * per-file `scopesById` map each time), all workspace defs (for the
+ * class-by-simple-name lookup), and used an O(scopes²) child-scope walk for
+ * hidden friends — once **per unresolved call site**. With hundreds of
+ * thousands of unresolved C++ sites that made the scope-resolution emit phase
+ * super-linear (observed ~6.7h on a large repo). This index moves all of that
+ * work to a single pass; per-site cost drops to O(associated namespaces).
+ */
+export interface AdlCandidateIndex {
+    /** simple name → class-like defs (Class/Struct/Interface/Enum), preserving
+     *  `scopes.defs.byId` iteration order so first-match / ambiguous semantics
+     *  match the legacy linear scan. */
+    readonly classDefsBySimple: Map<string, SymbolDefinition[]>;
+    /** namespace QName → simple name → callable defs owned by that namespace,
+     *  with inline-namespace transparency (inline-ns defs are also registered
+     *  under the parent namespace's QName). */
+    readonly nsCandidates: Map<string, Map<string, SymbolDefinition[]>>;
+    /** associated-class enclosing-namespace QName → simple name → hidden-friend
+     *  and class-member callable defs. */
+    readonly friendCandidates: Map<string, Map<string, SymbolDefinition[]>>;
+    /** namespace QName (own) → simple name → Function/Method defs, for the
+     *  qualified function-reference ADL path. */
+    readonly nsFunctionsByQName: Map<string, Map<string, SymbolDefinition[]>>;
+    /** simple name → Function/Method defs across all namespaces, for the
+     *  unqualified function-reference ADL path. */
+    readonly nsFunctionsBySimple: Map<string, SymbolDefinition[]>;
+    /** nodeId → visitation sequence number, used to merge per-namespace buckets
+     *  back into the exact legacy candidate order (file-major; namespace defs
+     *  before friend/member defs within a file). */
+    readonly seqByNodeId: Map<string, number>;
+}
+/**
+ * Return the nodeIds present in the index's candidate buckets
+ * (`nsCandidates` + `friendCandidates`) but missing from `seqByNodeId`, each
+ * reported once. Empty array means the seq-coverage invariant holds — which it
+ * must, since `buildAdlIndex` assigns a seq to every callable def in the same
+ * block that buckets it. Exported for the dev-gated guard in `buildAdlIndex`
+ * and its unit test.
+ */
+export declare function validateAdlSeqCoverage(idx: AdlCandidateIndex): string[];
 /** Record per-call-site argument info. Called once per call site from
  *  `emitCppScopeCaptures`. */
 export declare function markCppAdlSiteArgs(filePath: string, line: number, col: number, args: readonly CppAdlArgInfo[]): void;
 /** Mark a call site as ADL-suppressed (function child wrapped in
  *  `parenthesized_expression`, e.g. `(f)(s)`). */
 export declare function markCppAdlSiteNoAdl(filePath: string, line: number, col: number): void;
-/** Clear ADL state. Called from `clearFileLocalNames` so all C++ resolver
- *  per-pipeline state is reset together. */
+/** Clear ADL state. Called from `cppScopeResolver.loadResolutionConfig`
+ *  (alongside `clearFileLocalNames`) so all C++ resolver per-pipeline state is
+ *  reset together at the start of each resolution pass. */
 export declare function clearCppAdlState(): void;
 /**
  * Walk `parsed.scopes` to record each Class def's enclosing namespace