@optave/codegraph 3.1.1 → 3.1.2

package/src/dataflow.js

@@ -17,13 +17,13 @@ import {
   buildExtensionSet,
   buildExtToLangMap,
 } from './ast-analysis/shared.js';
-import { openReadonlyOrFail } from './db.js';
+import { walkWithVisitors } from './ast-analysis/visitor.js';
+import { createDataflowVisitor } from './ast-analysis/visitors/dataflow-visitor.js';
+import { hasDataflowTable, openReadonlyOrFail } from './db.js';
+import { isTestFile } from './infrastructure/test-filter.js';
 import { info } from './logger.js';
 import { paginateResult } from './paginate.js';
-
 import { ALL_SYMBOL_KINDS, normalizeSymbol } from './queries.js';
-import { outputResult } from './result-formatter.js';
-import { isTestFile } from './test-filter.js';
 
 // Re-export for backward compatibility
 export { DATAFLOW_RULES };
@@ -31,172 +31,13 @@ export { _makeDataflowRules as makeDataflowRules };
 
 export const DATAFLOW_EXTENSIONS = buildExtensionSet(DATAFLOW_RULES);
 
-// ── AST helpers ──────────────────────────────────────────────────────────────
-
-function truncate(str, max = 120) {
-  if (!str) return '';
-  return str.length > max ? `${str.slice(0, max)}…` : str;
-}
-
-/**
- * Get the name of a function node from the AST using rules.
- */
-function functionName(fnNode, rules) {
-  if (!fnNode) return null;
-  // Try the standard name field first (works for most languages)
-  const nameNode = fnNode.childForFieldName(rules.nameField);
-  if (nameNode) return nameNode.text;
-
-  // JS-specific: arrow_function/function_expression assigned to variable, pair, or assignment
-  const parent = fnNode.parent;
-  if (parent) {
-    if (rules.varAssignedFnParent && parent.type === rules.varAssignedFnParent) {
-      const n = parent.childForFieldName('name');
-      return n ? n.text : null;
-    }
-    if (rules.pairFnParent && parent.type === rules.pairFnParent) {
-      const keyNode = parent.childForFieldName('key');
-      return keyNode ? keyNode.text : null;
-    }
-    if (rules.assignmentFnParent && parent.type === rules.assignmentFnParent) {
-      const left = parent.childForFieldName(rules.assignLeftField);
-      return left ? left.text : null;
-    }
-  }
-  return null;
-}
-
-/**
- * Extract parameter names and indices from a formal_parameters node.
- */
-function extractParams(paramsNode, rules) {
-  if (!paramsNode) return [];
-  const result = [];
-  let index = 0;
-  for (const child of paramsNode.namedChildren) {
-    const names = extractParamNames(child, rules);
-    for (const name of names) {
-      result.push({ name, index });
-    }
-    index++;
-  }
-  return result;
-}
-
-function extractParamNames(node, rules) {
-  if (!node) return [];
-  const t = node.type;
-
-  // Language-specific override (Go, Rust, Java, C#, PHP, Ruby)
-  if (rules.extractParamName) {
-    const result = rules.extractParamName(node);
-    if (result) return result;
-  }
-
-  // Leaf identifier
-  if (t === rules.paramIdentifier) return [node.text];
-
-  // Wrapper types (TS required_parameter, Python typed_parameter, etc.)
-  if (rules.paramWrapperTypes.has(t)) {
-    const pattern = node.childForFieldName('pattern') || node.childForFieldName('name');
-    return pattern ? extractParamNames(pattern, rules) : [];
-  }
-
-  // Default parameter (assignment_pattern / default_parameter)
-  if (rules.defaultParamType && t === rules.defaultParamType) {
-    const left = node.childForFieldName('left') || node.childForFieldName('name');
-    return left ? extractParamNames(left, rules) : [];
-  }
-
-  // Rest / splat parameter
-  if (rules.restParamType && t === rules.restParamType) {
-    // Try name field first, then fall back to scanning children
-    const nameNode = node.childForFieldName('name');
-    if (nameNode) return [nameNode.text];
-    for (const child of node.namedChildren) {
-      if (child.type === rules.paramIdentifier) return [child.text];
-    }
-    return [];
-  }
-
-  // Object destructuring (JS only)
-  if (rules.objectDestructType && t === rules.objectDestructType) {
-    const names = [];
-    for (const child of node.namedChildren) {
-      if (rules.shorthandPropPattern && child.type === rules.shorthandPropPattern) {
-        names.push(child.text);
-      } else if (rules.pairPatternType && child.type === rules.pairPatternType) {
-        const value = child.childForFieldName('value');
-        if (value) names.push(...extractParamNames(value, rules));
-      } else if (rules.restParamType && child.type === rules.restParamType) {
-        names.push(...extractParamNames(child, rules));
-      }
-    }
-    return names;
-  }
-
-  // Array destructuring (JS only)
-  if (rules.arrayDestructType && t === rules.arrayDestructType) {
-    const names = [];
-    for (const child of node.namedChildren) {
-      names.push(...extractParamNames(child, rules));
-    }
-    return names;
-  }
-
-  return [];
-}
-
-/** Check if a node type is identifier-like for this language. */
-function isIdent(nodeType, rules) {
-  if (nodeType === 'identifier' || nodeType === rules.paramIdentifier) return true;
-  return rules.extraIdentifierTypes ? rules.extraIdentifierTypes.has(nodeType) : false;
-}
-
-/**
- * Resolve the name a call expression is calling using rules.
- */
-function resolveCalleeName(callNode, rules) {
-  const fn = callNode.childForFieldName(rules.callFunctionField);
-  if (!fn) {
-    // Some languages (Java method_invocation, Ruby call) use 'name' field directly
-    const nameNode = callNode.childForFieldName('name') || callNode.childForFieldName('method');
-    return nameNode ? nameNode.text : null;
-  }
-  if (isIdent(fn.type, rules)) return fn.text;
-  if (fn.type === rules.memberNode) {
-    const prop = fn.childForFieldName(rules.memberPropertyField);
-    return prop ? prop.text : null;
-  }
-  if (rules.optionalChainNode && fn.type === rules.optionalChainNode) {
-    const target = fn.namedChildren[0];
-    if (!target) return null;
-    if (target.type === rules.memberNode) {
-      const prop = target.childForFieldName(rules.memberPropertyField);
-      return prop ? prop.text : null;
-    }
-    if (target.type === 'identifier') return target.text;
-    const prop = fn.childForFieldName(rules.memberPropertyField);
-    return prop ? prop.text : null;
-  }
-  return null;
-}
-
-/**
- * Get the receiver (object) of a member expression using rules.
- */
-function memberReceiver(memberExpr, rules) {
-  const obj = memberExpr.childForFieldName(rules.memberObjectField);
-  if (!obj) return null;
-  if (isIdent(obj.type, rules)) return obj.text;
-  if (obj.type === rules.memberNode) return memberReceiver(obj, rules);
-  return null;
-}
+// ── AST helpers (now in ast-analysis/visitor-utils.js, kept as re-exports) ──
 
 // ── extractDataflow ──────────────────────────────────────────────────────────
 
 /**
  * Extract dataflow information from a parsed AST.
+ * Delegates to the dataflow visitor via the unified walker.
  *
  * @param {object} tree - tree-sitter parse tree
  * @param {string} filePath - relative file path
@@ -208,385 +49,13 @@ export function extractDataflow(tree, _filePath, _definitions, langId = 'javascr
   const rules = DATAFLOW_RULES.get(langId);
   if (!rules) return { parameters: [], returns: [], assignments: [], argFlows: [], mutations: [] };
 
-  const isCallNode = rules.callNodes ? (t) => rules.callNodes.has(t) : (t) => t === rules.callNode;
-
-  const parameters = [];
-  const returns = [];
-  const assignments = [];
-  const argFlows = [];
-  const mutations = [];
-
-  const scopeStack = [];
-
-  function currentScope() {
-    return scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
-  }
-
-  function findBinding(name) {
-    for (let i = scopeStack.length - 1; i >= 0; i--) {
-      const scope = scopeStack[i];
-      if (scope.params.has(name))
-        return { type: 'param', index: scope.params.get(name), funcName: scope.funcName };
-      if (scope.locals.has(name))
-        return { type: 'local', source: scope.locals.get(name), funcName: scope.funcName };
-    }
-    return null;
-  }
-
-  function enterScope(fnNode) {
-    const name = functionName(fnNode, rules);
-    const paramsNode = fnNode.childForFieldName(rules.paramListField);
-    const paramList = extractParams(paramsNode, rules);
-    const paramMap = new Map();
-    for (const p of paramList) {
-      paramMap.set(p.name, p.index);
-      if (name) {
-        parameters.push({
-          funcName: name,
-          paramName: p.name,
-          paramIndex: p.index,
-          line: (paramsNode?.startPosition?.row ?? fnNode.startPosition.row) + 1,
-        });
-      }
-    }
-    scopeStack.push({ funcName: name, funcNode: fnNode, params: paramMap, locals: new Map() });
-  }
-
-  function exitScope() {
-    scopeStack.pop();
-  }
-
-  function bindingConfidence(binding) {
-    if (!binding) return 0.5;
-    if (binding.type === 'param') return 1.0;
-    if (binding.type === 'local') {
-      if (binding.source?.type === 'call_return') return 0.9;
-      if (binding.source?.type === 'destructured') return 0.8;
-      return 0.9;
-    }
-    return 0.5;
-  }
-
-  /** Unwrap await if present, returning the inner expression. */
-  function unwrapAwait(node) {
-    if (rules.awaitNode && node.type === rules.awaitNode) {
-      return node.namedChildren[0] || node;
-    }
-    return node;
-  }
-
-  /** Check if a node is a call expression (single or multi-type). */
-  function isCall(node) {
-    return node && isCallNode(node.type);
-  }
-
-  /** Handle a variable declarator / short_var_declaration node. */
-  function handleVarDeclarator(node) {
-    let nameNode = node.childForFieldName(rules.varNameField);
-    let valueNode = rules.varValueField ? node.childForFieldName(rules.varValueField) : null;
-
-    // C#: initializer is inside equals_value_clause child
-    if (!valueNode && rules.equalsClauseType) {
-      for (const child of node.namedChildren) {
-        if (child.type === rules.equalsClauseType) {
-          valueNode = child.childForFieldName('value') || child.namedChildren[0];
-          break;
-        }
-      }
-    }
-
-    // Fallback: initializer is a direct unnamed child (C# variable_declarator)
-    if (!valueNode) {
-      for (const child of node.namedChildren) {
-        if (child !== nameNode && isCall(unwrapAwait(child))) {
-          valueNode = child;
-          break;
-        }
-      }
-    }
-
-    // Go: expression_list wraps LHS/RHS — unwrap to first named child
-    if (rules.expressionListType) {
-      if (nameNode?.type === rules.expressionListType) nameNode = nameNode.namedChildren[0];
-      if (valueNode?.type === rules.expressionListType) valueNode = valueNode.namedChildren[0];
-    }
-
-    const scope = currentScope();
-    if (!nameNode || !valueNode || !scope) return;
-
-    const unwrapped = unwrapAwait(valueNode);
-    const callExpr = isCall(unwrapped) ? unwrapped : null;
-
-    if (callExpr) {
-      const callee = resolveCalleeName(callExpr, rules);
-      if (callee && scope.funcName) {
-        // Destructuring: const { a, b } = foo()
-        if (
-          (rules.objectDestructType && nameNode.type === rules.objectDestructType) ||
-          (rules.arrayDestructType && nameNode.type === rules.arrayDestructType)
-        ) {
-          const names = extractParamNames(nameNode, rules);
-          for (const n of names) {
-            assignments.push({
-              varName: n,
-              callerFunc: scope.funcName,
-              sourceCallName: callee,
-              expression: truncate(node.text),
-              line: node.startPosition.row + 1,
-            });
-            scope.locals.set(n, { type: 'destructured', callee });
-          }
-        } else {
-          const varName =
-            nameNode.type === 'identifier' || nameNode.type === rules.paramIdentifier
-              ? nameNode.text
-              : nameNode.text;
-          assignments.push({
-            varName,
-            callerFunc: scope.funcName,
-            sourceCallName: callee,
-            expression: truncate(node.text),
-            line: node.startPosition.row + 1,
-          });
-          scope.locals.set(varName, { type: 'call_return', callee });
-        }
-      }
-    }
-  }
-
-  /** Handle assignment expressions (mutation detection + call captures). */
-  function handleAssignment(node) {
-    const left = node.childForFieldName(rules.assignLeftField);
-    const right = node.childForFieldName(rules.assignRightField);
-    const scope = currentScope();
-    if (!scope?.funcName) return;
-
-    // Mutation: obj.prop = value
-    if (left && rules.memberNode && left.type === rules.memberNode) {
-      const receiver = memberReceiver(left, rules);
-      if (receiver) {
-        const binding = findBinding(receiver);
-        if (binding) {
-          mutations.push({
-            funcName: scope.funcName,
-            receiverName: receiver,
-            binding,
-            mutatingExpr: truncate(node.text),
-            line: node.startPosition.row + 1,
-          });
-        }
-      }
-    }
-
-    // Non-declaration assignment: x = foo()
-    if (left && isIdent(left.type, rules) && right) {
-      const unwrapped = unwrapAwait(right);
-      const callExpr = isCall(unwrapped) ? unwrapped : null;
-      if (callExpr) {
-        const callee = resolveCalleeName(callExpr, rules);
-        if (callee) {
-          assignments.push({
-            varName: left.text,
-            callerFunc: scope.funcName,
-            sourceCallName: callee,
-            expression: truncate(node.text),
-            line: node.startPosition.row + 1,
-          });
-          scope.locals.set(left.text, { type: 'call_return', callee });
-        }
-      }
-    }
-  }
-
-  /** Handle call expressions: track argument flows. */
-  function handleCallExpr(node) {
-    const callee = resolveCalleeName(node, rules);
-    const argsNode = node.childForFieldName(rules.callArgsField);
-    const scope = currentScope();
-    if (!callee || !argsNode || !scope?.funcName) return;
-
-    let argIndex = 0;
-    for (let arg of argsNode.namedChildren) {
-      // PHP/Java: unwrap argument wrapper
-      if (rules.argumentWrapperType && arg.type === rules.argumentWrapperType) {
-        arg = arg.namedChildren[0] || arg;
-      }
-      const unwrapped =
-        rules.spreadType && arg.type === rules.spreadType ? arg.namedChildren[0] || arg : arg;
-      if (!unwrapped) {
-        argIndex++;
-        continue;
-      }
-
-      const argName = isIdent(unwrapped.type, rules) ? unwrapped.text : null;
-      const argMember =
-        rules.memberNode && unwrapped.type === rules.memberNode
-          ? memberReceiver(unwrapped, rules)
-          : null;
-      const trackedName = argName || argMember;
-
-      if (trackedName) {
-        const binding = findBinding(trackedName);
-        if (binding) {
-          argFlows.push({
-            callerFunc: scope.funcName,
-            calleeName: callee,
-            argIndex,
-            argName: trackedName,
-            binding,
-            confidence: bindingConfidence(binding),
-            expression: truncate(arg.text),
-            line: node.startPosition.row + 1,
-          });
-        }
-      }
-      argIndex++;
-    }
-  }
-
-  /** Detect mutating method calls in expression statements. */
-  function handleExprStmtMutation(node) {
-    if (rules.mutatingMethods.size === 0) return;
-    const expr = node.namedChildren[0];
-    if (!expr || !isCall(expr)) return;
-
-    let methodName = null;
-    let receiver = null;
-
-    // Standard pattern: call(fn: member(obj, prop))
-    const fn = expr.childForFieldName(rules.callFunctionField);
-    if (fn && fn.type === rules.memberNode) {
-      const prop = fn.childForFieldName(rules.memberPropertyField);
-      methodName = prop ? prop.text : null;
-      receiver = memberReceiver(fn, rules);
-    }
-
-    // Java/combined pattern: call node itself has object + name fields
-    if (!receiver && rules.callObjectField) {
-      const obj = expr.childForFieldName(rules.callObjectField);
-      const name = expr.childForFieldName(rules.callFunctionField);
-      if (obj && name) {
-        methodName = name.text;
-        receiver = isIdent(obj.type, rules) ? obj.text : null;
-      }
-    }
-
-    if (!methodName || !rules.mutatingMethods.has(methodName)) return;
-
-    const scope = currentScope();
-    if (!receiver || !scope?.funcName) return;
-
-    const binding = findBinding(receiver);
-    if (binding) {
-      mutations.push({
-        funcName: scope.funcName,
-        receiverName: receiver,
-        binding,
-        mutatingExpr: truncate(expr.text),
-        line: node.startPosition.row + 1,
-      });
-    }
-  }
-
-  // Recursive AST walk
-  function visit(node) {
-    if (!node) return;
-    const t = node.type;
-
-    // Enter function scopes
-    if (rules.functionNodes.has(t)) {
-      enterScope(node);
-      for (const child of node.namedChildren) {
-        visit(child);
-      }
-      exitScope();
-      return;
-    }
-
-    // Return statements
-    if (rules.returnNode && t === rules.returnNode) {
-      const scope = currentScope();
-      if (scope?.funcName) {
-        const expr = node.namedChildren[0];
-        const referencedNames = [];
-        if (expr) collectIdentifiers(expr, referencedNames, rules);
-        returns.push({
-          funcName: scope.funcName,
-          expression: truncate(expr ? expr.text : ''),
-          referencedNames,
-          line: node.startPosition.row + 1,
-        });
-      }
-      for (const child of node.namedChildren) {
-        visit(child);
-      }
-      return;
-    }
-
-    // Variable declarations
-    if (rules.varDeclaratorNode && t === rules.varDeclaratorNode) {
-      handleVarDeclarator(node);
-      for (const child of node.namedChildren) {
-        visit(child);
-      }
-      return;
-    }
-    if (rules.varDeclaratorNodes?.has(t)) {
-      handleVarDeclarator(node);
-      for (const child of node.namedChildren) {
-        visit(child);
-      }
-      return;
-    }
-
-    // Call expressions
-    if (isCallNode(t)) {
-      handleCallExpr(node);
-      for (const child of node.namedChildren) {
-        visit(child);
-      }
-      return;
-    }
-
-    // Assignment expressions
-    if (rules.assignmentNode && t === rules.assignmentNode) {
-      handleAssignment(node);
-      for (const child of node.namedChildren) {
-        visit(child);
-      }
-      return;
-    }
-
-    // Mutation detection via expression_statement
-    if (rules.expressionStmtNode && t === rules.expressionStmtNode) {
-      handleExprStmtMutation(node);
-    }
-
-    // Default: visit all children
-    for (const child of node.namedChildren) {
-      visit(child);
-    }
-  }
-
-  visit(tree.rootNode);
-
-  return { parameters, returns, assignments, argFlows, mutations };
-}
+  const visitor = createDataflowVisitor(rules);
+  const results = walkWithVisitors(tree.rootNode, [visitor], langId, {
+    functionNodeTypes: rules.functionNodes,
+    getFunctionName: () => null, // dataflow visitor handles its own name extraction
+  });
 
