gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -78,6 +78,29 @@ export function markCppAnonymousNamespaceRange(filePath, range) {
 export function isCppAnonymousNamespaceScope(scopeId) {
     return anonymousNamespaceScopeIds.has(scopeId);
 }
+/** Snapshot this file's file-local-linkage capture state for the side-channel. */
+export function collectCppFileLocalSideChannel(filePath) {
+    const names = fileLocalNames.get(filePath);
+    const anon = anonymousNamespaceRangesByFile.get(filePath);
+    return {
+        fileLocalNames: names === undefined ? [] : [...names],
+        anonymousNamespaceRanges: anon === undefined ? [] : [...anon],
+    };
+}
+/** Restore this file's file-local-linkage capture state from the side-channel. */
+export function applyCppFileLocalSideChannel(filePath, data) {
+    for (const name of data.fileLocalNames)
+        markFileLocal(filePath, name);
+    if (data.anonymousNamespaceRanges.length > 0) {
+        let set = anonymousNamespaceRangesByFile.get(filePath);
+        if (set === undefined) {
+            set = new Set();
+            anonymousNamespaceRangesByFile.set(filePath, set);
+        }
+        for (const r of data.anonymousNamespaceRanges)
+            set.add(r);
+    }
+}
 /** Clear tracked file-local names (call at start of each resolution pass). */
 export function clearFileLocalNames() {
     fileLocalNames.clear();
@@ -205,8 +228,33 @@ export function isCppDefGloballyVisible(filePath, nodeId) {
  * does, mirror this filter or harden registration so class/namespace
  * members never enter `localDefs` unqualified.
  */
+/**
+ * Per-pass memo: `moduleScope` → owning `ParsedFile`, keyed on the
+ * `parsedFiles` array identity. The shared finalize Phase-4 loop calls
+ * `expandsWildcardTo` (→ this) ONCE PER RESOLVED `#include` edge with the same
+ * `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}).
+ */
+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);
+    }
+    return index;
+}
 export function expandCppWildcardNames(targetModuleScope, parsedFiles) {
-    const target = parsedFiles.find((p) => p.moduleScope === targetModuleScope);
+    const target = moduleScopeIndex(parsedFiles).get(targetModuleScope);
     if (target === undefined)
         return [];
     // Build nodeId → owning Scope map from the structural scope tree.

package/dist/core/ingestion/languages/cpp/import-decomposer.d.ts

@@ -4,6 +4,13 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C++ #include maps to a wildcard import (all symbols
  * from the header are visible). Identical to C's splitCInclude.
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <map>      → system_lib_string
+ *   #include "User.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path); we skip it so it never
+ * becomes a garbage literal import source (issue #1919 F5).
  */
 export declare function splitCppInclude(node: SyntaxNode): CaptureMatch | null;
 /**

package/dist/core/ingestion/languages/cpp/import-decomposer.js

@@ -3,6 +3,13 @@ import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C++ #include maps to a wildcard import (all symbols
  * from the header are visible). Identical to C's splitCInclude.
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <map>      → system_lib_string
+ *   #include "User.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path); we skip it so it never
+ * becomes a garbage literal import source (issue #1919 F5).
  */
 export function splitCppInclude(node) {
     const pathNode = node.childForFieldName?.('path') ?? null;
@@ -20,6 +27,11 @@ export function splitCppInclude(node) {
     return buildIncludeCapture(node, pathNode);
 }
 function buildIncludeCapture(node, pathNode) {
+    // Skip computed includes (`#include MACRO`) — the path is an `identifier`,
+    // not a literal header path. Emitting it would create a garbage import.
+    if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') {
+        return null;
+    }
     let raw;
     if (pathNode.type === 'string_literal') {
         const content = pathNode.namedChildren.find((c) => c.type === 'string_content');

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

@@ -9,3 +9,4 @@ export { cppMergeBindings } from './merge-bindings.js';
 export { cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding } from './simple-hooks.js';
 export { resolveCppImportTarget } from './import-target.js';
 export { markFileLocal, isFileLocal, clearFileLocalNames, expandCppWildcardNames, } from './file-local-linkage.js';
+export { collectCppCaptureSideChannel, applyCppCaptureSideChannel, } from './capture-side-channel.js';

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

@@ -9,3 +9,4 @@ export { cppMergeBindings } from './merge-bindings.js';
 export { cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding } from './simple-hooks.js';
 export { resolveCppImportTarget } from './import-target.js';
 export { markFileLocal, isFileLocal, clearFileLocalNames, expandCppWildcardNames, } from './file-local-linkage.js';
+export { collectCppCaptureSideChannel, applyCppCaptureSideChannel, } from './capture-side-channel.js';

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

@@ -38,6 +38,14 @@ interface RangeKey {
  *  Called from `emitCppScopeCaptures` when the tree-sitter AST shows an
  *  `inline` keyword child on `namespace_definition`. */
 export declare function markCppInlineNamespaceRange(filePath: string, range: RangeKey): void;
+/** Snapshot this file's captured inline-namespace ranges for the worker→main
+ *  side-channel (#1983). `populateCppInlineNamespaceScopes` (in `populateOwners`)
+ *  later resolves these range keys to ScopeIds on the main thread, so only the
+ *  capture-time ranges need to cross the boundary. Returns the rangeKey strings
+ *  as a plain array (empty when this file recorded none). */
+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`. */
 export declare function clearCppInlineNamespaces(): void;
 /** Resolve captured ranges to actual ScopeIds by matching scope ranges

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

@@ -44,6 +44,27 @@ export function markCppInlineNamespaceRange(filePath, range) {
     }
     set.add(rangeKey(range));
 }
+/** Snapshot this file's captured inline-namespace ranges for the worker→main
+ *  side-channel (#1983). `populateCppInlineNamespaceScopes` (in `populateOwners`)
+ *  later resolves these range keys to ScopeIds on the main thread, so only the
+ *  capture-time ranges need to cross the boundary. Returns the rangeKey strings
+ *  as a plain array (empty when this file recorded none). */
+export function collectCppInlineNamespaceSideChannel(filePath) {
+    const set = inlineNamespaceRangesByFile.get(filePath);
+    return set === undefined ? [] : [...set];
+}
+/** Restore this file's captured inline-namespace ranges from the side-channel. */
+export function applyCppInlineNamespaceSideChannel(filePath, ranges) {
+    if (ranges.length === 0)
+        return;
+    let set = inlineNamespaceRangesByFile.get(filePath);
+    if (set === undefined) {
+        set = new Set();
+        inlineNamespaceRangesByFile.set(filePath, set);
+    }
+    for (const r of ranges)
+        set.add(r);
+}
 /** Clear all inline-namespace state. Called from `clearFileLocalNames`. */
 export function clearCppInlineNamespaces() {
     inlineNamespaceRangesByFile.clear();

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

@@ -47,6 +47,12 @@ const CPP_SCOPE_QUERY = `
     (template_argument_list) @declaration.template-arguments)
   body: (field_declaration_list)) @declaration.struct
 
+;; Declarations — struct (typedef struct { ... } Name)
+(type_definition
+  type: (struct_specifier
+    body: (field_declaration_list))
+  declarator: (type_identifier) @declaration.name) @declaration.struct
+
 ;; ─── Declarations — class / struct inside template_declaration ───────
 (template_declaration
   (class_specifier
@@ -76,6 +82,12 @@ const CPP_SCOPE_QUERY = `
 (enum_specifier
   name: (type_identifier) @declaration.name) @declaration.enum
 
+;; ─── Declarations — enum (typedef enum { ... } Name) ─────────────────
+(type_definition
+  type: (enum_specifier
+    body: (enumerator_list))
+  declarator: (type_identifier) @declaration.name) @declaration.enum
+
 ;; ─── Declarations — enum constants ───────────────────────────────────
 (enumerator
   name: (identifier) @declaration.name) @declaration.const
@@ -260,6 +272,15 @@ const CPP_SCOPE_QUERY = `
   declarator: (init_declarator
     declarator: (identifier) @declaration.name)) @declaration.variable
 
+;; ─── Declarations — variables (without initializer) ─────────────────
+;; Covers non-leading declarators in mixed declaration lists.
+(declaration
+  declarator: (identifier) @declaration.name) @declaration.variable
+
+(declaration
+  declarator: (pointer_declarator
+    declarator: (identifier) @declaration.name)) @declaration.variable
+
 ;; ─── Declarations — macro definitions ───────────────────────────────
 (preproc_def
   name: (identifier) @declaration.name) @declaration.macro

package/dist/core/ingestion/languages/cpp/range-bindings.js

@@ -1,6 +1,7 @@
 import { getCppParser } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
-import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
+import { logger } from '../../../logger.js';
 /**
  * Populate range-for loop variable type bindings for C++.
  *
@@ -20,10 +21,24 @@ export function populateCppRangeBindings(parsedFiles, _indexes, ctx) {
         if (sourceText === undefined)
             continue;
         const cachedTree = ctx.treeCache?.get(parsed.filePath);
-        const tree = cachedTree ??
-            parseSourceSafe(parser, sourceText, undefined, {
-                bufferSize: getTreeSitterBufferSize(sourceText),
-            });
+        let tree;
+        if (cachedTree !== undefined) {
+            tree = cachedTree;
+        }
+        else {
+            try {
+                tree = parseSourceSafe(parser, sourceText, undefined, {
+                    bufferSize: getTreeSitterBufferSize(sourceText),
+                });
+            }
+            catch (err) {
+                if (err instanceof ParseTimeoutError) {
+                    logger.warn({ file: parsed.filePath }, 'cpp range-binding: parse timed out, skipping file');
+                    continue;
+                }
+                throw err;
+            }
+        }
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;

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

@@ -1,7 +1,7 @@
 import { findClassBindingInScope, findEnclosingClassDef, } from '../../scope-resolution/scope/walkers.js';
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
-import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { populateClassOwnedMembers, tagNamespacePrefixes, } from '../../scope-resolution/scope/walkers.js';
 import { cppProvider } from '../c-cpp.js';
 import { cppArityCompatibility } from './arity.js';
 import { cppConversionRank } from './conversion-rank.js';
@@ -11,10 +11,38 @@ import { scanCppHeaderFiles } from './header-scan.js';
 import { expandCppWildcardNames, isFileLocal, clearFileLocalNames, populateCppAnonymousNamespaceScopes, populateCppNonGloballyVisible, isCppDefGloballyVisible, } from './file-local-linkage.js';
 import { populateCppDependentBases, clearCppDependentBases, isCppDependentBaseMember, } from './two-phase-lookup.js';
 import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates } from './adl.js';
+import { applyCppCaptureSideChannel } from './capture-side-channel.js';
 import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQualifiedNamespaceMember, } from './inline-namespaces.js';
 import { populateCppRangeBindings } from './range-bindings.js';
 import { cppConstraintCompatibility } from './constraint-filter.js';
 import { clearCppUserDefinedConversions, populateCppUserDefinedConversions, } from './user-defined-conversions.js';
+/**
+ * Per-pass memo of the augmented `#include`-resolution file set
+ * (`allFilePaths` ∪ header paths), keyed on the two stable source sets.
+ * `resolveImportTarget` is called once per C++ `#include`; the old code rebuilt
+ * a fresh ~F-entry `Set` on every call AND defeated the shared
+ * `resolveCImportTarget` suffix-index memo (in `c/import-target.ts`) by handing
+ * it a new set identity each time. Both inputs are stable per pass, so the
+ * union is built once and reused. `WeakMap`-keyed → reclaimed with the pass.
+ * (Twin of the C resolver's `augmentedFilePaths`.)
+ */
+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;
+}
 /**
  * C++ `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -49,10 +77,7 @@ export const cppScopeResolver = {
         // detection but are importable from .cpp files via #include.
         const headerPaths = resolutionConfig;
         if (headerPaths !== undefined && headerPaths.size > 0) {
-            const augmented = new Set(allFilePaths);
-            for (const h of headerPaths)
-                augmented.add(h);
-            return resolveCppImportTarget(targetRaw, fromFile, augmented);
+            return resolveCppImportTarget(targetRaw, fromFile, augmentedFilePaths(allFilePaths, headerPaths));
         }
         return resolveCppImportTarget(targetRaw, fromFile, allFilePaths);
     },
@@ -67,8 +92,30 @@ export const cppScopeResolver = {
     // `'unknown'` keeps the candidate, preserving "degrade not lie".
     constraintCompatibility: cppConstraintCompatibility,
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    // Worker-boundary restore (see `ScopeResolver.applyCaptureSideChannel`).
+    // `emitCppScopeCaptures` records per-file ADL call-site arg shapes
+    // (`markCppAdlSiteArgs`/`markCppAdlSiteNoAdl`), inline-/anonymous-namespace
+    // ranges (`markCppInlineNamespaceRange`/`markCppAnonymousNamespaceRange`),
+    // dependent-base names (`markCppDependentBase`/`markCppDependentPackBase`),
+    // and file-local linkage (`markFileLocal`) into module-level maps as a SIDE
+    // EFFECT — none of it is serialized onto the returned ParsedFile's scopes/defs.
+    // On the worker path those marks are populated in the worker process and lost
+    // across the MessageChannel / disk store; the main thread reuses the
+    // serialized ParsedFile and skips `extractParsedFile`, so `populateOwners` +
+    // the ADL / two-phase-lookup passes would see empty maps and emit zero edges.
+    // The worker stashed a plain-data snapshot on `parsed.captureSideChannel` via
+    // `cppProvider.collectCaptureSideChannel`; this restores it into the module
+    // maps WITHOUT any tree-sitter re-parse (the #1983 fix — the old re-parse
+    // replay re-OOM'd huge `.h`/`.cpp` repos). The freshly-extracted leg never
+    // calls this — its marks were just populated in this process.
+    applyCaptureSideChannel: applyCppCaptureSideChannel,
     populateOwners: (parsed) => {
         populateClassOwnedMembers(parsed);
+        // #1982: tag namespace-nested defs with their enclosing-namespace prefix so
+        // resolveDefGraphId can map them to the namespace-qualified structure-phase
+        // node (`NS.A.Inner`) instead of collapsing same-tail nested bases via the
+        // simpleKey fallback. Does NOT change qualifiedName (resolution unaffected).
+        tagNamespacePrefixes(parsed);
         // Resolve inline- and anonymous-namespace ranges (recorded at capture
         // time) to ScopeIds BEFORE `populateCppNonGloballyVisible` runs, so
         // both exemptions see the populated Sets.

package/dist/core/ingestion/languages/cpp/two-phase-lookup.d.ts

@@ -44,6 +44,26 @@ import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexe
  * `populateCppDependentBases`).
  */
 export declare function markCppDependentBase(filePath: string, className: string, baseName: string, qualifier?: string): void;
+export declare function markCppDependentPackBase(filePath: string, className: string): void;
+/**
+ * Plain-data, JSON-serializable snapshot of the per-file capture-time
+ * two-phase-lookup state. Carried on `ParsedFile.captureSideChannel` across the
+ * worker→main boundary (#1983). The resolved `dependentBaseNodeIds` index is
+ * rebuilt by `populateCppDependentBases` (workspace pass) after all files have
+ * their `populateOwners` applied, so only the two capture-time maps cross.
+ *
+ * Nested `Map`/`Set` are flattened to arrays here so the snapshot stays plain
+ * JSON (avoids relying on the parsedfile-store's Map/Set replacer for nested
+ * structures): `dependentBases` is `[className, [baseName, qualifiers[]][]][]`.
+ */
+export interface CppTwoPhaseSideChannel {
+    readonly dependentBases: readonly [string, readonly [string, readonly string[]][]][];
+    readonly dependentPackBaseClasses: readonly string[];
+}
+/** Snapshot this file's two-phase-lookup capture state for the side-channel. */
+export declare function collectCppTwoPhaseSideChannel(filePath: string): CppTwoPhaseSideChannel;
+/** Restore this file's two-phase-lookup capture state from the side-channel. */
+export declare function applyCppTwoPhaseSideChannel(filePath: string, data: CppTwoPhaseSideChannel): void;
 /** Clear two-phase-lookup state. Called from `clearFileLocalNames`. */
 export declare function clearCppDependentBases(): void;
 /**

package/dist/core/ingestion/languages/cpp/two-phase-lookup.js

@@ -41,6 +41,12 @@ import { findEnclosingClassDef } from '../../scope-resolution/scope/walkers.js';
  *   qualifier is '' when the base was unqualified.
  */
 const dependentBasesByFile = new Map();
+/**
+ * Class templates with pack-expanded bases (`struct Mix : Bases...`) have
+ * an unknown set of base classes. Unqualified member lookup inside the class
+ * cannot safely bind to class-owned methods outside the current class.
+ */
+const dependentPackBaseClassesByFile = new Map();
 /**
  * Post-`populateOwners` resolution: per-class-nodeId, the set of
  * dependent-base-class nodeIds. Built by `populateCppDependentBases`
@@ -76,9 +82,50 @@ export function markCppDependentBase(filePath, className, baseName, qualifier =
     }
     quals.add(qualifier);
 }
+export function markCppDependentPackBase(filePath, className) {
+    let perFile = dependentPackBaseClassesByFile.get(filePath);
+    if (perFile === undefined) {
+        perFile = new Set();
+        dependentPackBaseClassesByFile.set(filePath, perFile);
+    }
+    perFile.add(className);
+}
+/** Snapshot this file's two-phase-lookup capture state for the side-channel. */
+export function collectCppTwoPhaseSideChannel(filePath) {
+    const perFile = dependentBasesByFile.get(filePath);
+    const dependentBases = [];
+    if (perFile !== undefined) {
+        for (const [className, bases] of perFile) {
+            const baseEntries = [];
+            for (const [baseName, quals] of bases) {
+                baseEntries.push([baseName, [...quals]]);
+            }
+            dependentBases.push([className, baseEntries]);
+        }
+    }
+    const pack = dependentPackBaseClassesByFile.get(filePath);
+    return {
+        dependentBases,
+        dependentPackBaseClasses: pack === undefined ? [] : [...pack],
+    };
+}
+/** Restore this file's two-phase-lookup capture state from the side-channel. */
+export function applyCppTwoPhaseSideChannel(filePath, data) {
+    for (const [className, baseEntries] of data.dependentBases) {
+        for (const [baseName, quals] of baseEntries) {
+            for (const qualifier of quals) {
+                markCppDependentBase(filePath, className, baseName, qualifier);
+            }
+        }
+    }
+    for (const className of data.dependentPackBaseClasses) {
+        markCppDependentPackBase(filePath, className);
+    }
+}
 /** Clear two-phase-lookup state. Called from `clearFileLocalNames`. */
 export function clearCppDependentBases() {
     dependentBasesByFile.clear();
+    dependentPackBaseClassesByFile.clear();
     dependentBaseNodeIds.clear();
 }
 /**
@@ -97,7 +144,7 @@ export function clearCppDependentBases() {
  *     found (conservative: avoids false associations).
  */
 export function populateCppDependentBases(parsedFiles) {
-    if (dependentBasesByFile.size === 0)
+    if (dependentBasesByFile.size === 0 && dependentPackBaseClassesByFile.size === 0)
         return;
     // Build workspace-wide index: simpleName → {nodeId, nsPrefix}[]
     // nsPrefix is the dot-joined namespace path (qualifiedName without the
@@ -153,6 +200,15 @@ export function populateCppDependentBases(parsedFiles) {
             const nsPrefix = lastDot >= 0 ? qn.slice(0, lastDot) : '';
             localClassByName.set(simple, { nodeId: def.nodeId, nsPrefix });
         }
+        const packBaseClasses = dependentPackBaseClassesByFile.get(filePath);
+        if (packBaseClasses !== undefined) {
+            for (const className of packBaseClasses) {
+                const classEntry = localClassByName.get(className);
+                if (classEntry !== undefined) {
+                    dependentBaseNodeIds.set(classEntry.nodeId, new Set(['*pack-expansion*']));
+                }
+            }
+        }
         // V3: qualifier-based exact targeting. When the base specifier carries
         // a syntactic qualifier (e.g., `detail` in `detail::Inner<T>`), compute
         // the expected namespace prefix and use exact (===) match. Falls back to
@@ -247,13 +303,37 @@ export function populateCppDependentBases(parsedFiles) {
  * access; missing edges here match the compiler's diagnostic shape.
  */
 export function isCppDependentBaseMember(callerScopeId, candidateDef, scopes) {
-    if (candidateDef.ownerId === undefined)
-        return false;
     const enclosing = findEnclosingClassDef(callerScopeId, scopes);
     if (enclosing === undefined)
         return false;
     const bases = dependentBaseNodeIds.get(enclosing.nodeId);
     if (bases === undefined)
         return false;
+    if (bases.has('*pack-expansion*')) {
+        if (candidateDef.ownerId !== undefined)
+            return candidateDef.ownerId !== enclosing.nodeId;
+        if (candidateDef.type !== 'Method' && candidateDef.type !== 'Constructor')
+            return false;
+        const ownerName = getQualifiedParentName(candidateDef.qualifiedName);
+        const enclosingName = getQualifiedSimpleName(enclosing.qualifiedName);
+        return ownerName !== undefined && ownerName !== enclosingName;
+    }
+    if (candidateDef.ownerId === undefined)
+        return false;
     return bases.has(candidateDef.ownerId);
 }
+function getQualifiedParentName(qualifiedName) {
+    if (qualifiedName === undefined)
+        return undefined;
+    const lastDot = qualifiedName.lastIndexOf('.');
+    if (lastDot < 0)
+        return undefined;
+    const parent = qualifiedName.slice(0, lastDot);
+    return getQualifiedSimpleName(parent);
+}
+function getQualifiedSimpleName(qualifiedName) {
+    if (qualifiedName === undefined)
+        return undefined;
+    const lastDot = qualifiedName.lastIndexOf('.');
+    return lastDot >= 0 ? qualifiedName.slice(lastDot + 1) : qualifiedName;
+}