@optave/codegraph 3.12.0 → 3.15.0

package/src/ast-analysis/visitor-utils.ts

@@ -13,6 +13,7 @@ interface ParamInfo {
 
 interface LanguageRules {
   nameField: string;
+  nameExtractor?: ((node: TreeSitterNode) => string | null) | null;
   varAssignedFnParent?: string;
   pairFnParent?: string;
   assignmentFnParent?: string;
@@ -47,6 +48,10 @@ export function truncate(str: string, max = 120): string {
  */
 export function functionName(fnNode: TreeSitterNode | null, rules: LanguageRules): string | null {
   if (!fnNode) return null;
+  if (rules.nameExtractor) {
+    const extracted = rules.nameExtractor(fnNode);
+    if (extracted) return extracted;
+  }
   const nameNode = fnNode.childForFieldName(rules.nameField);
   if (nameNode) return nameNode.text;
 

package/src/ast-analysis/visitor.ts

@@ -152,24 +152,18 @@ function collectResults(visitors: Visitor[]): WalkResults {
   return results;
 }
 
-/**
- * Walk an AST root with multiple visitors in a single DFS pass.
- *
- * @param {object} rootNode   - tree-sitter root node to walk
- * @param {Visitor[]} visitors - array of visitor objects
- * @param {string} langId     - language identifier
- * @param {object} [options]
- * @param {Set}    [options.functionNodeTypes] - set of node types that are function boundaries
- * @param {Set}    [options.nestingNodeTypes]  - set of node types that increase nesting depth
- * @param {function} [options.getFunctionName] - (funcNode) => string|null
- * @returns {object} Map of visitor.name → finish() result
- */
-export function walkWithVisitors(
-  rootNode: TreeSitterNode,
-  visitors: Visitor[],
-  langId: string,
-  options: WalkOptions = {},
-): WalkResults {
+interface WalkState {
+  visitors: Visitor[];
+  allFuncTypes: Set<string>;
+  nestingNodeTypes: Set<string>;
+  getFunctionName: (node: TreeSitterNode) => string | null;
+  context: VisitorContext;
+  scopeStack: ScopeEntry[];
+  skipDepths: Map<number, number>;
+}
+
+/** Build walk state from options: resolve function types, init visitors, create shared context. */
+function buildWalkState(visitors: Visitor[], langId: string, options: WalkOptions): WalkState {
   const {
     functionNodeTypes = new Set<string>(),
     nestingNodeTypes = new Set<string>(),
@@ -179,7 +173,6 @@ export function walkWithVisitors(
   const allFuncTypes = mergeFunctionNodeTypes(visitors, functionNodeTypes);
   initVisitors(visitors, langId);
 
-  // Shared context object (mutated during walk)
   const scopeStack: ScopeEntry[] = [];
   const context: VisitorContext = {
     nestingLevel: 0,
@@ -188,49 +181,86 @@ export function walkWithVisitors(
     scopeStack,
   };
 
-  const skipDepths = new Map<number, number>();
+  return {
+    visitors,
+    allFuncTypes,
+    nestingNodeTypes,
+    getFunctionName,
+    context,
+    scopeStack,
+    skipDepths: new Map<number, number>(),
+  };
+}
 
-  function walk(node: TreeSitterNode | null, depth: number): void {
-    if (!node) return;
-    if (depth > MAX_WALK_DEPTH) {
-      debug(`walkWithVisitors: AST depth limit (${MAX_WALK_DEPTH}) hit — subtree truncated`);
-      return;
-    }
+/** Single DFS step: dispatch enter/exit hooks and recurse into children. */
+function walkNode(state: WalkState, node: TreeSitterNode | null, depth: number): void {
+  if (!node) return;
+  if (depth > MAX_WALK_DEPTH) {
+    debug(`walkWithVisitors: AST depth limit (${MAX_WALK_DEPTH}) hit — subtree truncated`);
+    return;
+  }
 
-    const type = node.type;
-    const isFuncBoundary = allFuncTypes.has(type);
-    let funcName: string | null = null;
+  const {
+    visitors,
+    allFuncTypes,
+    nestingNodeTypes,
+    getFunctionName,
+    context,
+    scopeStack,
+    skipDepths,
+  } = state;
+  const type = node.type;
+  const isFuncBoundary = allFuncTypes.has(type);
+  let funcName: string | null = null;
 
-    if (isFuncBoundary) {
-      funcName = getFunctionName(node);
-      context.currentFunction = node;
-      scopeStack.push({ funcName, funcNode: node, params: new Map(), locals: new Map() });
-      dispatchEnterFunction(visitors, skipDepths, node, funcName, context, depth);
-    }
+  if (isFuncBoundary) {
+    funcName = getFunctionName(node);
+    context.currentFunction = node;
+    scopeStack.push({ funcName, funcNode: node, params: new Map(), locals: new Map() });
+    dispatchEnterFunction(visitors, skipDepths, node, funcName, context, depth);
+  }
 
-    dispatchEnterNode(visitors, skipDepths, node, context, depth);
+  dispatchEnterNode(visitors, skipDepths, node, context, depth);
 
-    const addsNesting = nestingNodeTypes.has(type);
-    if (addsNesting) context.nestingLevel++;
+  const addsNesting = nestingNodeTypes.has(type);
+  if (addsNesting) context.nestingLevel++;
 
-    for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i), depth + 1);
-    }
+  for (let i = 0; i < node.childCount; i++) {
+    walkNode(state, node.child(i), depth + 1);
+  }
 
-    if (addsNesting) context.nestingLevel--;
+  if (addsNesting) context.nestingLevel--;
 
-    dispatchExitNode(visitors, skipDepths, node, context, depth);
-    clearSkipFlags(skipDepths, visitors.length, depth);
+  dispatchExitNode(visitors, skipDepths, node, context, depth);
+  clearSkipFlags(skipDepths, visitors.length, depth);
 
-    if (isFuncBoundary) {
-      dispatchExitFunction(visitors, skipDepths, node, funcName, context, depth);
-      scopeStack.pop();
-      context.currentFunction =
-        scopeStack.length > 0 ? scopeStack[scopeStack.length - 1]!.funcNode : null;
-    }
+  if (isFuncBoundary) {
+    dispatchExitFunction(visitors, skipDepths, node, funcName, context, depth);
+    scopeStack.pop();
+    context.currentFunction =
+      scopeStack.length > 0 ? scopeStack[scopeStack.length - 1]!.funcNode : null;
   }
+}
 
-  walk(rootNode, 0);
-
+/**
+ * Walk an AST root with multiple visitors in a single DFS pass.
+ *
+ * @param {object} rootNode   - tree-sitter root node to walk
+ * @param {Visitor[]} visitors - array of visitor objects
+ * @param {string} langId     - language identifier
+ * @param {object} [options]
+ * @param {Set}    [options.functionNodeTypes] - set of node types that are function boundaries
+ * @param {Set}    [options.nestingNodeTypes]  - set of node types that increase nesting depth
+ * @param {function} [options.getFunctionName] - (funcNode) => string|null
+ * @returns {object} Map of visitor.name → finish() result
+ */
+export function walkWithVisitors(
+  rootNode: TreeSitterNode,
+  visitors: Visitor[],
+  langId: string,
+  options: WalkOptions = {},
+): WalkResults {
+  const state = buildWalkState(visitors, langId, options);
+  walkNode(state, rootNode, 0);
   return collectResults(visitors);
 }

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

@@ -27,97 +27,28 @@ import { processTryCatch } from './cfg-try-catch.js';
 
 export type { CfgBlockInternal } from './cfg-shared.js';
 
-function processStatements(
+// ─── Statement handler dispatch ─────────────────────────────────────────
+
+type BoundProcessStatements = (
   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;
-}
+) => CfgBlockInternal | null;
 
-function processStatement(
-  stmt: TreeSitterNode,
+type StatementHandler = (
+  node: TreeSitterNode,
   currentBlock: CfgBlockInternal,
   S: FuncState,
   cfgRules: AnyRules,
-): CfgBlockInternal | null {
-  if (!stmt || !currentBlock) return currentBlock;
-
-  const effNode = effectiveNode(stmt, cfgRules);
-  const type = effNode.type;
+  processStmts: BoundProcessStatements,
+) => CfgBlockInternal | null;
 
-  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;
+interface StatementEntry {
+  match: (type: string) => boolean;
+  handle: StatementHandler;
 }
 
-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;
-}
+// ─── Helpers that do not depend on the dispatch closure ─────────────────
 
 function processBreak(
   node: TreeSitterNode,
@@ -165,7 +96,186 @@ function processContinue(
   return currentBlock;
 }
 
-function processFunctionBody(funcNode: TreeSitterNode, S: FuncState, cfgRules: AnyRules): void {
+// ─── Dispatch table builder ──────────────────────────────────────────────
+
+// ─── Terminal statement handlers (no processStatements dependency) ───────
+
+function handleReturn(n: TreeSitterNode, b: CfgBlockInternal, S: FuncState): null {
+  b.endLine = n.startPosition.row + 1;
+  S.addEdge(b, S.exitBlock, 'return');
+  return null;
+}
+
+function handleThrow(n: TreeSitterNode, b: CfgBlockInternal, S: FuncState): null {
+  b.endLine = n.startPosition.row + 1;
+  S.addEdge(b, S.exitBlock, 'exception');
+  return null;
+}
+
+/**
+ * Lookup structure for statement dispatch.
+ * - `map`: O(1) lookup for single-type matchers (one concrete node-type string per handler).
+ * - `fallback`: short linear scan for multi-predicate entries (if/for/while/switch rules that
+ *   match multiple concrete type strings depending on the language).
+ */
+interface StatementDispatch {
+  map: Map<string, StatementHandler>;
+  fallback: StatementEntry[];
+}
+
+/**
+ * Build a dispatch table for statement node types from cfgRules.
+ * Built once per createCfgVisitor call; optional entries (doNode, infiniteLoopNode,
+ * tryNode) are included only when the language rules define them.
+ *
+ * Single-type matchers go into a Map for O(1) lookup; multi-predicate entries
+ * (isIfNode, isForNode, isWhileNode, isSwitchNode) stay in a short fallback array
+ * scanned only on a map miss.
+ */
+function buildStatementDispatch(
+  cfgRules: AnyRules,
+  processLabeledFn: (
+    n: TreeSitterNode,
+    b: CfgBlockInternal,
+    S: FuncState,
+  ) => CfgBlockInternal | null,
+): StatementDispatch {
+  const map = new Map<string, StatementHandler>();
+
+  // Single-type required matchers
+  if (cfgRules.labeledNode) map.set(cfgRules.labeledNode, (n, b, S) => processLabeledFn(n, b, S));
+  if (cfgRules.returnNode) map.set(cfgRules.returnNode, handleReturn);
+  if (cfgRules.throwNode) map.set(cfgRules.throwNode, handleThrow);
+  if (cfgRules.breakNode) map.set(cfgRules.breakNode, (n, b, S) => processBreak(n, b, S));
+  if (cfgRules.continueNode) map.set(cfgRules.continueNode, (n, b, S) => processContinue(n, b, S));
+
+  // Single-type optional matchers
+  if (cfgRules.doNode)
+    map.set(cfgRules.doNode, (n, b, S, r, ps) => processDoWhileLoop(n, b, S, r, ps));
+  if (cfgRules.infiniteLoopNode)
+    map.set(cfgRules.infiniteLoopNode, (n, b, S, r, ps) => processInfiniteLoop(n, b, S, r, ps));
+  if (cfgRules.tryNode)
+    map.set(cfgRules.tryNode, (n, b, S, r, ps) => processTryCatch(n, b, S, r, ps));
+
+  // Multi-predicate entries that can match several concrete type strings per language;
+  // also handles unlessNode/untilNode aliases for if/while which may collide with other
+  // single-type map keys.
+  const fallback: StatementEntry[] = [
+    {
+      match: (t) => isIfNode(t, cfgRules) || (!!cfgRules.unlessNode && t === cfgRules.unlessNode),
+      handle: (n, b, S, r, ps) => processIf(n, b, S, r, ps),
+    },
+    {
+      match: (t) => isForNode(t, cfgRules),
+      handle: (n, b, S, r, ps) => processForLoop(n, b, S, r, ps),
+    },
+    {
+      match: (t) => isWhileNode(t, cfgRules) || (!!cfgRules.untilNode && t === cfgRules.untilNode),
+      handle: (n, b, S, r, ps) => processWhileLoop(n, b, S, r, ps),
+    },
+    {
+      match: (t) => isSwitchNode(t, cfgRules),
+      handle: (n, b, S, r, ps) => processSwitch(n, b, S, r, ps),
+    },
+  ];
+
+  return { map, fallback };
+}
+
+// ─── Bound statement processors ──────────────────────────────────────────
+
+/**
+ * Build {processStatement, processStatements} bound to cfgRules and a
+ * pre-built dispatch table. The two functions are mutually recursive via
+ * the closure — no cfgRules arguments needed at call sites inside the visitor.
+ */
+function buildStatementProcessors(cfgRules: AnyRules): {
+  processStatement: (
+    stmt: TreeSitterNode,
+    currentBlock: CfgBlockInternal,
+    S: FuncState,
+  ) => CfgBlockInternal | null;
+  processStatements: BoundProcessStatements;
+} {
+  // processLabeled needs processStatement from this closure, so we forward-declare
+  // it and patch it in after processStatement is defined.
+  let processStatementRef: (
+    stmt: TreeSitterNode,
+    block: CfgBlockInternal,
+    S: FuncState,
+  ) => CfgBlockInternal | null;
+
+  function processLabeled(
+    node: TreeSitterNode,
+    currentBlock: CfgBlockInternal,
+    S: FuncState,
+  ): 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 = processStatementRef(body, currentBlock, S);
+      S.labelMap.delete(labelName);
+      return result;
+    }
+    return currentBlock;
+  }
+
+  const dispatch = buildStatementDispatch(cfgRules, processLabeled);
+
+  function processStatement(
+    stmt: TreeSitterNode,
+    currentBlock: CfgBlockInternal,
+    S: FuncState,
+  ): CfgBlockInternal | null {
+    if (!stmt || !currentBlock) return currentBlock;
+
+    const effNode = effectiveNode(stmt, cfgRules);
+    const type = effNode.type;
+
+    // O(1) map lookup first; fall back to the short multi-predicate array on a miss
+    const mapHandler = dispatch.map.get(type);
+    if (mapHandler) return mapHandler(effNode, currentBlock, S, cfgRules, processStatements);
+    const fallbackEntry = dispatch.fallback.find((e) => e.match(type));
+    if (fallbackEntry)
+      return fallbackEntry.handle(effNode, currentBlock, S, cfgRules, processStatements);
+
+    if (!currentBlock.startLine) {
+      currentBlock.startLine = stmt.startPosition.row + 1;
+    }
+    currentBlock.endLine = stmt.endPosition.row + 1;
+    return currentBlock;
+  }
+
+  // Wire the forward reference so processLabeled can call processStatement
+  processStatementRef = processStatement;
+
+  function processStatements(
+    stmts: TreeSitterNode[],
+    currentBlock: CfgBlockInternal,
+    S: FuncState,
+  ): CfgBlockInternal | null {
+    let cur: CfgBlockInternal | null = currentBlock;
+    for (const stmt of stmts) {
+      if (!cur) break;
+      cur = processStatement(stmt, cur, S);
+    }
+    return cur;
+  }
+
+  return { processStatement, processStatements };
+}
+
+// ─── Function body walker ────────────────────────────────────────────────
+
+function processFunctionBody(
+  funcNode: TreeSitterNode,
+  S: FuncState,
+  cfgRules: AnyRules,
+  processStatements: BoundProcessStatements,
+): void {
   const body = funcNode.childForFieldName('body');
   if (!body) {
     S.blocks.length = 2;
@@ -194,18 +304,22 @@ function processFunctionBody(funcNode: TreeSitterNode, S: FuncState, cfgRules: A
   }
 
   const firstBody = S.blocks[2]!;
-  const lastBlock = processStatements(stmts, firstBody, S, cfgRules);
+  const lastBlock = processStatements(stmts, firstBody, S);
   if (lastBlock) {
     S.addEdge(lastBlock, S.exitBlock, 'fallthrough');
   }
   S.currentBlock = null;
 }
 
+// ─── Public visitor factory ───────────────────────────────────────────────
+
 export function createCfgVisitor(cfgRules: AnyRules): Visitor {
   const funcStateStack: FuncState[] = [];
   let S: FuncState | null = null;
   const results: CFGResultInternal[] = [];
 
+  const { processStatements } = buildStatementProcessors(cfgRules);
+
   return {
     name: 'cfg',
     functionNodeTypes: cfgRules.functionNodes,
@@ -218,7 +332,7 @@ export function createCfgVisitor(cfgRules: AnyRules): Visitor {
       if (S) funcStateStack.push(S);
       S = makeFuncState();
       S.funcNode = funcNode;
-      processFunctionBody(funcNode, S, cfgRules);
+      processFunctionBody(funcNode, S, cfgRules, processStatements);
     },
 
     exitFunction(

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

@@ -203,6 +203,43 @@ function classifyNode(
   if (cRules.caseNodes.has(type) && node.childCount > 0) acc.cyclomatic++;
 }
 
+/**
+ * Compute the effective nesting level for complexity classification.
+ *
+ * In file-level mode, funcDepth starts at 0 for the active function.
+ * In function-level mode, funcDepth starts at 1 for the root function
+ * (since enterFunction always increments it). Subtract 1 so the root
+ * function contributes 0 nesting and each nested level adds +1, matching
+ * the Rust engine's behavior.
+ */
+function computeEffectiveNesting(
+  contextNesting: number,
+  funcDepth: number,
+  nestingAdjust: number,
+  fileLevelWalk: boolean,
+): number {
+  const funcNesting = fileLevelWalk ? funcDepth : Math.max(0, funcDepth - 1);
+  return contextNesting + funcNesting - nestingAdjust;
+}
+
+/**
+ * If this node is an else-if that the walker treats as a nesting node but
+ * the DFS engine would NOT increment nesting for, track it so children see
+ * the correct (non-inflated) nesting level.
+ */
+function trackElseIfNestingAdjust(
+  node: TreeSitterNode,
+  cRules: AnyRules,
+  nestingAdjust: number,
+  adjustNodeIds: Set<number>,
+): number {
+  if (cRules.nestingNodes.has(node.type) && isElseIfNonNesting(node, node.type, cRules)) {
+    adjustNodeIds.add(node.id);
+    return nestingAdjust + 1;
+  }
+  return nestingAdjust;
+}
+
 export function createComplexityVisitor(
   cRules: AnyRules,
   hRules?: AnyRules | null,
@@ -265,23 +302,14 @@ export function createComplexityVisitor(
     enterNode(node: TreeSitterNode, context: VisitorContext): EnterNodeResult | undefined {
       if (fileLevelWalk && !activeFuncNode) return;
 
-      // In file-level mode, funcDepth starts at 0 for the active function.
-      // In function-level mode, funcDepth starts at 1 for the root function
-      // (since enterFunction always increments it). Nested functions add +1
-      // each level — subtract 1 so the root function contributes 0 nesting
-      // and each nested level adds +1, matching the Rust engine's behavior.
-      const funcNesting = fileLevelWalk ? funcDepth : Math.max(0, funcDepth - 1);
-      const nestingLevel = context.nestingLevel + funcNesting - nestingAdjust;
+      const nestingLevel = computeEffectiveNesting(
+        context.nestingLevel,
+        funcDepth,
+        nestingAdjust,
+        fileLevelWalk,
+      );
       classifyNode(node, nestingLevel, cRules, hRules, acc);
-
-      // If this is an else-if if_statement that the walker will treat as a
-      // nesting node (incrementing context.nestingLevel for children), but
-      // the DFS walk would NOT increment nesting for, compensate by bumping
-      // nestingAdjust so children see the correct level.
-      if (cRules.nestingNodes.has(node.type) && isElseIfNonNesting(node, node.type, cRules)) {
-        nestingAdjust++;
-        adjustNodeIds.add(node.id);
-      }
+      nestingAdjust = trackElseIfNestingAdjust(node, cRules, nestingAdjust, adjustNodeIds);
     },
 
     exitNode(node: TreeSitterNode): void {