@optave/codegraph 3.4.0 → 3.5.0

package/src/ast-analysis/rules/javascript.ts

@@ -237,6 +237,7 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
 export const astTypes: Record<string, string> | null = {
+  call_expression: 'call',
   new_expression: 'new',
   throw_statement: 'throw',
   await_expression: 'await',

package/src/ast-analysis/shared.ts

@@ -176,7 +176,6 @@ export function findFunctionNode(
     }
 
     for (let i = 0; i < node.childCount; i++) {
-      // biome-ignore lint/style/noNonNullAssertion: tree-sitter child(i) within childCount is always non-null
       search(node.child(i)!);
     }
   }

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

@@ -44,6 +44,14 @@ function extractExpressionText(node: TreeSitterNode): string | null {
   return truncate(node.text);
 }
 
+function extractCallName(node: TreeSitterNode): string {
+  for (const field of ['function', 'method', 'name']) {
+    const fn = node.childForFieldName(field);
+    if (fn) return fn.text;
+  }
+  return node.text?.split('(')[0] || '?';
+}
+
 function extractName(kind: string, node: TreeSitterNode): string | null {
   if (kind === 'throw') {
     for (let i = 0; i < node.childCount; i++) {
@@ -102,6 +110,93 @@ export function createAstStoreVisitor(
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
   }
 
+  /** Recursively walk a subtree collecting AST nodes — used for arguments-only traversal. */
+  function walkSubtree(node: TreeSitterNode | null): void {
+    if (!node) return;
+    if (matched.has(node.id)) return;
+
+    const kind = astTypeMap[node.type];
+    if (kind === 'call') {
+      // Capture this call and recurse only into its arguments
+      collectNode(node, kind);
+      walkCallArguments(node);
+      return;
+    }
+    if (kind) {
+      collectNode(node, kind);
+      if (kind !== 'string' && kind !== 'regex') return; // skipChildren for non-leaf kinds
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      walkSubtree(node.child(i));
+    }
+  }
+
+  /**
+   * Recurse into only the arguments of a call node — mirrors the native engine's
+   * strategy that prevents double-counting nested calls in the function field
+   * (e.g. chained calls like `a().b()`).
+   */
+  function walkCallArguments(callNode: TreeSitterNode): void {
+    // Try field-based lookup first, fall back to kind-based matching
+    const argsNode =
+      callNode.childForFieldName('arguments') ??
+      findChildByKind(callNode, ['arguments', 'argument_list', 'method_arguments']);
+    if (!argsNode) return;
+    for (let i = 0; i < argsNode.childCount; i++) {
+      walkSubtree(argsNode.child(i));
+    }
+  }
+
+  function findChildByKind(node: TreeSitterNode, kinds: string[]): TreeSitterNode | null {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && kinds.includes(child.type)) return child;
+    }
+    return null;
+  }
+
+  function collectNode(node: TreeSitterNode, kind: string): void {
+    if (matched.has(node.id)) return;
+
+    const line = node.startPosition.row + 1;
+    let name: string | null | undefined;
+    let text: string | null = null;
+
+    if (kind === 'call') {
+      name = extractCallName(node);
+      text = truncate(node.text);
+    } else if (kind === 'new') {
+      name = extractNewName(node);
+      text = truncate(node.text);
+    } else if (kind === 'throw') {
+      name = extractName('throw', node);
+      text = extractExpressionText(node);
+    } else if (kind === 'await') {
+      name = extractName('await', node);
+      text = extractExpressionText(node);
+    } else if (kind === 'string') {
+      const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
+      if (content.length < 2) return;
+      name = truncate(content, 100);
+      text = truncate(node.text);
+    } else if (kind === 'regex') {
+      name = node.text || '?';
+      text = truncate(node.text);
+    }
+
+    rows.push({
+      file: relPath,
+      line,
+      kind,
+      name,
+      text,
+      receiver: null,
+      parentNodeId: resolveParentNodeId(line),
+    });
+
+    matched.add(node.id);
+  }
+
   return {
     name: 'ast-store',
 
@@ -111,40 +206,14 @@ export function createAstStoreVisitor(
       const kind = astTypeMap[node.type];
       if (!kind) return;
 
-      const line = node.startPosition.row + 1;
-      let name: string | null | undefined;
-      let text: string | null = null;
-
-      if (kind === 'new') {
-        name = extractNewName(node);
-        text = truncate(node.text);
-      } else if (kind === 'throw') {
-        name = extractName('throw', node);
-        text = extractExpressionText(node);
-      } else if (kind === 'await') {
-        name = extractName('await', node);
-        text = extractExpressionText(node);
-      } else if (kind === 'string') {
-        const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-        if (content.length < 2) return;
-        name = truncate(content, 100);
-        text = truncate(node.text);
-      } else if (kind === 'regex') {
-        name = node.text || '?';
-        text = truncate(node.text);
-      }
+      collectNode(node, kind);
 
-      rows.push({
-        file: relPath,
-        line,
-        kind,
-        name,
-        text,
-        receiver: null,
-        parentNodeId: resolveParentNodeId(line),
-      });
-
-      matched.add(node.id);
+      if (kind === 'call') {
+        // Mirror native: skip full subtree, recurse only into arguments.
+        // Prevents double-counting chained calls like service.getUser().getName().
+        walkCallArguments(node);
+        return { skipChildren: true };
+      }
 
       if (kind !== 'string' && kind !== 'regex') {
         return { skipChildren: true };

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