@optave/codegraph 3.7.0 → 3.8.0

package/src/extractors/cuda.ts

@@ -0,0 +1,316 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from CUDA files.
+ *
+ * CUDA is a C++ superset. The tree-sitter-cuda grammar extends C++ with
+ * __global__, __device__, __host__, __shared__ qualifiers and kernel
+ * launch syntax (<<<...>>>). We reuse C++ handler patterns and add
+ * CUDA-specific qualifier detection.
+ */
+export function extractCudaSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkCudaNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+const CUDA_QUALIFIERS = new Set([
+  '__global__',
+  '__device__',
+  '__host__',
+  '__shared__',
+  '__constant__',
+]);
+
+function walkCudaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function_definition':
+      handleCudaFunctionDef(node, ctx);
+      break;
+    case 'class_specifier':
+      handleCudaClassSpecifier(node, ctx);
+      break;
+    case 'struct_specifier':
+      handleCudaStructSpecifier(node, ctx);
+      break;
+    case 'enum_specifier':
+      handleCudaEnumSpecifier(node, ctx);
+      break;
+    case 'namespace_definition':
+      handleCudaNamespaceDef(node, ctx);
+      break;
+    case 'type_definition':
+      handleCudaTypedef(node, ctx);
+      break;
+    case 'preproc_include':
+      handleCudaInclude(node, ctx);
+      break;
+    case 'call_expression':
+      handleCudaCallExpression(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkCudaNode(child, ctx);
+  }
+}
+
+// ── Handlers ───────────────────────────────────────────────────────────────
+
+function handleCudaFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const declarator = node.childForFieldName('declarator');
+  if (!declarator) return;
+  const funcDeclarator =
+    declarator.type === 'function_declarator'
+      ? declarator
+      : findChild(declarator, 'function_declarator');
+  if (!funcDeclarator) return;
+  const nameNode = funcDeclarator.childForFieldName('declarator');
+  if (!nameNode) return;
+  const name = nameNode.text;
+
+  const parentClass = findCudaParentClass(node);
+  const fullName = parentClass ? `${parentClass}.${name}` : name;
+  const kind = parentClass ? 'method' : 'function';
+
+  const params = extractCudaParameters(funcDeclarator.childForFieldName('parameters'));
+  const decorators = extractCudaQualifiers(node);
+
+  ctx.definitions.push({
+    name: fullName,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: parentClass ? extractModifierVisibility(node) : undefined,
+    decorators: decorators.length > 0 ? decorators : undefined,
+  });
+}
+
+function handleCudaClassSpecifier(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const children = extractCudaClassFields(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  const baseClause = findChild(node, 'base_class_clause');
+  if (baseClause) {
+    for (let i = 0; i < baseClause.childCount; i++) {
+      const child = baseClause.child(i);
+      if (child && (child.type === 'type_identifier' || child.type === 'qualified_identifier')) {
+        ctx.classes.push({
+          name: nameNode.text,
+          extends: child.text,
+          line: node.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+function handleCudaStructSpecifier(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const children = extractCudaClassFields(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'struct',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleCudaEnumSpecifier(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const children = extractCudaEnumEntries(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'enum',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleCudaNamespaceDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'namespace',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleCudaTypedef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  let name: string | undefined;
+  for (let i = node.childCount - 1; i >= 0; i--) {
+    const child = node.child(i);
+    if (
+      child &&
+      (child.type === 'type_identifier' ||
+        child.type === 'identifier' ||
+        child.type === 'primitive_type')
+    ) {
+      name = child.text;
+      break;
+    }
+  }
+  if (!name) return;
+  ctx.definitions.push({
+    name,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleCudaInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const pathNode = node.childForFieldName('path');
+  if (!pathNode) return;
+  const raw = pathNode.text;
+  const source = raw.replace(/^["<]|[">]$/g, '');
+  const lastName = source.split('/').pop() ?? source;
+  ctx.imports.push({
+    source,
+    names: [lastName],
+    line: node.startPosition.row + 1,
+    cInclude: true,
+  });
+}
+
+function handleCudaCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.childForFieldName('function');
+  if (!funcNode) return;
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+  if (funcNode.type === 'field_expression') {
+    const field = funcNode.childForFieldName('field');
+    const argument = funcNode.childForFieldName('argument');
+    if (field) call.name = field.text;
+    if (argument) call.receiver = argument.text;
+  } else {
+    call.name = funcNode.text;
+  }
+  if (call.name) ctx.calls.push(call);
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function extractCudaQualifiers(node: TreeSitterNode): string[] {
+  const qualifiers: string[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    // Check direct text match for bare qualifier tokens, or look inside
+    // storage_class_specifier / attribute_specifier wrapper nodes.
+    // Use `else if` to avoid pushing the same qualifier twice when
+    // wrapper-node text also matches CUDA_QUALIFIERS directly.
+    if (child.type === 'storage_class_specifier' || child.type === 'attribute_specifier') {
+      if (CUDA_QUALIFIERS.has(child.text)) qualifiers.push(child.text);
+    } else if (CUDA_QUALIFIERS.has(child.text)) {
+      qualifiers.push(child.text);
+    }
+  }
+  return qualifiers;
+}
+
+function findCudaParentClass(node: TreeSitterNode): string | null {
+  let current = node.parent;
+  while (current) {
+    if (current.type === 'field_declaration_list') {
+      const classNode = current.parent;
+      if (
+        classNode &&
+        (classNode.type === 'class_specifier' || classNode.type === 'struct_specifier')
+      ) {
+        const nameNode = classNode.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+function extractCudaParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  if (!paramListNode) return params;
+  for (let i = 0; i < paramListNode.childCount; i++) {
+    const param = paramListNode.child(i);
+    if (!param || param.type !== 'parameter_declaration') continue;
+    const nameNode = param.childForFieldName('declarator');
+    if (nameNode) {
+      const name =
+        nameNode.type === 'identifier'
+          ? nameNode.text
+          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
+    }
+  }
+  return params;
+}
+
+function extractCudaClassFields(classNode: TreeSitterNode): SubDeclaration[] {
+  const fields: SubDeclaration[] = [];
+  const body =
+    classNode.childForFieldName('body') || findChild(classNode, 'field_declaration_list');
+  if (!body) return fields;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== 'field_declaration') continue;
+    const nameNode = member.childForFieldName('declarator');
+    if (nameNode) {
+      const name =
+        nameNode.type === 'identifier'
+          ? nameNode.text
+          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      fields.push({
+        name,
+        kind: 'property',
+        line: member.startPosition.row + 1,
+        visibility: extractModifierVisibility(member),
+      });
+    }
+  }
+  return fields;
+}
+
+function extractCudaEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
+  const entries: SubDeclaration[] = [];
+  const body = findChild(enumNode, 'enumerator_list');
+  if (!body) return entries;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== 'enumerator') continue;
+    const nameNode = member.childForFieldName('name');
+    if (nameNode) {
+      entries.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });
+    }
+  }
+  return entries;
+}

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