@optave/codegraph 3.3.1 → 3.4.1

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

@@ -0,0 +1,196 @@
+import type { TreeSitterNode } from '../../types.js';
+
+export type AnyRules = any;
+
+/** Callback type for the mutual recursion with processStatements in cfg-visitor. */
+export type ProcessStatementsFn = (
+  stmts: TreeSitterNode[],
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+) => CfgBlockInternal | null;
+
+export function nn(node: TreeSitterNode | null, context?: string): TreeSitterNode {
+  if (node === null) {
+    throw new Error(`Unexpected null tree-sitter node${context ? ` (${context})` : ''}`);
+  }
+  return node;
+}
+
+export interface CfgBlockInternal {
+  index: number;
+  type: string;
+  startLine: number | null;
+  endLine: number | null;
+  label: string | null;
+}
+
+export interface CfgEdgeInternal {
+  sourceIndex: number;
+  targetIndex: number;
+  kind: string;
+}
+
+export interface LabelCtx {
+  headerBlock: CfgBlockInternal | null;
+  exitBlock: CfgBlockInternal | null;
+}
+
+export interface LoopCtx {
+  headerBlock: CfgBlockInternal;
+  exitBlock: CfgBlockInternal;
+}
+
+export interface FuncState {
+  blocks: CfgBlockInternal[];
+  edges: CfgEdgeInternal[];
+  makeBlock(
+    type: string,
+    startLine?: number | null,
+    endLine?: number | null,
+    label?: string | null,
+  ): CfgBlockInternal;
+  addEdge(source: CfgBlockInternal, target: CfgBlockInternal, kind: string): void;
+  entryBlock: CfgBlockInternal;
+  exitBlock: CfgBlockInternal;
+  currentBlock: CfgBlockInternal | null;
+  loopStack: LoopCtx[];
+  labelMap: Map<string, LabelCtx>;
+  cfgStack: FuncState[];
+  funcNode: TreeSitterNode | null;
+}
+
+export interface CFGResultInternal {
+  funcNode: TreeSitterNode;
+  blocks: CfgBlockInternal[];
+  edges: CfgEdgeInternal[];
+  cyclomatic: number;
+}
+
+export function isIfNode(type: string, cfgRules: AnyRules): boolean {
+  return type === cfgRules.ifNode || cfgRules.ifNodes?.has(type);
+}
+
+export function isForNode(type: string, cfgRules: AnyRules): boolean {
+  return cfgRules.forNodes.has(type);
+}
+
+export function isWhileNode(type: string, cfgRules: AnyRules): boolean {
+  return type === cfgRules.whileNode || cfgRules.whileNodes?.has(type);
+}
+
+export function isSwitchNode(type: string, cfgRules: AnyRules): boolean {
+  return type === cfgRules.switchNode || cfgRules.switchNodes?.has(type);
+}
+
+export function isCaseNode(type: string, cfgRules: AnyRules): boolean {
+  return (
+    type === cfgRules.caseNode || type === cfgRules.defaultNode || cfgRules.caseNodes?.has(type)
+  );
+}
+
+export function isBlockNode(type: string, cfgRules: AnyRules): boolean {
+  return type === 'statement_list' || type === cfgRules.blockNode || cfgRules.blockNodes?.has(type);
+}
+
+export function isControlFlow(type: string, cfgRules: AnyRules): boolean {
+  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
+  );
+}
+
+export function effectiveNode(node: TreeSitterNode, cfgRules: AnyRules): TreeSitterNode {
+  if (node.type === 'expression_statement' && node.namedChildCount === 1) {
+    const inner = nn(node.namedChild(0));
+    if (isControlFlow(inner.type, cfgRules)) return inner;
+  }
+  return node;
+}
+
+export function registerLabelCtx(
+  S: FuncState,
+  headerBlock: CfgBlockInternal,
+  exitBlock: CfgBlockInternal,
+): void {
+  for (const [, ctx] of Array.from(S.labelMap)) {
+    if (!ctx.headerBlock) {
+      ctx.headerBlock = headerBlock;
+      ctx.exitBlock = exitBlock;
+    }
+  }
+}
+
+export function getBodyStatements(
+  bodyNode: TreeSitterNode | null,
+  cfgRules: AnyRules,
+): TreeSitterNode[] {
+  if (!bodyNode) return [];
+  if (isBlockNode(bodyNode.type, cfgRules)) {
+    const stmts: TreeSitterNode[] = [];
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+      const child = nn(bodyNode.namedChild(i));
+      if (child.type === 'statement_list') {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          stmts.push(nn(child.namedChild(j)));
+        }
+      } else {
+        stmts.push(child);
+      }
+    }
+    return stmts;
+  }
+  return [bodyNode];
+}
+
+export function makeFuncState(): FuncState {
+  const blocks: CfgBlockInternal[] = [];
+  const edges: CfgEdgeInternal[] = [];
+  let nextIndex = 0;
+
+  function makeBlock(
+    type: string,
+    startLine: number | null = null,
+    endLine: number | null = null,
+    label: string | null = null,
+  ): CfgBlockInternal {
+    const block: CfgBlockInternal = { index: nextIndex++, type, startLine, endLine, label };
+    blocks.push(block);
+    return block;
+  }
+
+  function addEdge(source: CfgBlockInternal, target: CfgBlockInternal, kind: string): void {
+    edges.push({ sourceIndex: source.index, targetIndex: target.index, kind });
+  }
+
+  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(),
+    cfgStack: [],
+    funcNode: null,
+  };
+}

