gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -22,6 +22,7 @@
  *
  * Plan: `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
+import { generateId } from '../../../../lib/utils.js';
 import { lookupOwnedMembersByOwner } from '../../model/owned-members-lookup.js';
 import { reconcileOwnership, validateOwnershipParity } from './reconcile-ownership.js';
 import { validateBindingsImmutability } from './validate-bindings-immutability.js';
@@ -31,15 +32,47 @@ import { resolveReferenceSites } from '../../resolve-references.js';
 import { buildGraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { resolveDefGraphId } from '../graph-bridge/ids.js';
 import { buildPopulatedMethodDispatch } from '../graph-bridge/method-dispatch.js';
-import { tryEmitEdge } from '../graph-bridge/edges.js';
 import { propagateImportedReturnTypes } from '../passes/imported-return-types.js';
 import { emitReceiverBoundCalls } from '../passes/receiver-bound-calls.js';
 import { emitFreeCallFallback } from '../passes/free-call-fallback.js';
 import { emitReferencesViaLookup } from '../graph-bridge/references-to-edges.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
-import { findClassBindingInScope, findEnclosingClassDef } from '../scope/walkers.js';
+import { findEnclosingClassDef, resolveInheritanceBaseInScope } from '../scope/walkers.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
+import { logHeapProbe } from '../../utils/heap-probe.js';
+import { parseTruthyEnv } from '../../utils/env.js';
+import { TransitionalScopeTree } from '../../../../storage/scope-index-store.js';
+import { forceGc } from '../../../../storage/parsedfile-store.js';
 import { logger } from '../../../logger.js';
+/**
+ * Emit one class-owned inheritance edge directly (the inheritance pre-pass is
+ * the authoritative emitter — see `preEmitInheritanceEdges`). Encapsulates the
+ * dual dedup contract so the two sets' joint semantics live in one place:
+ *   - `existing` — coarse per-`(caller, target, type)` gate, seeded from the
+ *     graph (so this pass is a no-op when the legacy path already emitted it).
+ *   - `seen` — per-site key shared with the generic edge bridge so the two
+ *     passes never double-emit the same resolution.
+ * The `dedupKey` and `rel:` id shape match `tryEmitEdge` exactly, so graph
+ * output stays byte-identical. The caller is the enclosing class (NOT the
+ * method/constructor `resolveCallerGraphId` would prefer — that broke MRO for
+ * C# 12 primary constructors, #1951); the edge type is pre-discriminated.
+ */
+function emitInheritanceEdgeDirect(graph, seen, existing, callerGraphId, targetGraphId, edgeType, site) {
+    const edgeKey = `${edgeType}:${callerGraphId}->${targetGraphId}`;
+    const dedupKey = `${edgeKey}:${site.atRange.startLine}:${site.atRange.startCol}`;
+    if (existing.has(edgeKey) || seen.has(dedupKey))
+        return;
+    seen.add(dedupKey);
+    existing.add(edgeKey);
+    graph.addRelationship({
+        id: `rel:${dedupKey}`,
+        sourceId: callerGraphId,
+        targetId: targetGraphId,
+        type: edgeType,
+        confidence: 0.85,
+        reason: 'scope-resolution: inherits',
+    });
+}
 /**
  * Resolve inheritance reference sites early and pre-emit their EXTENDS edges
  * before MRO construction. This lets template-base captures contribute to the
@@ -51,10 +84,12 @@ import { logger } from '../../../logger.js';
 function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
     const handledSites = new Set();
     const seen = new Set();
+    // Tracks inheritance edges emitted during this pass so the structural
+    // interface-implementation pass (emitDetectedInterfaceImplementations) and
+    // repeated `inherits` sites don't double-emit. Starts empty: this pre-pass is
+    // the authoritative inheritance emitter — no EXTENDS/IMPLEMENTS edges exist in
+    // the graph before it runs (the legacy heritage path was removed in #942).
     const existing = new Set();
-    for (const rel of graph.iterRelationshipsByType('EXTENDS')) {
-        existing.add(`${rel.sourceId}->${rel.targetId}`);
-    }
     for (const site of scopes.referenceSites) {
         if (site.kind !== 'inherits')
             continue;
@@ -68,28 +103,90 @@ function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
             // edge. The shared bridge resolves the source via
             // `resolveCallerGraphId`, which can degrade class-heritage sites into
             // method-owned EXTENDS edges once methods exist on the class. This
-            // pre-pass is the authoritative inheritance emitter, so broad
+            // pre-pass is the authoritative inheritance emitter and pins the source
+            // to the enclosing class (via the `callerGraphId` override below), so
             // suppression keeps `buildMro` and the final graph class-owned.
             handledSites.add(siteKey);
         }
-        const targetDef = findClassBindingInScope(site.inScope, site.name, scopes);
-        if (targetDef === undefined)
-            continue;
+        // Resolve the deriving (caller) class first and reuse it as the enclosing
+        // context for qualified-base resolution — avoids a second findEnclosingClassDef
+        // walk per qualified site (#1982 perf). Both need the same enclosing class.
         const callerClass = findEnclosingClassDef(site.inScope, scopes);
         if (callerClass === undefined)
             continue;
+        const targetDef = resolveInheritanceBaseInScope(site.inScope, site.name, scopes, site.rawQualifiedName, callerClass);
+        if (targetDef === undefined)
+            continue;
         const callerGraphId = resolveDefGraphId(callerClass.filePath, callerClass, nodeLookup);
         const targetGraphId = resolveDefGraphId(targetDef.filePath, targetDef, nodeLookup);
         if (callerGraphId === undefined || targetGraphId === undefined)
             continue;
-        const edgeKey = `${callerGraphId}->${targetGraphId}`;
-        if (existing.has(edgeKey))
+        // Discriminate EXTENDS vs IMPLEMENTS by the resolved target's symbol kind:
+        // conforming to an interface OR mixing in a trait/protocol is IMPLEMENTS,
+        // deriving from a class-like is EXTENDS. The discriminator is purely
+        // symbol-kind-driven (no language is named here, per AGENTS.md): a base that
+        // resolves to neither an Interface nor a Trait symbol always takes the
+        // EXTENDS branch, so such languages are unchanged.
+        const edgeType = targetDef.type === 'Interface' || targetDef.type === 'Trait' ? 'IMPLEMENTS' : 'EXTENDS';
+        emitInheritanceEdgeDirect(graph, seen, existing, callerGraphId, targetGraphId, edgeType, site);
+    }
+    return handledSites;
+}
+/**
+ * Emit language-inferred structural interface implementations before MRO and
+ * interface dispatch are built. Languages such as Go do not declare
+ * `implements` explicitly, so their resolver can infer defId-level interface
+ * satisfaction from parsed files and this bridge converts those defIds to
+ * graph node ids.
+ *
+ * Existing explicit IMPLEMENTS edges win: the local `existing` set prevents
+ * duplicate structural edges and keeps this hook language-neutral. The reason
+ * string carries the provider language (`go-structural-implements`) so callers
+ * can distinguish inferred edges from source-declared heritage.
+ */
+function emitDetectedInterfaceImplementations(graph, parsedFiles, nodeLookup, provider, indexes, model) {
+    if (provider.detectInterfaceImplementations === undefined)
+        return 0;
+    const graphIdByDefId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                continue;
+            const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                graphIdByDefId.set(def.nodeId, graphId);
+        }
+    }
+    const existing = new Set();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        existing.add(`${rel.sourceId}->${rel.targetId}`);
+    }
+    let emitted = 0;
+    const detected = provider.detectInterfaceImplementations(parsedFiles, indexes, model);
+    for (const [interfaceDefId, implementorDefIds] of detected) {
+        const targetId = graphIdByDefId.get(interfaceDefId);
+        if (targetId === undefined)
             continue;
-        if (tryEmitEdge(graph, scopes, nodeLookup, site, targetDef, 'scope-resolution: inherits', seen, 0.85)) {
+        for (const implementorDefId of implementorDefIds) {
+            const sourceId = graphIdByDefId.get(implementorDefId);
+            if (sourceId === undefined)
+                continue;
+            const edgeKey = `${sourceId}->${targetId}`;
+            if (existing.has(edgeKey))
+                continue;
             existing.add(edgeKey);
+            graph.addRelationship({
+                id: generateId('IMPLEMENTS', edgeKey),
+                sourceId,
+                targetId,
+                type: 'IMPLEMENTS',
+                confidence: 0.85,
+                reason: `${provider.language}-structural-implements`,
+            });
+            emitted++;
         }
     }
-    return handledSites;
+    return emitted;
 }
 export function runScopeResolution(input, provider) {
     const { graph, files } = input;
@@ -118,16 +215,20 @@ export function runScopeResolution(input, provider) {
     let preExtractedHits = 0;
     const progressInterval = files.length > 0 ? Math.max(1, Math.floor(files.length / 50)) : 1;
     input.onProgress?.('extracting', 0, files.length);
+    logHeapProbe('sr-extract-start', `lang=${provider.language} files=${files.length}`);
     for (let fileIdx = 0; fileIdx < files.length; fileIdx++) {
         const file = files[fileIdx];
         let parsed;
         // Fast path: a worker (during the parse phase) already produced a
         // ParsedFile for this file via `extractParsedFile`. Reuse it
         // directly — skips a tree-sitter re-parse on the main thread.
+        let reusedPreExtracted = false;
         if (preExtracted !== undefined) {
             parsed = preExtracted.get(file.path);
-            if (parsed !== undefined)
+            if (parsed !== undefined) {
                 preExtractedHits++;
+                reusedPreExtracted = true;
+            }
         }
         if (parsed === undefined) {
             const cachedTree = treeCache?.get(file.path);
@@ -137,16 +238,31 @@ export function runScopeResolution(input, provider) {
                 continue;
             }
         }
+        // Worker-boundary restore: a pre-extracted ParsedFile was produced by
+        // `extractParsedFile` running INSIDE a worker, so any capture-time
+        // module-level side-channel state (`emitScopeCaptures` side effects that
+        // are NOT serialized onto the ParsedFile's scopes/defs — C++ ADL/namespace
+        // marks) was populated in the worker process and is missing here. The
+        // worker stashed a plain-data snapshot on `parsed.captureSideChannel` (via
+        // `collectCaptureSideChannel`); write it back into the module maps now,
+        // BEFORE populateOwners consumes the resolved ranges. NO re-parse — that is
+        // the #1983 fix. The fresh-extract leg above already populated those marks
+        // in this process, so it skips the restore. See
+        // `ScopeResolver.applyCaptureSideChannel`.
+        if (reusedPreExtracted && provider.applyCaptureSideChannel !== undefined) {
+            provider.applyCaptureSideChannel(parsed);
+        }
         provider.populateOwners(parsed);
         parsedFiles.push(parsed);
-        if (input.onProgress &&
-            ((fileIdx + 1) % progressInterval === 0 || fileIdx === files.length - 1)) {
-            input.onProgress('extracting', fileIdx + 1, files.length);
+        if ((fileIdx + 1) % progressInterval === 0 || fileIdx === files.length - 1) {
+            input.onProgress?.('extracting', fileIdx + 1, files.length);
+            logHeapProbe('sr-extract-progress', `lang=${provider.language} idx=${fileIdx + 1}/${files.length} parsedFiles=${parsedFiles.length} preExtractedHits=${preExtractedHits}`);
         }
     }
     if (PROF && preExtracted !== undefined) {
         logger.warn(`[scope-resolution prof] pre-extracted hits: ${preExtractedHits}/${files.length}`);
     }
+    logHeapProbe('sr-extract-end', `lang=${provider.language} parsedFiles=${parsedFiles.length} preExtractedHits=${preExtractedHits} skipped=${filesSkipped}`);
     provider.populateWorkspaceOwners?.(parsedFiles, { fileContents: getFileContents() });
     // Reconcile scope-resolution's ownership view into the SemanticModel.
     // See `reconcile-ownership.ts` for the full rationale (Contract
@@ -176,7 +292,9 @@ export function runScopeResolution(input, provider) {
     // ── Phase 2: finalize → ScopeResolutionIndexes ─────────────────────────
     input.onProgress?.('analyzing types', files.length, files.length);
     const allFilePaths = new Set(parsedFiles.map((f) => f.filePath));
-    const nodeLookup = buildGraphNodeLookup(graph);
+    logHeapProbe('sr-pre-nodeLookup', `lang=${provider.language}`);
+    const nodeLookup = input.prebuiltNodeLookup ?? buildGraphNodeLookup(graph);
+    logHeapProbe('sr-post-nodeLookup', `lang=${provider.language}`);
     const resolutionConfig = input.resolutionConfig;
     const finalized = finalizeScopeModel(parsedFiles, {
         hooks: {
@@ -185,13 +303,19 @@ export function runScopeResolution(input, provider) {
             mergeBindings: (existing, incoming, scopeId) => provider.mergeBindings(existing, incoming, scopeId),
         },
     });
+    logHeapProbe('sr-post-finalize', `lang=${provider.language}`);
     const preEmittedInheritanceSites = preEmitInheritanceEdges(graph, finalized, nodeLookup);
     // Call-based heritage hook (e.g., Ruby include/extend/prepend) — emits
     // IMPLEMENTS edges that `preEmitInheritanceEdges` cannot produce because
     // the heritage declarations are syntactic method calls, not grammar-level
     // heritage clauses. Must run BEFORE `buildMro` so MRO construction sees
     // the freshly-emitted IMPLEMENTS edges.
-    provider.emitHeritageEdges?.(graph, parsedFiles, nodeLookup);
+    provider.emitHeritageEdges?.(graph, parsedFiles, nodeLookup, finalized);
+    // Implicit IMPORTS-edge hook — for languages whose files have compiler-
+    // implicit cross-file visibility (no syntactic import statement). The
+    // finalized-ImportEdge pipeline (`emitImportEdges`) cannot produce these
+    // because there is no `ImportEdge` to materialize. Idempotent.
+    provider.emitImplicitImportEdges?.(graph, parsedFiles, nodeLookup, resolutionConfig);
     // Rebuild the node lookup after heritage-edge emission. Languages like
     // Ruby create Property graph nodes inside `emitHeritageEdges`; those
     // nodes must be visible to downstream passes (`emitReceiverBoundCalls`
@@ -199,6 +323,7 @@ export function runScopeResolution(input, provider) {
     // `nodeLookup`). Without this rebuild, Property nodes added by the
     // heritage hook are invisible and ACCESSES edges silently fail to emit.
     const postHeritageNodeLookup = provider.emitHeritageEdges !== undefined ? buildGraphNodeLookup(graph) : nodeLookup;
+    emitDetectedInterfaceImplementations(graph, parsedFiles, postHeritageNodeLookup, provider, finalized, readonlyModel);
     const mroByClassDefId = provider.buildMro(graph, parsedFiles, postHeritageNodeLookup);
     const extendsOnlyMroByClassDefId = provider.buildExtendsOnlyMro?.(graph, parsedFiles, postHeritageNodeLookup);
     // Replace the empty MethodDispatchIndex that finalizeScopeModel
@@ -216,7 +341,12 @@ export function runScopeResolution(input, provider) {
     // cannot carry. Must run AFTER `populateOwners` (so owned defs are
     // attributed correctly) and AFTER finalize (so module-scope
     // bindings are available).
-    const workspaceIndex = buildWorkspaceResolutionIndex(parsedFiles);
+    // Pass the scopeTree so the index's class/module Scope lookups are id-backed
+    // views that delegate to it (out-of-core scope index) — the index pins no Scope objects, so the
+    // disk seal can reclaim them. Byte-identical: the view returns the same Scope
+    // the resident tree holds (or a value-identical revived one in disk mode).
+    const workspaceIndex = buildWorkspaceResolutionIndex(parsedFiles, indexes.scopeTree);
+    logHeapProbe('sr-post-workspaceIndex', `lang=${provider.language}`);
     // Cross-file implicit-namespace visibility (C#). Must run before
     // propagateImportedReturnTypes so the latter pass sees siblings'
     // class bindings when chasing return-type chains across files.
@@ -226,6 +356,7 @@ export function runScopeResolution(input, provider) {
         provider.populateNamespaceSiblings(parsedFiles, indexes, {
             fileContents: getFileContents(),
             treeCache,
+            resolutionConfig,
         });
     }
     const tFinalize = PROF ? process.hrtime.bigint() : 0n;
@@ -233,7 +364,7 @@ export function runScopeResolution(input, provider) {
     // propagateImportedReturnTypes so the SCC-ordered pass sees the
     // mirrored bindings.
     if (provider.mirrorNamespaceTypeBindings !== undefined) {
-        provider.mirrorNamespaceTypeBindings(parsedFiles, indexes, workspaceIndex);
+        provider.mirrorNamespaceTypeBindings(parsedFiles, indexes, workspaceIndex, resolutionConfig);
     }
     // Cross-file return-type propagation (Contract Invariant I3 timing:
     // after finalize, before resolve). Split-timed separately so the
@@ -268,17 +399,43 @@ export function runScopeResolution(input, provider) {
         ownedMembersByOwner: (ownerDefId, memberName) => lookupOwnedMembersByOwner(readonlyModel, ownerDefId, memberName),
     });
     const tResolve = PROF ? process.hrtime.bigint() : 0n;
+    logHeapProbe('sr-post-resolve', `lang=${provider.language}`);
+    // ── Out-of-core scope seal boundary ─────────────────────────────────────
+    // Pass-A (finalize + propagate + resolve) is done; all whole-language reads
+    // of `Scope.bindings` are behind us. Emit reaches scopes ONLY via
+    // `scopeTree.getScope` (a point lookup), so seal the TransitionalScopeTree to
+    // disk now and drop the resident scopes. The scopes are pinned from THREE
+    // sides: (1) the model's frozen `scopeTree` — released by `seal()` nulling its
+    // resident backing from the inside; (2) `input.preExtractedParsedFiles` (held
+    // by the caller for its own post-run release) — released here since run.ts is
+    // its last reader after extract; (3) this function's `parsedFiles` — replaced
+    // by a scope-stripped copy that keeps only what emit reads (referenceSites /
+    // filePath / localDefs). All three released → the heavy payload is collectible.
+    let emitParsedFiles = parsedFiles;
+    if (input.scopeIndexStorePath !== undefined &&
+        parseTruthyEnv(process.env.GITNEXUS_DISK_SCOPE_INDEX) &&
+        indexes.scopeTree instanceof TransitionalScopeTree) {
+        logHeapProbe('sr-seal-pre', `lang=${provider.language}`);
+        indexes.scopeTree.seal(input.scopeIndexStorePath);
+        emitParsedFiles = parsedFiles.map((p) => ({ ...p, scopes: [] }));
+        parsedFiles.length = 0;
+        if (preExtracted !== undefined)
+            preExtracted.clear();
+        forceGc();
+        logHeapProbe('sr-seal-post', `lang=${provider.language}`);
+    }
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
     input.onProgress?.('linking symbols', files.length, files.length);
     const handledSites = new Set(preEmittedInheritanceSites);
-    const receiverExtras = emitReceiverBoundCalls(graph, indexes, parsedFiles, postHeritageNodeLookup, handledSites, provider, workspaceIndex, readonlyModel, {
+    const receiverExtras = emitReceiverBoundCalls(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, provider, workspaceIndex, readonlyModel, {
         recordResolutionOutcome,
     });
     const unresolvedReceiverExtras = provider.emitUnresolvedReceiverEdges !== undefined
-        ? provider.emitUnresolvedReceiverEdges(graph, indexes, parsedFiles, postHeritageNodeLookup, handledSites, readonlyModel)
+        ? provider.emitUnresolvedReceiverEdges(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, readonlyModel)
         : 0;
-    const freeCallExtras = emitFreeCallFallback(graph, indexes, parsedFiles, postHeritageNodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, {
+    const freeCallExtras = emitFreeCallFallback(graph, indexes, emitParsedFiles, postHeritageNodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, {
         allowGlobalFallback: provider.allowGlobalFreeCallFallback === true,
+        constructorCallTargetsClass: provider.constructorCallTargetsClass === true,
         isFileLocalDef: provider.isFileLocalDef,
         isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
         resolveAdlCandidates: provider.resolveAdlCandidates,
@@ -288,6 +445,15 @@ export function runScopeResolution(input, provider) {
     });
     const { emitted, skipped } = emitReferencesViaLookup(graph, indexes, referenceIndex, postHeritageNodeLookup, handledSites);
     const importsEmitted = emitImportEdges(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);
+    // Language-specific supplementary edges (e.g. Vue template-derived
+    // BINDS_EVENT_HANDLER / EMITS_EVENT / CALLS / ACCESSES edges).
+    // Runs last so the full graph — including import edges — is visible.
+    if (provider.emitPostResolutionEdges !== undefined) {
+        provider.emitPostResolutionEdges(graph, emitParsedFiles, postHeritageNodeLookup, indexes, {
+            fileContents: getFileContents(),
+            resolutionConfig,
+        });
+    }
     if (PROF) {
         const tEnd = process.hrtime.bigint();
         const ns = (a, b) => Number(b - a) / 1_000_000;
@@ -299,6 +465,7 @@ export function runScopeResolution(input, provider) {
             ` total=${ns(tStart, tEnd).toFixed(0)}ms` +
             ` (${parsedFiles.length} files)`);
     }
+    logHeapProbe('sr-end', `lang=${provider.language} parsedFiles=${parsedFiles.length}`);
     return {
         filesProcessed: parsedFiles.length,
         filesSkipped,

package/dist/core/ingestion/scope-resolution/pipeline/validate-bindings-immutability.js

@@ -74,5 +74,36 @@ export function validateBindingsImmutability(indexes, onWarn) {
             violations++;
         }
     }
+    // Fourth channel: `workspaceTypeBindings` (scope-independent global typeBindings,
+    // #1954). TypeRef-valued (no inner arrays), populated once by the hook then read
+    // through the walker fallback — assert the map itself stays mutable so the hook
+    // can populate it, mirroring the other shared channels.
+    if (Object.isFrozen(indexes.workspaceTypeBindings)) {
+        onWarn(`binding-immutability: indexes.workspaceTypeBindings is FROZEN — ` +
+            `the workspace type channel is populated post-finalize and must stay mutable. ` +
+            `See ScopeResolver Invariant I8.`);
+        violations++;
+    }
+    // Fifth/sixth channels: the per-namespace shared maps (#1871 named-namespace
+    // generalization). `namespaceFqnBindings` carries mutable BindingRef[] buckets
+    // (hooks `push()`); `namespaceTypeBindings` carries TypeRef values. Both are
+    // populated post-finalize; freezing an inner bucket/map defeats that.
+    for (const [ns, inner] of indexes.namespaceFqnBindings) {
+        for (const [name, bucket] of inner) {
+            if (Object.isFrozen(bucket)) {
+                onWarn(`binding-immutability: indexes.namespaceFqnBindings[${ns}][${name}] is FROZEN — ` +
+                    `per-namespace buckets are mutable by contract. See ScopeResolver Invariant I8.`);
+                violations++;
+            }
+        }
+    }
+    for (const [ns, inner] of indexes.namespaceTypeBindings) {
+        if (Object.isFrozen(inner)) {
+            onWarn(`binding-immutability: indexes.namespaceTypeBindings[${ns}] is FROZEN — ` +
+                `per-namespace type maps are populated post-finalize and must stay mutable. ` +
+                `See ScopeResolver Invariant I8.`);
+            violations++;
+        }
+    }
     return violations;
 }

package/dist/core/ingestion/scope-resolution/scope/walkers.d.ts

@@ -81,6 +81,21 @@ export declare function isClassLike(t: string): boolean;
  * exists in the chain.
  */
 export declare function findReceiverTypeBinding(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): TypeRef | undefined;
+/**
+ * Resolve a typeBinding for `name` from the per-namespace channel
+ * (`namespaceTypeBindings`) across the namespaces accessible from `moduleScopeId`.
+ * First accessible-namespace hit wins. Returns `undefined` when the module has no
+ * accessibility entry (non-module scope id, or a bundle that didn't populate the
+ * channel — all non-C# today). Shared by the two typeBindings chain-walkers so
+ * the named-namespace fallback stays identical between them.
+ */
+export declare function namespaceTypeBindingFor(moduleScopeId: ScopeId | null, name: string, scopes: ScopeResolutionIndexes): TypeRef | undefined;
+/**
+ * Walk the scope chain from `startScope` to its enclosing Module scope id, or
+ * `null` if none is found. Used by chain-followers that need the module scope to
+ * consult the accessibility-gated per-namespace channels.
+ */
+export declare function moduleScopeIdOf(startScope: ScopeId, scopes: ScopeResolutionIndexes): ScopeId | null;
 /**
  * Look up a class-like binding by name in the given scope's chain.
  *
@@ -99,6 +114,42 @@ export declare function findReceiverTypeBinding(startScope: ScopeId, receiverNam
  * Without (2) we'd miss every cross-file class-receiver call.
  */
 export declare function findClassBindingInScope(startScope: ScopeId, receiverName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
+/**
+ * Resolve a class-like inheritance target using the shared inheritance
+ * resolution chain. Keeps pre-emitted heritage edges and language-specific
+ * consumers of `inherits` sites aligned.
+ */
+export declare function resolveInheritanceBaseInScope(startScope: ScopeId, baseName: string, scopes: ScopeResolutionIndexes, rawQualifiedName?: string, enclosingClassDef?: SymbolDefinition): SymbolDefinition | undefined;
+/**
+ * Import/include-aware disambiguation for an *ambiguous* class-like base
+ * name. Engages ONLY as a fallback after `findClassBindingInScope` has
+ * already returned `undefined` — i.e. the scope-chain walk and the
+ * single-match `qualifiedNames` fast paths could not pick a winner because
+ * several same-named class-like defs exist (e.g. two `class Handler`s in
+ * different headers/namespaces).
+ *
+ * Disambiguates by the referencing file's import graph: the enclosing
+ * module scope's finalized `ImportEdge[]` (C++ `#include`, C# `using`, etc.)
+ * each carry the exporting file in `targetFile`. A candidate whose defining
+ * file is brought in by one of those edges is preferred. Resolution is
+ * tiered, strictest first, and only commits when EXACTLY ONE candidate
+ * survives a tier — so a still-ambiguous name keeps the historical
+ * "return undefined" refusal:
+ *
+ *   1. Exact file match — candidate.filePath === an import's `targetFile`
+ *      (covers C++ `#include "handler_a.h"` → that header's class).
+ *   2. Same-directory match — candidate.filePath sits in the same directory
+ *      as some import target file (covers C# `using MyApp.Models;`, where the
+ *      namespace import resolves to ONE representative file in the namespace's
+ *      directory, not necessarily the file declaring the referenced type).
+ *
+ * Language-neutral: keyed only on the finalized import edges and the
+ * candidate defs' `filePath`. Returns `undefined` (preserving refusal) when
+ * the name is single-match-resolvable already (never reached — caller gates
+ * on `findClassBindingInScope` miss), when no import disambiguates, or when
+ * a tier leaves more than one survivor.
+ */
+export declare function resolveAmbiguousInheritanceBaseViaImports(startScope: ScopeId, baseName: string, scopes: ScopeResolutionIndexes): SymbolDefinition | undefined;
 /**
  * Predicate for value-receiver bridge: the labels for which
  * `reconcileOwnership` registers methods/fields under the def's
@@ -183,6 +234,27 @@ export declare function findCallableBindingsAndAdlBlocker(startScope: ScopeId, n
  * so this single mutation is visible from both sides.
  */
 export declare function populateClassOwnedMembers(parsed: ParsedFile): void;
+/**
+ * Tag every def declared inside one or more `Namespace` scopes with its
+ * enclosing-namespace path (`NS`, `Outer.Inner`) on a sidecar `namespacePrefix`
+ * field — WITHOUT touching `qualifiedName`.
+ *
+ * Some scope-extractors qualify a nested type by its enclosing CLASS chain
+ * (`A.Inner`) but drop the enclosing NAMESPACE, while the structure phase keys
+ * the graph node by the full path (`NS.A.Inner`). `resolveDefGraphId` reads this
+ * tag to retry the node lookup with the namespace-prefixed key before the
+ * simple-name fallback, so same-tail nested bases don't collapse across sibling
+ * namespace members (#1982). `qualifiedName` is deliberately left unchanged, so
+ * the `qualifiedName`-keyed resolution index and existing namespace resolution
+ * (brace-init, UDC ranking, two-phase lookup) are untouched.
+ *
+ * Language-agnostic: it acts only on `Namespace`-kind scopes (a namespace-free
+ * language is a no-op) and is opt-in per provider (call after `populateOwners`).
+ * Namespace segments are taken as each namespace def's own tail, so it composes
+ * for nested namespaces regardless of whether the inner namespace's name is
+ * stored simple or already dotted. Skips defs already carrying the prefix.
+ */
+export declare function tagNamespacePrefixes(parsed: ParsedFile): void;
 /**
  * Walk a scope chain upward looking for the innermost enclosing
  * Class scope and return that class's def. Used by per-language