@optave/codegraph 3.11.2 → 3.13.0

package/src/domain/graph/builder/call-resolver.ts

@@ -23,8 +23,46 @@ export interface CallNodeLookup {
 
 export const RECEIVER_KINDS = new Set(['class', 'struct', 'interface', 'type', 'module']);
 
+/**
+ * Languages where bare `foo()` calls inside a class method are lexically scoped
+ * to the module, not the class — there is no implicit this/class binding.
+ * For these languages, the same-class fallback must not run for bare (no-receiver)
+ * calls that found no exact same-file match.
+ */
+const MODULE_SCOPED_BARE_CALL_EXTENSIONS = new Set([
+  '.js',
+  '.mjs',
+  '.cjs',
+  '.jsx',
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+]);
+
+export function isModuleScopedLanguage(relPath: string): boolean {
+  const ext = relPath.slice(relPath.lastIndexOf('.'));
+  return MODULE_SCOPED_BARE_CALL_EXTENSIONS.has(ext);
+}
+
 // ── Shared resolution functions ──────────────────────────────────────────
 
+/**
+ * Callable definition kinds — variable/constant bindings are NOT callable
+ * in the function-as-enclosing-scope sense (they are local declarations, not
+ * function bodies). Top-level variable bindings (e.g. Haskell `main = do …`)
+ * are handled separately as a fallback tier.
+ */
+const CALLABLE_KINDS = new Set(['function', 'method']);
+
+/**
+ * Variable-like binding kinds that may act as top-level callers when no
+ * enclosing function/method exists (e.g. Haskell top-level `main` is a
+ * `bind` node → kind `variable`).  Local variable declarations inside a
+ * function body must NOT win over the enclosing function.
+ */
+const TOP_LEVEL_BINDING_KINDS = new Set(['variable', 'constant']);
+
 export function findCaller(
   lookup: CallNodeLookup,
   call: { line: number },
@@ -36,25 +74,64 @@ export function findCaller(
   }>,
   relPath: string,
   fileNodeRow: { id: number },
-): { id: number } {
-  let caller: { id: number } | null = null;
-  let callerSpan = Infinity;
+): { id: number; callerName: string | null } {
+  // Pass 1: find the narrowest enclosing function/method.
+  let fnCaller: { id: number } | null = null;
+  let fnCallerName: string | null = null;
+  let fnCallerSpan = Infinity;
+
+  // Pass 2: find the widest (outermost) enclosing variable/constant binding.
+  // Used as fallback when no function/method encloses the call site
+  // (e.g. Haskell `main = do …` is a `bind` node with kind `variable`).
+  // We pick the WIDEST span (outermost binding), not the narrowest, so that
+  // nested `let` bindings inside `main`'s do-block do not shadow `main`
+  // itself as the attributing caller.  The outermost enclosing variable is
+  // the "function-like" top-level binding.
+  let varCaller: { id: number } | null = null;
+  let varCallerName: string | null = null;
+  let varCallerSpan = -1; // looking for WIDEST span, so start at -1
+
   for (const def of definitions) {
     if (def.line <= call.line) {
-      const end = def.endLine || Infinity;
+      const end = def.endLine ?? Infinity;
       if (call.line <= end) {
-        const span = end - def.line;
-        if (span < callerSpan) {
-          const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
-          if (row) {
-            caller = row;
-            callerSpan = span;
+        const span = end === Infinity ? Infinity : end - def.line;
+        if (CALLABLE_KINDS.has(def.kind)) {
+          if (span < fnCallerSpan) {
+            const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+            if (row) {
+              fnCaller = row;
+              fnCallerName = def.name;
+              fnCallerSpan = span;
+            }
+          }
+        } else if (TOP_LEVEL_BINDING_KINDS.has(def.kind)) {
+          if (span > varCallerSpan) {
+            const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+            if (row) {
+              varCaller = row;
+              varCallerName = def.name;
+              varCallerSpan = span;
+            }
           }
         }
       }
     }
   }
-  return caller ?? fileNodeRow;
+
+  // Prefer function/method enclosing scope over variable binding.
+  // If a function/method encloses the call, use it — local variable
+  // declarations inside the function body must not shadow it.
+  // Only fall back to a variable/constant binding when the call is at
+  // top-level scope (no enclosing function/method found), which handles
+  // languages like Haskell where `main` is a top-level `bind` node.
+  if (fnCaller) {
+    return { ...fnCaller, callerName: fnCallerName };
+  }
+  if (varCaller) {
+    return { ...varCaller, callerName: varCallerName };
+  }
+  return { ...fileNodeRow, callerName: null };
 }
 
 export function resolveByMethodOrGlobal(
@@ -62,17 +139,104 @@ export function resolveByMethodOrGlobal(
   call: { name: string; receiver?: string | null },
   relPath: string,
   typeMap: Map<string, unknown>,
+  callerName?: string | null,
 ): ReadonlyArray<{ id: number; file: string }> {
   if (call.receiver) {
-    const typeEntry = typeMap.get(call.receiver);
-    const typeName = typeEntry
+    // Strip "this." so `this.repo.method()` resolves via typeMap["repo"]
+    // (or the "this.repo" key seeded directly by the TSC property-declaration enricher).
+    const effectiveReceiver = call.receiver.startsWith('this.')
+      ? call.receiver.slice('this.'.length)
+      : call.receiver;
+    // For this.prop receivers, prefer the class-scoped key (ClassName.prop) seeded by
+    // handlePropWriteTypeMap / handleFieldDefTypeMap — prevents false edges when multiple
+    // classes define the same property name (issues #1323, #1458).
+    // Class-scoped lookup runs first so bare fallback keys (confidence 0.6) don't shadow
+    // the correct per-class entry when callerName is available.
+    let typeEntry: unknown;
+    if (call.receiver.startsWith('this.') && callerName) {
+      const dotIdx = callerName.lastIndexOf('.');
+      if (dotIdx > -1) {
+        const callerClass = callerName.slice(0, dotIdx);
+        typeEntry = typeMap.get(`${callerClass}.${effectiveReceiver}`);
+      }
+    }
+    typeEntry ??=
+      typeMap.get(effectiveReceiver) ??
+      typeMap.get(call.receiver) ??
+      // Phase 8.3f: callee-scoped rest-param key (`callee::restName`) to avoid
+      // same-name rest-binding collision across functions in the same file (#1358).
+      (callerName ? typeMap.get(`${callerName}::${effectiveReceiver}`) : undefined);
+    let typeName = typeEntry
       ? typeof typeEntry === 'string'
         ? typeEntry
         : (typeEntry as { type?: string }).type
       : null;
+
+    // Belt-and-suspenders fallback for inline new-expression receivers that
+    // extractReceiverName did not normalise (e.g. raw text leaked from an
+    // unhandled AST node type).  extractReceiverName already handles the common
+    // `new_expression` / `parenthesized_expression(new_expression)` shapes by
+    // returning the constructor name directly, so this branch is exercised only
+    // by future node types or constructs that fall through to the raw-text path.
+    // The uppercase-initial restriction ([A-Z_$]) is a heuristic to distinguish
+    // constructors (PascalCase) from regular functions and avoids false positives
+    // on `(new xmlParser()).parse()` style calls.
+    if (!typeName && call.receiver) {
+      const m = /^\(?\s*new\s+([A-Z_$][A-Za-z0-9_$]*)/.exec(call.receiver);
+      if (m?.[1]) typeName = m[1];
+    }
+
     if (typeName) {
-      const typed = lookup.byName(`${typeName}.${call.name}`).filter((n) => n.kind === 'method');
+      const typed = lookup
+        .byName(`${typeName}.${call.name}`)
+        .filter((n) => n.kind === 'method' && computeConfidence(relPath, n.file, null) >= 0.5);
       if (typed.length > 0) return typed;
+
+      // Prototype alias: `Foo.prototype.bar = identifier` seeds typeMap['Foo.bar'] = { type: identifier }.
+      // Checked after the symbol-DB lookup so an actual method definition always wins.
+      const protoEntry = typeMap.get(`${typeName}.${call.name}`);
+      const protoTarget = protoEntry
+        ? typeof protoEntry === 'string'
+          ? protoEntry
+          : (protoEntry as { type?: string }).type
+        : null;
+      if (protoTarget) {
+        const resolved = lookup
+          .byName(protoTarget)
+          .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+        if (resolved.length > 0) return resolved;
+      }
+    }
+
+    // Direct qualified method lookup: ClassName.staticMethod() or ClassName.instanceMethod()
+    // when the receiver is a class name with no typeMap entry. Handles static method calls
+    // like `C6.staticMethod()` or `D.d()` where the receiver IS the class.
+    // Matches both 'method' and 'function' kinds to cover field-initializer synthetic defs.
+    if (!typeName) {
+      const qualifiedName = `${effectiveReceiver}.${call.name}`;
+      const direct = lookup
+        .byName(qualifiedName)
+        .filter(
+          (n) =>
+            (n.kind === 'method' || n.kind === 'function') &&
+            computeConfidence(relPath, n.file, null) >= 0.5,
+        );
+      if (direct.length > 0) return direct;
+    }
+
+    // Phase 8.3d: composite pts key — `obj.prop = fn` seeds typeMap['obj.prop'] = { type: 'fn' }.
+    // When a call site references `obj.prop` as a callback, resolve directly to the target fn.
+    const compositeEntry = typeMap.get(`${call.receiver}.${call.name}`);
+    const ptsTarget = compositeEntry
+      ? typeof compositeEntry === 'string'
+        ? compositeEntry
+        : (compositeEntry as { type?: string }).type
+      : null;
+    if (ptsTarget) {
+      const resolved = lookup
+        .byName(ptsTarget)
+        .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+      if (resolved.length > 0) return resolved;
     }
   }
   if (
@@ -81,7 +245,68 @@ export function resolveByMethodOrGlobal(
     call.receiver === 'self' ||
     call.receiver === 'super'
   ) {
-    return lookup.byName(call.name).filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+    // Phase 8.3f: accessor this-dispatch via Object.defineProperty.
+    // When a plain function (no class prefix) is registered as a get/set accessor for `obj`
+    // via Object.defineProperty, typeMap seeds 'callerName:this' = 'obj'.
+    // We then resolve this.method() → typeMap['obj.method'] → the concrete definition.
+    // This runs before the broad exact-name lookup to avoid false positives from
+    // unrelated same-file definitions.
+    if (call.receiver === 'this' && callerName && !callerName.includes('.')) {
+      const accessorThisEntry = typeMap.get(`${callerName}:this`);
+      const objName = accessorThisEntry
+        ? typeof accessorThisEntry === 'string'
+          ? accessorThisEntry
+          : (accessorThisEntry as { type?: string }).type
+        : null;
+      if (objName) {
+        const objMethodEntry = typeMap.get(`${objName}.${call.name}`);
+        const targetFn = objMethodEntry
+          ? typeof objMethodEntry === 'string'
+            ? objMethodEntry
+            : (objMethodEntry as { type?: string }).type
+          : null;
+        if (targetFn) {
+          const resolved = lookup
+            .byName(targetFn)
+            .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+          if (resolved.length > 0) return resolved;
+        }
+      }
+    }
+
+    const exact = lookup
+      .byName(call.name)
+      .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+    if (exact.length > 0) return exact;
+
+    // Try same-class method lookup via callerName.
+    // e.g. `this.area()` inside `Shape.describe` → try `Shape.area`.
+    // Also covers no-receiver calls inside class methods, e.g. `IsValidEmail(x)` inside
+    // `Validators.ValidateUser` → try `Validators.IsValidEmail` (C#/Java static siblings).
+    // This seeds the initial edge that runChaPostPass later expands to subclass overrides.
+    //
+    // For JS/TS, bare (no-receiver) calls are module-scoped — there is no implicit class
+    // binding. Skip the same-class fallback for bare calls in those languages to prevent
+    // false positives (e.g. `flush()` inside `Processor.run` must not resolve to
+    // `Processor.flush`). this.method() calls are unaffected: they still reach the fallback
+    // because `call.receiver === 'this'` is truthy, not a bare call.
+    const isBareCall = !call.receiver;
+    if (callerName && !(isBareCall && isModuleScopedLanguage(relPath))) {
+      const dotIdx = callerName.lastIndexOf('.');
+      if (dotIdx > -1) {
+        // Extract only the segment immediately before the method name so that
+        // 'Namespace.ClassName.method' yields 'ClassName', not 'Namespace.ClassName'.
+        // Symbols are stored under their bare class name, not their qualified path.
+        const prevDot = callerName.lastIndexOf('.', dotIdx - 1);
+        const callerClass = callerName.slice(prevDot + 1, dotIdx);
+        const qualifiedName = `${callerClass}.${call.name}`;
+        const sameClass = lookup
+          .byName(qualifiedName)
+          .filter((t) => t.kind === 'method' && computeConfidence(relPath, t.file, null) >= 0.5);
+        if (sameClass.length > 0) return sameClass;
+      }
+    }
+    return exact; // empty
   }
   return [];
 }
@@ -92,6 +317,7 @@ export function resolveCallTargets(
   relPath: string,
   importedNames: Map<string, string>,
   typeMap: Map<string, unknown>,
+  callerName?: string | null,
 ): { targets: Array<{ id: number; file: string }>; importedFrom: string | undefined } {
   const importedFrom = importedNames.get(call.name);
   let targets: ReadonlyArray<{ id: number; file: string }> | undefined;
@@ -109,7 +335,7 @@ export function resolveCallTargets(
   if (!targets || targets.length === 0) {
     targets = lookup.byNameAndFile(call.name, relPath);
     if (targets.length === 0) {
-      targets = resolveByMethodOrGlobal(lookup, call, relPath, typeMap);
+      targets = resolveByMethodOrGlobal(lookup, call, relPath, typeMap, callerName);
     }
   }
 
@@ -129,13 +355,17 @@ export function resolveCallTargets(
  * Returns the edge tuple to insert, or null if nothing matched or the edge
  * was already seen.  Callers are responsible for the actual DB/array insert.
  *
- * Receiver resolution collects all same-file candidates first (no kind
- * filter), falls back to global candidates only when the same-file set is
- * entirely empty, then filters the chosen set by RECEIVER_KINDS.  This
- * matches the native Rust build path: if a file imports a name that happens
- * to be emitted as `kind='function'` in the importer, the same-file set is
- * non-empty and blocks the global fallback, so no receiver edge is emitted.
- * Keeping this behaviour identical to the Rust path maintains engine parity.
+ * Receiver resolution:
+ * 1. Look up same-file nodes for `effectiveReceiver` (unfiltered by kind).
+ * 2. If any same-file node exists AND `effectiveReceiver` is not in `importedNames`
+ *    (i.e. it is a locally-defined symbol, not an import artifact), apply
+ *    RECEIVER_KINDS and return the filtered set — no global fallback.
+ *    A local `function C(){}` means this file owns `C`; no cross-file class
+ *    should win over it (issue #1539).
+ * 3. If the same-file node IS an import artifact (e.g. destructured require),
+ *    or no same-file node exists at all, fall back to global candidates filtered
+ *    by RECEIVER_KINDS.  This preserves the pre-#1539 behaviour for cases where
+ *    an imported name appears as kind='function' in the importer file.
  */
 export function resolveReceiverEdge(
   lookup: CallNodeLookup,
@@ -144,6 +374,7 @@ export function resolveReceiverEdge(
   relPath: string,
   typeMap: Map<string, unknown>,
   seenCallEdges: Set<string>,
+  importedNames: ReadonlyMap<string, string>,
 ): { callerId: number; receiverId: number; confidence: number } | null {
   const typeEntry = typeMap.get(call.receiver);
   const typeName = typeEntry
@@ -156,18 +387,15 @@ export function resolveReceiverEdge(
       ? ((typeEntry as { confidence?: number }).confidence ?? null)
       : null;
   const effectiveReceiver = typeName || call.receiver;
-  // Filter-before: apply RECEIVER_KINDS to same-file candidates first, then
-  // fall back to global candidates (also filtered) only when same-file yields
-  // nothing.  This prevents an imported name emitted as kind='function' in the
-  // importing file from blocking the fallback to the actual class/struct/etc.
-  // node in the defining file.
-  const sameFileCandidates = lookup
-    .byNameAndFile(effectiveReceiver, relPath)
-    .filter((n) => RECEIVER_KINDS.has(n.kind ?? ''));
-  const candidates =
-    sameFileCandidates.length > 0
-      ? sameFileCandidates
-      : lookup.byName(effectiveReceiver).filter((n) => RECEIVER_KINDS.has(n.kind ?? ''));
+  // Block global fallback only when the same-file node is a local definition,
+  // not when it's an import artifact (e.g. `const { C } = require(…)` seeds a
+  // kind='function' node in the importer but the real class lives elsewhere).
+  const sameFileAll = lookup.byNameAndFile(effectiveReceiver, relPath);
+  const isLocalDefinition = sameFileAll.length > 0 && !importedNames?.has(effectiveReceiver);
+  const sameFileCandidates = sameFileAll.filter((n) => RECEIVER_KINDS.has(n.kind ?? ''));
+  const candidates = isLocalDefinition
+    ? sameFileCandidates
+    : lookup.byName(effectiveReceiver).filter((n) => RECEIVER_KINDS.has(n.kind ?? ''));
   if (candidates.length === 0) return null;
   const recvTarget = candidates[0]!;
   const recvKey = `recv|${caller.id}|${recvTarget.id}`;

package/src/domain/graph/builder/cha.ts

@@ -0,0 +1,192 @@
+/**
+ * Phase 8.5: Class Hierarchy Analysis (CHA) + Rapid Type Analysis (RTA)
+ *
+ * CHA resolves virtual/interface method dispatch to all known concrete
+ * implementations.  RTA refines the CHA set by filtering out types that are
+ * never instantiated in the program (no `new X()` anywhere in the codebase).
+ *
+ * Used by:
+ *   - buildFileCallEdges (WASM/JS path) — inline during per-file edge building
+ *   - buildChaPostPass (native path)    — JS post-pass on top of native edges
+ */
+
+import type { ExtractorOutput } from '../../../types.js';
+import type { CallNodeLookup } from './call-resolver.js';
+
+// ── CHA context ──────────────────────────────────────────────────────────────
+
+export interface ChaContext {
+  /** interface/class name → concrete classes that implement or extend it */
+  readonly implementors: ReadonlyMap<string, readonly string[]>;
+  /** class name → direct parent class name (from `extends`) */
+  readonly parents: ReadonlyMap<string, string>;
+  /** RTA: class names that appear in `new X()` anywhere in the project */
+  readonly instantiatedTypes: ReadonlySet<string>;
+}
+
+export const EMPTY_CHA_CONTEXT: ChaContext = {
+  implementors: new Map(),
+  parents: new Map(),
+  instantiatedTypes: new Set(),
+};
+
+/**
+ * Build the CHA context from all parsed file symbols.
+ *
+ * Must be called AFTER cross-file return-type propagation so that typeMap
+ * confidence values reflect propagated types (used for RTA seeding).
+ */
+export function buildChaContext(fileSymbols: ReadonlyMap<string, ExtractorOutput>): ChaContext {
+  const implementors = new Map<string, string[]>();
+  const parents = new Map<string, string>();
+  const instantiatedTypes = new Set<string>();
+
+  for (const symbols of fileSymbols.values()) {
+    for (const cls of symbols.classes) {
+      if (cls.implements) {
+        let list = implementors.get(cls.implements);
+        if (!list) {
+          list = [];
+          implementors.set(cls.implements, list);
+        }
+        if (!list.includes(cls.name)) list.push(cls.name);
+      }
+      if (cls.extends) {
+        // child → parent (for this/super hierarchy walking)
+        if (!parents.has(cls.name)) parents.set(cls.name, cls.extends);
+        // parent → children (for CHA dispatch expansion via extends)
+        let list = implementors.get(cls.extends);
+        if (!list) {
+          list = [];
+          implementors.set(cls.extends, list);
+        }
+        if (!list.includes(cls.name)) list.push(cls.name);
+      }
+    }
+
+    // RTA: Phase 8.5 dedicated newExpressions list (all `new X()` in the file)
+    if (symbols.newExpressions) {
+      for (const typeName of symbols.newExpressions) {
+        instantiatedTypes.add(typeName);
+      }
+    }
+    // RTA fallback: constructor-confidence typeMap entries (confidence >= 0.9)
+    // covers codebases that haven't been re-parsed since Phase 8.5 was added.
+    if (symbols.typeMap instanceof Map) {
+      for (const entry of symbols.typeMap.values()) {
+        if (typeof entry !== 'string' && entry.confidence >= 0.9) {
+          instantiatedTypes.add(entry.type);
+        }
+      }
+    }
+  }
+
+  return { implementors, parents, instantiatedTypes };
+}
+
+// ── this / self / super resolution ──────────────────────────────────────────
+
+/**
+ * Resolve `this.method()`, `self.method()`, or `super.method()` through the
+ * class hierarchy of the calling method.
+ *
+ * callerName must be a qualified method name ("ClassName.callerFn") for the
+ * class context to be determinable.  Returns [] for plain functions.
+ *
+ * For `super`, resolution starts from the parent of the caller's class.
+ * For `this`/`self`, resolution starts from the caller's own class and walks
+ * up the inheritance chain (supporting inherited method lookup).
+ *
+ * When `callerFile` is provided, same-file method nodes are preferred: if the
+ * hierarchy walk finds a qualified method that exists in both the caller's own
+ * file AND in unrelated files (e.g. a class named `A` that appears in multiple
+ * fixture files), only the same-file nodes are returned.  This prevents
+ * cross-fixture false edges caused by accidental name collisions across
+ * unrelated files in the same project build.  When no same-file nodes exist,
+ * all found nodes are returned as before.
+ */
+export function resolveThisDispatch(
+  methodName: string,
+  callerName: string | null,
+  receiver: 'this' | 'self' | 'super',
+  chaCtx: ChaContext,
+  lookup: CallNodeLookup,
+  callerFile?: string | null,
+): ReadonlyArray<{ id: number; file: string }> {
+  if (!callerName) return [];
+  const dotIdx = callerName.indexOf('.');
+  if (dotIdx === -1) return [];
+
+  const callerClass = callerName.slice(0, dotIdx);
+  const startClass = receiver === 'super' ? chaCtx.parents.get(callerClass) : callerClass;
+  if (!startClass) return [];
+
+  // Walk up the hierarchy; the visited set guards against cycles in malformed data.
+  let current: string | undefined = startClass;
+  const visited = new Set<string>();
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const qualified = `${current}.${methodName}`;
+    const found = lookup.byName(qualified).filter((n) => n.kind === 'method');
+    if (found.length > 0) {
+      // When the caller's file is known, prefer same-file nodes to avoid
+      // emitting cross-file edges to identically-named methods in unrelated
+      // files.  Only fall back to the full set when no same-file node exists.
+      if (callerFile && found.some((n) => n.file === callerFile)) {
+        return found.filter((n) => n.file === callerFile);
+      }
+      return found;
+    }
+    current = chaCtx.parents.get(current);
+  }
+  return [];
+}
+
+// ── CHA dispatch expansion ───────────────────────────────────────────────────
+
+/**
+ * CHA + RTA: given a receiver type (class or interface), return all concrete
+ * method implementations reachable via the class hierarchy.
+ *
+ * Only returns methods on types that are actually instantiated somewhere in
+ * the project (RTA filter).  Returns [] when no concrete instantiated type
+ * overrides the given method.
+ *
+ * BFS over the implementors map handles multi-level hierarchies (e.g.
+ * IFoo → AbstractFoo → ConcreteFoo) so that abstract intermediate classes
+ * are transparently skipped while their concrete subclasses are still reached.
+ */
+export function resolveChaTargets(
+  typeName: string,
+  methodName: string,
+  chaCtx: ChaContext,
+  lookup: CallNodeLookup,
+): ReadonlyArray<{ id: number; file: string }> {
+  const results: Array<{ id: number; file: string }> = [];
+
+  const queue: string[] = [typeName];
+  const visited = new Set<string>();
+  visited.add(typeName);
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const children = chaCtx.implementors.get(current);
+    if (!children?.length) continue;
+
+    for (const cls of children) {
+      if (visited.has(cls)) continue;
+      visited.add(cls);
+
+      if (chaCtx.instantiatedTypes.has(cls)) {
+        const qualified = `${cls}.${methodName}`;
+        const found = lookup.byName(qualified).filter((n) => n.kind === 'method');
+        results.push(...found);
+      }
+
+      // Traverse even non-instantiated classes — they may have instantiated subclasses.
+      queue.push(cls);
+    }
+  }
+
+  return results;
+}

package/src/domain/graph/builder/context.ts

@@ -68,6 +68,8 @@ export class PipelineContext {
   batchResolved!: Map<string, string> | null;
   reexportMap!: Map<string, unknown[]>;
   barrelOnlyFiles!: Set<string>;
+  /** Phase 8.4: cache for resolveBarrelExport results keyed as "barrelPath|symbolName". */
+  barrelExportCache: Map<string, string | null> = new Map();
 
   // ── Node lookup (set by insertNodes / buildEdges stages) ───────────
   nodesByName!: Map<string, NodeRow[]>;
@@ -88,6 +90,7 @@ export class PipelineContext {
     edgeKind: string;
     confidence: number;
     dynamic: number;
+    technique: string | null;
   }> = [];
 
   // ── Misc state ─────────────────────────────────────────────────────