package/src/ast-analysis/visitors/cfg-try-catch.ts

@@ -0,0 +1,142 @@
+import type { TreeSitterNode } from '../../types.js';
+import type { AnyRules, CfgBlockInternal, FuncState, ProcessStatementsFn } from './cfg-shared.js';
+import { getBodyStatements, nn } from './cfg-shared.js';
+
+export function processTryCatch(
+  tryStmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): CfgBlockInternal {
+  currentBlock.endLine = tryStmt.startPosition.row + 1;
+
+  const joinBlock = S.makeBlock('body');
+
+  const tryBody = tryStmt.childForFieldName('body');
+  let tryBodyStart: number;
+  let tryStmts: TreeSitterNode[];
+  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 = nn(tryStmt.namedChild(i));
+      if (cfgRules.catchNode && child.type === cfgRules.catchNode) continue;
+      if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) continue;
+      tryStmts.push(child);
+    }
+  }
+
+  const tryBlock = S.makeBlock('body', tryBodyStart, null, 'try');
+  S.addEdge(currentBlock, tryBlock, 'fallthrough');
+  const tryEnd = processStatements(tryStmts, tryBlock, S, cfgRules);
+
+  const { catchHandler, finallyHandler } = findTryHandlers(tryStmt, cfgRules);
+
+  if (catchHandler) {
+    processCatchHandler(
+      catchHandler,
+      tryBlock,
+      tryEnd,
+      finallyHandler,
+      joinBlock,
+      S,
+      cfgRules,
+      processStatements,
+    );
+  } else if (finallyHandler) {
+    processFinallyOnly(finallyHandler, tryEnd, joinBlock, S, cfgRules, processStatements);
+  } else {
+    if (tryEnd) S.addEdge(tryEnd, joinBlock, 'fallthrough');
+  }
+
+  return joinBlock;
+}
+
+function findTryHandlers(
+  tryStmt: TreeSitterNode,
+  cfgRules: AnyRules,
+): { catchHandler: TreeSitterNode | null; finallyHandler: TreeSitterNode | null } {
+  let catchHandler: TreeSitterNode | null = null;
+  let finallyHandler: TreeSitterNode | null = null;
+  for (let i = 0; i < tryStmt.namedChildCount; i++) {
+    const child = nn(tryStmt.namedChild(i));
+    if (cfgRules.catchNode && child.type === cfgRules.catchNode) catchHandler = child;
+    if (cfgRules.finallyNode && child.type === cfgRules.finallyNode) finallyHandler = child;
+  }
+  return { catchHandler, finallyHandler };
+}
+
+function processCatchHandler(
+  catchHandler: TreeSitterNode,
+  tryBlock: CfgBlockInternal,
+  tryEnd: CfgBlockInternal | null,
+  finallyHandler: TreeSitterNode | null,
+  joinBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): void {
+  const catchBlock = S.makeBlock('catch', catchHandler.startPosition.row + 1, null, 'catch');
+  S.addEdge(tryBlock, catchBlock, 'exception');
+
+  const catchBodyNode = catchHandler.childForFieldName('body');
+  let catchStmts: TreeSitterNode[];
+  if (catchBodyNode) {
+    catchStmts = getBodyStatements(catchBodyNode, cfgRules);
+  } else {
+    catchStmts = [];
+    for (let i = 0; i < catchHandler.namedChildCount; i++) {
+      catchStmts.push(nn(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');
+  }
+}
+
+function processFinallyOnly(
+  finallyHandler: TreeSitterNode,
+  tryEnd: CfgBlockInternal | null,
+  joinBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: ProcessStatementsFn,
+): void {
+  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');
+}

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

@@ -0,0 +1,253 @@
+import type { TreeSitterNode, Visitor, VisitorContext } from '../../types.js';
+import { processIf, processSwitch } from './cfg-conditionals.js';
+import {
+  processDoWhileLoop,
+  processForLoop,
+  processInfiniteLoop,
+  processWhileLoop,
+} from './cfg-loops.js';
+import type {
+  AnyRules,
+  CFGResultInternal,
+  CfgBlockInternal,
+  FuncState,
+  LabelCtx,
+} from './cfg-shared.js';
+import {
+  effectiveNode,
+  getBodyStatements,
+  isBlockNode,
+  isForNode,
+  isIfNode,
+  isSwitchNode,
+  isWhileNode,
+  makeFuncState,
+} from './cfg-shared.js';
+import { processTryCatch } from './cfg-try-catch.js';
+
+export type { CfgBlockInternal } from './cfg-shared.js';
+
+function processStatements(
+  stmts: TreeSitterNode[],
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+): CfgBlockInternal | null {
+  let cur: CfgBlockInternal | null = currentBlock;
+  for (const stmt of stmts) {
+    if (!cur) break;
+    cur = processStatement(stmt, cur, S, cfgRules);
+  }
+  return cur;
+}
+
+function processStatement(
+  stmt: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+): CfgBlockInternal | null {
+  if (!stmt || !currentBlock) return currentBlock;
+
+  const effNode = effectiveNode(stmt, cfgRules);
+  const type = effNode.type;
+
+  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, processStatements);
+  }
+  if (isForNode(type, cfgRules)) {
+    return processForLoop(effNode, currentBlock, S, cfgRules, processStatements);
+  }
+  if (isWhileNode(type, cfgRules) || (cfgRules.untilNode && type === cfgRules.untilNode)) {
+    return processWhileLoop(effNode, currentBlock, S, cfgRules, processStatements);
+  }
+  if (cfgRules.doNode && type === cfgRules.doNode) {
+    return processDoWhileLoop(effNode, currentBlock, S, cfgRules, processStatements);
+  }
+  if (cfgRules.infiniteLoopNode && type === cfgRules.infiniteLoopNode) {
+    return processInfiniteLoop(effNode, currentBlock, S, cfgRules, processStatements);
+  }
+  if (isSwitchNode(type, cfgRules)) {
+    return processSwitch(effNode, currentBlock, S, cfgRules, processStatements);
+  }
+  if (cfgRules.tryNode && type === cfgRules.tryNode) {
+    return processTryCatch(effNode, currentBlock, S, cfgRules, processStatements);
+  }
+  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);
+  }
+
+  if (!currentBlock.startLine) {
+    currentBlock.startLine = stmt.startPosition.row + 1;
+  }
+  currentBlock.endLine = stmt.endPosition.row + 1;
+  return currentBlock;
+}
+
+function processLabeled(
+  node: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+  cfgRules: AnyRules,
+): CfgBlockInternal | null {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
+  const body = node.childForFieldName('body');
+  if (body && labelName) {
+    const labelCtx: 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;
+}
+
+function processBreak(
+  node: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+): CfgBlockInternal | null {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
+
+  let target: CfgBlockInternal | null = null;
+  if (labelName && S.labelMap.has(labelName)) {
+    target = (S.labelMap.get(labelName) as LabelCtx).exitBlock;
+  } else if (S.loopStack.length > 0) {
+    target = S.loopStack[S.loopStack.length - 1]!.exitBlock;
+  }
+
+  if (target) {
+    currentBlock.endLine = node.startPosition.row + 1;
+    S.addEdge(currentBlock, target, 'break');
+    return null;
+  }
+  return currentBlock;
+}
+
+function processContinue(
+  node: TreeSitterNode,
+  currentBlock: CfgBlockInternal,
+  S: FuncState,
+): CfgBlockInternal | null {
+  const labelNode = node.childForFieldName('label');
+  const labelName = labelNode ? labelNode.text : null;
+
+  let target: CfgBlockInternal | null = null;
+  if (labelName && S.labelMap.has(labelName)) {
+    target = (S.labelMap.get(labelName) as LabelCtx).headerBlock;
+  } else if (S.loopStack.length > 0) {
+    target = S.loopStack[S.loopStack.length - 1]!.headerBlock;
+  }
+
+  if (target) {
+    currentBlock.endLine = node.startPosition.row + 1;
+    S.addEdge(currentBlock, target, 'continue');
+    return null;
+  }
+  return currentBlock;
+}
+
+function processFunctionBody(funcNode: TreeSitterNode, S: FuncState, cfgRules: AnyRules): void {
+  const body = funcNode.childForFieldName('body');
+  if (!body) {
+    S.blocks.length = 2;
+    S.edges.length = 0;
+    S.addEdge(S.entryBlock, S.exitBlock, 'fallthrough');
+    S.currentBlock = null;
+    return;
+  }
+
+  if (!isBlockNode(body.type, cfgRules)) {
+    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;
+  }
+
+  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;
+}
+
+export function createCfgVisitor(cfgRules: AnyRules): Visitor {
+  const funcStateStack: FuncState[] = [];
+  let S: FuncState | null = null;
+  const results: CFGResultInternal[] = [];
+
+  return {
+    name: 'cfg',
+    functionNodeTypes: cfgRules.functionNodes,
+
+    enterFunction(
+      funcNode: TreeSitterNode,
+      _funcName: string | null,
+      _context: VisitorContext,
+    ): void {
+      if (S) funcStateStack.push(S);
+      S = makeFuncState();
+      S.funcNode = funcNode;
+      processFunctionBody(funcNode, S, cfgRules);
+    },
+
+    exitFunction(
+      funcNode: TreeSitterNode,
+      _funcName: string | null,
+      _context: VisitorContext,
+    ): void {
+      if (S && S.funcNode === funcNode) {
+        const cyclomatic = S.edges.length - S.blocks.length + 2;
+        results.push({
+          funcNode: S.funcNode as TreeSitterNode,
+          blocks: S.blocks,
+          edges: S.edges,
+          cyclomatic: Math.max(cyclomatic, 1),
+        });
+      }
+      S = funcStateStack.length > 0 ? (funcStateStack.pop() as FuncState) : null;
+    },
+
+    enterNode(_node: TreeSitterNode, _context: VisitorContext): undefined {
+      // No-op
+    },
+
+    exitNode(_node: TreeSitterNode, _context: VisitorContext): void {
+      // No-op
+    },
+
+    finish(): CFGResultInternal[] {
+      return results;
+    },
+  };
+}