@optave/codegraph 3.8.0 → 3.9.0

package/src/ast-analysis/visitor.ts

@@ -20,6 +20,127 @@ import type {
   WalkResults,
 } from '../types.js';
 
+/** Merge each visitor's custom functionNodeTypes into the master set. */
+function mergeFunctionNodeTypes(visitors: Visitor[], base: Set<string>): Set<string> {
+  const merged = new Set(base);
+  for (const v of visitors) {
+    if (v.functionNodeTypes) {
+      for (const t of v.functionNodeTypes) merged.add(t);
+    }
+  }
+  return merged;
+}
+
+/** Initialize all visitors for a given language. */
+function initVisitors(visitors: Visitor[], langId: string): void {
+  for (const v of visitors) {
+    if (v.init) v.init(langId);
+  }
+}
+
+/** Check whether a visitor should be skipped at the current depth. */
+function isSkipped(
+  skipDepths: Map<number, number>,
+  visitorIndex: number,
+  currentDepth: number,
+): boolean {
+  const skipAt = skipDepths.get(visitorIndex);
+  // Skipped if skip was requested at a shallower (or equal) depth
+  // We skip descendants, not the node itself, so skip when currentDepth > skipAt
+  return skipAt !== undefined && currentDepth > skipAt;
+}
+
+/** Dispatch enterFunction hooks to all non-skipped visitors. */
+function dispatchEnterFunction(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  funcName: string | null,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.enterFunction && !isSkipped(skipDepths, i, depth)) {
+      v.enterFunction(node, funcName, context);
+    }
+  }
+}
+
+/** Dispatch enterNode hooks and track skipChildren requests. */
+function dispatchEnterNode(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.enterNode && !isSkipped(skipDepths, i, depth)) {
+      const result = v.enterNode(node, context);
+      if (result?.skipChildren) {
+        skipDepths.set(i, depth);
+      }
+    }
+  }
+}
+
+/** Dispatch exitNode hooks to all non-skipped visitors. */
+function dispatchExitNode(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.exitNode && !isSkipped(skipDepths, i, depth)) {
+      v.exitNode(node, context);
+    }
+  }
+}
+
+/** Clear skip flags for visitors that started skipping at this depth. */
+function clearSkipFlags(
+  skipDepths: Map<number, number>,
+  visitorCount: number,
+  depth: number,
+): void {
+  for (let i = 0; i < visitorCount; i++) {
+    if (skipDepths.get(i) === depth) {
+      skipDepths.delete(i);
+    }
+  }
+}
+
+/** Dispatch exitFunction hooks to all non-skipped visitors. */
+function dispatchExitFunction(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  funcName: string | null,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.exitFunction && !isSkipped(skipDepths, i, depth)) {
+      v.exitFunction(node, funcName, context);
+    }
+  }
+}
+
+/** Collect finish() results from all visitors into a name-keyed map. */
+function collectResults(visitors: Visitor[]): WalkResults {
+  const results: WalkResults = {};
+  for (const v of visitors) {
+    results[v.name] = v.finish ? v.finish() : undefined;
+  }
+  return results;
+}
+
 /**
  * Walk an AST root with multiple visitors in a single DFS pass.
  *
@@ -44,18 +165,8 @@ export function walkWithVisitors(
     getFunctionName = () => null,
   } = options;
 
-  // Merge all visitors' functionNodeTypes into the master set
-  const allFuncTypes = new Set(functionNodeTypes);
-  for (const v of visitors) {
-    if (v.functionNodeTypes) {
-      for (const t of v.functionNodeTypes) allFuncTypes.add(t);
-    }
-  }
-
-  // Initialize visitors
-  for (const v of visitors) {
-    if (v.init) v.init(langId);
-  }
+  const allFuncTypes = mergeFunctionNodeTypes(visitors, functionNodeTypes);
+  initVisitors(visitors, langId);
 
   // Shared context object (mutated during walk)
   const scopeStack: ScopeEntry[] = [];
@@ -66,95 +177,45 @@ export function walkWithVisitors(
     scopeStack,
   };
 
-  // Track which visitors have requested skipChildren at each depth
-  // Key: visitor index, Value: depth at which skip was requested
   const skipDepths = new Map<number, number>();
 
   function walk(node: TreeSitterNode | null, depth: number): void {
     if (!node) return;
 
     const type = node.type;
-    const isFunction = allFuncTypes.has(type);
+    const isFuncBoundary = allFuncTypes.has(type);
     let funcName: string | null = null;
 
-    // Function boundary: enter
-    if (isFunction) {
+    if (isFuncBoundary) {
       funcName = getFunctionName(node);
       context.currentFunction = node;
       scopeStack.push({ funcName, funcNode: node, params: new Map(), locals: new Map() });
-      for (let i = 0; i < visitors.length; i++) {
-        const v = visitors[i]!;
-        if (v.enterFunction && !isSkipped(i, depth)) {
-          v.enterFunction(node, funcName, context);
-        }
-      }
+      dispatchEnterFunction(visitors, skipDepths, node, funcName, context, depth);
     }
 
-    // enterNode hooks
-    for (let i = 0; i < visitors.length; i++) {
-      const v = visitors[i]!;
-      if (v.enterNode && !isSkipped(i, depth)) {
-        const result = v.enterNode(node, context);
-        if (result?.skipChildren) {
-          skipDepths.set(i, depth);
-        }
-      }
-    }
+    dispatchEnterNode(visitors, skipDepths, node, context, depth);
 
-    // Nesting tracking
     const addsNesting = nestingNodeTypes.has(type);
     if (addsNesting) context.nestingLevel++;
 
-    // Recurse children using node.child(i) (all children, not just named)
     for (let i = 0; i < node.childCount; i++) {
       walk(node.child(i), depth + 1);
     }
 
-    // Undo nesting
     if (addsNesting) context.nestingLevel--;
 
-    // exitNode hooks
-    for (let i = 0; i < visitors.length; i++) {
-      const v = visitors[i]!;
-      if (v.exitNode && !isSkipped(i, depth)) {
-        v.exitNode(node, context);
-      }
-    }
-
-    // Clear skip for any visitor that started skipping at this depth
-    for (let i = 0; i < visitors.length; i++) {
-      if (skipDepths.get(i) === depth) {
-        skipDepths.delete(i);
-      }
-    }
+    dispatchExitNode(visitors, skipDepths, node, context, depth);
+    clearSkipFlags(skipDepths, visitors.length, depth);
 
-    // Function boundary: exit
-    if (isFunction) {
-      for (let i = 0; i < visitors.length; i++) {
-        const v = visitors[i]!;
-        if (v.exitFunction && !isSkipped(i, depth)) {
-          v.exitFunction(node, funcName, context);
-        }
-      }
+    if (isFuncBoundary) {
+      dispatchExitFunction(visitors, skipDepths, node, funcName, context, depth);
       scopeStack.pop();
       context.currentFunction =
         scopeStack.length > 0 ? scopeStack[scopeStack.length - 1]!.funcNode : null;
     }
   }
 
-  function isSkipped(visitorIndex: number, currentDepth: number): boolean {
-    const skipAt = skipDepths.get(visitorIndex);
-    // Skipped if skip was requested at a shallower (or equal) depth
-    // We skip descendants, not the node itself, so skip when currentDepth > skipAt
-    return skipAt !== undefined && currentDepth > skipAt;
-  }
-
   walk(rootNode, 0);
 
-  // Collect results
-  const results: WalkResults = {};
-  for (const v of visitors) {
-    results[v.name] = v.finish ? v.finish() : undefined;
-  }
-  return results;
+  return collectResults(visitors);
 }

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

@@ -44,33 +44,33 @@ function extractExpressionText(node: TreeSitterNode): string | null {
   return truncate(node.text);
 }
 
-function extractName(kind: string, node: TreeSitterNode): string | null {
-  if (kind === 'throw') {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (!child) continue;
-      if (child.type === 'new_expression') return extractNewName(child);
-      if (child.type === 'call_expression') {
-        const fn = child.childForFieldName('function');
-        return fn ? fn.text : child.text?.split('(')[0] || '?';
-      }
-      if (child.type === 'identifier') return child.text;
+/** Extract the name from a throw statement's child nodes. */
+function extractThrowName(node: TreeSitterNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'new_expression') return extractNewName(child);
+    if (child.type === 'call_expression') {
+      const fn = child.childForFieldName('function');
+      return fn ? fn.text : child.text?.split('(')[0] || '?';
     }
