@optave/codegraph 3.1.5 → 3.2.0

package/src/ast-analysis/visitors/cfg-visitor.js

@@ -10,756 +10,746 @@
  * hooks, using a control-flow frame stack to track branch/loop/switch context.
  */
 
-/**
- * Create a CFG visitor for use with walkWithVisitors.
- *
- * @param {object} cfgRules - CFG_RULES for the language
- * @returns {Visitor}
- */
-export function createCfgVisitor(cfgRules) {
-  // ── Per-function state ──────────────────────────────────────────────
-  // Pushed/popped on enterFunction/exitFunction for nested function support.
-
-  /** @type {Array<object>} Stack of per-function CFG state */
-  const funcStateStack = [];
-
-  /** @type {object|null} Active per-function state */
-  let S = null;
-
-  // Collected results (one per top-level function)
-  const results = [];
-
-  function makeFuncState() {
-    const blocks = [];
-    const edges = [];
-    let nextIndex = 0;
-
-    function makeBlock(type, startLine = null, endLine = null, label = null) {
-      const block = { index: nextIndex++, type, startLine, endLine, label };
-      blocks.push(block);
-      return block;
-    }
-
-    function addEdge(source, target, kind) {
-      edges.push({ sourceIndex: source.index, targetIndex: target.index, kind });
-    }
+// ── Node-type predicates ────────────────────────────────────────────────
 
-    const entry = makeBlock('entry');
-    const exit = makeBlock('exit');
-    const firstBody = makeBlock('body');
-    addEdge(entry, firstBody, 'fallthrough');
-
-    return {
-      blocks,
-      edges,
-      makeBlock,
-      addEdge,
-      entryBlock: entry,
-      exitBlock: exit,
-      currentBlock: firstBody,
-      loopStack: [],
-      labelMap: new Map(),
-      /** Control-flow frame stack for nested if/switch/try/loop/labeled */
-      cfgStack: [],
-      funcNode: null,
-    };
-  }
-
-  // ── Helpers ─────────────────────────────────────────────────────────
+function isIfNode(type, cfgRules) {
+  return type === cfgRules.ifNode || cfgRules.ifNodes?.has(type);
+}
 
-  function isIfNode(type) {
-    return type === cfgRules.ifNode || cfgRules.ifNodes?.has(type);
-  }
+function isForNode(type, cfgRules) {
+  return cfgRules.forNodes.has(type);
+}
 
-  function isForNode(type) {
-    return cfgRules.forNodes.has(type);
-  }
+function isWhileNode(type, cfgRules) {
+  return type === cfgRules.whileNode || cfgRules.whileNodes?.has(type);
+}
 
-  function isWhileNode(type) {
-    return type === cfgRules.whileNode || cfgRules.whileNodes?.has(type);
-  }
+function isSwitchNode(type, cfgRules) {
+  return type === cfgRules.switchNode || cfgRules.switchNodes?.has(type);
+}
 
-  function isSwitchNode(type) {
-    return type === cfgRules.switchNode || cfgRules.switchNodes?.has(type);
-  }
+function isCaseNode(type, cfgRules) {
+  return (
+    type === cfgRules.caseNode || type === cfgRules.defaultNode || cfgRules.caseNodes?.has(type)
+  );
+}
 
-  function isCaseNode(type) {
-    return (
-      type === cfgRules.caseNode || type === cfgRules.defaultNode || cfgRules.caseNodes?.has(type)
-    );
-  }
+function isBlockNode(type, cfgRules) {
+  return type === 'statement_list' || type === cfgRules.blockNode || cfgRules.blockNodes?.has(type);
+}
 
-  function isBlockNode(type) {
-    return (
-      type === 'statement_list' || type === cfgRules.blockNode || cfgRules.blockNodes?.has(type)
-    );
-  }
+/** Check if a node is a control-flow statement that we handle specially */
+function isControlFlow(type, cfgRules) {
+  return (
+    isIfNode(type, cfgRules) ||
+    (cfgRules.unlessNode && type === cfgRules.unlessNode) ||
+    isForNode(type, cfgRules) ||
+    isWhileNode(type, cfgRules) ||
+    (cfgRules.untilNode && type === cfgRules.untilNode) ||
+    (cfgRules.doNode && type === cfgRules.doNode) ||
+    (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) ||
+    isSwitchNode(type, cfgRules) ||
+    (cfgRules.tryNode && type === cfgRules.tryNode) ||
+    type === cfgRules.returnNode ||
+    type === cfgRules.throwNode ||
+    type === cfgRules.breakNode ||
+    type === cfgRules.continueNode ||
+    type === cfgRules.labeledNode
+  );
+}
 
-  /** Check if a node is a control-flow statement that we handle specially */
-  function isControlFlow(type) {
-    return (
-      isIfNode(type) ||
-      (cfgRules.unlessNode && type === cfgRules.unlessNode) ||
-      isForNode(type) ||
-      isWhileNode(type) ||
-      (cfgRules.untilNode && type === cfgRules.untilNode) ||
-      (cfgRules.doNode && type === cfgRules.doNode) ||
-      (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) ||
-      isSwitchNode(type) ||
-      (cfgRules.tryNode && type === cfgRules.tryNode) ||
-      type === cfgRules.returnNode ||
-      type === cfgRules.throwNode ||
-      type === cfgRules.breakNode ||
-      type === cfgRules.continueNode ||
-      type === cfgRules.labeledNode
-    );
-  }
+// ── Utility functions ───────────────────────────────────────────────────
 
-  /**
-   * Get the actual control-flow node (unwrapping expression_statement if needed).
-   */
-  function effectiveNode(node) {
-    if (node.type === 'expression_statement' && node.namedChildCount === 1) {
-      const inner = node.namedChild(0);
-      if (isControlFlow(inner.type)) return inner;
-    }
-    return node;
+/**
+ * Get the actual control-flow node (unwrapping expression_statement if needed).
+ */
+function effectiveNode(node, cfgRules) {
+  if (node.type === 'expression_statement' && node.namedChildCount === 1) {
+    const inner = node.namedChild(0);
+    if (isControlFlow(inner.type, cfgRules)) return inner;
   }
+  return node;
+}
 
-  /**
-   * Register a loop/switch in label map for labeled break/continue.
-   */
-  function registerLabelCtx(headerBlock, exitBlock) {
-    for (const [, ctx] of S.labelMap) {
-      if (!ctx.headerBlock) {
-        ctx.headerBlock = headerBlock;
-        ctx.exitBlock = exitBlock;
-      }
+/**
+ * Register a loop/switch in label map for labeled break/continue.
+ */
+function registerLabelCtx(S, headerBlock, exitBlock) {
+  for (const [, ctx] of S.labelMap) {
+    if (!ctx.headerBlock) {
+      ctx.headerBlock = headerBlock;
+      ctx.exitBlock = exitBlock;
     }
   }
+}
 
-  /**
-   * Get statements from a body node (block or single statement).
-   * Returns effective (unwrapped) nodes.
-   */
-  function getBodyStatements(bodyNode) {
-    if (!bodyNode) return [];
-    if (isBlockNode(bodyNode.type)) {
-      const stmts = [];
-      for (let i = 0; i < bodyNode.namedChildCount; i++) {
-        const child = bodyNode.namedChild(i);
-        if (child.type === 'statement_list') {
-          for (let j = 0; j < child.namedChildCount; j++) {
-            stmts.push(child.namedChild(j));
-          }
-        } else {
-          stmts.push(child);
+/**
+ * Get statements from a body node (block or single statement).
+ * Returns effective (unwrapped) nodes.
+ */
+function getBodyStatements(bodyNode, cfgRules) {
+  if (!bodyNode) return [];
+  if (isBlockNode(bodyNode.type, cfgRules)) {
+    const stmts = [];
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+      const child = bodyNode.namedChild(i);
+      if (child.type === 'statement_list') {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          stmts.push(child.namedChild(j));
         }
+      } else {
+        stmts.push(child);
       }
-      return stmts;
     }
-    return [bodyNode];
+    return stmts;
   }
+  return [bodyNode];
+}
 
-  // ── Statement-level processing (replicates buildFunctionCFG logic) ──
-  // The visitor delegates to these for each control-flow construct,
-  // processing the body statements sequentially just like the original.
+function makeFuncState() {
+  const blocks = [];
+  const edges = [];
+  let nextIndex = 0;
 
-  function processStatements(stmts, currentBlock) {
-    let cur = currentBlock;
-    for (const stmt of stmts) {
-      if (!cur) break;
-      cur = processStatement(stmt, cur);
-    }
-    return cur;
+  function makeBlock(type, startLine = null, endLine = null, label = null) {
+    const block = { index: nextIndex++, type, startLine, endLine, label };
+    blocks.push(block);
+    return block;
   }
 
-  function processStatement(stmt, currentBlock) {
-    if (!stmt || !currentBlock) return currentBlock;
+  function addEdge(source, target, kind) {
+    edges.push({ sourceIndex: source.index, targetIndex: target.index, kind });
+  }
 
-    // Unwrap expression_statement for Rust-style control flow expressions
-    const effNode = effectiveNode(stmt);
-    const type = effNode.type;
+  const entry = makeBlock('entry');
+  const exit = makeBlock('exit');
+  const firstBody = makeBlock('body');
+  addEdge(entry, firstBody, 'fallthrough');
 
-    // Labeled statement
-    if (type === cfgRules.labeledNode) {
-      return processLabeled(effNode, currentBlock);
-    }
+  return {
+    blocks,
+    edges,
+    makeBlock,
+    addEdge,
+    entryBlock: entry,
+    exitBlock: exit,
+    currentBlock: firstBody,
+    loopStack: [],
+    labelMap: new Map(),
+    cfgStack: [],
+    funcNode: null,
+  };
+}
 
-    // If / unless
-    if (isIfNode(type) || (cfgRules.unlessNode && type === cfgRules.unlessNode)) {
-      return processIf(effNode, currentBlock);
-    }
+// ── Statement processors ────────────────────────────────────────────────
 
-    // For loops
-    if (isForNode(type)) {
-      return processForLoop(effNode, currentBlock);
-    }
+function processStatements(stmts, currentBlock, S, cfgRules) {
+  let cur = currentBlock;
+  for (const stmt of stmts) {
+    if (!cur) break;
+    cur = processStatement(stmt, cur, S, cfgRules);
+  }
+  return cur;
+}
 
-    // While / until
-    if (isWhileNode(type) || (cfgRules.untilNode && type === cfgRules.untilNode)) {
-      return processWhileLoop(effNode, currentBlock);
-    }
+function processStatement(stmt, currentBlock, S, cfgRules) {
+  if (!stmt || !currentBlock) return currentBlock;
 
-    // Do-while
-    if (cfgRules.doNode && type === cfgRules.doNode) {
-      return processDoWhileLoop(effNode, currentBlock);
-    }
+  const effNode = effectiveNode(stmt, cfgRules);
+  const type = effNode.type;
 
-    // Infinite loop (Rust)
-    if (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) {
-      return processInfiniteLoop(effNode, currentBlock);
-    }
+  if (type === cfgRules.labeledNode) {
+    return processLabeled(effNode, currentBlock, S, cfgRules);
+  }
+  if (isIfNode(type, cfgRules) || (cfgRules.unlessNode && type === cfgRules.unlessNode)) {
+    return processIf(effNode, currentBlock, S, cfgRules);
+  }
+  if (isForNode(type, cfgRules)) {
+    return processForLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (isWhileNode(type, cfgRules) || (cfgRules.untilNode && type === cfgRules.untilNode)) {
+    return processWhileLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (cfgRules.doNode && type === cfgRules.doNode) {
+    return processDoWhileLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) {
+    return processInfiniteLoop(effNode, currentBlock, S, cfgRules);
+  }
+  if (isSwitchNode(type, cfgRules)) {
+    return processSwitch(effNode, currentBlock, S, cfgRules);
+  }
+  if (cfgRules.tryNode && type === cfgRules.tryNode) {
+    return processTryCatch(effNode, currentBlock, S, cfgRules);
+  }
+  if (type === cfgRules.returnNode) {
+    currentBlock.endLine = effNode.startPosition.row + 1;
+    S.addEdge(currentBlock, S.exitBlock, 'return');
+    return null;
+  }
+  if (type === cfgRules.throwNode) {
+    currentBlock.endLine = effNode.startPosition.row + 1;
+    S.addEdge(currentBlock, S.exitBlock, 'exception');
+    return null;
+  }
+  if (type === cfgRules.breakNode) {
+    return processBreak(effNode, currentBlock, S);
+  }
+  if (type === cfgRules.continueNode) {
+    return processContinue(effNode, currentBlock, S);
+  }
 
-    // Switch / match
-    if (isSwitchNode(type)) {
-      return processSwitch(effNode, currentBlock);
-    }
+  // Regular statement — extend current block
+  if (!currentBlock.startLine) {
+    currentBlock.startLine = stmt.startPosition.row + 1;
+  }
+  currentBlock.endLine = stmt.endPosition.row + 1;
+  return currentBlock;
+}
 
-    // Try/catch/finally
-    if (cfgRules.tryNode && type === cfgRules.tryNode) {
-      return processTryCatch(effNode, currentBlock);
-    }
+// ── Labeled / break / continue ──────────────────────────────────────────
+
+function processLabeled(node, currentBlock, S, cfgRules) {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
+  const body = node.childForFieldName('body');
+  if (body && labelName) {
+    const labelCtx = { headerBlock: null, exitBlock: null };
+    S.labelMap.set(labelName, labelCtx);
+    const result = processStatement(body, currentBlock, S, cfgRules);
+    S.labelMap.delete(labelName);
+    return result;
+  }
+  return currentBlock;
+}
 
-    // Return
-    if (type === cfgRules.returnNode) {
-      currentBlock.endLine = effNode.startPosition.row + 1;
-      S.addEdge(currentBlock, S.exitBlock, 'return');
-      return null;
-    }
+function processBreak(node, currentBlock, S) {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
 
-    // Throw
-    if (type === cfgRules.throwNode) {
-      currentBlock.endLine = effNode.startPosition.row + 1;
-      S.addEdge(currentBlock, S.exitBlock, 'exception');
-      return null;
-    }
+  let target = null;
+  if (labelName && S.labelMap.has(labelName)) {
+    target = S.labelMap.get(labelName).exitBlock;
+  } else if (S.loopStack.length > 0) {
+    target = S.loopStack[S.loopStack.length - 1].exitBlock;
+  }
 
-    // Break
-    if (type === cfgRules.breakNode) {
-      return processBreak(effNode, currentBlock);
-    }
+  if (target) {
+    currentBlock.endLine = node.startPosition.row + 1;
+    S.addEdge(currentBlock, target, 'break');
+    return null;
+  }
+  return currentBlock;
+}
 
-    // Continue
-    if (type === cfgRules.continueNode) {
-      return processContinue(effNode, currentBlock);
-    }
+function processContinue(node, currentBlock, S) {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
 
-    // Regular statement — extend current block
-    if (!currentBlock.startLine) {
-      currentBlock.startLine = stmt.startPosition.row + 1;
-    }
-    currentBlock.endLine = stmt.endPosition.row + 1;
-    return currentBlock;
-  }
-
-  function processLabeled(node, currentBlock) {
-    const labelNode = node.childForFieldName('label');
-    const labelName = labelNode ? labelNode.text : null;
-    const body = node.childForFieldName('body');
-    if (body && labelName) {
-      const labelCtx = { headerBlock: null, exitBlock: null };
-      S.labelMap.set(labelName, labelCtx);
-      const result = processStatement(body, currentBlock);
-      S.labelMap.delete(labelName);
-      return result;
-    }
-    return currentBlock;
+  let target = null;
+  if (labelName && S.labelMap.has(labelName)) {
+    target = S.labelMap.get(labelName).headerBlock;
+  } else if (S.loopStack.length > 0) {
+    target = S.loopStack[S.loopStack.length - 1].headerBlock;
   }
 
-  function processBreak(node, currentBlock) {
-    const labelNode = node.childForFieldName('label');
-    const labelName = labelNode ? labelNode.text : null;
+  if (target) {
+    currentBlock.endLine = node.startPosition.row + 1;
+    S.addEdge(currentBlock, target, 'continue');
+    return null;
+  }
+  return currentBlock;
+}
 
-    let target = null;
-    if (labelName && S.labelMap.has(labelName)) {
-      target = S.labelMap.get(labelName).exitBlock;
-    } else if (S.loopStack.length > 0) {
-      target = S.loopStack[S.loopStack.length - 1].exitBlock;
-    }
+// ── If / else-if / else ─────────────────────────────────────────────────
+
+function processIf(ifStmt, currentBlock, S, cfgRules) {
+  currentBlock.endLine = ifStmt.startPosition.row + 1;
+
+  const condBlock = S.makeBlock(
+    'condition',
+    ifStmt.startPosition.row + 1,
+    ifStmt.startPosition.row + 1,
+    'if',
+  );
+  S.addEdge(currentBlock, condBlock, 'fallthrough');
+
+  const joinBlock = S.makeBlock('body');
+
+  // True branch
+  const consequentField = cfgRules.ifConsequentField || 'consequence';
+  const consequent = ifStmt.childForFieldName(consequentField);
+  const trueBlock = S.makeBlock('branch_true', null, null, 'then');
+  S.addEdge(condBlock, trueBlock, 'branch_true');
+  const trueStmts = getBodyStatements(consequent, cfgRules);
+  const trueEnd = processStatements(trueStmts, trueBlock, S, cfgRules);
+  if (trueEnd) {
+    S.addEdge(trueEnd, joinBlock, 'fallthrough');
+  }
 
-    if (target) {
-      currentBlock.endLine = node.startPosition.row + 1;
-      S.addEdge(currentBlock, target, 'break');
-      return null;
-    }
-    return currentBlock;
+  // False branch
+  if (cfgRules.elifNode) {
+    processElifSiblings(ifStmt, condBlock, joinBlock, S, cfgRules);
+  } else {
+    processAlternative(ifStmt, condBlock, joinBlock, S, cfgRules);
   }
 
-  function processContinue(node, currentBlock) {
-    const labelNode = node.childForFieldName('label');
-    const labelName = labelNode ? labelNode.text : null;
+  return joinBlock;
+}
 
-    let target = null;
-    if (labelName && S.labelMap.has(labelName)) {
-      target = S.labelMap.get(labelName).headerBlock;
-    } else if (S.loopStack.length > 0) {
-      target = S.loopStack[S.loopStack.length - 1].headerBlock;
-    }
+function processAlternative(ifStmt, condBlock, joinBlock, S, cfgRules) {
+  const alternative = ifStmt.childForFieldName('alternative');
+  if (!alternative) {
+    S.addEdge(condBlock, joinBlock, 'branch_false');
+    return;
+  }
 
-    if (target) {
-      currentBlock.endLine = node.startPosition.row + 1;
-      S.addEdge(currentBlock, target, 'continue');
-      return null;
+  if (cfgRules.elseViaAlternative && alternative.type !== cfgRules.elseClause) {
+    // Pattern C: direct alternative (Go, Java, C#)
+    if (isIfNode(alternative.type, cfgRules)) {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const elseIfEnd = processIf(alternative, falseBlock, S, cfgRules);
+      if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
+    } else {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const falseStmts = getBodyStatements(alternative, cfgRules);
+      const falseEnd = processStatements(falseStmts, falseBlock, S, cfgRules);
+      if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
+    }
+  } else if (alternative.type === cfgRules.elseClause) {
+    // Pattern A: else_clause wrapper (JS/TS, Rust)
+    const elseChildren = [];
+    for (let i = 0; i < alternative.namedChildCount; i++) {
+      elseChildren.push(alternative.namedChild(i));
+    }
+    if (elseChildren.length === 1 && isIfNode(elseChildren[0].type, cfgRules)) {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const elseIfEnd = processIf(elseChildren[0], falseBlock, S, cfgRules);
+      if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
+    } else {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const falseEnd = processStatements(elseChildren, falseBlock, S, cfgRules);
+      if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
     }
-    return currentBlock;
   }
+}
 
-  // ── If/else-if/else ─────────────────────────────────────────────────
-
-  function processIf(ifStmt, currentBlock) {
-    currentBlock.endLine = ifStmt.startPosition.row + 1;
+function processElifSiblings(ifStmt, firstCondBlock, joinBlock, S, cfgRules) {
+  let lastCondBlock = firstCondBlock;
+  let foundElse = false;
 
-    const condBlock = S.makeBlock(
-      'condition',
-      ifStmt.startPosition.row + 1,
-      ifStmt.startPosition.row + 1,
-      'if',
-    );
-    S.addEdge(currentBlock, condBlock, 'fallthrough');
-
-    const joinBlock = S.makeBlock('body');
-
-    // True branch
-    const consequentField = cfgRules.ifConsequentField || 'consequence';
-    const consequent = ifStmt.childForFieldName(consequentField);
-    const trueBlock = S.makeBlock('branch_true', null, null, 'then');
-    S.addEdge(condBlock, trueBlock, 'branch_true');
-    const trueStmts = getBodyStatements(consequent);
-    const trueEnd = processStatements(trueStmts, trueBlock);
-    if (trueEnd) {
-      S.addEdge(trueEnd, joinBlock, 'fallthrough');
-    }
+  for (let i = 0; i < ifStmt.namedChildCount; i++) {
+    const child = ifStmt.namedChild(i);
 
-    // False branch
-    if (cfgRules.elifNode) {
-      processElifSiblings(ifStmt, condBlock, joinBlock);
-    } else {
-      const alternative = ifStmt.childForFieldName('alternative');
-      if (alternative) {
-        if (cfgRules.elseViaAlternative && alternative.type !== cfgRules.elseClause) {
-          // Pattern C: direct alternative (Go, Java, C#)
-          if (isIfNode(alternative.type)) {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const elseIfEnd = processIf(alternative, falseBlock);
-            if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
-          } else {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const falseStmts = getBodyStatements(alternative);
-            const falseEnd = processStatements(falseStmts, falseBlock);
-            if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
-          }
-        } else if (alternative.type === cfgRules.elseClause) {
-          // Pattern A: else_clause wrapper (JS/TS, Rust)
-          const elseChildren = [];
-          for (let i = 0; i < alternative.namedChildCount; i++) {
-            elseChildren.push(alternative.namedChild(i));
-          }
-          if (elseChildren.length === 1 && isIfNode(elseChildren[0].type)) {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const elseIfEnd = processIf(elseChildren[0], falseBlock);
-            if (elseIfEnd) S.addEdge(elseIfEnd, joinBlock, 'fallthrough');
-          } else {
-            const falseBlock = S.makeBlock('branch_false', null, null, 'else');
-            S.addEdge(condBlock, falseBlock, 'branch_false');
-            const falseEnd = processStatements(elseChildren, falseBlock);
-            if (falseEnd) S.addEdge(falseEnd, joinBlock, 'fallthrough');
-          }
-        }
+    if (child.type === cfgRules.elifNode) {
+      const elifCondBlock = S.makeBlock(
+        'condition',
+        child.startPosition.row + 1,
+        child.startPosition.row + 1,
+        'else-if',
+      );
+      S.addEdge(lastCondBlock, elifCondBlock, 'branch_false');
+
+      const elifConsequentField = cfgRules.ifConsequentField || 'consequence';
+      const elifConsequent = child.childForFieldName(elifConsequentField);
+      const elifTrueBlock = S.makeBlock('branch_true', null, null, 'then');
+      S.addEdge(elifCondBlock, elifTrueBlock, 'branch_true');
+      const elifTrueStmts = getBodyStatements(elifConsequent, cfgRules);
+      const elifTrueEnd = processStatements(elifTrueStmts, elifTrueBlock, S, cfgRules);
+      if (elifTrueEnd) S.addEdge(elifTrueEnd, joinBlock, 'fallthrough');
+
+      lastCondBlock = elifCondBlock;
+    } else if (child.type === cfgRules.elseClause) {
+      const elseBlock = S.makeBlock('branch_false', null, null, 'else');
+      S.addEdge(lastCondBlock, elseBlock, 'branch_false');
+
+      const elseBody = child.childForFieldName('body');
+      let elseStmts;
+      if (elseBody) {
+        elseStmts = getBodyStatements(elseBody, cfgRules);
       } else {
-        // No else
-        S.addEdge(condBlock, joinBlock, 'branch_false');
-      }
-    }
-
-    return joinBlock;
-  }
-
-  function processElifSiblings(ifStmt, firstCondBlock, joinBlock) {
-    let lastCondBlock = firstCondBlock;
-    let foundElse = false;
-
-    for (let i = 0; i < ifStmt.namedChildCount; i++) {
-      const child = ifStmt.namedChild(i);
-
-      if (child.type === cfgRules.elifNode) {
-        const elifCondBlock = S.makeBlock(
-          'condition',
-          child.startPosition.row + 1,
-          child.startPosition.row + 1,
-          'else-if',
-        );
-        S.addEdge(lastCondBlock, elifCondBlock, 'branch_false');
-
-        const elifConsequentField = cfgRules.ifConsequentField || 'consequence';
-        const elifConsequent = child.childForFieldName(elifConsequentField);
-        const elifTrueBlock = S.makeBlock('branch_true', null, null, 'then');
-        S.addEdge(elifCondBlock, elifTrueBlock, 'branch_true');
-        const elifTrueStmts = getBodyStatements(elifConsequent);
-        const elifTrueEnd = processStatements(elifTrueStmts, elifTrueBlock);
-        if (elifTrueEnd) S.addEdge(elifTrueEnd, joinBlock, 'fallthrough');
-
-        lastCondBlock = elifCondBlock;
-      } else if (child.type === cfgRules.elseClause) {
-        const elseBlock = S.makeBlock('branch_false', null, null, 'else');
-        S.addEdge(lastCondBlock, elseBlock, 'branch_false');
-
-        const elseBody = child.childForFieldName('body');
-        let elseStmts;
-        if (elseBody) {
-          elseStmts = getBodyStatements(elseBody);
-        } else {
-          elseStmts = [];
-          for (let j = 0; j < child.namedChildCount; j++) {
-            elseStmts.push(child.namedChild(j));
-          }
+        elseStmts = [];
+        for (let j = 0; j < child.namedChildCount; j++) {
+          elseStmts.push(child.namedChild(j));
         }
-        const elseEnd = processStatements(elseStmts, elseBlock);
-        if (elseEnd) S.addEdge(elseEnd, joinBlock, 'fallthrough');
-
-        foundElse = true;
       }
-    }
+      const elseEnd = processStatements(elseStmts, elseBlock, S, cfgRules);
+      if (elseEnd) S.addEdge(elseEnd, joinBlock, 'fallthrough');
 
-    if (!foundElse) {
-      S.addEdge(lastCondBlock, joinBlock, 'branch_false');
+      foundElse = true;
     }
   }
 
-  // ── Loops ───────────────────────────────────────────────────────────
-
-  function processForLoop(forStmt, currentBlock) {
-    const headerBlock = S.makeBlock(
-      'loop_header',
-      forStmt.startPosition.row + 1,
-      forStmt.startPosition.row + 1,
-      'for',
-    );
-    S.addEdge(currentBlock, headerBlock, 'fallthrough');
-
-    const loopExitBlock = S.makeBlock('body');
-    const loopCtx = { headerBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(headerBlock, loopExitBlock);
+  if (!foundElse) {
+    S.addEdge(lastCondBlock, joinBlock, 'branch_false');
+  }
+}
 
-    const body = forStmt.childForFieldName('body');
-    const bodyBlock = S.makeBlock('loop_body');
-    S.addEdge(headerBlock, bodyBlock, 'branch_true');
+// ── Loops ───────────────────────────────────────────────────────────────
+
+function processForLoop(forStmt, currentBlock, S, cfgRules) {
+  const headerBlock = S.makeBlock(
+    'loop_header',
+    forStmt.startPosition.row + 1,
+    forStmt.startPosition.row + 1,
+    'for',
+  );
+  S.addEdge(currentBlock, headerBlock, 'fallthrough');
+
+  const loopExitBlock = S.makeBlock('body');
+  const loopCtx = { headerBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, headerBlock, loopExitBlock);
+
+  const body = forStmt.childForFieldName('body');
+  const bodyBlock = S.makeBlock('loop_body');
+  S.addEdge(headerBlock, bodyBlock, 'branch_true');
+
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+
+  S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+function processWhileLoop(whileStmt, currentBlock, S, cfgRules) {
+  const headerBlock = S.makeBlock(
+    'loop_header',
+    whileStmt.startPosition.row + 1,
+    whileStmt.startPosition.row + 1,
+    'while',
+  );
+  S.addEdge(currentBlock, headerBlock, 'fallthrough');
+
+  const loopExitBlock = S.makeBlock('body');
+  const loopCtx = { headerBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, headerBlock, loopExitBlock);
+
+  const body = whileStmt.childForFieldName('body');
+  const bodyBlock = S.makeBlock('loop_body');
+  S.addEdge(headerBlock, bodyBlock, 'branch_true');
+
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+
+  S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-    S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
-    S.loopStack.pop();
-    return loopExitBlock;
-  }
+function processDoWhileLoop(doStmt, currentBlock, S, cfgRules) {
+  const bodyBlock = S.makeBlock('loop_body', doStmt.startPosition.row + 1, null, 'do');
+  S.addEdge(currentBlock, bodyBlock, 'fallthrough');
 
-  function processWhileLoop(whileStmt, currentBlock) {
-    const headerBlock = S.makeBlock(
-      'loop_header',
-      whileStmt.startPosition.row + 1,
-      whileStmt.startPosition.row + 1,
-      'while',
-    );
-    S.addEdge(currentBlock, headerBlock, 'fallthrough');
+  const condBlock = S.makeBlock('loop_header', null, null, 'do-while');
+  const loopExitBlock = S.makeBlock('body');
 
-    const loopExitBlock = S.makeBlock('body');
-    const loopCtx = { headerBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(headerBlock, loopExitBlock);
+  const loopCtx = { headerBlock: condBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, condBlock, loopExitBlock);
 
-    const body = whileStmt.childForFieldName('body');
-    const bodyBlock = S.makeBlock('loop_body');
-    S.addEdge(headerBlock, bodyBlock, 'branch_true');
+  const body = doStmt.childForFieldName('body');
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, condBlock, 'fallthrough');
 
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+  S.addEdge(condBlock, bodyBlock, 'loop_back');
+  S.addEdge(condBlock, loopExitBlock, 'loop_exit');
 
-    S.addEdge(headerBlock, loopExitBlock, 'loop_exit');
-    S.loopStack.pop();
-    return loopExitBlock;
-  }
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-  function processDoWhileLoop(doStmt, currentBlock) {
-    const bodyBlock = S.makeBlock('loop_body', doStmt.startPosition.row + 1, null, 'do');
-    S.addEdge(currentBlock, bodyBlock, 'fallthrough');
+function processInfiniteLoop(loopStmt, currentBlock, S, cfgRules) {
+  const headerBlock = S.makeBlock(
+    'loop_header',
+    loopStmt.startPosition.row + 1,
+    loopStmt.startPosition.row + 1,
+    'loop',
+  );
+  S.addEdge(currentBlock, headerBlock, 'fallthrough');
+
+  const loopExitBlock = S.makeBlock('body');
+  const loopCtx = { headerBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, headerBlock, loopExitBlock);
+
+  const body = loopStmt.childForFieldName('body');
+  const bodyBlock = S.makeBlock('loop_body');
+  S.addEdge(headerBlock, bodyBlock, 'branch_true');
+
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+
+  // No loop_exit from header — only via break
+  S.loopStack.pop();
+  return loopExitBlock;
+}
 
-    const condBlock = S.makeBlock('loop_header', null, null, 'do-while');
-    const loopExitBlock = S.makeBlock('body');
+// ── Switch / match ──────────────────────────────────────────────────────
 
-    const loopCtx = { headerBlock: condBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(condBlock, loopExitBlock);
+function processSwitch(switchStmt, currentBlock, S, cfgRules) {
+  currentBlock.endLine = switchStmt.startPosition.row + 1;
 
-    const body = doStmt.childForFieldName('body');
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, condBlock, 'fallthrough');
+  const switchHeader = S.makeBlock(
+    'condition',
+    switchStmt.startPosition.row + 1,
+    switchStmt.startPosition.row + 1,
+    'switch',
+  );
+  S.addEdge(currentBlock, switchHeader, 'fallthrough');
 
-    S.addEdge(condBlock, bodyBlock, 'loop_back');
-    S.addEdge(condBlock, loopExitBlock, 'loop_exit');
+  const joinBlock = S.makeBlock('body');
+  const switchCtx = { headerBlock: switchHeader, exitBlock: joinBlock };
+  S.loopStack.push(switchCtx);
 
-    S.loopStack.pop();
-    return loopExitBlock;
-  }
+  const switchBody = switchStmt.childForFieldName('body');
+  const container = switchBody || switchStmt;
 
-  function processInfiniteLoop(loopStmt, currentBlock) {
-    const headerBlock = S.makeBlock(
-      'loop_header',
-      loopStmt.startPosition.row + 1,
-      loopStmt.startPosition.row + 1,
-      'loop',
-    );
-    S.addEdge(currentBlock, headerBlock, 'fallthrough');
+  let hasDefault = false;
+  for (let i = 0; i < container.namedChildCount; i++) {
+    const caseClause = container.namedChild(i);
 
-    const loopExitBlock = S.makeBlock('body');
-    const loopCtx = { headerBlock, exitBlock: loopExitBlock };
-    S.loopStack.push(loopCtx);
-    registerLabelCtx(headerBlock, loopExitBlock);
+    const isDefault = caseClause.type === cfgRules.defaultNode;
+    const isCase = isDefault || isCaseNode(caseClause.type, cfgRules);
+    if (!isCase) continue;
 
-    const body = loopStmt.childForFieldName('body');
-    const bodyBlock = S.makeBlock('loop_body');
-    S.addEdge(headerBlock, bodyBlock, 'branch_true');
+    const caseLabel = isDefault ? 'default' : 'case';
+    const caseBlock = S.makeBlock('case', caseClause.startPosition.row + 1, null, caseLabel);
+    S.addEdge(switchHeader, caseBlock, isDefault ? 'branch_false' : 'branch_true');
+    if (isDefault) hasDefault = true;
 
-    const bodyStmts = getBodyStatements(body);
-    const bodyEnd = processStatements(bodyStmts, bodyBlock);
-    if (bodyEnd) S.addEdge(bodyEnd, headerBlock, 'loop_back');
+    const caseStmts = extractCaseBody(caseClause, cfgRules);
+    const caseEnd = processStatements(caseStmts, caseBlock, S, cfgRules);
+    if (caseEnd) S.addEdge(caseEnd, joinBlock, 'fallthrough');
+  }
 
-    // No loop_exit from header — only via break
-    S.loopStack.pop();
-    return loopExitBlock;
+  if (!hasDefault) {
+    S.addEdge(switchHeader, joinBlock, 'branch_false');
   }
 
-  // ── Switch / match ──────────────────────────────────────────────────
+  S.loopStack.pop();
+  return joinBlock;
+}
 
-  function processSwitch(switchStmt, currentBlock) {
-    currentBlock.endLine = switchStmt.startPosition.row + 1;
+function extractCaseBody(caseClause, cfgRules) {
+  const caseBodyNode =
+    caseClause.childForFieldName('body') || caseClause.childForFieldName('consequence');
+  if (caseBodyNode) {
+    return getBodyStatements(caseBodyNode, cfgRules);
+  }
 
-    const switchHeader = S.makeBlock(
-      'condition',
-      switchStmt.startPosition.row + 1,
-      switchStmt.startPosition.row + 1,
-      'switch',
-    );
-    S.addEdge(currentBlock, switchHeader, 'fallthrough');
-
-    const joinBlock = S.makeBlock('body');
-    const switchCtx = { headerBlock: switchHeader, exitBlock: joinBlock };
-    S.loopStack.push(switchCtx);
-
-    const switchBody = switchStmt.childForFieldName('body');
-    const container = switchBody || switchStmt;
-
-    let hasDefault = false;
-    for (let i = 0; i < container.namedChildCount; i++) {
-      const caseClause = container.namedChild(i);
-
-      const isDefault = caseClause.type === cfgRules.defaultNode;
-      const isCase = isDefault || isCaseNode(caseClause.type);
-      if (!isCase) continue;
-
-      const caseLabel = isDefault ? 'default' : 'case';
-      const caseBlock = S.makeBlock('case', caseClause.startPosition.row + 1, null, caseLabel);
-      S.addEdge(switchHeader, caseBlock, isDefault ? 'branch_false' : 'branch_true');
-      if (isDefault) hasDefault = true;
-
-      // Extract case body
-      const caseBodyNode =
-        caseClause.childForFieldName('body') || caseClause.childForFieldName('consequence');
-      let caseStmts;
-      if (caseBodyNode) {
-        caseStmts = getBodyStatements(caseBodyNode);
-      } else {
-        caseStmts = [];
-        const valueNode = caseClause.childForFieldName('value');
-        const patternNode = caseClause.childForFieldName('pattern');
-        for (let j = 0; j < caseClause.namedChildCount; j++) {
-          const child = caseClause.namedChild(j);
-          if (child !== valueNode && child !== patternNode && child.type !== 'switch_label') {
-            if (child.type === 'statement_list') {
-              for (let k = 0; k < child.namedChildCount; k++) {
-                caseStmts.push(child.namedChild(k));
-              }
-            } else {
-              caseStmts.push(child);
-            }
-          }
+  const stmts = [];
+  const valueNode = caseClause.childForFieldName('value');
+  const patternNode = caseClause.childForFieldName('pattern');
+  for (let j = 0; j < caseClause.namedChildCount; j++) {
+    const child = caseClause.namedChild(j);
+    if (child !== valueNode && child !== patternNode && child.type !== 'switch_label') {
+      if (child.type === 'statement_list') {
+        for (let k = 0; k < child.namedChildCount; k++) {
+          stmts.push(child.namedChild(k));
         }
+      } else {
+        stmts.push(child);
       }
-
-      const caseEnd = processStatements(caseStmts, caseBlock);
-      if (caseEnd) S.addEdge(caseEnd, joinBlock, 'fallthrough');
     }
+  }
+  return stmts;
+}
 
-    if (!hasDefault) {
-      S.addEdge(switchHeader, joinBlock, 'branch_false');
-    }
+// ── Try / catch / finally ───────────────────────────────────────────────
+
+function processTryCatch(tryStmt, currentBlock, S, cfgRules) {
+  currentBlock.endLine = tryStmt.startPosition.row + 1;
 
-    S.loopStack.pop();
-    return joinBlock;
+  const joinBlock = S.makeBlock('body');
+
+  // Try body
+  const tryBody = tryStmt.childForFieldName('body');
+  let tryBodyStart;
+  let tryStmts;
+  if (tryBody) {
+    tryBodyStart = tryBody.startPosition.row + 1;
+    tryStmts = getBodyStatements(tryBody, cfgRules);
+  } else {
+    tryBodyStart = tryStmt.startPosition.row + 1;
+    tryStmts = [];
+    for (let i = 0; i < tryStmt.namedChildCount; i++) {
+      const child = tryStmt.namedChild(i);
+      if (cfgRules.catchNode && child.type === cfgRules.catchNode) continue;
+      if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) continue;
+      tryStmts.push(child);
+    }
   }
 
-  // ── Try/catch/finally ───────────────────────────────────────────────
+  const tryBlock = S.makeBlock('body', tryBodyStart, null, 'try');
+  S.addEdge(currentBlock, tryBlock, 'fallthrough');
+  const tryEnd = processStatements(tryStmts, tryBlock, S, cfgRules);
 
-  function processTryCatch(tryStmt, currentBlock) {
-    currentBlock.endLine = tryStmt.startPosition.row + 1;
+  // Find catch and finally handlers
+  const { catchHandler, finallyHandler } = findTryHandlers(tryStmt, cfgRules);
 
-    const joinBlock = S.makeBlock('body');
+  if (catchHandler) {
+    processCatchHandler(catchHandler, tryBlock, tryEnd, finallyHandler, joinBlock, S, cfgRules);
+  } else if (finallyHandler) {
+    processFinallyOnly(finallyHandler, tryEnd, joinBlock, S, cfgRules);
+  } else {
+    if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
+  }
 
-    // Try body
-    const tryBody = tryStmt.childForFieldName('body');
-    let tryBodyStart;
-    let tryStmts;
-    if (tryBody) {
-      tryBodyStart = tryBody.startPosition.row + 1;
-      tryStmts = getBodyStatements(tryBody);
-    } else {
-      tryBodyStart = tryStmt.startPosition.row + 1;
-      tryStmts = [];
-      for (let i = 0; i < tryStmt.namedChildCount; i++) {
-        const child = tryStmt.namedChild(i);
-        if (cfgRules.catchNode && child.type === cfgRules.catchNode) continue;
-        if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) continue;
-        tryStmts.push(child);
-      }
-    }
+  return joinBlock;
+}
 
-    const tryBlock = S.makeBlock('body', tryBodyStart, null, 'try');
-    S.addEdge(currentBlock, tryBlock, 'fallthrough');
-    const tryEnd = processStatements(tryStmts, tryBlock);
+function findTryHandlers(tryStmt, cfgRules) {
+  let catchHandler = null;
+  let finallyHandler = null;
+  for (let i = 0; i < tryStmt.namedChildCount; i++) {
+    const child = tryStmt.namedChild(i);
+    if (cfgRules.catchNode && child.type === cfgRules.catchNode) catchHandler = child;
+    if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) finallyHandler = child;
+  }
+  return { catchHandler, finallyHandler };
+}
 
-    // Find catch and finally handlers
-    let catchHandler = null;
-    let finallyHandler = null;
-    for (let i = 0; i < tryStmt.namedChildCount; i++) {
-      const child = tryStmt.namedChild(i);
-      if (cfgRules.catchNode && child.type === cfgRules.catchNode) catchHandler = child;
-      if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) finallyHandler = child;
+function processCatchHandler(
+  catchHandler,
+  tryBlock,
+  tryEnd,
+  finallyHandler,
+  joinBlock,
+  S,
+  cfgRules,
+) {
+  const catchBlock = S.makeBlock('catch', catchHandler.startPosition.row + 1, null, 'catch');
+  S.addEdge(tryBlock, catchBlock, 'exception');
+
+  const catchBodyNode = catchHandler.childForFieldName('body');
+  let catchStmts;
+  if (catchBodyNode) {
+    catchStmts = getBodyStatements(catchBodyNode, cfgRules);
+  } else {
+    catchStmts = [];
+    for (let i = 0; i < catchHandler.namedChildCount; i++) {
+      catchStmts.push(catchHandler.namedChild(i));
     }
+  }
+  const catchEnd = processStatements(catchStmts, catchBlock, S, cfgRules);
+
+  if (finallyHandler) {
+    const finallyBlock = S.makeBlock(
+      'finally',
+      finallyHandler.startPosition.row + 1,
+      null,
+      'finally',
+    );
+    if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
+    if (catchEnd) S.addEdge(catchEnd, finallyBlock, 'fallthrough');
+
+    const finallyBodyNode = finallyHandler.childForFieldName('body');
+    const finallyStmts = finallyBodyNode
+      ? getBodyStatements(finallyBodyNode, cfgRules)
+      : getBodyStatements(finallyHandler, cfgRules);
+    const finallyEnd = processStatements(finallyStmts, finallyBlock, S, cfgRules);
+    if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
+  } else {
+    if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
+    if (catchEnd) S.addEdge(catchEnd, joinBlock, 'fallthrough');
+  }
+}
 
-    if (catchHandler) {
-      const catchBlock = S.makeBlock('catch', catchHandler.startPosition.row + 1, null, 'catch');
-      S.addEdge(tryBlock, catchBlock, 'exception');
+function processFinallyOnly(finallyHandler, tryEnd, joinBlock, S, cfgRules) {
+  const finallyBlock = S.makeBlock(
+    'finally',
+    finallyHandler.startPosition.row + 1,
+    null,
+    'finally',
+  );
+  if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
+
+  const finallyBodyNode = finallyHandler.childForFieldName('body');
+  const finallyStmts = finallyBodyNode
+    ? getBodyStatements(finallyBodyNode, cfgRules)
+    : getBodyStatements(finallyHandler, cfgRules);
+  const finallyEnd = processStatements(finallyStmts, finallyBlock, S, cfgRules);
+  if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
+}
 
-      const catchBodyNode = catchHandler.childForFieldName('body');
-      let catchStmts;
-      if (catchBodyNode) {
-        catchStmts = getBodyStatements(catchBodyNode);
-      } else {
-        catchStmts = [];
-        for (let i = 0; i < catchHandler.namedChildCount; i++) {
-          catchStmts.push(catchHandler.namedChild(i));
-        }
-      }
-      const catchEnd = processStatements(catchStmts, catchBlock);
-
-      if (finallyHandler) {
-        const finallyBlock = S.makeBlock(
-          'finally',
-          finallyHandler.startPosition.row + 1,
-          null,
-          'finally',
-        );
-        if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
-        if (catchEnd) S.addEdge(catchEnd, finallyBlock, 'fallthrough');
-
-        const finallyBodyNode = finallyHandler.childForFieldName('body');
-        const finallyStmts = finallyBodyNode
-          ? getBodyStatements(finallyBodyNode)
-          : getBodyStatements(finallyHandler);
-        const finallyEnd = processStatements(finallyStmts, finallyBlock);
-        if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
-      } else {
-        if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
-        if (catchEnd) S.addEdge(catchEnd, joinBlock, 'fallthrough');
-      }
-    } else if (finallyHandler) {
-      const finallyBlock = S.makeBlock(
-        'finally',
-        finallyHandler.startPosition.row + 1,
-        null,
-        'finally',
-      );
-      if (tryEnd) S.addEdge(tryEnd, finallyBlock, 'fallthrough');
-
-      const finallyBodyNode = finallyHandler.childForFieldName('body');
-      const finallyStmts = finallyBodyNode
-        ? getBodyStatements(finallyBodyNode)
-        : getBodyStatements(finallyHandler);
-      const finallyEnd = processStatements(finallyStmts, finallyBlock);
-      if (finallyEnd) S.addEdge(finallyEnd, joinBlock, 'fallthrough');
-    } else {
-      if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
-    }
+// ── Enter-function body processing ──────────────────────────────────────
+
+function processFunctionBody(funcNode, S, cfgRules) {
+  const body = funcNode.childForFieldName('body');
+  if (!body) {
+    // No body — entry → exit
+    S.blocks.length = 2;
+    S.edges.length = 0;
+    S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
+    S.currentBlock = null;
+    return;
+  }
 
-    return joinBlock;
+  if (!isBlockNode(body.type, cfgRules)) {
+    // Expression body (e.g., arrow function `(x) => x + 1`)
+    const bodyBlock = S.blocks[2];
+    bodyBlock.startLine = body.startPosition.row + 1;
+    bodyBlock.endLine = body.endPosition.row + 1;
+    S.addEdge(bodyBlock, S.exitBlock, 'fallthrough');
+    S.currentBlock = null;
+    return;
   }
 
-  // ── Visitor interface ───────────────────────────────────────────────
+  // Block body — process statements
+  const stmts = getBodyStatements(body, cfgRules);
+  if (stmts.length === 0) {
+    S.blocks.length = 2;
+    S.edges.length = 0;
+    S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
+    S.currentBlock = null;
+    return;
+  }
+
+  const firstBody = S.blocks[2];
+  const lastBlock = processStatements(stmts, firstBody, S, cfgRules);
+  if (lastBlock) {
+    S.addEdge(lastBlock, S.exitBlock, 'fallthrough');
+  }
+  S.currentBlock = null;
+}
+
+// ── Visitor factory ─────────────────────────────────────────────────────
+
+/**
+ * Create a CFG visitor for use with walkWithVisitors.
+ *
+ * @param {object} cfgRules - CFG_RULES for the language
+ * @returns {Visitor}
+ */
+export function createCfgVisitor(cfgRules) {
+  const funcStateStack = [];
+  let S = null;
+  const results = [];
 
   return {
     name: 'cfg',
     functionNodeTypes: cfgRules.functionNodes,
 
     enterFunction(funcNode, _funcName, _context) {
-      if (S) {
-        // Nested function — push current state
-        funcStateStack.push(S);
-      }
+      if (S) funcStateStack.push(S);
       S = makeFuncState();
       S.funcNode = funcNode;
-
-      // Check for expression body (arrow functions): no block body
-      const body = funcNode.childForFieldName('body');
-      if (!body) {
-        // No body at all — entry → exit
-        // Remove the firstBody block and its edge
-        S.blocks.length = 2; // keep entry + exit
-        S.edges.length = 0;
-        S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
-        S.currentBlock = null;
-        return;
-      }
-
-      if (!isBlockNode(body.type)) {
-        // Expression body (e.g., arrow function `(x) => x + 1`)
-        // entry → body → exit (body is the expression)
-        const bodyBlock = S.blocks[2]; // the firstBody we already created
-        bodyBlock.startLine = body.startPosition.row + 1;
-        bodyBlock.endLine = body.endPosition.row + 1;
-        S.addEdge(bodyBlock, S.exitBlock, 'fallthrough');
-        S.currentBlock = null; // no further processing needed
-        return;
-      }
-
-      // Block body — process statements
-      const stmts = getBodyStatements(body);
-      if (stmts.length === 0) {
-        // Empty function
-        S.blocks.length = 2;
-        S.edges.length = 0;
-        S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
-        S.currentBlock = null;
-        return;
-      }
-
-      // Process all body statements using the statement-level processor
-      const firstBody = S.blocks[2]; // the firstBody block
-      const lastBlock = processStatements(stmts, firstBody);
-      if (lastBlock) {
-        S.addEdge(lastBlock, S.exitBlock, 'fallthrough');
-      }
-      S.currentBlock = null; // done processing
+      processFunctionBody(funcNode, S, cfgRules);
     },
 
     exitFunction(funcNode, _funcName, _context) {
       if (S && S.funcNode === funcNode) {
-        // Derive cyclomatic complexity from CFG: E - N + 2
         const cyclomatic = S.edges.length - S.blocks.length + 2;
         results.push({
           funcNode: S.funcNode,
@@ -768,21 +758,17 @@ export function createCfgVisitor(cfgRules) {
           cyclomatic: Math.max(cyclomatic, 1),
         });
       }
-
-      // Pop to parent function state (if nested)
       S = funcStateStack.length > 0 ? funcStateStack.pop() : null;
     },
 
     enterNode(_node, _context) {
-      // No-op — all CFG construction is done in enterFunction via
-      // processStatements.  We intentionally do NOT return skipChildren here
-      // so that the walker still recurses into children, allowing nested
-      // function definitions to trigger enterFunction/exitFunction and get
-      // their own CFG computed via the funcStateStack.
+      // No-op — all CFG construction is done in enterFunction via processStatements.
+      // We intentionally do NOT return skipChildren so the walker recurses into
+      // children, allowing nested functions to trigger enterFunction/exitFunction.
     },
 
     exitNode(_node, _context) {
-      // No-op — all work done in enterFunction/exitFunction
+      // No-op
     },
 
     finish() {