@optave/codegraph 3.6.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/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 });
+      }
+    }
+  }
+}