@optave/codegraph 3.7.0 → 3.8.1

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,49 +44,33 @@ 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;
+/** 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] || '?';
+    }
+    if (child.type === 'identifier') return child.text;
   }
-  return node.text?.split('(')[0] || '?';
-}
-
-/** Extract receiver for call expressions (e.g. "obj" in "obj.method()"). */
-function extractCallReceiver(node: TreeSitterNode): string | null {
-  const fn = node.childForFieldName('function');
-  if (!fn || fn.type !== 'member_expression') return null;
-  const obj = fn.childForFieldName('object');
-  return obj ? obj.text : 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 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] || '?';
     }
-    return truncate(node.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;
-      }
+    if (child.type === 'identifier' || child.type === 'member_expression') {
+      return child.text;
     }
-    return truncate(node.text);
   }
   return truncate(node.text);
 }
@@ -118,90 +102,43 @@ 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;
+  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 };
     }
-    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;
-    let receiver: string | null = null;
-
-    if (kind === 'call') {
-      name = extractCallName(node);
-      text = truncate(node.text);
-      receiver = extractCallReceiver(node);
-    } 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);
-    }
+    const resolved = resolveNameAndText(node, kind);
+    if (resolved.skip) return;
 
     rows.push({
       file: relPath,
-      line,
+      line: node.startPosition.row + 1,
       kind,
-      name,
-      text,
-      receiver,
-      parentNodeId: resolveParentNodeId(line),
+      name: resolved.name,
+      text: resolved.text,
+      receiver: null,
+      parentNodeId: resolveParentNodeId(node.startPosition.row + 1),
     });
 
     matched.add(node.id);
@@ -221,13 +158,6 @@ export function createAstStoreVisitor(
 
       collectNode(node, kind);
 
-      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/complexity-visitor.ts

@@ -156,6 +156,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,
@@ -178,15 +199,11 @@ 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;
       } else {
         funcDepth++;
       }
@@ -197,18 +214,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,26 +230,8 @@ 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);
-      }
-
-      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++;
+      classifyNode(node, nestingLevel, cRules, hRules, acc);
     },
 
     exitNode(node: TreeSitterNode): void {