@optave/codegraph 3.1.0 → 3.1.2

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

@@ -0,0 +1,176 @@
+/**
+ * Shared AST helper functions used by multiple visitors (dataflow, etc.).
+ *
+ * Extracted from dataflow.js to be reusable across the visitor framework.
+ */
+
+/**
+ * Truncate a string to a maximum length.
+ */
+export 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.
+ */
+export function functionName(fnNode, rules) {
+  if (!fnNode) return null;
+  const nameNode = fnNode.childForFieldName(rules.nameField);
+  if (nameNode) return nameNode.text;
+
+  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.
+ */
+export 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;
+}
+
+/**
+ * Extract parameter names from a single parameter node.
+ */
+export function extractParamNames(node, rules) {
+  if (!node) return [];
+  const t = node.type;
+
+  if (rules.extractParamName) {
+    const result = rules.extractParamName(node);
+    if (result) return result;
+  }
+
+  if (t === rules.paramIdentifier) return [node.text];
+
+  if (rules.paramWrapperTypes.has(t)) {
+    const pattern = node.childForFieldName('pattern') || node.childForFieldName('name');
+    return pattern ? extractParamNames(pattern, rules) : [];
+  }
+
+  if (rules.defaultParamType && t === rules.defaultParamType) {
+    const left = node.childForFieldName('left') || node.childForFieldName('name');
+    return left ? extractParamNames(left, rules) : [];
+  }
+
+  if (rules.restParamType && t === rules.restParamType) {
+    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 [];
+  }
+
+  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;
+  }
+
+  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.
+ */
+export 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.
+ */
+export function resolveCalleeName(callNode, rules) {
+  const fn = callNode.childForFieldName(rules.callFunctionField);
+  if (!fn) {
+    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.
+ */
+export 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;
+}
+
+/**
+ * Collect all identifier names referenced within a node.
+ */
+export 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);
+  }
+}

package/src/ast-analysis/visitor.js

@@ -0,0 +1,162 @@
+/**
+ * Shared DFS walker with pluggable visitors for AST analysis.
+ *
+ * Provides a single tree traversal that multiple analysis visitors can hook into,
+ * avoiding redundant walks over the same AST. Two hook styles:
+ *
+ *  - Node-level: enterNode / exitNode (called for every node)
+ *  - Function-level: enterFunction / exitFunction (called at function boundaries)
+ *
+ * The walker maintains shared context (nestingLevel, scopeStack, currentFunction)
+ * so individual visitors don't need to track traversal state themselves.
+ *
+ * @typedef {object} VisitorContext
+ * @property {number}  nestingLevel    - Current nesting depth (for complexity)
+ * @property {object}  currentFunction - Enclosing function node (or null)
+ * @property {string}  langId          - Language ID
+ * @property {Array}   scopeStack      - Function scope stack [{funcName, funcNode, params, locals}]
+ *
+ * @typedef {object} Visitor
+ * @property {string}   name
+ * @property {function} [init](langId, rules)         - Called once before the walk
+ * @property {function} [enterNode](node, context)     - Called entering each node; return { skipChildren: true } to skip this visitor's hooks for descendants
+ * @property {function} [exitNode](node, context)      - Called leaving each node
+ * @property {function} [enterFunction](funcNode, funcName, context) - Called entering a function
+ * @property {function} [exitFunction](funcNode, funcName, context)  - Called leaving a function
+ * @property {function} [finish]()                     - Called after the walk; return collected data
+ * @property {Set}      [functionNodeTypes]            - Extra function node types this visitor cares about
+ */
+
+/**
+ * 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, visitors, langId, options = {}) {
+  const {
+    functionNodeTypes = new Set(),
+    nestingNodeTypes = new Set(),
+    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);
+  }
+
+  // Shared context object (mutated during walk)
+  const scopeStack = [];
+  const context = {
+    nestingLevel: 0,
+    currentFunction: null,
+    langId,
+    scopeStack,
+  };
+
+  // Track which visitors have requested skipChildren at each depth
+  // Key: visitor index, Value: depth at which skip was requested
+  const skipDepths = new Map();
+
+  function walk(node, depth) {
+    if (!node) return;
+
+    const type = node.type;
+    const isFunction = allFuncTypes.has(type);
+    let funcName = null;
+
+    // Function boundary: enter
+    if (isFunction) {
+      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);
+        }
+      }
+    }
+
+    // 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);
+        }
+      }
+    }
+
+    // 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);
+      }
+    }
+
+    // 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);
+        }
+      }
+      scopeStack.pop();
+      context.currentFunction =
+        scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].funcNode : null;
+    }
+  }
+
+  function isSkipped(visitorIndex, currentDepth) {
+    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 = {};
+  for (const v of visitors) {
+    results[v.name] = v.finish ? v.finish() : undefined;
+  }
+  return results;
+}

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

@@ -0,0 +1,150 @@
+/**
+ * Visitor: Extract new/throw/await/string/regex AST nodes during a shared walk.
+ *
+ * Replaces the standalone walkAst() DFS in ast.js with a visitor that plugs
+ * into the unified walkWithVisitors framework.
+ */
+
+/** Max length for the `text` column. */
+const TEXT_MAX = 200;
+
+function truncate(s, max = TEXT_MAX) {
+  if (!s) return null;
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+function extractNewName(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child.type === 'identifier') return child.text;
+    if (child.type === 'member_expression') return child.text;
+  }
+  return node.text?.split('(')[0]?.replace('new ', '').trim() || '?';
+}
+
+function extractExpressionText(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child.type !== 'throw' && child.type !== 'await') {
+      return truncate(child.text);
+    }
+  }
+  return truncate(node.text);
+}
+
+function extractName(kind, node) {
+  if (kind === 'throw') {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      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 truncate(node.text);
+  }
+  if (kind === 'await') {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      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);
+}
+
+/**
+ * Create an AST-store visitor for use with walkWithVisitors.
+ *
+ * @param {object} astTypeMap - node type → kind mapping (e.g. JS_TS_AST_TYPES)
+ * @param {object[]} defs     - symbol definitions for parent lookup
+ * @param {string} relPath    - relative file path
+ * @param {Map} nodeIdMap     - def key → node ID mapping
+ * @returns {Visitor}
+ */
+export function createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap) {
+  const rows = [];
+  // Track which nodes we've already matched to avoid duplicates in recursive walk
+  const matched = new Set();
+
+  function findParentDef(line) {
+    let best = null;
+    for (const def of defs) {
+      if (def.line <= line && (def.endLine == null || def.endLine >= line)) {
+        if (!best || def.endLine - def.line < best.endLine - best.line) {
+          best = def;
+        }
+      }
+    }
+    return best;
+  }
+
+  function resolveParentNodeId(line) {
+    const parentDef = findParentDef(line);
+    if (!parentDef) return null;
+    return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
+  }
+
+  return {
+    name: 'ast-store',
+
+    enterNode(node, _context) {
+      if (matched.has(node.id)) return;
+
+      const kind = astTypeMap[node.type];
+      if (!kind) return;
+
+      const line = node.startPosition.row + 1;
+      let name;
+      let text = 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; // skip trivial strings, walker still descends
+        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);
+
+      // Don't recurse into children for new/throw/await (same as original walkAst)
+      if (kind !== 'string' && kind !== 'regex') {
+        return { skipChildren: true };
+      }
+    },
+
+    finish() {
+      return rows;
+    },
+  };
+}