-/**
- * Collect all identifier names referenced within a node.
- * Uses isIdent() to support language-specific identifier node types
- * (e.g. PHP's `variable_name`).
- */
-function collectIdentifiers(node, out, rules) {
-  if (!node) return;
-  if (isIdent(node.type, rules)) {
-    out.push(node.text);
-    return;
-  }
-  for (const child of node.namedChildren) {
-    collectIdentifiers(child, out, rules);
-  }
+  return results.dataflow;
 }
 
 // ── buildDataflowEdges ──────────────────────────────────────────────────────
@@ -792,18 +261,6 @@ function findNodes(db, name, opts = {}) {
   return opts.noTests ? rows.filter((n) => !isTestFile(n.file)) : rows;
 }
 
-/**
- * Check if the dataflow table exists and has data.
- */
-function hasDataflowTable(db) {
-  try {
-    const row = db.prepare('SELECT COUNT(*) as c FROM dataflow').get();
-    return row.c > 0;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Return all dataflow edges for a symbol.
  *
@@ -1147,113 +604,3 @@ export function dataflowImpactData(name, customDbPath, opts = {}) {
     db.close();
   }
 }
-
-// ── Display formatters ──────────────────────────────────────────────────────
-
-/**
- * CLI display for dataflow command.
- */
-export function dataflow(name, customDbPath, opts = {}) {
-  if (opts.impact) {
-    return dataflowImpact(name, customDbPath, opts);
-  }
-
-  const data = dataflowData(name, customDbPath, opts);
-
-  if (outputResult(data, 'results', opts)) return;
-
-  if (data.warning) {
-    console.log(`⚠  ${data.warning}`);
-    return;
-  }
-  if (data.results.length === 0) {
-    console.log(`No symbols matching "${name}".`);
-    return;
-  }
-
-  for (const r of data.results) {
-    console.log(`\n${r.kind} ${r.name}  (${r.file}:${r.line})`);
-    console.log('─'.repeat(60));
-
-    if (r.flowsTo.length > 0) {
-      console.log('\n  Data flows TO:');
-      for (const f of r.flowsTo) {
-        const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
-        console.log(`    → ${f.target} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
-      }
-    }
-
-    if (r.flowsFrom.length > 0) {
-      console.log('\n  Data flows FROM:');
-      for (const f of r.flowsFrom) {
-        const conf = f.confidence < 1.0 ? ` [${(f.confidence * 100).toFixed(0)}%]` : '';
-        console.log(`    ← ${f.source} (${f.file}:${f.line}) arg[${f.paramIndex}]${conf}`);
-      }
-    }
-
-    if (r.returns.length > 0) {
-      console.log('\n  Return value consumed by:');
-      for (const c of r.returns) {
-        console.log(`    → ${c.consumer} (${c.file}:${c.line})  ${c.expression}`);
-      }
-    }
-
-    if (r.returnedBy.length > 0) {
-      console.log('\n  Uses return value of:');
-      for (const p of r.returnedBy) {
-        console.log(`    ← ${p.producer} (${p.file}:${p.line})  ${p.expression}`);
-      }
-    }
-
-    if (r.mutates.length > 0) {
-      console.log('\n  Mutates:');
-      for (const m of r.mutates) {
-        console.log(`    ✎ ${m.expression}  (line ${m.line})`);
-      }
-    }
-
-    if (r.mutatedBy.length > 0) {
-      console.log('\n  Mutated by:');
-      for (const m of r.mutatedBy) {
-        console.log(`    ✎ ${m.source} — ${m.expression}  (line ${m.line})`);
-      }
-    }
-  }
-}
-
-/**
- * CLI display for dataflow --impact.
- */
-function dataflowImpact(name, customDbPath, opts = {}) {
-  const data = dataflowImpactData(name, customDbPath, {
-    noTests: opts.noTests,
-    depth: opts.depth ? Number(opts.depth) : 5,
-    file: opts.file,
-    kind: opts.kind,
-    limit: opts.limit,
-    offset: opts.offset,
-  });
-
-  if (outputResult(data, 'results', opts)) return;
-
-  if (data.warning) {
-    console.log(`⚠  ${data.warning}`);
-    return;
-  }
-  if (data.results.length === 0) {
-    console.log(`No symbols matching "${name}".`);
-    return;
-  }
-
-  for (const r of data.results) {
-    console.log(
-      `\n${r.kind} ${r.name}  (${r.file}:${r.line})  — ${r.totalAffected} data-dependent consumer${r.totalAffected !== 1 ? 's' : ''}`,
-    );
-    for (const [level, items] of Object.entries(r.levels)) {
-      console.log(`  Level ${level}:`);
-      for (const item of items) {
-        console.log(`    ${item.name} (${item.file}:${item.line})`);
-      }
-    }
-  }
-}