@optave/codegraph 3.10.0 → 3.11.1

package/src/features/cochange.ts

@@ -137,77 +137,50 @@ export function computeCoChanges(
   return { pairs: results, fileCommitCounts };
 }
 
-export function analyzeCoChanges(
-  customDbPath?: string,
-  opts: {
-    since?: string;
-    minSupport?: number;
-    maxFilesPerCommit?: number;
-    full?: boolean;
-  } = {},
-):
-  | { pairsFound: number; commitsScanned: number; since: string; minSupport: number }
-  | { error: string } {
-  const dbPath = findDbPath(customDbPath);
-  const db = openDb(dbPath);
-  initSchema(db);
-
-  const repoRoot = path.resolve(path.dirname(dbPath), '..');
-
-  if (!fs.existsSync(path.join(repoRoot, '.git'))) {
-    closeDb(db);
-    return { error: `Not a git repository: ${repoRoot}` };
-  }
-
-  const since = opts.since || '1 year ago';
-  const minSupport = opts.minSupport ?? 3;
-  const maxFilesPerCommit = opts.maxFilesPerCommit ?? 50;
-
-  // Check for incremental state
-  let afterSha: string | null = null;
-  if (!opts.full) {
-    try {
-      const row = db
-        .prepare<{ value: string }>(
-          "SELECT value FROM co_change_meta WHERE key = 'last_analyzed_commit'",
-        )
-        .get();
-      if (row) afterSha = row.value;
-    } catch {
-      /* table may not exist yet */
-    }
+/** Read the SHA of the most recently analyzed commit (incremental state). */
+function loadLastAnalyzedSha(db: BetterSqlite3Database): string | null {
+  try {
+    const row = db
+      .prepare<{ value: string }>(
+        "SELECT value FROM co_change_meta WHERE key = 'last_analyzed_commit'",
+      )
+      .get();
+    return row ? row.value : null;
+  } catch {
+    /* table may not exist yet */
+    return null;
   }
+}
 
-  // If full re-scan, clear existing data
-  if (opts.full) {
-    db.exec('DELETE FROM co_changes');
-    db.exec('DELETE FROM co_change_meta');
-    db.exec('DELETE FROM file_commit_counts');
-  }
+/** Wipe all co-change tables for a full re-scan. */
+function clearCoChangeTables(db: BetterSqlite3Database): void {
+  db.exec('DELETE FROM co_changes');
+  db.exec('DELETE FROM co_change_meta');
+  db.exec('DELETE FROM file_commit_counts');
+}
 
-  // Collect known files from the graph for filtering
-  let knownFiles: Set<string> | null = null;
+/** Collect the set of files currently tracked by the graph for filtering. */
+function loadKnownFiles(db: BetterSqlite3Database): Set<string> | null {
   try {
     const rows = db.prepare<{ file: string }>('SELECT DISTINCT file FROM nodes').all();
-    knownFiles = new Set(rows.map((r) => r.file));
+    return new Set(rows.map((r) => r.file));
   } catch {
     /* nodes table may not exist */
+    return null;
   }
+}
 
-  const { commits } = scanGitHistory(repoRoot, { since, afterSha });
-  const { pairs: coChanges, fileCommitCounts } = computeCoChanges(commits, {
-    minSupport,
-    maxFilesPerCommit,
-    knownFiles,
-  });
-
-  // Upsert per-file commit counts so Jaccard can be recomputed from totals
+/** Upsert per-file commit counts and pair counts (Jaccard recomputed later). */
+function persistCoChangeResults(
+  db: BetterSqlite3Database,
+  fileCommitCounts: Map<string, number>,
+  coChanges: Map<string, CoChangePair>,
+): void {
   const fileCountUpsert = db.prepare(`
     INSERT INTO file_commit_counts (file, commit_count) VALUES (?, ?)
     ON CONFLICT(file) DO UPDATE SET commit_count = commit_count + excluded.commit_count
   `);
 
-  // Upsert pair counts (accumulate commit_count, jaccard placeholder — recomputed below)
   const pairUpsert = db.prepare(`
     INSERT INTO co_changes (file_a, file_b, commit_count, jaccard, last_commit_epoch)
     VALUES (?, ?, ?, 0, ?)
@@ -226,24 +199,31 @@ export function analyzeCoChanges(
     }
   });
   insertMany();
+}
 
-  // Recompute Jaccard for all affected pairs from total file commit counts
-  const affectedFiles = [...fileCommitCounts.keys()];
-  if (affectedFiles.length > 0) {
-    const ph = affectedFiles.map(() => '?').join(',');
-    db.prepare(`
-      UPDATE co_changes SET jaccard = (
-        SELECT CAST(co_changes.commit_count AS REAL) / (
-          COALESCE(fa.commit_count, 0) + COALESCE(fb.commit_count, 0) - co_changes.commit_count
-        )
-        FROM file_commit_counts fa, file_commit_counts fb
-        WHERE fa.file = co_changes.file_a AND fb.file = co_changes.file_b
+/** Recompute Jaccard for every pair touching any file in `affectedFiles`. */
+function recomputeJaccardForAffected(db: BetterSqlite3Database, affectedFiles: string[]): void {
+  if (affectedFiles.length === 0) return;
+  const ph = affectedFiles.map(() => '?').join(',');
+  db.prepare(`
+    UPDATE co_changes SET jaccard = (
+      SELECT CAST(co_changes.commit_count AS REAL) / (
+        COALESCE(fa.commit_count, 0) + COALESCE(fb.commit_count, 0) - co_changes.commit_count
       )
-      WHERE file_a IN (${ph}) OR file_b IN (${ph})
-    `).run(...affectedFiles, ...affectedFiles);
-  }
+      FROM file_commit_counts fa, file_commit_counts fb
+      WHERE fa.file = co_changes.file_a AND fb.file = co_changes.file_b
+    )
+    WHERE file_a IN (${ph}) OR file_b IN (${ph})
+  `).run(...affectedFiles, ...affectedFiles);
+}
 
-  // Update metadata
+/** Update co_change_meta with the latest analyzer run parameters. */
+function updateCoChangeMeta(
+  db: BetterSqlite3Database,
+  commits: CommitEntry[],
+  since: string,
+  minSupport: number,
+): void {
   const metaUpsert = db.prepare(`
     INSERT INTO co_change_meta (key, value) VALUES (?, ?)
     ON CONFLICT(key) DO UPDATE SET value = excluded.value
@@ -254,6 +234,49 @@ export function analyzeCoChanges(
   metaUpsert.run('analyzed_at', new Date().toISOString());
   metaUpsert.run('since', since);
   metaUpsert.run('min_support', String(minSupport));
+}
+
+export function analyzeCoChanges(
+  customDbPath?: string,
+  opts: {
+    since?: string;
+    minSupport?: number;
+    maxFilesPerCommit?: number;
+    full?: boolean;
+  } = {},
+):
+  | { pairsFound: number; commitsScanned: number; since: string; minSupport: number }
+  | { error: string } {
+  const dbPath = findDbPath(customDbPath);
+  const db = openDb(dbPath);
+  initSchema(db);
+
+  const repoRoot = path.resolve(path.dirname(dbPath), '..');
+
+  if (!fs.existsSync(path.join(repoRoot, '.git'))) {
+    closeDb(db);
+    return { error: `Not a git repository: ${repoRoot}` };
+  }
+
+  const since = opts.since || '1 year ago';
+  const minSupport = opts.minSupport ?? 3;
+  const maxFilesPerCommit = opts.maxFilesPerCommit ?? 50;
+
+  const afterSha = opts.full ? null : loadLastAnalyzedSha(db);
+  if (opts.full) clearCoChangeTables(db);
+
+  const knownFiles = loadKnownFiles(db);
+
+  const { commits } = scanGitHistory(repoRoot, { since, afterSha });
+  const { pairs: coChanges, fileCommitCounts } = computeCoChanges(commits, {
+    minSupport,
+    maxFilesPerCommit,
+    knownFiles,
+  });
+
+  persistCoChangeResults(db, fileCommitCounts, coChanges);
+  recomputeJaccardForAffected(db, [...fileCommitCounts.keys()]);
+  updateCoChangeMeta(db, commits, since, minSupport);
 
   const totalPairs = db
     .prepare<{ cnt: number }>('SELECT COUNT(*) as cnt FROM co_changes')

package/src/features/complexity.ts

@@ -31,44 +31,36 @@ const COMPLEXITY_EXTENSIONS = buildExtensionSet(COMPLEXITY_RULES);
 
 // ─── Halstead Metrics Computation ─────────────────────────────────────────
 
-export function computeHalsteadMetrics(
-  functionNode: TreeSitterNode,
-  language: string,
-): HalsteadDerivedMetrics | null {
-  const rules = HALSTEAD_RULES.get(language) as HalsteadRules | undefined;
-  if (!rules) return null;
-
-  const operators = new Map<string, number>(); // type -> count
-  const operands = new Map<string, number>(); // text -> count
-
-  function walk(node: TreeSitterNode | null): void {
-    if (!node) return;
-
-    // Skip type annotation subtrees
-    if (rules?.skipTypes.has(node.type)) return;
+/** Classify a tree-sitter node as a Halstead operator or operand,
+ *  updating the running counts. Pure helper extracted from computeHalsteadMetrics
+ *  to keep the dispatcher thin. */
+function classifyHalsteadToken(
+  node: TreeSitterNode,
+  rules: HalsteadRules,
+  operators: Map<string, number>,
+  operands: Map<string, number>,
+): void {
+  // Compound operators (non-leaf): count the node type as an operator
+  if (rules.compoundOperators.has(node.type)) {
+    operators.set(node.type, (operators.get(node.type) || 0) + 1);
+  }
 
-    // Compound operators (non-leaf): count the node type as an operator
-    if (rules?.compoundOperators.has(node.type)) {
+  // Leaf nodes: classify as operator or operand
+  if (node.childCount === 0) {
+    if (rules.operatorLeafTypes.has(node.type)) {
       operators.set(node.type, (operators.get(node.type) || 0) + 1);
-    }
-
-    // Leaf nodes: classify as operator or operand
-    if (node.childCount === 0) {
-      if (rules?.operatorLeafTypes.has(node.type)) {
-        operators.set(node.type, (operators.get(node.type) || 0) + 1);
-      } else if (rules?.operandLeafTypes.has(node.type)) {
-        const text = node.text;
-        operands.set(text, (operands.get(text) || 0) + 1);
-      }
-    }
-
-    for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i));
+    } else if (rules.operandLeafTypes.has(node.type)) {
+      const text = node.text;
+      operands.set(text, (operands.get(text) || 0) + 1);
     }
   }
+}
 
-  walk(functionNode);
-
+/** Build a HalsteadDerivedMetrics summary from the raw operator/operand counts. */
+function summarizeHalsteadCounts(
+  operators: Map<string, number>,
+  operands: Map<string, number>,
+): HalsteadDerivedMetrics {
   const n1 = operators.size; // distinct operators
   const n2 = operands.size; // distinct operands
   let bigN1 = 0; // total operators
@@ -79,7 +71,6 @@ export function computeHalsteadMetrics(
   const vocabulary = n1 + n2;
   const length = bigN1 + bigN2;
 
-  // Guard against zero
   const volume = vocabulary > 0 ? length * Math.log2(vocabulary) : 0;
   const difficulty = n2 > 0 ? (n1 / 2) * (bigN2 / n2) : 0;
   const effort = difficulty * volume;
@@ -99,6 +90,31 @@ export function computeHalsteadMetrics(
   };
 }
 
+export function computeHalsteadMetrics(
+  functionNode: TreeSitterNode,
+  language: string,
+): HalsteadDerivedMetrics | null {
+  const rules = HALSTEAD_RULES.get(language) as HalsteadRules | undefined;
+  if (!rules) return null;
+
+  const operators = new Map<string, number>(); // type -> count
+  const operands = new Map<string, number>(); // text -> count
+
+  function walk(node: TreeSitterNode | null): void {
+    if (!node) return;
+    // Skip type annotation subtrees
+    if (rules?.skipTypes.has(node.type)) return;
+    classifyHalsteadToken(node, rules as HalsteadRules, operators, operands);
+    for (let i = 0; i < node.childCount; i++) {
+      walk(node.child(i));
+    }
+  }
+
+  walk(functionNode);
+
+  return summarizeHalsteadCounts(operators, operands);
+}
+
 // ─── LOC Metrics Computation ──────────────────────────────────────────────
 // Delegated to ast-analysis/metrics.js; re-exported for backward compatibility.
 export const computeLOCMetrics = _computeLOCMetrics;
@@ -535,6 +551,89 @@ function upsertAstComplexity(
   return 1;
 }
 
+/** Decision outcome for a single definition during native bulk-row collection.
+ *  - 'skip': the definition is legitimately ignorable (non-function, missing line,
+ *            interface stub, unsupported language).
+ *  - 'fallback': a genuine function body is missing precomputed complexity —
+ *                the whole native fast path must abort to JS.
+ *  - 'emit': the definition has complexity data and a row was (or will be) appended. */
+type NativeRowDecision = 'skip' | 'fallback' | 'emit';
+
+/** Classify a definition relative to the native bulk path. Returns
+ *  'skip' to ignore it, 'fallback' to bail out, or 'emit' if the row should be added. */
+function classifyDefinitionForNativeBulk(
+  def: FileSymbols['definitions'][0],
+  langSupported: boolean,
+): NativeRowDecision {
+  if (def.kind !== 'function' && def.kind !== 'method') return 'skip';
+  if (!def.line) return 'skip';
+  if (!def.complexity) {
+    // Interface/type property signatures and single-line stubs are extracted
+    // as methods but the native engine correctly never assigns complexity.
+    // Mirror the leniency in initWasmParsersIfNeeded to avoid bailing out
+    // of the native bulk-insert path for every TypeScript codebase (#846).
+    if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) return 'skip';
+    // Languages without complexity rules will never have data — skip them
+    // rather than bailing out of the entire native bulk path.
+    if (!langSupported) return 'skip';
+    return 'fallback'; // genuine function body missing complexity — needs JS fallback
+  }
+  return 'emit';
+}
+
+/** Build a single native-bulk row from a definition with complexity data. */
+function buildNativeBulkRow(
+  nodeId: number,
+  def: FileSymbols['definitions'][0],
+): Record<string, unknown> {
+  const ch = def.complexity?.halstead;
+  const cl = def.complexity?.loc;
+  return {
+    nodeId,
+    cognitive: def.complexity?.cognitive ?? 0,
+    cyclomatic: def.complexity?.cyclomatic ?? 0,
+    maxNesting: def.complexity?.maxNesting ?? 0,
+    loc: cl ? cl.loc : 0,
+    sloc: cl ? cl.sloc : 0,
+    commentLines: cl ? cl.commentLines : 0,
+    halsteadN1: ch ? ch.n1 : 0,
+    halsteadN2: ch ? ch.n2 : 0,
+    halsteadBigN1: ch ? ch.bigN1 : 0,
+    halsteadBigN2: ch ? ch.bigN2 : 0,
+    halsteadVocabulary: ch ? ch.vocabulary : 0,
+    halsteadLength: ch ? ch.length : 0,
+    halsteadVolume: ch ? ch.volume : 0,
+    halsteadDifficulty: ch ? ch.difficulty : 0,
+    halsteadEffort: ch ? ch.effort : 0,
+    halsteadBugs: ch ? ch.bugs : 0,
+    maintainabilityIndex: def.complexity?.maintainabilityIndex ?? 0,
+  };
+}
+
+/** Try to collect a single file's definitions into native-bulk rows.
+ *  Returns 'fallback' if any definition forces a JS fallback. */
+function collectFileBulkRows(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: FileSymbols,
+  rows: Array<Record<string, unknown>>,
+): NativeRowDecision {
+  const ext = path.extname(relPath).toLowerCase();
+  const langId = symbols._langId || '';
+  const langSupported = COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(langId);
+
+  for (const def of symbols.definitions) {
+    const decision = classifyDefinitionForNativeBulk(def, langSupported);
+    if (decision === 'skip') continue;
+    if (decision === 'fallback') return 'fallback';
+
+    const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+    if (!nodeId) continue;
+    rows.push(buildNativeBulkRow(nodeId, def));
+  }
+  return 'emit';
+}
+
 /** Collect native bulk-insert rows from precomputed complexity data.
  *  Returns the rows array, or null if any definition is missing complexity
  *  (signalling that JS fallback is needed). */
@@ -543,53 +642,9 @@ function collectNativeBulkRows(
   fileSymbols: Map<string, FileSymbols>,
 ): Array<Record<string, unknown>> | null {
   const rows: Array<Record<string, unknown>> = [];
-
   for (const [relPath, symbols] of fileSymbols) {
-    const ext = path.extname(relPath).toLowerCase();
-    const langId = symbols._langId || '';
-    const langSupported = COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(langId);
-
-    for (const def of symbols.definitions) {
-      if (def.kind !== 'function' && def.kind !== 'method') continue;
-      if (!def.line) continue;
-      // Interface/type property signatures and single-line stubs are extracted
-      // as methods but the native engine correctly never assigns complexity.
-      // Mirror the leniency in initWasmParsersIfNeeded to avoid bailing out
-      // of the native bulk-insert path for every TypeScript codebase (#846).
-      if (!def.complexity) {
-        if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) continue;
-        // Languages without complexity rules will never have data — skip them
-        // rather than bailing out of the entire native bulk path.
-        if (!langSupported) continue;
-        return null; // genuine function body missing complexity — needs JS fallback
-      }
-      const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-      if (!nodeId) continue;
-      const ch = def.complexity.halstead;
-      const cl = def.complexity.loc;
-      rows.push({
-        nodeId,
-        cognitive: def.complexity.cognitive ?? 0,
-        cyclomatic: def.complexity.cyclomatic ?? 0,
-        maxNesting: def.complexity.maxNesting ?? 0,
-        loc: cl ? cl.loc : 0,
-        sloc: cl ? cl.sloc : 0,
-        commentLines: cl ? cl.commentLines : 0,
-        halsteadN1: ch ? ch.n1 : 0,
-        halsteadN2: ch ? ch.n2 : 0,
-        halsteadBigN1: ch ? ch.bigN1 : 0,
-        halsteadBigN2: ch ? ch.bigN2 : 0,
-        halsteadVocabulary: ch ? ch.vocabulary : 0,
-        halsteadLength: ch ? ch.length : 0,
-        halsteadVolume: ch ? ch.volume : 0,
-        halsteadDifficulty: ch ? ch.difficulty : 0,
-        halsteadEffort: ch ? ch.effort : 0,
-        halsteadBugs: ch ? ch.bugs : 0,
-        maintainabilityIndex: def.complexity.maintainabilityIndex ?? 0,
-      });
-    }
+    if (collectFileBulkRows(db, relPath, symbols, rows) === 'fallback') return null;
   }
-
   return rows;
 }
 

package/src/features/dataflow.ts

@@ -675,6 +675,51 @@ interface BfsParentEntry {
   expression: string;
 }
 
+type DataflowNeighbor = {
+  id: number;
+  file: string;
+  edge_kind: string;
+  expression: string;
+};
+
+interface DataflowBfsState {
+  visited: Set<number>;
+  parent: Map<number, BfsParentEntry>;
+  nextQueue: number[];
+  found: boolean;
+}
+
+/**
+ * Process a single neighbor in the dataflow BFS. Returns true once the target
+ * has been reached so the caller can stop expanding.
+ */
+function processDataflowNeighbor(
+  n: DataflowNeighbor,
+  currentId: number,
+  targetId: number,
+  noTests: boolean,
+  state: DataflowBfsState,
+): boolean {
+  if (noTests && isTestFile(n.file)) return false;
+  const entry: BfsParentEntry = {
+    parentId: currentId,
+    edgeKind: n.edge_kind,
+    expression: n.expression,
+  };
+  if (n.id === targetId) {
+    if (!state.found) {
+      state.found = true;
+      state.parent.set(n.id, entry);
+    }
+    return true;
+  }
+  if (state.visited.has(n.id)) return false;
+  state.visited.add(n.id);
+  state.parent.set(n.id, entry);
+  state.nextQueue.push(n.id);
+  return false;
+}
+
 /** BFS through dataflow edges to find a path from source to target. */
 function bfsDataflowPath(
   db: BetterSqlite3Database,
@@ -689,50 +734,28 @@ function bfsDataflowPath(
      WHERE d.source_id = ? AND d.kind IN ('flows_to', 'returns')`,
   );
 
-  const visited = new Set<number>([sourceId]);
-  const parent = new Map<number, BfsParentEntry>();
+  const state: DataflowBfsState = {
+    visited: new Set<number>([sourceId]),
+    parent: new Map<number, BfsParentEntry>(),
+    nextQueue: [],
+    found: false,
+  };
   let queue = [sourceId];
-  let found = false;
 
   for (let depth = 1; depth <= maxDepth; depth++) {
-    const nextQueue: number[] = [];
+    state.nextQueue = [];
     for (const currentId of queue) {
-      const neighbors = neighborStmt.all(currentId) as Array<{
-        id: number;
-        file: string;
-        edge_kind: string;
-        expression: string;
-      }>;
+      const neighbors = neighborStmt.all(currentId) as DataflowNeighbor[];
       for (const n of neighbors) {
-        if (noTests && isTestFile(n.file)) continue;
-        if (n.id === targetId) {
-          if (!found) {
-            found = true;
-            parent.set(n.id, {
-              parentId: currentId,
-              edgeKind: n.edge_kind,
-              expression: n.expression,
-            });
-          }
-          continue;
-        }
-        if (!visited.has(n.id)) {
-          visited.add(n.id);
-          parent.set(n.id, {
-            parentId: currentId,
-            edgeKind: n.edge_kind,
-            expression: n.expression,
-          });
-          nextQueue.push(n.id);
-        }
+        processDataflowNeighbor(n, currentId, targetId, noTests, state);
       }
     }
-    if (found) break;
-    queue = nextQueue;
+    if (state.found) break;
+    queue = state.nextQueue;
     if (queue.length === 0) break;
   }
 
-  return found ? parent : null;
+  return state.found ? state.parent : null;
 }
 
 /** Reconstruct a path from BFS parent map. */

package/src/features/flow.ts

@@ -133,6 +133,41 @@ interface BfsState {
   truncated: boolean;
 }
 
+interface FlowBfsFrame {
+  visited: Set<number>;
+  cycles: Array<{ from: string; to: string; depth: number }>;
+  nodeDepths: Map<number, number>;
+  idToNode: Map<number, NodeInfo>;
+  nextFrontier: number[];
+  levelNodes: NodeInfo[];
+}
+
+/** Process one callee row, recording cycle hits or expanding frontier. */
+function processFlowCallee(
+  c: CalleeRow,
+  fid: number,
+  depth: number,
+  noTests: boolean,
+  frame: FlowBfsFrame,
+): void {
+  if (noTests && isTestFile(c.file)) return;
+
+  if (frame.visited.has(c.id)) {
+    const fromNode = frame.idToNode.get(fid);
+    if (fromNode) {
+      frame.cycles.push({ from: fromNode.name, to: c.name, depth });
+    }
+    return;
+  }
+
+  frame.visited.add(c.id);
+  frame.nextFrontier.push(c.id);
+  const nodeInfo: NodeInfo = toSymbolRef(c);
+  frame.levelNodes.push(nodeInfo);
+  frame.nodeDepths.set(c.id, depth);
+  frame.idToNode.set(c.id, nodeInfo);
+}
+
 /** Forward BFS through callees, collecting steps, cycles, and node depth info. */
 function bfsCallees(
   db: ReturnType<typeof openReadonlyOrFail>,
@@ -157,37 +192,26 @@ function bfsCallees(
   );
 
   for (let d = 1; d <= maxDepth; d++) {
-    const nextFrontier: number[] = [];
-    const levelNodes: NodeInfo[] = [];
+    const frame: FlowBfsFrame = {
+      visited,
+      cycles,
+      nodeDepths,
+      idToNode,
+      nextFrontier: [],
+      levelNodes: [],
+    };
 
     for (const fid of frontier) {
-      const callees = calleesStmt.all(fid);
-
-      for (const c of callees) {
-        if (noTests && isTestFile(c.file)) continue;
-
-        if (visited.has(c.id)) {
-          const fromNode = idToNode.get(fid);
-          if (fromNode) {
-            cycles.push({ from: fromNode.name, to: c.name, depth: d });
-          }
-          continue;
-        }
-
-        visited.add(c.id);
-        nextFrontier.push(c.id);
-        const nodeInfo: NodeInfo = toSymbolRef(c);
-        levelNodes.push(nodeInfo);
-        nodeDepths.set(c.id, d);
-        idToNode.set(c.id, nodeInfo);
+      for (const c of calleesStmt.all(fid)) {
+        processFlowCallee(c, fid, d, noTests, frame);
       }
     }
 
-    if (levelNodes.length > 0) {
-      steps.push({ depth: d, nodes: levelNodes });
+    if (frame.levelNodes.length > 0) {
+      steps.push({ depth: d, nodes: frame.levelNodes });
     }
 
-    frontier = nextFrontier;
+    frontier = frame.nextFrontier;
     if (frontier.length === 0) break;
     if (d === maxDepth && frontier.length > 0) truncated = true;
   }