@optave/codegraph 3.11.0 → 3.11.2

package/src/ast-analysis/engine.ts

@@ -753,6 +753,146 @@ function allNativeDataComplete(
 
 // ─── Public API ──────────────────────────────────────────────────────────
 
+/** Distribute the per-file walk time equally among the visitors that ran. */
+function accumulateWalkTime(
+  timing: AnalysisTiming,
+  walkMs: number,
+  astVisitor: Visitor | null,
+  complexityVisitor: Visitor | null,
+  cfgVisitor: Visitor | null,
+  dataflowVisitor: Visitor | null,
+): void {
+  const activeCount = [astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor].filter(
+    Boolean,
+  ).length;
+  if (activeCount === 0) return;
+
+  const share = walkMs / activeCount;
+  if (astVisitor) timing.astMs += share;
+  if (complexityVisitor) timing.complexityMs += share;
+  if (cfgVisitor) timing.cfgMs += share;
+  if (dataflowVisitor) timing.dataflowMs += share;
+}
+
+/** Apply visitor walk results to the per-file symbols/definitions. */
+function applyVisitorResults(
+  results: WalkResults,
+  symbols: ExtractorOutput,
+  langId: string,
+  astVisitor: Visitor | null,
+  complexityVisitor: Visitor | null,
+  cfgVisitor: Visitor | null,
+  dataflowVisitor: Visitor | null,
+): void {
+  const defs = symbols.definitions || [];
+
+  if (astVisitor) {
+    const astRows = (results['ast-store'] || []) as ASTNodeRow[];
+    if (astRows.length > 0) symbols.astNodes = astRows;
+  }
+
+  if (complexityVisitor) storeComplexityResults(results, defs, langId);
+  if (cfgVisitor) storeCfgResults(results, defs);
+  if (dataflowVisitor) symbols.dataflow = results.dataflow as DataflowResult;
+}
+
+/** Process a single file: set up visitors, walk the tree, and apply results. */
+function processFileWalk(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: ExtractorOutput,
+  langId: string,
+  opts: AnalysisOpts,
+  timing: AnalysisTiming,
+): void {
+  if (!symbols._tree) return;
+
+  const { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor } =
+    setupVisitors(db, relPath, symbols, langId, opts);
+
+  if (visitors.length === 0) return;
+
+  const walkStart = performance.now();
+  const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
+  const walkMs = performance.now() - walkStart;
+
+  accumulateWalkTime(timing, walkMs, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor);
+  applyVisitorResults(
+    results,
+    symbols,
+    langId,
+    astVisitor,
+    complexityVisitor,
+    cfgVisitor,
+    dataflowVisitor,
+  );
+}
+
+/**
+ * Unified pre-walk: run all applicable visitors in a single DFS per file.
+ * Returns the total wall-clock time for diagnostics.
+ */
+function runUnifiedWalkPass(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, ExtractorOutput>,
+  extToLang: Map<string, string>,
+  opts: AnalysisOpts,
+  timing: AnalysisTiming,
+): number {
+  const t0walk = performance.now();
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (!symbols._tree) continue;
+
+    const ext = path.extname(relPath).toLowerCase();
+    const langId = symbols._langId || extToLang.get(ext);
+    if (!langId) continue;
+
+    processFileWalk(db, relPath, symbols, langId, opts, timing);
+  }
+
+  return performance.now() - t0walk;
+}
+
+/** Try native Rust standalone analysis to fill gaps before WASM fallback. */
+function tryNativeStandaloneAnalysis(
+  fileSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+  opts: AnalysisOpts,
+  extToLang: Map<string, string>,
+): void {
+  const native = loadNative();
+  if (!native?.analyzeComplexity && !native?.buildCfgAnalysis && !native?.extractDataflowAnalysis) {
+    return;
+  }
+  const t0native = performance.now();
+  runNativeAnalysis(native, fileSymbols, rootDir, opts, extToLang);
+  debug(`native standalone analysis: ${(performance.now() - t0native).toFixed(1)}ms`);
+}
+
+/**
+ * Fast path: when all files were parsed by the native engine with full analysis,
+ * skip WASM re-parse and JS visitor walks entirely and go straight to DB persistence.
+ * Returns true if the fast path handled the work.
+ */
+async function runFastPathIfApplicable(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+  opts: AnalysisOpts,
+  engineOpts: EngineOpts | undefined,
+  timing: AnalysisTiming,
+): Promise<boolean> {
+  if (!allNativeDataComplete(fileSymbols, opts)) return false;
+
+  debug('native full-analysis fast path: all data present, skipping WASM/visitor passes');
+  const doComplexity = opts.complexity !== false;
+  const doCfg = opts.cfg !== false;
+  if (doComplexity && doCfg) reconcileCfgCyclomatic(fileSymbols);
+  await delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing);
+  return true;
+}
+
 export async function runAnalyses(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, ExtractorOutput>,
@@ -771,80 +911,24 @@ export async function runAnalyses(
 
   const extToLang = buildExtToLangMap();
 
-  // Fast path: when all files were parsed by the native engine with full analysis
-  // (parseFilesFull), all data is already present — skip WASM re-parse and JS
-  // visitor walks entirely, go straight to DB persistence.
-  if (allNativeDataComplete(fileSymbols, opts)) {
-    debug('native full-analysis fast path: all data present, skipping WASM/visitor passes');
-    if (doComplexity && doCfg) reconcileCfgCyclomatic(fileSymbols);
-    await delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing);
+  if (await runFastPathIfApplicable(db, fileSymbols, rootDir, opts, engineOpts, timing)) {
     return timing;
   }
 
   // Native analysis pass: try Rust standalone functions before WASM fallback.
   // This fills in complexity/CFG/dataflow for files that the native parse pipeline
   // missed, avoiding the need to parse with WASM + run JS visitors.
-  const native = loadNative();
-  if (native?.analyzeComplexity || native?.buildCfgAnalysis || native?.extractDataflowAnalysis) {
-    const t0native = performance.now();
-    runNativeAnalysis(native, fileSymbols, rootDir, opts, extToLang);
-    debug(`native standalone analysis: ${(performance.now() - t0native).toFixed(1)}ms`);
-  }
+  tryNativeStandaloneAnalysis(fileSymbols, rootDir, opts, extToLang);
 
   // WASM pre-parse for files that still need it (AST store, or native gaps)
   await ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir);
 
-  // Unified pre-walk: run all applicable visitors in a single DFS per file.
   // Time each file's walk and distribute equally among active visitors
   // so that phase timers (astMs, complexityMs, etc.) reflect real work — not
   // just the DB-write tail in delegateToBuildFunctions.
-  const t0walk = performance.now();
-
-  for (const [relPath, symbols] of fileSymbols) {
-    if (!symbols._tree) continue;
-
-    const ext = path.extname(relPath).toLowerCase();
-    const langId = symbols._langId || extToLang.get(ext);
-    if (!langId) continue;
-
-    const { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor } =
-      setupVisitors(db, relPath, symbols, langId, opts);
-
-    if (visitors.length === 0) continue;
-
-    const walkStart = performance.now();
-    const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
-    const walkMs = performance.now() - walkStart;
-
-    // Distribute walk time equally among active visitors
-    const activeCount = [astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor].filter(
-      Boolean,
-    ).length;
-    if (activeCount > 0) {
-      const share = walkMs / activeCount;
-      if (astVisitor) timing.astMs += share;
-      if (complexityVisitor) timing.complexityMs += share;
-      if (cfgVisitor) timing.cfgMs += share;
-      if (dataflowVisitor) timing.dataflowMs += share;
-    }
-
-    const defs = symbols.definitions || [];
-
-    if (astVisitor) {
-      const astRows = (results['ast-store'] || []) as ASTNodeRow[];
-      if (astRows.length > 0) symbols.astNodes = astRows;
-    }
-
-    if (complexityVisitor) storeComplexityResults(results, defs, langId);
-    if (cfgVisitor) storeCfgResults(results, defs);
-    if (dataflowVisitor) symbols.dataflow = results.dataflow as DataflowResult;
-  }
-
-  // Total wall-clock time for the unified walk loop, including per-file
-  // setupVisitors overhead. Walk time is already distributed into per-phase
-  // timers above, so this field overlaps with (astMs + complexityMs + ...).
-  // It is kept as a diagnostic cross-check, not an additive bucket.
-  timing._unifiedWalkMs = performance.now() - t0walk;
+  // _unifiedWalkMs is kept as a diagnostic cross-check (overlaps with the
+  // per-phase timers above, not additive).
+  timing._unifiedWalkMs = runUnifiedWalkPass(db, fileSymbols, extToLang, opts, timing);
 
   // Reconcile: apply CFG-derived cyclomatic override for any definitions that have
   // both precomputed complexity and CFG data but whose cyclomatic was never overridden.

package/src/ast-analysis/visitor-utils.ts

@@ -88,78 +88,118 @@ export function extractParams(
   return result;
 }
 
-/** Extract names from a rest parameter (e.g. `...args`). */
-function extractRestParamNames(node: TreeSitterNode, rules: LanguageRules): string[] {
-  const nameNode = node.childForFieldName('name');
-  if (nameNode) return [nameNode.text];
-  for (const child of node.namedChildren) {
-    if (child.type === rules.paramIdentifier) return [child.text];
-  }
-  return [];
-}
-
-/** Extract names from an object destructuring pattern (e.g. `{ a, b: c }`). */
-function extractObjectDestructNames(node: TreeSitterNode, rules: LanguageRules): string[] {
-  const names: string[] = [];
-  for (const child of node.namedChildren) {
-    if (rules.shorthandPropPattern && child.type === rules.shorthandPropPattern) {
-      names.push(child.text);
-    } else if (rules.pairPatternType && child.type === rules.pairPatternType) {
-      const value = child.childForFieldName('value');
-      if (value) names.push(...extractParamNames(value, rules));
-    } else if (rules.restParamType && child.type === rules.restParamType) {
-      names.push(...extractParamNames(child, rules));
-    }
-  }
-  return names;
-}
-
-/** Extract names from an array destructuring pattern (e.g. `[a, b]`). */
-function extractArrayDestructNames(node: TreeSitterNode, rules: LanguageRules): string[] {
-  const names: string[] = [];
-  for (const child of node.namedChildren) {
-    names.push(...extractParamNames(child, rules));
-  }
-  return names;
-}
-
 /**
- * Extract parameter names from a single parameter node.
+ * Resolve a single parameter node to either a direct list of names (base case)
+ * or a list of child nodes that still need processing. Returns `null` if the
+ * node yields nothing.
+ *
+ * This base case keeps destructuring helpers from recursing back into
+ * `extractParamNames`, breaking the 3-node mutual recursion cycle between
+ * `extractParamNames`, `extractObjectDestructNames`, and `extractArrayDestructNames`.
  */
-export function extractParamNames(node: TreeSitterNode | null, rules: LanguageRules): string[] {
-  if (!node) return [];
+function resolveParamNode(
+  node: TreeSitterNode,
+  rules: LanguageRules,
+): { names?: string[]; next?: TreeSitterNode[] } | null {
   const t = node.type;
 
   if (rules.extractParamName) {
     const result = rules.extractParamName(node);
-    if (result) return result;
+    if (result) return { names: result };
   }
 
-  if (t === rules.paramIdentifier) return [node.text];
+  if (t === rules.paramIdentifier) return { names: [node.text] };
 
   if (rules.paramWrapperTypes.has(t)) {
     const pattern = node.childForFieldName('pattern') || node.childForFieldName('name');
-    return pattern ? extractParamNames(pattern, rules) : [];
+    return pattern ? { next: [pattern] } : null;
   }
 
   if (rules.defaultParamType && t === rules.defaultParamType) {
     const left = node.childForFieldName('left') || node.childForFieldName('name');
-    return left ? extractParamNames(left, rules) : [];
+    return left ? { next: [left] } : null;
   }
 
   if (rules.restParamType && t === rules.restParamType) {
-    return extractRestParamNames(node, rules);
+    const nameNode = node.childForFieldName('name');
+    if (nameNode) return { names: [nameNode.text] };
+    for (const child of node.namedChildren) {
+      if (child.type === rules.paramIdentifier) return { names: [child.text] };
+    }
+    return null;
   }
 
   if (rules.objectDestructType && t === rules.objectDestructType) {
-    return extractObjectDestructNames(node, rules);
+    return { next: collectObjectDestructChildren(node, rules) };
   }
 
   if (rules.arrayDestructType && t === rules.arrayDestructType) {
-    return extractArrayDestructNames(node, rules);
+    return { next: [...node.namedChildren] };
+  }
+
+  return null;
+}
+
+/**
+ * Collect child nodes from an object destructuring pattern that should be
+ * processed for further name extraction. Returns nodes (not names) so the
+ * caller drives traversal via a worklist instead of recursion.
+ */
+function collectObjectDestructChildren(
+  node: TreeSitterNode,
+  rules: LanguageRules,
+): TreeSitterNode[] {
+  const next: TreeSitterNode[] = [];
+  for (const child of node.namedChildren) {
+    if (rules.shorthandPropPattern && child.type === rules.shorthandPropPattern) {
+      // Shorthand prop is a direct identifier — handled by the shorthand
+      // guard in the `extractParamNames` worklist loop (before `resolveParamNode`).
+      next.push(child);
+    } else if (rules.pairPatternType && child.type === rules.pairPatternType) {
+      const value = child.childForFieldName('value');
+      if (value) next.push(value);
+    } else if (rules.restParamType && child.type === rules.restParamType) {
+      next.push(child);
+    }
   }
+  return next;
+}
 
-  return [];
+/**
+ * Extract parameter names from a single parameter node.
+ *
+ * Uses an iterative worklist to handle nested destructuring (objects, arrays,
+ * defaults, rest, wrappers) without mutual recursion through helper functions.
+ */
+export function extractParamNames(node: TreeSitterNode | null, rules: LanguageRules): string[] {
+  if (!node) return [];
+
+  const names: string[] = [];
+  const stack: TreeSitterNode[] = [node];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+
+    // Shorthand identifier inside an object destructuring is just the node's text.
+    if (rules.shorthandPropPattern && current.type === rules.shorthandPropPattern) {
+      names.push(current.text);
+      continue;
+    }
+
+    const resolved = resolveParamNode(current, rules);
+    if (!resolved) continue;
+    if (resolved.names) names.push(...resolved.names);
+    if (resolved.next) {
+      // Push in reverse so traversal order matches the previous recursive order.
+      for (let i = resolved.next.length - 1; i >= 0; i--) {
+        const child = resolved.next[i];
+        if (child) stack.push(child);
+      }
+    }
+  }
+
+  return names;
 }
 
 /**

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -181,46 +181,17 @@ function newTypesFor(astTypeMap: Record<string, string>): Set<string> {
   return s;
 }
 
-export function createAstStoreVisitor(
-  astTypeMap: Record<string, string>,
-  defs: Definition[],
-  relPath: string,
-  nodeIdMap: Map<string, number>,
-  stringConfig: AstStringConfig = DEFAULT_STRING_CONFIG,
-  stopRecurseKinds: ReadonlySet<string> = new Set(),
-): Visitor {
-  const rows: AstStoreRow[] = [];
-  const matched = new Set<number>();
-  const newTypes = newTypesFor(astTypeMap);
-  // When nodeIdMap is empty, parentNodeId resolution is wasted work — the
-  // worker passes an empty map and the main thread re-resolves against its
-  // own DB-populated map in features/ast.ts::collectFileAstRows. Skip the
-  // findParentDef linear scan in that case.
-  const skipParentLookup = nodeIdMap.size === 0;
-
-  function findParentDef(line: number): Definition | null {
-    let best: Definition | null = null;
-    for (const def of defs) {
-      if (def.line <= line && (def.endLine == null || def.endLine >= line)) {
-        if (!best || (def.endLine ?? 0) - def.line < (best.endLine ?? 0) - best.line) {
-          best = def;
-        }
-      }
-    }
-    return best;
-  }
-
-  function resolveParentNodeId(line: number): number | null {
-    if (skipParentLookup) return null;
-    const parentDef = findParentDef(line);
-    if (!parentDef) return null;
-    return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
-  }
+type NameTextResult = { name: string | null | undefined; text: string | null; skip?: boolean };
+type KindHandler = (node: TreeSitterNode) => NameTextResult;
 
-  type NameTextResult = { name: string | null | undefined; text: string | null; skip?: boolean };
-  type KindHandler = (node: TreeSitterNode) => NameTextResult;
+const DEFAULT_NAME_TEXT_RESULT: NameTextResult = { name: undefined, text: null };
 
-  const kindHandlers: Record<string, KindHandler> = {
+/** Build the per-kind resolver map for name/text extraction. */
+function buildKindHandlers(
+  newTypes: Set<string>,
+  stringConfig: AstStringConfig,
+): Record<string, KindHandler> {
+  return {
     new: (node) => ({ name: extractConstructorName(node), text: truncate(node.text) }),
     throw: (node) => ({
       name: extractThrowName(node, newTypes),
@@ -234,31 +205,102 @@ export function createAstStoreVisitor(
     },
     regex: (node) => ({ name: node.text || '?', text: truncate(node.text) }),
   };
-  const defaultResult: NameTextResult = { name: undefined, text: null };
+}
 
-  function resolveNameAndText(node: TreeSitterNode, kind: string): NameTextResult {
-    const handler = kindHandlers[kind];
-    return handler ? handler(node) : defaultResult;
+/** Find the innermost definition whose line range contains `line`. */
+function findParentDef(line: number, defs: Definition[]): Definition | null {
+  let best: Definition | null = null;
+  for (const def of defs) {
+    if (def.line <= line && (def.endLine == null || def.endLine >= line)) {
+      if (!best || (def.endLine ?? 0) - def.line < (best.endLine ?? 0) - best.line) {
+        best = def;
+      }
+    }
   }
+  return best;
+}
+
+/** Resolve the parent definition's node id for a given source line. */
+function resolveParentNodeId(
+  line: number,
+  defs: Definition[],
+  nodeIdMap: Map<string, number>,
+  skipParentLookup: boolean,
+): number | null {
+  if (skipParentLookup) return null;
+  const parentDef = findParentDef(line, defs);
+  if (!parentDef) return null;
+  return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
+}
 
-  function collectNode(node: TreeSitterNode, kind: string): void {
-    if (matched.has(node.id)) return;
+interface CollectCtx {
+  rows: AstStoreRow[];
+  matched: Set<number>;
+  relPath: string;
+  defs: Definition[];
+  nodeIdMap: Map<string, number>;
+  skipParentLookup: boolean;
+  kindHandlers: Record<string, KindHandler>;
+}
 
-    const resolved = resolveNameAndText(node, kind);
-    if (resolved.skip) return;
+function collectNode(ctx: CollectCtx, node: TreeSitterNode, kind: string): void {
+  if (ctx.matched.has(node.id)) return;
+
+  const handler = ctx.kindHandlers[kind];
+  const resolved = handler ? handler(node) : DEFAULT_NAME_TEXT_RESULT;
+  if (resolved.skip) return;
+
+  const line = node.startPosition.row + 1;
+  ctx.rows.push({
+    file: ctx.relPath,
+    line,
+    kind,
+    name: resolved.name,
+    text: resolved.text,
+    receiver: null,
+    parentNodeId: resolveParentNodeId(line, ctx.defs, ctx.nodeIdMap, ctx.skipParentLookup),
+  });
+
+  ctx.matched.add(node.id);
+}
 
-    rows.push({
-      file: relPath,
-      line: node.startPosition.row + 1,
-      kind,
-      name: resolved.name,
-      text: resolved.text,
-      receiver: null,
-      parentNodeId: resolveParentNodeId(node.startPosition.row + 1),
-    });
+/**
+ * Resolve the kind for a tree-sitter node, or `null` if the node should be ignored.
+ *
+ * Gate with `hasOwn` because plain-object lookup walks Object.prototype:
+ * tree-sitter node types like `constructor` (Haskell sum-types: Left,
+ * Right) would otherwise resolve to `Object.prototype.constructor` (the
+ * Object() function), which then crashes the worker boundary with
+ * "function Object() { [native code] } could not be cloned" when the
+ * resulting astNodes row is structured-cloned back to the main thread.
+ */
+function resolveAstKind(node: TreeSitterNode, astTypeMap: Record<string, string>): string | null {
+  if (!Object.hasOwn(astTypeMap, node.type)) return null;
+  return astTypeMap[node.type] || null;
+}
 
-    matched.add(node.id);
-  }
+export function createAstStoreVisitor(
+  astTypeMap: Record<string, string>,
+  defs: Definition[],
+  relPath: string,
+  nodeIdMap: Map<string, number>,
+  stringConfig: AstStringConfig = DEFAULT_STRING_CONFIG,
+  stopRecurseKinds: ReadonlySet<string> = new Set(),
+): Visitor {
+  const newTypes = newTypesFor(astTypeMap);
+  // When nodeIdMap is empty, parentNodeId resolution is wasted work — the
+  // worker passes an empty map and the main thread re-resolves against its
+  // own DB-populated map in features/ast.ts::collectFileAstRows. Skip the
+  // findParentDef linear scan in that case.
+  const ctx: CollectCtx = {
+    rows: [],
+    matched: new Set<number>(),
+    relPath,
+    defs,
+    nodeIdMap,
+    skipParentLookup: nodeIdMap.size === 0,
+    kindHandlers: buildKindHandlers(newTypes, stringConfig),
+  };
 
   return {
     name: 'ast-store',
@@ -267,19 +309,12 @@ export function createAstStoreVisitor(
       // Guard: skip re-collection but do NOT skipChildren — node.id (memory address)
       // can be reused by tree-sitter, so a collision would incorrectly suppress an
       // unrelated subtree. The parent call's skipChildren handles the intended case.
-      if (matched.has(node.id)) return;
-
-      // Gate with `hasOwn` because plain-object lookup walks Object.prototype:
-      // tree-sitter node types like `constructor` (Haskell sum-types: Left,
-      // Right) would otherwise resolve to `Object.prototype.constructor` (the
-      // Object() function), which then crashes the worker boundary with
-      // "function Object() { [native code] } could not be cloned" when the
-      // resulting astNodes row is structured-cloned back to the main thread.
-      if (!Object.hasOwn(astTypeMap, node.type)) return;
-      const kind = astTypeMap[node.type];
+      if (ctx.matched.has(node.id)) return;
+
+      const kind = resolveAstKind(node, astTypeMap);
       if (!kind) return;
 
-      collectNode(node, kind);
+      collectNode(ctx, node, kind);
 
       // Mirror the native walker's recursion policy. In JS/TS, the native
       // javascript.rs walker returns after collecting `new` or `throw` to
@@ -293,7 +328,7 @@ export function createAstStoreVisitor(
     },
 
     finish(): AstStoreRow[] {
-      return rows;
+      return ctx.rows;
     },
   };
 }