@optave/codegraph 3.6.0 → 3.7.0

package/src/extractors/dart.ts

@@ -0,0 +1,304 @@
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Dart files.
+ */
+export function extractDartSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkDartNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkDartNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'class_definition':
+      handleDartClass(node, ctx);
+      break;
+    case 'enum_declaration':
+      handleDartEnum(node, ctx);
+      break;
+    case 'mixin_declaration':
+      handleDartMixin(node, ctx);
+      break;
+    case 'extension_declaration':
+      handleDartExtension(node, ctx);
+      break;
+    case 'function_signature':
+      handleDartFunction(node, ctx);
+      break;
+    case 'method_signature':
+      handleDartMethodSig(node, ctx);
+      break;
+    case 'library_import':
+      handleDartImport(node, ctx);
+      break;
+    case 'constructor_invocation':
+    case 'new_expression':
+      handleDartConstructorCall(node, ctx);
+      break;
+    case 'type_alias':
+      handleDartTypeAlias(node, ctx);
+      break;
+    case 'selector':
+      handleDartSelector(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkDartNode(child, ctx);
+  }
+}
+
+function handleDartClass(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const children: SubDeclaration[] = [];
+
+  const body = node.childForFieldName('body') || findChild(node, 'class_body');
+  if (body) {
+    extractDartClassMembers(body, name, ctx, children);
+  }
+
+  ctx.definitions.push({
+    name,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  extractDartInheritance(node, name, ctx);
+}
+
+function extractDartClassMembers(
+  body: TreeSitterNode,
+  className: string,
+  ctx: ExtractorOutput,
+  children: SubDeclaration[],
+): void {
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member) continue;
+
+    if (member.type === 'method_signature' || member.type === 'function_signature') {
+      const fnName = extractDartFunctionName(member);
+      if (fnName) {
+        ctx.definitions.push({
+          name: `${className}.${fnName}`,
+          kind: 'method',
+          line: member.startPosition.row + 1,
+          endLine: nodeEndLine(member),
+        });
+      }
+    } else if (member.type === 'declaration') {
+      // Field declarations
+      for (let j = 0; j < member.childCount; j++) {
+        const decl = member.child(j);
+        if (decl?.type === 'identifier') {
+          children.push({
+            name: decl.text,
+            kind: 'property',
+            line: member.startPosition.row + 1,
+          });
+          break;
+        }
+      }
+    }
+  }
+}
+
+function extractDartFunctionName(node: TreeSitterNode): string | null {
+  const nameNode = node.childForFieldName('name');
+  if (nameNode) return nameNode.text;
+
+  // Walk children for function_signature inside method_signature
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'function_signature' ||
+      child.type === 'getter_signature' ||
+      child.type === 'setter_signature' ||
+      child.type === 'constructor_signature'
+    ) {
+      const name = child.childForFieldName('name');
+      if (name) return name.text;
+    }
+  }
+  return null;
+}
+
+function handleDartEnum(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'enum',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartMixin(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartExtension(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartFunction(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Skip methods already emitted by class handler
+  if (isInsideDartClass(node)) return;
+
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartMethodSig(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  if (isInsideDartClass(node)) return;
+  const fnName = extractDartFunctionName(node);
+  if (!fnName) return;
+
+  ctx.definitions.push({
+    name: fnName,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function isInsideDartClass(node: TreeSitterNode): boolean {
+  let current = node.parent;
+  while (current) {
+    if (
+      current.type === 'class_body' ||
+      current.type === 'class_definition' ||
+      current.type === 'enum_body' ||
+      current.type === 'mixin_declaration'
+    ) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+function handleDartImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const spec = findChild(node, 'import_specification');
+  if (!spec) return;
+
+  const uri = findChild(spec, 'configurable_uri') || findChild(spec, 'uri');
+  if (!uri) return;
+
+  const source = uri.text.replace(/^['"]|['"]$/g, '');
+  const names: string[] = [];
+
+  // Check for `as` alias
+  const alias = findChild(spec, 'identifier');
+  if (alias) names.push(alias.text);
+
+  ctx.imports.push({
+    source,
+    names: names.length > 0 ? names : [source.split('/').pop() || source],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleDartConstructorCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'type_identifier') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.calls.push({
+    name: nameNode.text,
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleDartSelector(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // selector with argument_part represents a function call
+  const argPart = findChild(node, 'argument_part');
+  if (!argPart) return;
+
+  // Look for the identifier this selector belongs to
+  const unconditional = findChild(node, 'unconditional_assignable_selector');
+  if (unconditional) {
+    const id = findChild(unconditional, 'identifier');
+    if (id) {
+      ctx.calls.push({ name: id.text, line: node.startPosition.row + 1 });
+    }
+  }
+}
+
+function handleDartTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'type_identifier') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function extractDartInheritance(node: TreeSitterNode, name: string, ctx: ExtractorOutput): void {
+  const superclass = node.childForFieldName('superclass');
+  if (superclass) {
+    const typeName =
+      findChild(superclass, 'type_identifier') || findChild(superclass, 'identifier');
+    if (typeName) {
+      ctx.classes.push({ name, extends: typeName.text, line: node.startPosition.row + 1 });
+    }
+  }
+
+  const interfaces = node.childForFieldName('interfaces');
+  if (interfaces) {
+    for (let i = 0; i < interfaces.childCount; i++) {
+      const iface = interfaces.child(i);
+      if (!iface) continue;
+      const typeName =
+        iface.type === 'type_identifier'
+          ? iface
+          : findChild(iface, 'type_identifier') || findChild(iface, 'identifier');
+      if (typeName) {
+        ctx.classes.push({ name, implements: typeName.text, line: node.startPosition.row + 1 });
+      }
+    }
+  }
+}

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);
+}