@optave/codegraph 3.12.0 → 3.15.0

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

@@ -5,8 +5,16 @@
  * Both callers supply a `CallNodeLookup` adapter that abstracts their
  * node-lookup mechanism (pre-loaded Maps vs. per-query SQLite statements).
  * The resolution logic lives here exactly once.
+ *
+ * `resolveByMethodOrGlobal` delegates its two branches to strategy helpers
+ * in `../resolver/strategy.ts` to keep per-strategy complexity manageable.
  */
 import { computeConfidence } from '../resolve.js';
+import {
+  isModuleScopedLanguage,
+  resolveByGlobal,
+  resolveByReceiver,
+} from '../resolver/strategy.js';
 
 // ── Public interface ─────────────────────────────────────────────────────
 
@@ -23,165 +31,148 @@ export interface CallNodeLookup {
 
 export const RECEIVER_KINDS = new Set(['class', 'struct', 'interface', 'type', 'module']);
 
+// Re-export so consumers that import isModuleScopedLanguage from this module
+// continue to work without changes (build-edges.ts, etc.).
+export { isModuleScopedLanguage };
+
+// ── Shared resolution functions ──────────────────────────────────────────
+
 /**
- * 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.
+ * 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 MODULE_SCOPED_BARE_CALL_EXTENSIONS = new Set([
-  '.js',
-  '.mjs',
-  '.cjs',
-  '.jsx',
-  '.ts',
-  '.tsx',
-  '.mts',
-  '.cts',
-]);
+const CALLABLE_KINDS = new Set(['function', 'method']);
 
-export function isModuleScopedLanguage(relPath: string): boolean {
-  const ext = relPath.slice(relPath.lastIndexOf('.'));
-  return MODULE_SCOPED_BARE_CALL_EXTENSIONS.has(ext);
-}
+/**
+ * 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']);
 
-// ── Shared resolution functions ──────────────────────────────────────────
+type Def = { name: string; kind: string; line: number; endLine?: number | null };
+type CallerMatch = { id: number; name: string } | null;
 
-export function findCaller(
+/**
+ * Find the narrowest enclosing function/method definition for `callLine`.
+ * Returns the DB node and name, or null if none encloses the call.
+ */
+function findEnclosingCallable(
   lookup: CallNodeLookup,
-  call: { line: number },
-  definitions: ReadonlyArray<{
-    name: string;
-    kind: string;
-    line: number;
-    endLine?: number | null;
-  }>,
+  callLine: number,
+  definitions: ReadonlyArray<Def>,
   relPath: string,
-  fileNodeRow: { id: number },
-): { id: number; callerName: string | null } {
-  let caller: { id: number } | null = null;
-  let callerName: string | null = null;
-  let callerSpan = Infinity;
+): CallerMatch {
+  let best: CallerMatch = null;
+  let bestSpan = Infinity;
   for (const def of definitions) {
-    if (def.line <= call.line) {
-      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;
-            callerName = def.name;
-            callerSpan = span;
-          }
-        }
+    if (!CALLABLE_KINDS.has(def.kind)) continue;
+    if (def.line > callLine) continue;
+    const end = def.endLine ?? Infinity;
+    if (callLine > end) continue;
+    const span = end === Infinity ? Infinity : end - def.line;
+    if (span < bestSpan) {
+      const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+      if (row) {
+        best = { ...row, name: def.name };
+        bestSpan = span;
       }
     }
   }
-  return { ...(caller ?? fileNodeRow), callerName };
+  return best;
 }
 
