optave-codegraph 3.13.0

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

@@ -0,0 +1,334 @@
+import type {
+  Definition,
+  EnterNodeResult,
+  TreeSitterNode,
+  Visitor,
+  VisitorContext,
+} from '../../types.js';
+import type { AstStringConfig } from '../rules/index.js';
+
+const TEXT_MAX = 200;
+
+// ── Cross-language node-type constants (mirror Rust `helpers.rs`) ────────
+const IDENT_TYPES = new Set<string>([
+  'identifier',
+  'type_identifier',
+  'name',
+  'qualified_name',
+  'scoped_identifier',
+  'qualified_identifier',
+  'member_expression',
+  'member_access_expression',
+  'field_expression',
+  'attribute',
+  'scoped_type_identifier',
+]);
+
+const CALL_TYPES = new Set<string>([
+  'call_expression',
+  'call',
+  'invocation_expression',
+  'method_invocation',
+  'function_call_expression',
+  'member_call_expression',
+  'scoped_call_expression',
+]);
+
+const DEFAULT_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"`', stringPrefixes: '' };
+
+// Keyword tokens skipped when extracting the inner expression text of a
+// throw/raise/await/new node. Module-level constant avoids reallocating on
+// every call (can be hot in large files).
+const CHILD_EXPR_SKIP_KEYWORDS = new Set<string>(['throw', 'raise', 'await', 'new']);
+
+interface AstStoreRow {
+  file: string;
+  line: number;
+  kind: string;
+  name: string | null | undefined;
+  text: string | null;
+  receiver: string | null;
+  parentNodeId: number | null;
+}
+
+function truncate(s: string | null | undefined, max: number = TEXT_MAX): string | null {
+  if (!s) return null;
+  return s.length <= max ? s : `${s.slice(0, max - 1)}…`;
+}
+
+function trimLeadingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = 0;
+  while (i < s.length && chars.includes(s[i]!)) i++;
+  return i === 0 ? s : s.slice(i);
+}
+
+function trimTrailingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = s.length;
+  while (i > 0 && chars.includes(s[i - 1]!)) i--;
+  return i === s.length ? s : s.slice(0, i);
+}
+
+/** Extract constructor name from a `new_expression` / `object_creation_expression`. */
+function extractConstructorName(node: TreeSitterNode): string {
+  for (const field of ['type', 'class', 'constructor']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (IDENT_TYPES.has(child.type)) return child.text;
+  }
+  const raw = node.text || '';
+  const beforeParen = raw.split('(')[0] || raw;
+  return beforeParen.replace(/^new\s+/, '').trim() || '?';
+}
+
+/** Extract function name from a call node. */
+function extractCallName(node: TreeSitterNode): string {
+  for (const field of ['function', 'method', 'name']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
+  }
+  const text = node.text || '';
+  return text.split('(')[0] || '?';
+}
+
+/** Extract name from a throw/raise statement — matches native `extract_throw_target`. */
+function extractThrowName(node: TreeSitterNode, newTypes: Set<string>): string {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const ck = child.type;
+    if (newTypes.has(ck)) return extractConstructorName(child);
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
+  }
+  return truncate(node.text) ?? node.text ?? '';
+}
+
+/** Extract name from an await expression — matches native `extract_awaited_name`. */
+function extractAwaitName(node: TreeSitterNode): string {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const ck = child.type;
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
+  }
+  return truncate(node.text) ?? node.text ?? '';
+}
+
+/** Extract text of the expression inside a throw/await, skipping the keyword. */
+function extractChildExpressionText(node: TreeSitterNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (!CHILD_EXPR_SKIP_KEYWORDS.has(child.type)) return truncate(child.text);
+  }
+  return truncate(node.text);
+}
+
+/**
+ * Count code points cheaply: skip the `[...s]` spread when `s.length` already
+ * decides the answer. Each code point is 1 or 2 UTF-16 units, so `.length < 2`
+ * implies `< 2` code points and `.length >= 3` already guarantees `>= 2` code
+ * points (worst case: one surrogate pair + one BMP char = 2 code points).
+ * Only `.length === 2` is genuinely ambiguous (could be a single surrogate
+ * pair = 1 code point, or two BMP chars = 2 code points) and needs the spread.
+ */
+function codePointCountAtLeast2(s: string): boolean {
+  const len = s.length;
+  if (len < 2) return false;
+  if (len >= 3) return true;
+  return [...s].length >= 2;
+}
+
+/**
+ * Extract string content from a string-literal node, mirroring the native
+ * engine's `build_string_node` (`helpers.rs`). Returns `null` when the
+ * content is shorter than 2 Unicode code points.
+ */
+function extractStringContent(node: TreeSitterNode, cfg: AstStringConfig): string | null {
+  const raw = node.text ?? '';
+  const isRawString = node.type.includes('raw_string');
+
+  let s = raw;
+  s = trimLeadingChars(s, '@');
+  if (cfg.stringPrefixes) s = trimLeadingChars(s, cfg.stringPrefixes);
+  if (isRawString) s = trimLeadingChars(s, 'r#');
+  s = trimLeadingChars(s, cfg.quoteChars);
+  if (isRawString) s = trimTrailingChars(s, '#');
+  s = trimTrailingChars(s, cfg.quoteChars);
+
+  return codePointCountAtLeast2(s) ? s : null;
+}
+
+// Per-astTypeMap cache for the set of node-types that map to kind 'new'.
+// Computed once per unique astTypeMap reference (one per language) instead
+// of once per file.
+const _newTypesCache = new WeakMap<Record<string, string>, Set<string>>();
+function newTypesFor(astTypeMap: Record<string, string>): Set<string> {
+  let s = _newTypesCache.get(astTypeMap);
+  if (s) return s;
+  s = new Set<string>();
+  for (const type in astTypeMap) {
+    if (astTypeMap[type] === 'new') s.add(type);
+  }
+  _newTypesCache.set(astTypeMap, s);
+  return s;
+}
+
+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 };
+
+/** 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),
+      text: extractChildExpressionText(node),
+    }),
+    await: (node) => ({ name: extractAwaitName(node), text: extractChildExpressionText(node) }),
+    string: (node) => {
+      const content = extractStringContent(node, stringConfig);
+      if (content == null) return { name: null, text: null, skip: true };
+      return { name: truncate(content, 100), text: truncate(node.text) };
+    },
+    regex: (node) => ({ name: node.text || '?', text: truncate(node.text) }),
+  };
+}
+
+/** 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;
+}
+
+interface CollectCtx {
+  rows: AstStoreRow[];
+  matched: Set<number>;
+  relPath: string;
+  defs: Definition[];
+  nodeIdMap: Map<string, number>;
+  skipParentLookup: boolean;
+  kindHandlers: Record<string, KindHandler>;
+}
+
+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);
+}
+
+/**
+ * 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;
+}
+
+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',
+
+    enterNode(node: TreeSitterNode, _context: VisitorContext): EnterNodeResult | undefined {
+      // 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 (ctx.matched.has(node.id)) return;
+
+      const kind = resolveAstKind(node, astTypeMap);
+      if (!kind) return;
+
+      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
+      // avoid double-counting the wrapped expression (e.g. `throw new
+      // Error('x')` emits one `throw` row, not throw+new+string). Other
+      // languages go through helpers.rs::walk_ast_nodes_with_config_depth
+      // which always recurses — so `stopRecurseKinds` is empty for them.
+      if (stopRecurseKinds.has(kind)) {
+        return { skipChildren: true };
+      }
+    },
+
+    finish(): AstStoreRow[] {
+      return ctx.rows;
+    },
+  };
+}

package/src/ast-analysis/visitors/cfg-conditionals.ts

@@ -0,0 +1,227 @@
+import type { TreeSitterNode } from '../../types.js';
+import type {
+  AnyRules,
+  CfgBlockInternal,
+  FuncState,
+  LoopCtx,
+  ProcessStatementsFn,
+} from './cfg-shared.js';
+import { getBodyStatements, isCaseNode, isIfNode, nn } from './cfg-shared.js';
+
+export function processIf(
+  ifStmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): CfgBlockInternal {
+  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');
+
+  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 (cfgRules.elifNode) {
+    processElifSiblings(ifStmt, condBlock, joinBlock, S, cfgRules, processStatements);
+  } else {
+    processAlternative(ifStmt, condBlock, joinBlock, S, cfgRules, processStatements);
+  }
+
+  return joinBlock;
+}
+
+function processAlternative(
+  ifStmt: TreeSitterNode,
+  condBlock: CfgBlockInternal,
+  joinBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): void {
+  const alternative = ifStmt.childForFieldName('alternative');
+  if (!alternative) {
+    S.addEdge(condBlock, joinBlock, 'branch_false');
+    return;
+  }
+
+  if (cfgRules.elseViaAlternative && alternative.type !== cfgRules.elseClause) {
+    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, processStatements);
+      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) {
+    const elseChildren: TreeSitterNode[] = [];
+    for (let i = 0; i < alternative.namedChildCount; i++) {
+      elseChildren.push(nn(alternative.namedChild(i)));
+    }
+    const firstChild = elseChildren[0];
+    if (elseChildren.length === 1 && firstChild && isIfNode(firstChild.type, cfgRules)) {
+      const falseBlock = S.makeBlock('branch_false', null, null, 'else-if');
+      S.addEdge(condBlock, falseBlock, 'branch_false');
+      const elseIfEnd = processIf(firstChild, falseBlock, S, cfgRules, processStatements);
+      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');
+    }
+  }
+}
+
+function processElifSiblings(
+  ifStmt: TreeSitterNode,
+  firstCondBlock: CfgBlockInternal,
+  joinBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): void {
+  let lastCondBlock = firstCondBlock;
+  let foundElse = false;
+
+  for (let i = 0; i < ifStmt.namedChildCount; i++) {
+    const child = nn(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, 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: TreeSitterNode[];
+      if (elseBody) {
+        elseStmts = getBodyStatements(elseBody, cfgRules);
+      } else {
+        elseStmts = [];
+        for (let j = 0; j < child.namedChildCount; j++) {
+          elseStmts.push(nn(child.namedChild(j)));
+        }
+      }
+      const elseEnd = processStatements(elseStmts, elseBlock, S, cfgRules);
+      if (elseEnd) S.addEdge(elseEnd, joinBlock, 'fallthrough');
+
+      foundElse = true;
+    }
+  }
+
+  if (!foundElse) {
+    S.addEdge(lastCondBlock, joinBlock, 'branch_false');
+  }
+}
+
+export function processSwitch(
+  switchStmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): CfgBlockInternal {
+  currentBlock.endLine = switchStmt.startPosition.row + 1;
+
+  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: LoopCtx = { 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 = nn(container.namedChild(i));
+
+    const isDefault = caseClause.type === cfgRules.defaultNode;
+    const isCase = isDefault || isCaseNode(caseClause.type, cfgRules);
+    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;
+
+    const caseStmts = extractCaseBody(caseClause, cfgRules);
+    const caseEnd = processStatements(caseStmts, caseBlock, S, cfgRules);
+    if (caseEnd) S.addEdge(caseEnd, joinBlock, 'fallthrough');
+  }
+
+  if (!hasDefault) {
+    S.addEdge(switchHeader, joinBlock, 'branch_false');
+  }
+
+  S.loopStack.pop();
+  return joinBlock;
+}
+
+function extractCaseBody(caseClause: TreeSitterNode, cfgRules: AnyRules): TreeSitterNode[] {
+  const caseBodyNode =
+    caseClause.childForFieldName('body') || caseClause.childForFieldName('consequence');
+  if (caseBodyNode) {
+    return getBodyStatements(caseBodyNode, cfgRules);
+  }
+
+  const stmts: TreeSitterNode[] = [];
+  const valueNode = caseClause.childForFieldName('value');
+  const patternNode = caseClause.childForFieldName('pattern');
+  for (let j = 0; j < caseClause.namedChildCount; j++) {
+    const child = nn(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(nn(child.namedChild(k)));
+        }
+      } else {
+        stmts.push(child);
+      }
+    }
+  }
+  return stmts;
+}

package/src/ast-analysis/visitors/cfg-loops.ts

@@ -0,0 +1,136 @@
+import type { TreeSitterNode } from '../../types.js';
+import type {
+  AnyRules,
+  CfgBlockInternal,
+  FuncState,
+  LoopCtx,
+  ProcessStatementsFn,
+} from './cfg-shared.js';
+import { getBodyStatements, registerLabelCtx } from './cfg-shared.js';
+
+export function processForLoop(
+  forStmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): CfgBlockInternal {
+  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: 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;
+}
+
+export function processWhileLoop(
+  whileStmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): CfgBlockInternal {
+  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: 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;
+}
+
+export function processDoWhileLoop(
+  doStmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): CfgBlockInternal {
+  const bodyBlock = S.makeBlock('loop_body', doStmt.startPosition.row + 1, null, 'do');
+  S.addEdge(currentBlock, bodyBlock, 'fallthrough');
+
+  const condBlock = S.makeBlock('loop_header', null, null, 'do-while');
+  const loopExitBlock = S.makeBlock('body');
+
+  const loopCtx: LoopCtx = { headerBlock: condBlock, exitBlock: loopExitBlock };
+  S.loopStack.push(loopCtx);
+  registerLabelCtx(S, condBlock, loopExitBlock);
+
+  const body = doStmt.childForFieldName('body');
+  const bodyStmts = getBodyStatements(body, cfgRules);
+  const bodyEnd = processStatements(bodyStmts, bodyBlock, S, cfgRules);
+  if (bodyEnd) S.addEdge(bodyEnd, condBlock, 'fallthrough');
+
+  S.addEdge(condBlock, bodyBlock, 'loop_back');
+  S.addEdge(condBlock, loopExitBlock, 'loop_exit');
+
+  S.loopStack.pop();
+  return loopExitBlock;
+}
+
+export function processInfiniteLoop(
+  loopStmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): CfgBlockInternal {
+  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: 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');
+
+  S.loopStack.pop();
+  return loopExitBlock;
+}