@optave/codegraph 3.11.0 → 3.11.2

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

@@ -0,0 +1,181 @@
+/**
+ * Shared call-edge resolution — used by both the full build pipeline
+ * (build-edges.ts) and the incremental watch path (incremental.ts).
+ *
+ * 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.
+ */
+import { computeConfidence } from '../resolve.js';
+
+// ── Public interface ─────────────────────────────────────────────────────
+
+export interface CallNodeLookup {
+  byNameAndFile(
+    name: string,
+    file: string,
+  ): ReadonlyArray<{ id: number; file: string; kind?: string }>;
+  byName(name: string): ReadonlyArray<{ id: number; file: string; kind?: string }>;
+  isBarrel(file: string): boolean;
+  resolveBarrel(barrelFile: string, symbolName: string): string | null;
+  nodeId(name: string, kind: string, file: string, line: number): { id: number } | undefined;
+}
+
+export const RECEIVER_KINDS = new Set(['class', 'struct', 'interface', 'type', 'module']);
+
+// ── Shared resolution functions ──────────────────────────────────────────
+
+export function findCaller(
+  lookup: CallNodeLookup,
+  call: { line: number },
+  definitions: ReadonlyArray<{
+    name: string;
+    kind: string;
+    line: number;
+    endLine?: number | null;
+  }>,
+  relPath: string,
+  fileNodeRow: { id: number },
+): { id: number } {
+  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 = lookup.nodeId(def.name, def.kind, relPath, def.line);
+          if (row) {
+            caller = row;
+            callerSpan = span;
+          }
+        }
+      }
+    }
+  }
+  return caller ?? fileNodeRow;
+}
+
+export function resolveByMethodOrGlobal(
+  lookup: CallNodeLookup,
+  call: { name: string; receiver?: string | null },
+  relPath: string,
+  typeMap: Map<string, unknown>,
+): ReadonlyArray<{ id: number; file: string }> {
+  if (call.receiver) {
+    const typeEntry = typeMap.get(call.receiver);
+    const typeName = typeEntry
+      ? typeof typeEntry === 'string'
+        ? typeEntry
+        : (typeEntry as { type?: string }).type
+      : null;
+    if (typeName) {
+      const typed = lookup.byName(`${typeName}.${call.name}`).filter((n) => n.kind === 'method');
+      if (typed.length > 0) return typed;
+    }
+  }
+  if (
+    !call.receiver ||
+    call.receiver === 'this' ||
+    call.receiver === 'self' ||
+    call.receiver === 'super'
+  ) {
+    return lookup.byName(call.name).filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+  }
+  return [];
+}
+
+export function resolveCallTargets(
+  lookup: CallNodeLookup,
+  call: { name: string; receiver?: string | null },
+  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: ReadonlyArray<{ id: number; file: string }> | undefined;
+
+  if (importedFrom) {
+    targets = lookup.byNameAndFile(call.name, importedFrom);
+    if (targets.length === 0 && lookup.isBarrel(importedFrom)) {
+      const actualSource = lookup.resolveBarrel(importedFrom, call.name);
+      if (actualSource) {
+        targets = lookup.byNameAndFile(call.name, actualSource);
+      }
+    }
+  }
+
+  if (!targets || targets.length === 0) {
+    targets = lookup.byNameAndFile(call.name, relPath);
+    if (targets.length === 0) {
+      targets = resolveByMethodOrGlobal(lookup, call, relPath, typeMap);
+    }
+  }
+
+  const resolved = [...(targets ?? [])];
+  if (resolved.length > 1) {
+    resolved.sort((a, b) => {
+      const confA = computeConfidence(relPath, a.file, importedFrom ?? null);
+      const confB = computeConfidence(relPath, b.file, importedFrom ?? null);
+      return confB - confA;
+    });
+  }
+  return { targets: resolved, importedFrom };
+}
+
+/**
+ * Resolve the receiver-type edge for a call site.
+ * 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.
+ */
+export function resolveReceiverEdge(
+  lookup: CallNodeLookup,
+  call: { name: string; receiver: string },
+  caller: { id: number },
+  relPath: string,
+  typeMap: Map<string, unknown>,
+  seenCallEdges: Set<string>,
+): { callerId: number; receiverId: number; confidence: number } | null {
+  const typeEntry = typeMap.get(call.receiver);
+  const typeName = typeEntry
+    ? typeof typeEntry === 'string'
+      ? typeEntry
+      : ((typeEntry as { type?: string }).type ?? null)
+    : null;
+  const typeConfidence =
+    typeEntry && typeof typeEntry !== 'string'
+      ? ((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 ?? ''));
+  if (candidates.length === 0) return null;
+  const recvTarget = candidates[0]!;
+  const recvKey = `recv|${caller.id}|${recvTarget.id}`;
+  if (seenCallEdges.has(recvKey)) return null;
+  seenCallEdges.add(recvKey);
+  return {
+    callerId: caller.id,
+    receiverId: recvTarget.id,
+    confidence: typeConfidence ?? (typeName ? 0.9 : 0.7),
+  };
+}

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

