feat(cfg): bypass JS CFG visitor on native builds, fix Go for-range parity (#595)

* feat(cfg): bypass JS CFG visitor on native builds, fix Go for-range parity

Add allCfgNative() fast path in buildCFGData that skips WASM parser
init, tree parsing, and JS visitor when all definitions already have
native CFG data from the Rust extractor — directly persists to SQLite.

Fix Go for-range loop detection in Rust CFG builder: check for
range_clause child node so for-range is treated as bounded (emitting
branch_true + loop_exit) instead of infinite.

Expand parity tests: add Go/Rust/Ruby to matrix, add complex pattern
fixtures (try/catch/finally, switch, do-while, nested loops, labeled
break) validating block counts, edge counts, and kinds match.

* feat(cfg): bypass JS CFG visitor on native builds, fix Go for-range parity

Add allCfgNative() fast path in buildCFGData that skips WASM parser
init, tree parsing, and JS visitor when all definitions already have
native CFG data from the Rust extractor — directly persists to SQLite.

Fix Go for-range loop detection in Rust CFG builder: check for
range_clause child node so for-range is treated as bounded (emitting
branch_true + loop_exit) instead of infinite.

Expand parity tests: add Go/Rust/Ruby to matrix, add complex pattern
fixtures (try/catch/finally, switch, do-while, nested loops, labeled
break) validating block counts, edge counts, and kinds match.

* fix(cfg): resolve temporary value borrow error in has_child_of_kind

Use a let binding for the tree cursor instead of borrowing a temporary,
fixing E0716 compilation error on all platforms.

* fix(cfg): remove unnecessary parentheses in allCfgNative check

Biome formatter flagged the redundant grouping parens around the
optional-chain expression.

* fix(test): move hasGoRangeFix to beforeAll, use ctx.skip() for skipped tests

- Move hasGoRangeFix computation into beforeAll where nativeResults is
  already populated, fixing the IIFE evaluation-order bug that always
  yielded false.
- Replace bare return statements with ctx.skip() so Vitest reports
  skipped tests explicitly instead of as silent passes.
- Fix inaccurate test description: complex-dowhile uses early return,
  not break.

* fix(cfg): bind iterator result to extend cursor lifetime

The iterator returned by node.children() borrows the cursor, but the
cursor is dropped at the end of the statement when the result is returned
directly. Binding the result to a local variable ensures the cursor
outlives the iterator.

* fix(cfg): align allCfgNative with initCfgParsers, clean stale CFG rows on fast path (#595)

- Skip _tree files in allCfgNative to match initCfgParsers behavior,
  preventing false fast-path suppression in mixed-engine pipelines
- Always call deleteCfgForNode in fast path before checking cfg content,
  ensuring stale rows are cleaned when function bodies are removed
- Replace bare return guards with ctx.skip() in parity tests so Vitest
  reports them as skipped rather than silently passed

Impact: 2 functions changed, 6 affected

* fix(cfg): prevent fast path from wiping CFG in WASM-only builds (#595)

When all files have _tree set (WASM-only builds), allCfgNative()
vacuously returns true. The fast path then deletes all existing CFG
rows without recomputing them, since _tree files have no native CFG.

Guard the fast path with !symbols._tree so _tree files fall through
to the slow path where getTreeAndLang uses the pre-parsed tree directly.

Impact: 1 functions changed, 5 affected

* refactor(cfg): simplify has_child_of_kind by returning directly (#595)

Impact: 1 functions changed, 1 affected

* docs(test): clarify hasGoRangeFix heuristic false-positive risk (#595)

* fix(cfg): revert has_child_of_kind simplification (borrow checker) (#595)

The intermediate `result` variable is required because `cursor` must
outlive the iterator returned by `node.children()`. Returning directly
causes a borrow-after-drop error since cursor is dropped before the
temporary iterator's destructor runs.

Impact: 1 functions changed, 1 affected

* refactor(cfg): extract hasNativeCfgForFile shared predicate (#595)

The native-CFG check was duplicated in allCfgNative, initCfgParsers,
and getTreeAndLang. Extract into a single hasNativeCfgForFile helper
so all three callers stay in sync automatically.

Impact: 4 functions changed, 4 affected

* fix(cfg): address review feedback — vacuous allCfgNative, stale CFG cleanup, doc comment (#595)

- allCfgNative now returns false (not vacuous true) when fileSymbols is
  empty, all-_tree, or contains only non-CFG extensions. Tracks hasCfgFile
  sentinel to distinguish "all native" from "nothing to process".
- Fast path adds !symbols._tree guard so WASM-parsed files fall through
  to the slow path (prevents CFG wipe on WASM-only builds).
- Both fast and slow paths now unconditionally call deleteCfgForNode before
  the blocks-length guard, cleaning stale cfg_blocks/cfg_edges rows when
  a function body is removed.
- Added doc comment to has_child_of_kind clarifying shallow (one-level)
  direct-child check semantics.

Impact: 2 functions changed, 6 affected

* fix(test): guard against silent pass when no defs have CFG blocks (#595)

* docs(cfg): clarify parsers=null invariant for _tree files in fast path (#595)

Impact: 1 functions changed, 5 affected

* fix(test): guard against findFunctionNode returning null for all defs (#595)

Both the parity test loop and complex patterns suite could silently pass
with zero assertions if findFunctionNode returned null for every entry in
defsWithCfg (e.g., due to line-number offset mismatch between native and
WASM parsers). Added defsWithNode guard that calls ctx.skip() when no
function nodes are found, matching the existing defsWithCfg pattern.

Author: carlos-alm

crates/codegraph-core/src/cfg.rs

@@ -803,6 +803,8 @@ impl<'a> CfgBuilder<'a> {
                 for_stmt.child_by_field_name(field).is_some()
                     || for_stmt.child_by_field_name("right").is_some()
                     || for_stmt.child_by_field_name("value").is_some()
+                    // Go: for-range has a range_clause child (no condition/right/value fields)
+                    || has_child_of_kind(for_stmt, "range_clause")
                     // Explicit iterator-style node kinds across supported languages:
                     // JS: for_in_statement, Java: enhanced_for_statement,
                     // C#/PHP: foreach_statement, Ruby: for
@@ -1134,6 +1136,14 @@ impl<'a> CfgBuilder<'a> {
 
 // ─── Helpers ────────────────────────────────────────────────────────────
 
+/// Returns true if `node` has a direct child whose node kind equals `kind`.
+/// This is a shallow (one-level) check — it does not recurse into grandchildren.
+fn has_child_of_kind(node: &Node, kind: &str) -> bool {
+    let mut cursor = node.walk();
+    let result = node.children(&mut cursor).any(|c| c.kind() == kind);
+    result
+}
+
 fn node_line(node: &Node) -> u32 {
     node.start_position().row as u32 + 1
 }

src/features/cfg.ts

@@ -84,6 +84,17 @@ interface FileSymbols {
   _langId?: string;
 }
 
+/**
+ * Check whether all function/method definitions in a single file already
+ * have native CFG data (blocks populated by the Rust extractor).
+ * cfg === null means no body (expected); cfg with empty blocks means not computed.
+ */
+function hasNativeCfgForFile(symbols: FileSymbols): boolean {
+  return symbols.definitions
+    .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
+    .every((d) => d.cfg === null || (d.cfg?.blocks?.length ?? 0) > 0);
+}
+
 async function initCfgParsers(
   fileSymbols: Map<string, FileSymbols>,
 ): Promise<{ parsers: unknown; getParserFn: unknown }> {
@@ -93,10 +104,7 @@ async function initCfgParsers(
     if (!symbols._tree) {
       const ext = path.extname(relPath).toLowerCase();
       if (CFG_EXTENSIONS.has(ext)) {
-        const hasNativeCfg = symbols.definitions
-          .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
-          .every((d) => d.cfg === null || (d.cfg?.blocks?.length ?? 0) > 0);
-        if (!hasNativeCfg) {
+        if (!hasNativeCfgForFile(symbols)) {
           needsFallback = true;
           break;
         }
@@ -129,11 +137,7 @@ function getTreeAndLang(
   let tree = symbols._tree;
   let langId = symbols._langId;
 
-  const allNative = symbols.definitions
-    .filter((d) => (d.kind === 'function' || d.kind === 'method') && d.line)
-    .every((d) => d.cfg === null || (d.cfg?.blocks?.length ?? 0) > 0);
-
-  if (!tree && !allNative) {
+  if (!tree && !hasNativeCfgForFile(symbols)) {
     if (!getParserFn) return null;
     langId = extToLang.get(ext);
     if (!langId || !CFG_RULES.has(langId)) return null;
@@ -246,14 +250,43 @@ function persistCfg(
 
 // ─── Build-Time: Compute CFG for Changed Files ─────────────────────────
 
+/**
+ * Check if all function/method definitions across all files already have
+ * native CFG data (blocks array populated by the Rust extractor).
+ * When true, the WASM parser and JS CFG visitor can be fully bypassed.
+ */
+function allCfgNative(fileSymbols: Map<string, FileSymbols>): boolean {
+  let hasCfgFile = false;
+  for (const [relPath, symbols] of fileSymbols) {
+    if (symbols._tree) continue; // already parsed via WASM; will use _tree in slow path
+    const ext = path.extname(relPath).toLowerCase();
+    if (!CFG_EXTENSIONS.has(ext)) continue;
+    hasCfgFile = true;
+
+    if (!hasNativeCfgForFile(symbols)) return false;
+  }
+  // Return false when no CFG files found (empty map, all _tree, or all non-CFG
+  // extensions) to avoid vacuously triggering the fast path.
+  return hasCfgFile;
+}
+
 export async function buildCFGData(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   rootDir: string,
   _engineOpts?: unknown,
 ): Promise<void> {
+  // Fast path: when all function/method defs already have native CFG data,
+  // skip WASM parser init, tree parsing, and JS visitor entirely — just persist.
+  const allNative = allCfgNative(fileSymbols);
+
   const extToLang = buildExtToLangMap();
-  const { parsers, getParserFn } = await initCfgParsers(fileSymbols);
+  let parsers: unknown = null;
+  let getParserFn: unknown = null;
+
+  if (!allNative) {
+    ({ parsers, getParserFn } = await initCfgParsers(fileSymbols));
+  }
 
   const insertBlock = db.prepare(
     `INSERT INTO cfg_blocks (function_node_id, block_index, block_type, start_line, end_line, label)
@@ -270,6 +303,35 @@ export async function buildCFGData(
       const ext = path.extname(relPath).toLowerCase();
       if (!CFG_EXTENSIONS.has(ext)) continue;
 
+      // Native fast path: skip tree/visitor setup when all CFG is pre-computed.
+      // Only apply to files without _tree — files with _tree were WASM-parsed
+      // and need the slow path (visitor) to compute CFG.
+      if (allNative && !symbols._tree) {
+        for (const def of symbols.definitions) {
+          if (def.kind !== 'function' && def.kind !== 'method') continue;
+          if (!def.line) continue;
+
+          const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+          if (!nodeId) continue;
+
+          // Always delete stale CFG rows (handles body-removed case)
+          deleteCfgForNode(db, nodeId);
+          if (!def.cfg?.blocks?.length) continue;
+
+          persistCfg(
+            def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] },
+            nodeId,
+            insertBlock,
+            insertEdge,
+          );
+          analyzed++;
+        }
+        continue;
+      }
+
+      // When allNative=true, parsers/getParserFn are null. This is safe because
+      // _tree files use symbols._tree directly in getTreeAndLang (the parser
+      // code path is never reached). Non-_tree files are handled by the fast path above.
       const treeLang = getTreeAndLang(symbols, relPath, rootDir, extToLang, parsers, getParserFn);
       if (!treeLang) continue;
       const { tree, langId } = treeLang;
@@ -302,9 +364,10 @@ export async function buildCFGData(
           if (r) cfg = { blocks: r.blocks, edges: r.edges };
         }
 
+        // Always purge stale rows (handles body-removed case)
+        deleteCfgForNode(db, nodeId);
         if (!cfg || cfg.blocks.length === 0) continue;
 
-        deleteCfgForNode(db, nodeId);
         persistCfg(cfg, nodeId, insertBlock, insertEdge);
         analyzed++;
       }