@optave/codegraph 3.6.0 → 3.8.0

package/src/extractors/elixir.ts

@@ -0,0 +1,251 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Elixir files.
+ *
+ * Elixir's tree-sitter grammar represents most constructs as generic `call` nodes.
+ * We distinguish modules, functions, imports etc. by the call target's identifier text.
+ */
+export function extractElixirSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkElixirNode(tree.rootNode, ctx, null);
+  return ctx;
+}
+
+function walkElixirNode(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  let nextModule = currentModule;
+
+  if (node.type === 'call') {
+    const target = node.childForFieldName('target');
+    if (target?.type === 'identifier' && target.text === 'defmodule') {
+      const args = findChild(node, 'arguments');
+      const aliasNode = args && findChild(args, 'alias');
+      if (aliasNode) nextModule = aliasNode.text;
+    }
+    handleElixirCall(node, ctx, nextModule);
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkElixirNode(child, ctx, nextModule);
+  }
+}
+
+function handleElixirCall(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  const target = node.childForFieldName('target');
+  if (!target) return;
+
+  if (target.type === 'identifier') {
+    const keyword = target.text;
+    switch (keyword) {
+      case 'defmodule':
+        handleDefmodule(node, ctx);
+        return;
+      case 'def':
+      case 'defp':
+        handleDefFunction(node, ctx, currentModule, keyword === 'defp' ? 'private' : 'public');
+        return;
+      case 'defprotocol':
+        handleDefprotocol(node, ctx);
+        return;
+      case 'defimpl':
+        handleDefimpl(node, ctx);
+        return;
+      case 'import':
+      case 'use':
+      case 'require':
+      case 'alias':
+        handleElixirImport(node, ctx, keyword);
+        return;
+      default:
+        // Regular function call
+        ctx.calls.push({ name: keyword, line: node.startPosition.row + 1 });
+        return;
+    }
+  }
+
+  if (target.type === 'dot') {
+    handleDotCall(node, target, ctx);
+  }
+}
+
+function handleDefmodule(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+  const name = aliasNode.text;
+
+  const children: SubDeclaration[] = [];
+  const doBlock = findChild(node, 'do_block');
+  if (doBlock) {
+    collectModuleMembers(doBlock, ctx, name, children);
+  }
+
+  ctx.definitions.push({
+    name,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function collectModuleMembers(
+  doBlock: TreeSitterNode,
+  _ctx: ExtractorOutput,
+  _moduleName: string,
+  children: SubDeclaration[],
+): void {
+  for (let i = 0; i < doBlock.childCount; i++) {
+    const child = doBlock.child(i);
+    if (!child || child.type !== 'call') continue;
+    const target = child.childForFieldName('target');
+    if (!target || target.type !== 'identifier') continue;
+
+    if (target.text === 'def' || target.text === 'defp') {
+      const fnName = extractFunctionName(child);
+      if (fnName) {
+        children.push({
+          name: fnName,
+          kind: 'property',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+function handleDefFunction(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+  visibility: 'public' | 'private',
+): void {
+  const fnName = extractFunctionName(node);
+  if (!fnName) return;
+
+  const fullName = currentModule ? `${currentModule}.${fnName}` : fnName;
+  const params = extractElixirParams(node);
+
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility,
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function extractFunctionName(defCallNode: TreeSitterNode): string | null {
+  const args = findChild(defCallNode, 'arguments');
+  if (!args) return null;
+
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child) continue;
+    if (child.type === 'call') {
+      const target = child.childForFieldName('target');
+      if (target?.type === 'identifier') return target.text;
+    }
+    if (child.type === 'identifier') return child.text;
+  }
+  return null;
+}
+
+function extractElixirParams(defCallNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const args = findChild(defCallNode, 'arguments');
+  if (!args) return params;
+
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child || child.type !== 'call') continue;
+    const innerArgs = findChild(child, 'arguments');
+    if (!innerArgs) continue;
+    for (let j = 0; j < innerArgs.childCount; j++) {
+      const param = innerArgs.child(j);
+      if (!param) continue;
+      if (param.type === 'identifier') {
+        params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function handleDefprotocol(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+
+  ctx.definitions.push({
+    name: aliasNode.text,
+    kind: 'interface',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDefimpl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+
+  ctx.definitions.push({
+    name: aliasNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleElixirImport(node: TreeSitterNode, ctx: ExtractorOutput, keyword: string): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+
+  ctx.imports.push({
+    source: aliasNode.text,
+    names: [keyword],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleDotCall(node: TreeSitterNode, dotNode: TreeSitterNode, ctx: ExtractorOutput): void {
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+  const right = findChild(dotNode, 'identifier');
+  const left = findChild(dotNode, 'alias');
+
+  if (right) call.name = right.text;
+  if (left) call.receiver = left.text;
+
+  if (call.name) ctx.calls.push(call);
+}

package/src/extractors/erlang.ts

@@ -0,0 +1,252 @@
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Erlang files.
+ *
+ * tree-sitter-erlang (WhatsApp) grammar notes:
+ * - module_attribute: -module(name).
+ * - record_decl: -record(name, {fields}).
+ * - fun_decl: contains function_clause children
+ * - function_clause: atom expr_args clause_body
+ * - call: function calls, with remote child for module:func
+ * - expr_args: parenthesized argument lists
+ */
+export function extractErlangSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkErlangNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkErlangNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'module_attribute':
+      handleModuleAttr(node, ctx);
+      break;
+    case 'record_decl':
+      handleRecordDecl(node, ctx);
+      break;
+    case 'type_alias':
+    case 'opaque':
+      handleTypeAlias(node, ctx);
+      break;
+    case 'fun_decl':
+      handleFunDecl(node, ctx);
+      break;
+    case 'function_clause':
+      // Only handle if not inside fun_decl (fun_decl handles its own clauses)
+      if (node.parent?.type !== 'fun_decl') {
+        handleFunctionClause(node, ctx);
+      }
+      break;
+    case 'pp_define':
+      handleDefine(node, ctx);
+      break;
+    case 'pp_include':
+    case 'pp_include_lib':
+      handleInclude(node, ctx);
+      break;
+    case 'import_attribute':
+      handleImportAttr(node, ctx);
+      break;
+    case 'call':
+      handleCall(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkErlangNode(child, ctx);
+  }
+}
+
+function handleModuleAttr(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // module_attribute: - module ( atom ) .
+  const nameNode = findChild(node, 'atom');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleRecordDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // record_decl: - record ( atom , { record_field, ... } ) .
+  const nameNode = findChild(node, 'atom');
+  if (!nameNode) return;
+
+  const children: SubDeclaration[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'record_field' || child.type === 'typed_record_field') {
+      const fieldName = findChild(child, 'atom');
+      if (fieldName) {
+        children.push({
+          name: fieldName.text,
+          kind: 'property',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+  }
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'record',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'atom');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleFunDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // fun_decl contains one or more function_clause children + dots
+  // Extract from the first function_clause
+  const clause = findChild(node, 'function_clause');
+  if (!clause) return;
+
+  handleFunctionClause(clause, ctx);
+}
+
+function handleFunctionClause(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // function_clause: atom expr_args clause_body
+  const nameNode = findChild(node, 'atom');
+  if (!nameNode) return;
+
+  // Don't duplicate if we already have this function
+  if (ctx.definitions.some((d) => d.name === nameNode.text && d.kind === 'function')) return;
+
+  const params = extractErlangParams(node);
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node.parent?.type === 'fun_decl' ? node.parent : node),
+    children: params.length > 0 ? params : undefined,
+    visibility: 'public',
+  });
+}
+
+function extractErlangParams(clauseNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const argsNode = findChild(clauseNode, 'expr_args');
+  if (!argsNode) return params;
+
+  for (let i = 0; i < argsNode.childCount; i++) {
+    const child = argsNode.child(i);
+    if (!child) continue;
+    if (child.type === 'var') {
+      params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+    }
+    if (child.type === 'atom') {
+      params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+    }
+  }
+  return params;
+}
+
+function handleDefine(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // pp_define: -define(NAME, value).
+  const nameNode =
+    findChild(node, 'var') || findChild(node, 'atom') || findChild(node, 'macro_lhs');
+  if (!nameNode) return;
+
+  const name =
+    nameNode.type === 'macro_lhs'
+      ? (findChild(nameNode, 'var')?.text ?? nameNode.text)
+      : nameNode.text;
+
+  ctx.definitions.push({
+    name,
+    kind: 'variable',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const strNode = findChild(node, 'string');
+  if (!strNode) return;
+
+  const source = strNode.text.replace(/^"|"$/g, '');
+  ctx.imports.push({
+    source,
+    names: ['include'],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleImportAttr(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const moduleNode = findChild(node, 'atom');
+  if (!moduleNode) return;
+
+  const names: string[] = [];
+  // Find exported function names
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'fa') {
+      const fnName = findChild(child, 'atom');
+      if (fnName) names.push(fnName.text);
+    }
+  }
+
+  ctx.imports.push({
+    source: moduleNode.text,
+    names: names.length > 0 ? names : [moduleNode.text],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // call: first child is function ref (atom or remote), then expr_args
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+
+  if (funcNode.type === 'atom' || funcNode.type === 'identifier') {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  } else if (funcNode.type === 'remote') {
+    // module:function — remote has atom : atom children
+    const atoms: string[] = [];
+    for (let i = 0; i < funcNode.childCount; i++) {
+      const child = funcNode.child(i);
+      if (child && (child.type === 'atom' || child.type === 'var')) {
+        atoms.push(child.text);
+      }
+    }
+    if (atoms.length >= 2) {
+      ctx.calls.push({
+        name: atoms[atoms.length - 1]!,
+        receiver: atoms.slice(0, -1).join(':'),
+        line: node.startPosition.row + 1,
+      });
+    } else if (atoms.length === 1) {
+      ctx.calls.push({ name: atoms[0]!, line: node.startPosition.row + 1 });
+    }
+  }
+}