@optave/codegraph 3.11.1 → 3.12.0

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

@@ -7,7 +7,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { purgeFilesData } from '../../../db/index.js';
-import { warn } from '../../../infrastructure/logger.js';
+import { debug, warn } from '../../../infrastructure/logger.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../../shared/constants.js';
 import { compileGlobs, matchesAny } from '../../../shared/globs.js';
 import type {
@@ -313,9 +313,9 @@ function getEdgeStmt(db: BetterSqlite3Database, chunkSize: number): SqliteStatem
   }
   let stmt = cache.get(chunkSize);
   if (!stmt) {
-    const ph = '(?,?,?,?,?)';
+    const ph = '(?,?,?,?,?,?)';
     stmt = db.prepare(
-      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic) VALUES ' +
+      'INSERT INTO edges (source_id,target_id,kind,confidence,dynamic,technique) VALUES ' +
         Array.from({ length: chunkSize }, () => ph).join(','),
     );
     cache.set(chunkSize, stmt);
@@ -344,7 +344,7 @@ export function batchInsertNodes(db: BetterSqlite3Database, rows: unknown[][]):
 
 /**
  * Batch-insert edge rows via multi-value INSERT statements.
- * Each row: [source_id, target_id, kind, confidence, dynamic]
+ * Each row: [source_id, target_id, kind, confidence, dynamic, technique]
  */
 export function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]): void {
   if (!rows.length) return;
@@ -355,8 +355,178 @@ export function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]):
     const vals: unknown[] = [];
     for (let j = i; j < end; j++) {
       const r = rows[j] as unknown[];
-      vals.push(r[0], r[1], r[2], r[3], r[4]);
+      vals.push(r[0], r[1], r[2], r[3], r[4], r[5] ?? null);
     }
     stmt.run(...vals);
   }
 }
