@optave/codegraph 3.5.0 → 3.7.0

package/src/extractors/rust.ts

@@ -5,7 +5,14 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { findChild, MAX_WALK_DEPTH, nodeEndLine, rustVisibility } from './helpers.js';
+import {
+  extractBodyMembers,
+  findParentNode,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+  rustVisibility,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /**
  * Extract symbols from Rust files.
@@ -206,16 +213,9 @@ function handleRustMacroInvocation(node: TreeSitterNode, ctx: ExtractorOutput):
   }
 }
 
+const RUST_IMPL_TYPES = ['impl_item'] as const;
 function findCurrentImpl(node: TreeSitterNode): string | null {
-  let current = node.parent;
-  while (current) {
-    if (current.type === 'impl_item') {
-      const typeNode = current.childForFieldName('type');
-      return typeNode ? typeNode.text : null;
-    }
-    current = current.parent;
-  }
-  return null;
+  return findParentNode(node, RUST_IMPL_TYPES, 'type');
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────
@@ -227,8 +227,7 @@ function extractRustParameters(paramListNode: TreeSitterNode | null): SubDeclara
     const param = paramListNode.child(i);
     if (!param) continue;
     if (param.type === 'self_parameter') {
-      // Skip self parameters — matches native engine behaviour
-      continue;
+      // Skip self — matches native engine behaviour
     } else if (param.type === 'parameter') {
       const pattern = param.childForFieldName('pattern');
       if (pattern) {
@@ -240,34 +239,16 @@ function extractRustParameters(paramListNode: TreeSitterNode | null): SubDeclara
 }
 
 function extractStructFields(structNode: TreeSitterNode): SubDeclaration[] {
-  const fields: SubDeclaration[] = [];
-  const fieldList =
-    structNode.childForFieldName('body') || findChild(structNode, 'field_declaration_list');
-  if (!fieldList) return fields;
-  for (let i = 0; i < fieldList.childCount; i++) {
-    const field = fieldList.child(i);
-    if (!field || field.type !== 'field_declaration') continue;
-    const nameNode = field.childForFieldName('name');
-    if (nameNode) {
-      fields.push({ name: nameNode.text, kind: 'property', line: field.startPosition.row + 1 });
-    }
-  }
-  return fields;
+  return extractBodyMembers(
+    structNode,
+    ['body', 'field_declaration_list'],
+    'field_declaration',
+    'property',
+  );
 }
 
 function extractEnumVariants(enumNode: TreeSitterNode): SubDeclaration[] {
-  const variants: SubDeclaration[] = [];
-  const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_variant_list');
-  if (!body) return variants;
-  for (let i = 0; i < body.childCount; i++) {
-    const variant = body.child(i);
-    if (!variant || variant.type !== 'enum_variant') continue;
-    const nameNode = variant.childForFieldName('name');
-    if (nameNode) {
-      variants.push({ name: nameNode.text, kind: 'constant', line: variant.startPosition.row + 1 });
-    }
-  }
-  return variants;
+  return extractBodyMembers(enumNode, ['body', 'enum_variant_list'], 'enum_variant', 'constant');
 }
 
 function extractRustTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
@@ -283,7 +264,7 @@ function extractRustTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, dep
     const typeNode = node.childForFieldName('type');
     if (pattern && pattern.type === 'identifier' && typeNode) {
       const typeName = extractRustTypeName(typeNode);
-      if (typeName) ctx.typeMap?.set(pattern.text, { type: typeName, confidence: 0.9 });
+      if (typeName && ctx.typeMap) setTypeMapEntry(ctx.typeMap, pattern.text, typeName, 0.9);
     }
   }
 
@@ -295,7 +276,7 @@ function extractRustTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, dep
       const name = pattern.type === 'identifier' ? pattern.text : null;
       if (name && name !== 'self' && name !== '&self' && name !== '&mut self') {
         const typeName = extractRustTypeName(typeNode);
-        if (typeName) ctx.typeMap?.set(name, { type: typeName, confidence: 0.9 });
+        if (typeName && ctx.typeMap) setTypeMapEntry(ctx.typeMap, name, typeName, 0.9);
       }
     }
   }
@@ -328,56 +309,55 @@ function extractRustTypeName(typeNode: TreeSitterNode): string | null {
   return null;
 }
 
-function extractRustUsePath(node: TreeSitterNode | null): { source: string; names: string[] }[] {
-  if (!node) return [];
-
-  if (node.type === 'use_list') {
-    const results: { source: string; names: string[] }[] = [];
-    for (let i = 0; i < node.childCount; i++) {
-      results.push(...extractRustUsePath(node.child(i)));
+/** Collect names from a scoped_use_list's list node. */
+function collectScopedNames(listNode: TreeSitterNode): string[] {
+  const names: string[] = [];
+  for (let i = 0; i < listNode.childCount; i++) {
+    const child = listNode.child(i);
+    if (!child) continue;
+    if (child.type === 'identifier' || child.type === 'self') {
+      names.push(child.text);
+    } else if (child.type === 'use_as_clause') {
+      const name = (child.childForFieldName('alias') || child.childForFieldName('name'))?.text;
+      if (name) names.push(name);
     }
-    return results;
   }
+  return names;
+}
 
-  if (node.type === 'scoped_use_list') {
-    const pathNode = node.childForFieldName('path');
-    const listNode = node.childForFieldName('list');
-    const prefix = pathNode ? pathNode.text : '';
-    if (listNode) {
-      const names: string[] = [];
-      for (let i = 0; i < listNode.childCount; i++) {
-        const child = listNode.child(i);
-        if (
-          child &&
-          (child.type === 'identifier' || child.type === 'use_as_clause' || child.type === 'self')
-        ) {
-          const name =
-            child.type === 'use_as_clause'
-              ? (child.childForFieldName('alias') || child.childForFieldName('name'))?.text
-              : child.text;
-          if (name) names.push(name);
-        }
+function extractRustUsePath(node: TreeSitterNode | null): { source: string; names: string[] }[] {
+  if (!node) return [];
+
+  switch (node.type) {
+    case 'use_list': {
+      const results: { source: string; names: string[] }[] = [];
+      for (let i = 0; i < node.childCount; i++) {
+        results.push(...extractRustUsePath(node.child(i)));
       }
-      return [{ source: prefix, names }];
+      return results;
     }
-    return [{ source: prefix, names: [] }];
-  }
-
-  if (node.type === 'use_as_clause') {
-    const name = node.childForFieldName('alias') || node.childForFieldName('name');
-    return [{ source: node.text, names: name ? [name.text] : [] }];
-  }
-
-  if (node.type === 'use_wildcard') {
-    const pathNode = node.childForFieldName('path');
-    return [{ source: pathNode ? pathNode.text : '*', names: ['*'] }];
-  }
-
-  if (node.type === 'scoped_identifier' || node.type === 'identifier') {
-    const text = node.text;
-    const lastName = text.split('::').pop() ?? text;
-    return [{ source: text, names: [lastName] }];
+    case 'scoped_use_list': {
+      const pathNode = node.childForFieldName('path');
+      const listNode = node.childForFieldName('list');
+      const prefix = pathNode ? pathNode.text : '';
+      if (!listNode) return [{ source: prefix, names: [] }];
+      return [{ source: prefix, names: collectScopedNames(listNode) }];
+    }
+    case 'use_as_clause': {
+      const name = node.childForFieldName('alias') || node.childForFieldName('name');
+      return [{ source: node.text, names: name ? [name.text] : [] }];
+    }
+    case 'use_wildcard': {
+      const pathNode = node.childForFieldName('path');
+      return [{ source: pathNode ? pathNode.text : '*', names: ['*'] }];
+    }
+    case 'scoped_identifier':
+    case 'identifier': {
+      const text = node.text;
+      const lastName = text.split('::').pop() ?? text;
+      return [{ source: text, names: [lastName] }];
+    }
+    default:
+      return [];
   }
-
-  return [];
 }

package/src/extractors/scala.ts

@@ -0,0 +1,285 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Scala files.
+ */
+export function extractScalaSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkScalaNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkScalaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'class_definition':
+      handleScalaClassDef(node, ctx);
+      break;
+    case 'trait_definition':
+      handleScalaTraitDef(node, ctx);
+      break;
+    case 'object_definition':
+      handleScalaObjectDef(node, ctx);
+      break;
+    case 'function_definition':
+      handleScalaFunctionDef(node, ctx);
+      break;
+    case 'import_declaration':
+      handleScalaImportDecl(node, ctx);
+      break;
+    case 'call_expression':
+      handleScalaCallExpression(node, ctx);
+      break;
+    case 'val_definition':
+    case 'var_definition':
+      handleScalaValVarDef(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkScalaNode(child, ctx);
+  }
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function handleScalaClassDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const children = extractScalaBodyMembers(node, name, ctx);
+
+  ctx.definitions.push({
+    name,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  extractScalaInheritance(node, name, ctx);
+}
+
+function handleScalaTraitDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const children = extractScalaBodyMembers(node, name, ctx);
+
+  ctx.definitions.push({
+    name,
+    kind: 'interface',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  extractScalaInheritance(node, name, ctx);
+}
+
+function handleScalaObjectDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const children = extractScalaBodyMembers(node, name, ctx);
+
+  ctx.definitions.push({
+    name,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  extractScalaInheritance(node, name, ctx);
+}
+
+function handleScalaFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Skip methods already emitted by class/trait/object handlers
+  if (node.parent?.type === 'template_body') {
+    const grandparent = node.parent.parent;
+    if (
+      grandparent &&
+      (grandparent.type === 'class_definition' ||
+        grandparent.type === 'trait_definition' ||
+        grandparent.type === 'object_definition')
+    ) {
+      return;
+    }
+  }
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const params = extractScalaParameters(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: extractModifierVisibility(node),
+  });
+}
+
+function handleScalaImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // import_declaration has alternating `identifier` and `.` children directly (NO import_expression wrapper)
+  const parts: string[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'identifier' || child.type === 'type_identifier') {
+      parts.push(child.text);
+    }
+  }
+  if (parts.length === 0) return;
+  const fullPath = parts.join('.');
+  const lastName = parts[parts.length - 1] ?? fullPath;
+  ctx.imports.push({
+    source: fullPath,
+    names: [lastName],
+    line: node.startPosition.row + 1,
+    scalaImport: true,
+  });
+}
+
+function handleScalaCallExpression(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 value = funcNode.childForFieldName('value');
+    if (field) call.name = field.text;
+    if (value) call.receiver = value.text;
+  } else {
+    call.name = funcNode.text;
+  }
+  if (call.name) ctx.calls.push(call);
+}
+
+function handleScalaValVarDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Only handle top-level vals/vars — skip class members and function-local bindings
+  if (node.parent?.type === 'template_body') return;
+  if (node.parent?.type === 'block' || node.parent?.type === 'indented_block') return;
+  const pattern = node.childForFieldName('pattern');
+  if (!pattern) return;
+  const nameNode = pattern.type === 'identifier' ? pattern : findChild(pattern, 'identifier');
+  if (!nameNode) return;
+  const kind = node.type === 'val_definition' ? 'constant' : 'variable';
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+// ── Inheritance helpers ─────────────────────────────────────────────────────
+
+function extractScalaInheritance(node: TreeSitterNode, name: string, ctx: ExtractorOutput): void {
+  const extendsClause = findChild(node, 'extends_clause');
+  if (!extendsClause) return;
+  let foundExtends = false;
+  for (let i = 0; i < extendsClause.childCount; i++) {
+    const child = extendsClause.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'type_identifier' ||
+      child.type === 'generic_type' ||
+      child.type === 'identifier'
+    ) {
+      const typeName = child.type === 'generic_type' ? child.child(0)?.text : child.text;
+      if (!typeName) continue;
+      if (!foundExtends) {
+        ctx.classes.push({
+          name,
+          extends: typeName,
+          line: node.startPosition.row + 1,
+        });
+        foundExtends = true;
+      } else {
+        ctx.classes.push({
+          name,
+          implements: typeName,
+          line: node.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+// ── Body member extraction ──────────────────────────────────────────────────
+
+function extractScalaBodyMembers(
+  parentNode: TreeSitterNode,
+  parentName: string,
+  ctx: ExtractorOutput,
+): SubDeclaration[] {
+  const children: SubDeclaration[] = [];
+  const body = findChild(parentNode, 'template_body');
+  if (!body) return children;
+
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member) continue;
+
+    if (member.type === 'function_definition') {
+      const methName = member.childForFieldName('name');
+      if (methName) {
+        ctx.definitions.push({
+          name: `${parentName}.${methName.text}`,
+          kind: 'method',
+          line: member.startPosition.row + 1,
+          endLine: member.endPosition.row + 1,
+          visibility: extractModifierVisibility(member),
+        });
+      }
+    } else if (member.type === 'val_definition' || member.type === 'var_definition') {
+      const pattern = member.childForFieldName('pattern');
+      if (pattern) {
+        const nameNode = pattern.type === 'identifier' ? pattern : findChild(pattern, 'identifier');
+        if (nameNode) {
+          children.push({
+            name: nameNode.text,
+            kind: 'property',
+            line: member.startPosition.row + 1,
+            visibility: extractModifierVisibility(member),
+          });
+        }
+      }
+    }
+  }
+
+  return children;
+}
+
+// ── Parameter extraction ────────────────────────────────────────────────────
+
+function extractScalaParameters(funcNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramList = findChild(funcNode, 'parameters');
+  if (!paramList) return params;
+  for (let i = 0; i < paramList.childCount; i++) {
+    const param = paramList.child(i);
+    if (!param || param.type !== 'parameter') continue;
+    const nameNode = findChild(param, 'identifier');
+    if (nameNode) {
+      params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+    }
+  }
+  return params;
+}