-export function resolveByMethodOrGlobal(
+/**
+ * Find the widest (outermost) enclosing variable/constant binding for `callLine`.
+ * Used as fallback for top-level bindings (e.g. Haskell `main = do …`).
+ * We pick the WIDEST span so that nested `let` bindings inside `main`'s
+ * do-block do not shadow `main` itself as the attributing caller.
+ */
+function findEnclosingBinding(
   lookup: CallNodeLookup,
-  call: { name: string; receiver?: string | null },
+  callLine: number,
+  definitions: ReadonlyArray<Def>,
   relPath: string,
-  typeMap: Map<string, unknown>,
-  callerName?: string | null,
-): ReadonlyArray<{ id: number; file: string }> {
-  if (call.receiver) {
-    // 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, also try the class-scoped key (ClassName.prop) seeded by
-    // handlePropWriteTypeMap — prevents false edges when multiple classes define the same
-    // property name (issue #1323).
-    let 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);
-    if (!typeEntry && call.receiver.startsWith('this.') && callerName) {
-      const dotIdx = callerName.lastIndexOf('.');
-      if (dotIdx > -1) {
-        const callerClass = callerName.slice(0, dotIdx);
-        typeEntry = typeMap.get(`${callerClass}.${effectiveReceiver}`);
+): CallerMatch {
+  let best: CallerMatch = null;
+  let bestSpan = -1; // looking for WIDEST span, so start at -1
+  for (const def of definitions) {
+    if (!TOP_LEVEL_BINDING_KINDS.has(def.kind)) continue;
+    if (def.line > callLine) continue;
+    const end = def.endLine ?? Infinity;
+    if (callLine > end) continue;
+    const span = end === Infinity ? Infinity : end - def.line;
+    if (span > bestSpan) {
+      const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+      if (row) {
+        best = { ...row, name: def.name };
+        bestSpan = span;
       }
     }
-    let typeName = typeEntry
-      ? typeof typeEntry === 'string'
-        ? typeEntry
-        : (typeEntry as { type?: string }).type
-      : null;
+  }
+  return best;
+}
 
-    // 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];
-    }
+export function findCaller(
+  lookup: CallNodeLookup,
+  call: { line: number },
+  definitions: ReadonlyArray<Def>,
+  relPath: string,
+  fileNodeRow: { id: number },
+): { id: number; callerName: string | null } {
+  // Pass 1: find the narrowest enclosing function/method.
+  const fnCaller = findEnclosingCallable(lookup, call.line, definitions, relPath);
 
-    if (typeName) {
-      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;
+  // Prefer function/method enclosing scope over variable binding.
+  // 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 { id: fnCaller.id, callerName: fnCaller.name };
+  }
 
-      // 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;
-      }
-    }
+  // Pass 2: find the widest (outermost) enclosing variable/constant binding.
+  const varCaller = findEnclosingBinding(lookup, call.line, definitions, relPath);
+  if (varCaller) {
+    return { id: varCaller.id, callerName: varCaller.name };
+  }
 
-    // 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;
-    }
+  return { ...fileNodeRow, callerName: null };
+}
 
-    // 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;
-    }
+/**
+ * Dispatcher for call-site resolution.
+ *
+ * Delegates to two strategy helpers (in `../resolver/strategy.ts`) to keep
+ * each branch independently readable and under the complexity threshold:
+ *   - resolveByReceiver  — receiver is a concrete object/class reference
+ *   - resolveByGlobal    — bare call, or this/self/super receiver
+ *
+ * The original logic is unchanged; only the physical location moved.
+ */
+export function resolveByMethodOrGlobal(
+  lookup: CallNodeLookup,
+  call: { name: string; receiver?: string | null },
+  relPath: string,
+  typeMap: Map<string, unknown>,
+  callerName?: string | null,
+): ReadonlyArray<{ id: number; file: string }> {
+  if (
+    call.receiver &&
+    call.receiver !== 'this' &&
+    call.receiver !== 'self' &&
+    call.receiver !== 'super'
+  ) {
+    return resolveByReceiver(
+      lookup,
+      call as { name: string; receiver: string },
+      relPath,
+      typeMap,
+      callerName,
+    );
   }
   if (
     !call.receiver ||
@@ -189,68 +180,7 @@ export function resolveByMethodOrGlobal(
     call.receiver === 'self' ||
     call.receiver === 'super'
   ) {
-    // 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 resolveByGlobal(lookup, call, relPath, typeMap, callerName);
   }
   return [];
 }
@@ -263,6 +193,12 @@ export function resolveCallTargets(
   typeMap: Map<string, unknown>,
   callerName?: string | null,
 ): { targets: Array<{ id: number; file: string }>; importedFrom: string | undefined } {
+  // Flagged dynamic calls use synthetic names like '<dynamic:eval>'. Short-circuit
+  // so they never accidentally match a real symbol via lookup.byName.
+  if (call.name.startsWith('<dynamic:')) {
+    return { targets: [], importedFrom: undefined };
+  }
+
   const importedFrom = importedNames.get(call.name);
   let targets: ReadonlyArray<{ id: number; file: string }> | undefined;
 
@@ -299,13 +235,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,
@@ -314,6 +254,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
@@ -326,18 +267,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

@@ -96,6 +96,14 @@ export function buildChaContext(fileSymbols: ReadonlyMap<string, ExtractorOutput
  * 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,
@@ -103,6 +111,7 @@ export function resolveThisDispatch(
   receiver: 'this' | 'self' | 'super',
   chaCtx: ChaContext,
   lookup: CallNodeLookup,
+  callerFile?: string | null,
 ): ReadonlyArray<{ id: number; file: string }> {
   if (!callerName) return [];
   const dotIdx = callerName.indexOf('.');
@@ -119,7 +128,15 @@ export function resolveThisDispatch(
     visited.add(current);
     const qualified = `${current}.${methodName}`;
     const found = lookup.byName(qualified).filter((n) => n.kind === 'method');
-    if (found.length > 0) return found;
+    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 [];

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

@@ -91,6 +91,7 @@ export class PipelineContext {
     confidence: number;
     dynamic: number;
     technique: string | null;
+    dynamicKind: string | null;
   }> = [];
 
   // ── Misc state ─────────────────────────────────────────────────────