@@ -76,108 +76,117 @@ export function passesIncludeExclude(
   return true;
 }
 
+/** Per-walk state computed once at the top-level invocation. */
+interface CollectContext {
+  readonly rootDir: string;
+  readonly includeRegexes: readonly RegExp[];
+  readonly excludeRegexes: readonly RegExp[];
+  readonly hasGlobFilters: boolean;
+  readonly extraIgnore: Set<string> | null;
+  readonly visited: Set<string>;
+}
+
+/** Detect a symlink loop for `dir`. Returns true if `dir` was already visited. */
+function isSymlinkLoop(dir: string, visited: Set<string>): boolean {
+  let realDir: string;
+  try {
+    realDir = fs.realpathSync(dir);
+  } catch {
+    return true;
+  }
+  if (visited.has(realDir)) {
+    warn(`Symlink loop detected, skipping: ${dir}`);
+    return true;
+  }
+  visited.add(realDir);
+  return false;
+}
+
+/** Read directory entries, returning null on error (already logged). */
+function readDirSafe(dir: string): fs.Dirent[] | null {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err: unknown) {
+    warn(`Cannot read directory ${dir}: ${(err as Error).message}`);
+    return null;
+  }
+}
+
+/** True if `entry` is a source file we should collect under `ctx`. */
+function isCollectableSourceFile(full: string, entry: fs.Dirent, ctx: CollectContext): boolean {
+  if (!EXTENSIONS.has(path.extname(entry.name))) return false;
+  if (!ctx.hasGlobFilters) return true;
+  const rel = normalizePath(path.relative(ctx.rootDir, full));
+  return passesIncludeExclude(rel, ctx.includeRegexes, ctx.excludeRegexes);
+}
+
+function walkCollect(
+  dir: string,
+  files: string[],
+  directories: Set<string> | null,
+  ctx: CollectContext,
+): void {
+  if (isSymlinkLoop(dir, ctx.visited)) return;
+
+  const entries = readDirSafe(dir);
+  if (!entries) return;
+
+  let hasFiles = false;
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry, ctx.extraIgnore)) continue;
+
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkCollect(full, files, directories, ctx);
+    } else if (isCollectableSourceFile(full, entry, ctx)) {
+      files.push(full);
+      hasFiles = true;
+    }
+  }
+  if (directories && hasFiles) {
+    directories.add(dir);
+  }
+}
+
 /**
  * Recursively collect all source files under `dir`.
  * When `directories` is a Set, also tracks which directories contain files.
  *
- * The first invocation establishes `dir` as the project root against which
- * `config.include` / `config.exclude` globs are matched.
+ * `dir` establishes the project root against which `config.include` /
+ * `config.exclude` globs are matched.
  */
 export function collectFiles(
   dir: string,
   files: string[],
   config: Partial<CodegraphConfig>,
   directories: Set<string>,
-  _visited?: Set<string>,
-  _rootDir?: string,
-  _includeRegexes?: readonly RegExp[],
-  _excludeRegexes?: readonly RegExp[],
 ): { files: string[]; directories: Set<string> };
 export function collectFiles(
   dir: string,
   files?: string[],
   config?: Partial<CodegraphConfig>,
   directories?: null,
-  _visited?: Set<string>,
-  _rootDir?: string,
-  _includeRegexes?: readonly RegExp[],
-  _excludeRegexes?: readonly RegExp[],
 ): string[];
 export function collectFiles(
   dir: string,
   files: string[] = [],
   config: Partial<CodegraphConfig> = {},
   directories: Set<string> | null = null,
-  _visited: Set<string> = new Set(),
-  _rootDir?: string,
-  _includeRegexes?: readonly RegExp[],
-  _excludeRegexes?: readonly RegExp[],
 ): string[] | { files: string[]; directories: Set<string> } {
   const trackDirs = directories instanceof Set;
-  let hasFiles = false;
-
-  // First call: compute root and compile include/exclude patterns once,
-  // then pass them down recursive calls so we don't recompile per directory.
-  const rootDir = _rootDir ?? dir;
-  const includeRegexes = _includeRegexes ?? compileGlobs(config.include);
-  const excludeRegexes = _excludeRegexes ?? compileGlobs(config.exclude);
-  const hasGlobFilters = includeRegexes.length > 0 || excludeRegexes.length > 0;
-
-  // Merge config ignoreDirs with defaults
-  const extraIgnore = config.ignoreDirs ? new Set(config.ignoreDirs) : null;
-
-  // Detect symlink loops (before I/O to avoid wasted readdirSync)
-  let realDir: string;
-  try {
-    realDir = fs.realpathSync(dir);
-  } catch {
-    return trackDirs ? { files, directories: directories as Set<string> } : files;
-  }
-  if (_visited.has(realDir)) {
-    warn(`Symlink loop detected, skipping: ${dir}`);
-    return trackDirs ? { files, directories: directories as Set<string> } : files;
-  }
-  _visited.add(realDir);
-
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch (err: unknown) {
-    warn(`Cannot read directory ${dir}: ${(err as Error).message}`);
-    return trackDirs ? { files, directories: directories as Set<string> } : files;
-  }
+  const includeRegexes = compileGlobs(config.include);
+  const excludeRegexes = compileGlobs(config.exclude);
+  const ctx: CollectContext = {
+    rootDir: dir,
+    includeRegexes,
+    excludeRegexes,
+    hasGlobFilters: includeRegexes.length > 0 || excludeRegexes.length > 0,
+    extraIgnore: config.ignoreDirs ? new Set(config.ignoreDirs) : null,
+    visited: new Set(),
+  };
 
-  for (const entry of entries) {
-    if (shouldSkipEntry(entry, extraIgnore)) continue;
+  walkCollect(dir, files, trackDirs ? (directories as Set<string>) : null, ctx);
 
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (trackDirs) {
-        collectFiles(
-          full,
-          files,
-          config,
-          directories as Set<string>,
-          _visited,
-          rootDir,
-          includeRegexes,
-          excludeRegexes,
-        );
-      } else {
-        collectFiles(full, files, config, null, _visited, rootDir, includeRegexes, excludeRegexes);
-      }
-    } else if (EXTENSIONS.has(path.extname(entry.name))) {
-      if (hasGlobFilters) {
-        const rel = normalizePath(path.relative(rootDir, full));
-        if (!passesIncludeExclude(rel, includeRegexes, excludeRegexes)) continue;
-      }
-      files.push(full);
-      hasFiles = true;
-    }
-  }
-  if (trackDirs && hasFiles) {
-    (directories as Set<string>).add(dir);
-  }
   return trackDirs ? { files, directories: directories as Set<string> } : files;
 }