@optave/codegraph 3.4.0 → 3.4.1

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;
+}

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');
+}