+
+/**
+ * CHA (Class Hierarchy Analysis) post-pass.
+ *
+ * Expands virtual-dispatch call edges for class hierarchies and interface
+ * implementations already present in the DB:
+ *
+ *  1. Build implementors map: parent/interface → [child/implementing class] from
+ *     `extends` and `implements` edges.
+ *  2. Collect RTA evidence: class nodes that appear as `calls` targets (new X()).
+ *  3. Find all `calls` edges to qualified method nodes (name contains '.').
+ *  4. For each such call, expand to concrete overrides via the implementors map,
+ *     filtered by RTA when evidence exists.
+ *
+ * Used by both the native orchestrator post-pass and the WASM build-edges pass.
+ */
+export function runChaPostPass(db: BetterSqlite3Database): number {
+  const hasHierarchy = db
+    .prepare(`SELECT 1 FROM edges WHERE kind IN ('extends', 'implements') LIMIT 1`)
+    .get();
+  if (!hasHierarchy) return 0;
+
+  const hierarchyRows = db
+    .prepare(
+      `SELECT src.name AS child_name, tgt.name AS parent_name
+       FROM edges e
+       JOIN nodes src ON e.source_id = src.id
+       JOIN nodes tgt ON e.target_id = tgt.id
+       WHERE e.kind IN ('extends', 'implements')`,
+    )
+    .all() as Array<{ child_name: string; parent_name: string }>;
+
+  const implementorSets = new Map<string, Set<string>>();
+  for (const row of hierarchyRows) {
+    let set = implementorSets.get(row.parent_name);
+    if (!set) {
+      set = new Set<string>();
+      implementorSets.set(row.parent_name, set);
+    }
+    set.add(row.child_name);
+  }
+  if (implementorSets.size === 0) return 0;
+  // Convert to arrays for iteration compatibility with the rest of the function
+  const implementors = new Map([...implementorSets.entries()].map(([k, v]) => [k, [...v]]));
+
+  // RTA: collect class names instantiated via constructor calls (`new X()`).
+  let rtaRows = db
+    .prepare(
+      `SELECT DISTINCT tgt.name
+       FROM edges e
+       JOIN nodes tgt ON e.target_id = tgt.id
+       WHERE e.kind = 'calls' AND tgt.kind = 'class'`,
+    )
+    .all() as Array<{ name: string }>;
+  if (rtaRows.length === 0) {
+    // Fallback: some languages (e.g. TypeScript via WASM) record constructor calls as
+    // 'function' or 'constructor' kind rather than 'class'. Restrict to names that are
+    // actually known class names to avoid treating unrelated function calls like `logger()`
+    // as class-instantiation evidence.
+    // Include both parent/interface names AND implementor (child) names so that
+    // `new UserRepository()` (a child class) is correctly detected as RTA evidence.
+    const knownClassNames = [
+      ...new Set([
+        ...implementorSets.keys(),
+        ...[...implementorSets.values()].flatMap((s) => [...s]),
+      ]),
+    ];
+    if (knownClassNames.length > 0) {
+      // Chunk to stay within SQLite SQLITE_MAX_VARIABLE_NUMBER (999 in many builds).
+      const CHUNK = 999;
+      for (let i = 0; i < knownClassNames.length; i += CHUNK) {
+        const chunk = knownClassNames.slice(i, i + CHUNK);
+        const placeholders = chunk.map(() => '?').join(',');
+        const chunkRows = db
+          .prepare(
+            `SELECT DISTINCT tgt.name
+             FROM edges e
+             JOIN nodes tgt ON e.target_id = tgt.id
+             WHERE e.kind = 'calls' AND tgt.kind IN ('constructor', 'function')
+             AND tgt.name IN (${placeholders})`,
+          )
+          .all(...chunk) as Array<{ name: string }>;
+        rtaRows = rtaRows.concat(chunkRows);
+      }
+    }
+  }
+  const instantiated = new Set(rtaRows.map((r) => r.name));
+  const noRtaEvidence = instantiated.size === 0;
+  if (noRtaEvidence) {
+    debug('runChaPostPass: no constructor-call evidence — proceeding without RTA filter');
+  }
+
+  const callToMethods = db
+    .prepare(
+      `SELECT e.source_id, tgt.name AS method_name
+       FROM edges e
+       JOIN nodes tgt ON e.target_id = tgt.id
+       WHERE e.kind = 'calls' AND tgt.kind = 'method'
+       AND INSTR(tgt.name, '.') > 0`,
+    )
+    .all() as Array<{ source_id: number; method_name: string }>;
+
+  const seen = new Set<string>();
+  // Scope deduplication to only the source_ids we are about to expand, avoiding
+  // a full-table scan. CHA only inserts edges FROM callers that already call a
+  // qualified method (the source_ids in callToMethods), so we only need to
+  // check existing edges for those specific callers.
+  const callerIds = [...new Set(callToMethods.map((r) => r.source_id))];
+  if (callerIds.length > 0) {
+    // Chunk to stay within SQLite SQLITE_MAX_VARIABLE_NUMBER (999 in many builds).
+    const CHUNK = 999;
+    for (let i = 0; i < callerIds.length; i += CHUNK) {
+      const chunk = callerIds.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => '?').join(',');
+      const existingPairs = db
+        .prepare(
+          `SELECT source_id, target_id FROM edges WHERE kind = 'calls' AND source_id IN (${placeholders})`,
+        )
+        .all(...chunk) as Array<{ source_id: number; target_id: number }>;
+      for (const e of existingPairs) seen.add(`${e.source_id}|${e.target_id}`);
+    }
+  }
+
+  // No LIMIT: multiple files can define the same qualified name in a monorepo.
+  const findMethodStmt = db.prepare(`SELECT id FROM nodes WHERE name = ? AND kind = 'method'`);
+  const newEdges: Array<[number, number, string, number, number, string]> = [];
+
+  for (const { source_id, method_name } of callToMethods) {
+    const dotIdx = method_name.indexOf('.');
+    if (dotIdx === -1) continue;
+    const typeName = method_name.slice(0, dotIdx);
+    const methodSuffix = method_name.slice(dotIdx + 1);
+
+    // BFS over the implementors map — handles multi-level hierarchies where
+    // abstract/non-instantiated classes sit between the call-site type and
+    // the concrete leaf implementations (matches runPostNativeCha, issue #1311).
+    const bfsQueue: string[] = [typeName];
+    const bfsVisited = new Set<string>([typeName]);
+    while (bfsQueue.length > 0) {
+      const current = bfsQueue.shift()!;
+      const children = implementors.get(current);
+      if (!children?.length) continue;
+
+      for (const cls of children) {
+        if (bfsVisited.has(cls)) continue;
+        bfsVisited.add(cls);
+
+        if (noRtaEvidence || instantiated.has(cls)) {
+          const qualifiedName = `${cls}.${methodSuffix}`;
+          const methodNodes = findMethodStmt.all(qualifiedName) as Array<{ id: number }>;
+          for (const methodNode of methodNodes) {
+            const key = `${source_id}|${methodNode.id}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            newEdges.push([source_id, methodNode.id, 'calls', 0.8, 0, 'cha']);
+          }
+        }
+
+        // Always traverse children — non-instantiated classes may have instantiated subclasses.
+        bfsQueue.push(cls);
+      }
+    }
+  }
+
+  if (newEdges.length > 0) {
+    db.transaction(() => batchInsertEdges(db, newEdges))();
+    debug(`runChaPostPass: inserted ${newEdges.length} CHA dispatch edge(s)`);
+  }
+  return newEdges.length;
+}

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

@@ -21,6 +21,12 @@ import type {
 } from '../../../types.js';
 import { parseFileIncremental } from '../../parser.js';
 import { computeConfidence, resolveImportPath } from '../resolve.js';
+import {
+  type CallNodeLookup,
+  findCaller,
+  resolveCallTargets,
+  resolveReceiverEdge,
+} from './call-resolver.js';
 import { BUILTIN_RECEIVERS, readFileSafe } from './helpers.js';
 
 // ── Local types ─────────────────────────────────────────────────────────
@@ -185,8 +191,9 @@ function rebuildReverseDepEdges(
     aliases,
     skipBarrel ? null : db,
   );
-  const importedNames = buildImportedNamesMap(symbols, rootDir, depRelPath, aliases);
-  edgesAdded += buildCallEdges(stmts, depRelPath, symbols, fileNodeRow, importedNames);
+  const importedNames = buildImportedNamesMap(symbols, rootDir, depRelPath, aliases, db);
+  edgesAdded += buildCallEdges(db, stmts, depRelPath, symbols, fileNodeRow, importedNames);
+  edgesAdded += buildClassHierarchyEdges(stmts, depRelPath, symbols);
   return edgesAdded;
 }
 
@@ -353,7 +360,13 @@ function emitEdgesForImport(
   const targetRow = stmts.getNodeId.get(resolvedPath, 'file', resolvedPath, 0);
   if (!targetRow) return 0;
 
-  const edgeKind = imp.reexport ? 'reexports' : imp.typeOnly ? 'imports-type' : 'imports';
+  const edgeKind = imp.reexport
+    ? 'reexports'
+    : imp.typeOnly
+      ? 'imports-type'
+      : imp.dynamicImport
+        ? 'dynamic-imports'
+        : 'imports';
   stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
   let edgesAdded = 1;
 
@@ -387,6 +400,7 @@ function buildImportedNamesMap(
   rootDir: string,
   relPath: string,
   aliases: PathAliases,
+  db: BetterSqlite3Database,
 ): Map<string, string> {
   const importedNames = new Map<string, string>();
   for (const imp of symbols.imports) {
@@ -397,78 +411,79 @@ function buildImportedNamesMap(
       aliases,
     );
     for (const name of imp.names) {
-      importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
+      const cleanName = name.replace(/^\*\s+as\s+/, '');
+      // Mirror full-build's `buildImportedNamesMap`: follow barrel re-exports so
+      // `importedNames` maps to the *defining* file, not the barrel. This ensures
+      // `computeConfidence` gets `importedFrom === targetFile` and returns 1.0
+      // instead of the cross-directory fallback (0.3).
+      let targetFile = resolvedPath;
+      if (isBarrelFile(db, resolvedPath)) {
+        const actual = resolveBarrelTarget(db, resolvedPath, cleanName);
+        if (actual) targetFile = actual;
+      }
+      importedNames.set(cleanName, targetFile);
     }
   }
   return importedNames;
 }
 
-// ── Call edge building ──────────────────────────────────────────────────
+// ── Class hierarchy edges ───────────────────────────────────────────────
 
-function findCaller(
-  call: ExtractorOutput['calls'][number],
-  definitions: ExtractorOutput['definitions'],
-  relPath: string,
-  stmts: IncrementalStmts,
-): { id: number } | null {
-  let caller: { id: number } | null = null;
-  let callerSpan = 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 = stmts.getNodeId.get(def.name, def.kind, relPath, def.line);
-          if (row) {
-            caller = row;
-            callerSpan = span;
-          }
-        }
-      }
-    }
-  }
-  return caller;
-}
+type NodeWithKind = { id: number; kind: string; file: string };
+
+const HIERARCHY_SOURCE_KINDS = new Set(['class', 'struct', 'record', 'enum']);
+const EXTENDS_TARGET_KINDS = new Set(['class', 'struct', 'trait', 'record']);
+const IMPLEMENTS_TARGET_KINDS = new Set(['interface', 'trait', 'class']);
 
-function resolveCallTargets(
+function buildClassHierarchyEdges(
   stmts: IncrementalStmts,
-  call: ExtractorOutput['calls'][number],
   relPath: string,
-  importedNames: Map<string, string>,
-  typeMap: Map<string, unknown>,
-): { targets: Array<{ id: number; file: string }>; importedFrom: string | undefined } {
-  const importedFrom = importedNames.get(call.name);
-  let targets: Array<{ id: number; file: string }> | undefined;
-  if (importedFrom) {
-    targets = stmts.findNodeInFile.all(call.name, importedFrom) as Array<{
-      id: number;
-      file: string;
-    }>;
-  }
-  if (!targets || targets.length === 0) {
-    targets = stmts.findNodeInFile.all(call.name, relPath) as Array<{ id: number; file: string }>;
-    if (targets.length === 0) {
-      targets = stmts.findNodeByName.all(call.name) as Array<{ id: number; file: string }>;
+  symbols: ExtractorOutput,
+): number {
+  let edgesAdded = 0;
+  for (const cls of symbols.classes) {
+    const sourceRow = (stmts.findNodeInFile.all(cls.name, relPath) as NodeWithKind[]).find((n) =>
+      HIERARCHY_SOURCE_KINDS.has(n.kind),
+    );
+    if (!sourceRow) continue;
+
+    if (cls.extends) {
+      for (const t of (stmts.findNodeByName.all(cls.extends) as NodeWithKind[]).filter((n) =>
+        EXTENDS_TARGET_KINDS.has(n.kind),
+      )) {
+        stmts.insertEdge.run(sourceRow.id, t.id, 'extends', 1.0, 0);
+        edgesAdded++;
+      }
     }
-  }
-  // Type-aware resolution: translate variable receiver to declared type
-  if ((!targets || targets.length === 0) && call.receiver && typeMap) {
-    const typeEntry = typeMap.get(call.receiver);
-    const typeName = typeEntry
-      ? typeof typeEntry === 'string'
-        ? typeEntry
-        : (typeEntry as { type?: string }).type
-      : null;
-    if (typeName) {
-      const qualified = `${typeName}.${call.name}`;
-      targets = stmts.findNodeByName.all(qualified) as Array<{ id: number; file: string }>;
+    if (cls.implements) {
+      for (const t of (stmts.findNodeByName.all(cls.implements) as NodeWithKind[]).filter((n) =>
+        IMPLEMENTS_TARGET_KINDS.has(n.kind),
+      )) {
+        stmts.insertEdge.run(sourceRow.id, t.id, 'implements', 1.0, 0);
+        edgesAdded++;
+      }
     }
   }
-  return { targets: targets ?? [], importedFrom };
+  return edgesAdded;
+}
+
+// ── Call edge building ──────────────────────────────────────────────────
+
+function makeIncrementalLookup(db: BetterSqlite3Database, stmts: IncrementalStmts): CallNodeLookup {
+  return {
+    byNameAndFile: (name, file) =>
+      stmts.findNodeInFile.all(name, file) as Array<{ id: number; file: string; kind?: string }>,
+    byName: (name) =>
+      stmts.findNodeByName.all(name) as Array<{ id: number; file: string; kind?: string }>,
+    isBarrel: (file) => isBarrelFile(db, file),
+    resolveBarrel: (barrelFile, symbolName) => resolveBarrelTarget(db, barrelFile, symbolName),
+    nodeId: (name, kind, file, line) =>
+      stmts.getNodeId.get(name, kind, file, line) as { id: number } | undefined,
+  };
 }
 
 function buildCallEdges(
+  db: BetterSqlite3Database,
   stmts: IncrementalStmts,
   relPath: string,
   symbols: ExtractorOutput,
@@ -487,26 +502,130 @@ function buildCallEdges(
             ]),
           )
         : new Map();
+
+  // Phase 8.3f: seed typeMap[callee::restName] = { type: argName } from
+  // objectRestParamBindings × paramBindings, mirroring buildObjectRestParamPostPass.
+  // Scoped keys prevent same-name rest-param collisions when two functions in
+  // the same file both use `...rest` (#1358). The unscoped key is also seeded
+  // when only one callee uses a given rest name, preserving resolution when
+  // callerName is null (findCaller couldn't identify the enclosing function).
+  if (symbols.objectRestParamBindings?.length && symbols.paramBindings?.length) {
+    const restNameCallees = new Map<string, Set<string>>();
+    for (const orpb of symbols.objectRestParamBindings) {
+      if (!restNameCallees.has(orpb.restName)) restNameCallees.set(orpb.restName, new Set());
+      restNameCallees.get(orpb.restName)!.add(orpb.callee);
+    }
+    for (const orpb of symbols.objectRestParamBindings) {
+      for (const pb of symbols.paramBindings) {
+        if (pb.callee === orpb.callee && pb.argIndex === orpb.argIndex) {
+          const scopedKey = `${orpb.callee}::${orpb.restName}`;
+          if (!typeMap.has(scopedKey)) {
+            typeMap.set(scopedKey, { type: pb.argName, confidence: 0.65 });
+            if (restNameCallees.get(orpb.restName)!.size === 1 && !typeMap.has(orpb.restName)) {
+              typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const seenCallEdges = new Set<string>();
+  const lookup = makeIncrementalLookup(db, stmts);
   let edgesAdded = 0;
+
   for (const call of symbols.calls) {
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
-    const caller = findCaller(call, symbols.definitions, relPath, stmts) || fileNodeRow;
-    const { targets, importedFrom } = resolveCallTargets(
-      stmts,
+    const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
+    const { targets: initialTargets, importedFrom } = resolveCallTargets(
+      lookup,
       call,
       relPath,
       importedNames,
       typeMap,
+      caller.callerName,
     );
+    let targets = initialTargets;
+
+    if (targets.length === 0 && call.receiver === 'this' && caller.callerName != null) {
+      const dotIdx = caller.callerName.indexOf('.');
+      if (dotIdx > 0) {
+        const className = caller.callerName.slice(0, dotIdx);
+        const qualifiedName = `${className}.${call.name}`;
+        const qualified = lookup
+          .byNameAndFile(qualifiedName, relPath)
+          .filter((n) => n.kind === 'method');
+        if (qualified.length > 0) {
+          targets = qualified;
+        }
+      }
+    }
+
+    if (
+      targets.length === 0 &&
+      call.receiver === 'this' &&
+      caller.callerName != null &&
+      symbols.definePropertyReceivers
+    ) {
+      const receiverVarName = symbols.definePropertyReceivers.get(caller.callerName);
+      if (receiverVarName) {
+        const typeEntry = typeMap.get(receiverVarName);
+        const typeName = typeEntry
+          ? typeof typeEntry === 'string'
+            ? typeEntry
+            : (typeEntry as { type?: string }).type
+          : null;
+        if (typeName) {
+          const qualifiedName = `${typeName}.${call.name}`;
+          const qualified = lookup.byNameAndFile(qualifiedName, relPath);
+          if (qualified.length > 0) {
+            targets = [...qualified];
+          }
+        }
+        if (targets.length === 0) {
+          // Narrow to function/method kinds only to avoid matching unrelated
+          // variables or classes that share a name in the same file.
+          const sameFile = lookup
+            .byNameAndFile(call.name, relPath)
+            .filter((n) => n.kind === 'function' || n.kind === 'method');
+          if (sameFile.length > 0) {
+            targets = [...sameFile];
+          }
+        }
+      }
+    }
 
     for (const t of targets) {
-      if (t.id !== caller.id) {
+      const edgeKey = `${caller.id}|${t.id}`;
+      if (t.id !== caller.id && !seenCallEdges.has(edgeKey)) {
+        seenCallEdges.add(edgeKey);
         const confidence = computeConfidence(relPath, t.file, importedFrom ?? null);
         stmts.insertEdge.run(caller.id, t.id, 'calls', confidence, call.dynamic ? 1 : 0);
         edgesAdded++;
       }
     }
+
+    if (
+      call.receiver &&
+      !BUILTIN_RECEIVERS.has(call.receiver) &&
+      call.receiver !== 'this' &&
+      call.receiver !== 'self' &&
+      call.receiver !== 'super'
+    ) {
+      const recv = resolveReceiverEdge(
+        lookup,
+        { name: call.name, receiver: call.receiver },
+        caller,
+        relPath,
+        typeMap,
+        seenCallEdges,
+      );
+      if (recv) {
+        stmts.insertEdge.run(recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0);
+        edgesAdded++;
+      }
+    }
   }
   return edgesAdded;
 }
@@ -549,8 +668,9 @@ function rebuildEdgesForTargetFile(
   let edgesAdded = buildContainmentEdges(db, stmts, relPath, symbols);
   edgesAdded += rebuildDirContainment(db, stmts, relPath);
   edgesAdded += buildImportEdges(stmts, relPath, symbols, rootDir, fileNodeRow.id, aliases, db);
-  const importedNames = buildImportedNamesMap(symbols, rootDir, relPath, aliases);
-  edgesAdded += buildCallEdges(stmts, relPath, symbols, fileNodeRow, importedNames);
+  const importedNames = buildImportedNamesMap(symbols, rootDir, relPath, aliases, db);
+  edgesAdded += buildCallEdges(db, stmts, relPath, symbols, fileNodeRow, importedNames);
+  edgesAdded += buildClassHierarchyEdges(stmts, relPath, symbols);
   return edgesAdded;
 }