-    return truncate(node.text);
+    if (child.type === 'identifier') return child.text;
   }
-  if (kind === 'await') {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (!child) continue;
-      if (child.type === 'call_expression') {
-        const fn = child.childForFieldName('function');
-        return fn ? fn.text : child.text?.split('(')[0] || '?';
-      }
-      if (child.type === 'identifier' || child.type === 'member_expression') {
-        return child.text;
-      }
+  return truncate(node.text);
+}
+
+/** Extract the name from an await expression's child nodes. */
+function extractAwaitName(node: TreeSitterNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'call_expression') {
+      const fn = child.childForFieldName('function');
+      return fn ? fn.text : child.text?.split('(')[0] || '?';
+    }
+    if (child.type === 'identifier' || child.type === 'member_expression') {
+      return child.text;
     }
-    return truncate(node.text);
   }
   return truncate(node.text);
 }
@@ -102,40 +102,43 @@ export function createAstStoreVisitor(
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
   }
 
+  function resolveNameAndText(
+    node: TreeSitterNode,
+    kind: string,
+  ): { name: string | null | undefined; text: string | null; skip?: boolean } {
+    switch (kind) {
+      case 'new':
+        return { name: extractNewName(node), text: truncate(node.text) };
+      case 'throw':
+        return { name: extractThrowName(node), text: extractExpressionText(node) };
+      case 'await':
+        return { name: extractAwaitName(node), text: extractExpressionText(node) };
+      case 'string': {
+        const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
+        if (content.length < 2) return { name: null, text: null, skip: true };
+        return { name: truncate(content, 100), text: truncate(node.text) };
+      }
+      case 'regex':
+        return { name: node.text || '?', text: truncate(node.text) };
+      default:
+        return { name: undefined, text: 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 === '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);
-    }
+    const resolved = resolveNameAndText(node, kind);
+    if (resolved.skip) return;
 
     rows.push({
       file: relPath,
-      line,
+      line: node.startPosition.row + 1,
       kind,
-      name,
-      text,
+      name: resolved.name,
+      text: resolved.text,
       receiver: null,
-      parentNodeId: resolveParentNodeId(line),
+      parentNodeId: resolveParentNodeId(node.startPosition.row + 1),
     });
 
     matched.add(node.id);

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

@@ -40,6 +40,32 @@ function classifyHalstead(node: TreeSitterNode, hRules: AnyRules, acc: Complexit
   }
 }
 
+/**
+ * Detect whether a branch node is an else-if that the DFS walk would NOT
+ * increment nesting for.  Returns true for:
+ *  - Pattern A (JS/C#/Rust): if_statement whose parent is else_clause
+ *  - Pattern C (Go/Java): if_statement that is the alternative of parent if
+ *
+ * Pattern B (Python elif_clause) is not an issue because elif_clause is
+ * never in nestingNodes.
+ */
+function isElseIfNonNesting(node: TreeSitterNode, type: string, cRules: AnyRules): boolean {
+  if (type !== cRules.ifNodeType) return false;
+
+  if (cRules.elseViaAlternative) {
+    // Pattern C
+    return (
+      node.parent?.type === cRules.ifNodeType &&
+      node.parent?.childForFieldName('alternative')?.id === node.id
+    );
+  }
+  if (cRules.elseNodeType) {
+    // Pattern A
+    return node.parent?.type === cRules.elseNodeType;
+  }
+  return false;
+}
+
 function classifyBranchNode(
   node: TreeSitterNode,
   type: string,
@@ -156,6 +182,27 @@ function resetAccumulators(hRules: AnyRules | null | undefined): ComplexityAcc {
   };
 }
 
+/** Classify a single node for all complexity metrics (Halstead, branching, logical ops, etc.). */
+function classifyNode(
+  node: TreeSitterNode,
+  nestingLevel: number,
+  cRules: AnyRules,
+  hRules: AnyRules | null | undefined,
+  acc: ComplexityAcc,
+): void {
+  const type = node.type;
+
+  if (hRules) classifyHalstead(node, hRules, acc);
+  if (nestingLevel > acc.maxNesting) acc.maxNesting = nestingLevel;
+  if (type === cRules.logicalNodeType) classifyLogicalOp(node, cRules, acc);
+  if (type === cRules.optionalChainType) acc.cyclomatic++;
+  if (cRules.branchNodes.has(type) && node.childCount > 0) {
+    classifyBranchNode(node, type, nestingLevel, cRules, acc);
+  }
+  classifyPlainElse(node, type, cRules, acc);
+  if (cRules.caseNodes.has(type) && node.childCount > 0) acc.cyclomatic++;
+}
+
 export function createComplexityVisitor(
   cRules: AnyRules,
   hRules?: AnyRules | null,
@@ -169,6 +216,13 @@ export function createComplexityVisitor(
   let funcDepth = 0;
   const results: PerFunctionResult[] = [];
 
+  // The walker increments context.nestingLevel for ALL nodes in nestingNodeTypes
+  // (including if_statement). But the DFS engine does NOT increment nesting for
+  // else-if if_statement nodes. Track a correction counter so children of else-if
+  // nodes see the correct (non-inflated) nesting level.
+  let nestingAdjust = 0;
+  const adjustNodeIds = new Set<number>();
+
   return {
     name: 'complexity',
     functionNodeTypes: cRules.functionNodes,
@@ -178,15 +232,13 @@ export function createComplexityVisitor(
       funcName: string | null,
       _context: VisitorContext,
     ): void {
-      if (fileLevelWalk) {
-        if (!activeFuncNode) {
-          acc = resetAccumulators(hRules);
-          activeFuncNode = funcNode;
-          activeFuncName = funcName;
-          funcDepth = 0;
-        } else {
-          funcDepth++;
-        }
+      if (fileLevelWalk && !activeFuncNode) {
+        acc = resetAccumulators(hRules);
+        activeFuncNode = funcNode;
+        activeFuncName = funcName;
+        funcDepth = 0;
+        nestingAdjust = 0;
+        adjustNodeIds.clear();
       } else {
         funcDepth++;
       }
@@ -197,18 +249,14 @@ export function createComplexityVisitor(
       _funcName: string | null,
       _context: VisitorContext,
     ): void {
-      if (fileLevelWalk) {
-        if (funcNode === activeFuncNode) {
-          results.push({
-            funcNode,
-            funcName: activeFuncName,
-            metrics: collectResult(funcNode, acc, hRules, langId),
-          });
-          activeFuncNode = null;
-          activeFuncName = null;
-        } else {
-          funcDepth--;
-        }
+      if (fileLevelWalk && funcNode === activeFuncNode) {
+        results.push({
+          funcNode,
+          funcName: activeFuncName,
+          metrics: collectResult(funcNode, acc, hRules, langId),
+        });
+        activeFuncNode = null;
+        activeFuncName = null;
       } else {
         funcDepth--;
       }
@@ -217,29 +265,30 @@ export function createComplexityVisitor(
     enterNode(node: TreeSitterNode, context: VisitorContext): EnterNodeResult | undefined {
       if (fileLevelWalk && !activeFuncNode) return;
 
-      const type = node.type;
-      const nestingLevel = fileLevelWalk ? context.nestingLevel + funcDepth : context.nestingLevel;
-
-      if (hRules) classifyHalstead(node, hRules, acc);
-
-      if (nestingLevel > acc.maxNesting) acc.maxNesting = nestingLevel;
-
-      if (type === cRules.logicalNodeType) {
-        classifyLogicalOp(node, cRules, acc);
+      // 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;
+      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);
       }
-
-      if (type === cRules.optionalChainType) acc.cyclomatic++;
-
-      if (cRules.branchNodes.has(type) && node.childCount > 0) {
-        classifyBranchNode(node, type, nestingLevel, cRules, acc);
-      }
-
-      classifyPlainElse(node, type, cRules, acc);
-
-      if (cRules.caseNodes.has(type) && node.childCount > 0) acc.cyclomatic++;
     },
 
     exitNode(node: TreeSitterNode): void {
+      if (adjustNodeIds.has(node.id)) {
+        nestingAdjust--;
+        adjustNodeIds.delete(node.id);
+      }
       if (hRules?.skipTypes.has(node.type)) acc.halsteadSkipDepth--;
     },