@optave/codegraph 3.7.0 → 3.8.1

package/src/extractors/fsharp.ts

@@ -0,0 +1,253 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from F# files.
+ *
+ * tree-sitter-fsharp grammar notes:
+ * - named_module: top-level module declaration
+ * - function_declaration_left: LHS of `let name params = ...`
+ * - import_decl: `open Namespace`
+ * - type_definition > union_type_defn / record_type_defn
+ * - application_expression: function calls
+ */
+export function extractFSharpSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkFSharpNode(tree.rootNode, ctx, null);
+  return ctx;
+}
+
+function walkFSharpNode(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  let nextModule = currentModule;
+
+  switch (node.type) {
+    case 'named_module':
+      nextModule = handleNamedModule(node, ctx);
+      break;
+    case 'function_declaration_left':
+      handleFunctionDecl(node, ctx, currentModule);
+      break;
+    case 'type_definition':
+      handleTypeDef(node, ctx);
+      break;
+    case 'import_decl':
+      handleImportDecl(node, ctx);
+      break;
+    case 'application_expression':
+      handleApplication(node, ctx);
+      break;
+    case 'dot_expression':
+      handleDotExpression(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkFSharpNode(child, ctx, nextModule);
+  }
+}
+
+function handleNamedModule(node: TreeSitterNode, ctx: ExtractorOutput): string | null {
+  const nameNode = findChild(node, 'long_identifier');
+  if (!nameNode) return null;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+
+  return nameNode.text;
+}
+
+function handleFunctionDecl(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  // function_declaration_left: "add x y" — first child is the name identifier
+  const nameNode = findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  // Avoid duplicates — the walk will also visit children
+  if (
+    ctx.definitions.some((d) => d.name === nameNode.text && d.line === node.startPosition.row + 1)
+  )
+    return;
+
+  const params = extractFSharpParams(node);
+  const name = currentModule ? `${currentModule}.${nameNode.text}` : nameNode.text;
+
+  ctx.definitions.push({
+    name,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node.parent ?? node),
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function extractFSharpParams(declLeft: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const argPatterns = findChild(declLeft, 'argument_patterns');
+  if (!argPatterns) return params;
+
+  collectParamIdentifiers(argPatterns, params);
+  return params;
+}
+
+function collectParamIdentifiers(node: TreeSitterNode, params: SubDeclaration[]): void {
+  if (node.type === 'identifier') {
+    params.push({ name: node.text, kind: 'parameter', line: node.startPosition.row + 1 });
+    return;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) collectParamIdentifiers(child, params);
+  }
+}
+
+function handleTypeDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // type_definition contains union_type_defn, record_type_defn, etc.
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+
+    if (
+      child.type === 'union_type_defn' ||
+      child.type === 'record_type_defn' ||
+      child.type === 'type_abbreviation_defn' ||
+      child.type === 'class_type_defn' ||
+      child.type === 'interface_type_defn' ||
+      child.type === 'type_defn'
+    ) {
+      const nameNode = findChild(child, 'type_name');
+      const name = nameNode
+        ? (findChild(nameNode, 'identifier')?.text ?? nameNode.text)
+        : findChild(child, 'identifier')?.text;
+      if (!name) continue;
+
+      const kind = determineFSharpTypeKind(child);
+      const children: SubDeclaration[] = [];
+      extractFSharpTypeMembers(child, children);
+
+      ctx.definitions.push({
+        name,
+        kind,
+        line: child.startPosition.row + 1,
+        endLine: nodeEndLine(child),
+        children: children.length > 0 ? children : undefined,
+      });
+    }
+  }
+}
+
+function determineFSharpTypeKind(
+  typeDefn: TreeSitterNode,
+): 'class' | 'type' | 'record' | 'enum' | 'interface' {
+  switch (typeDefn.type) {
+    case 'union_type_defn':
+      return 'enum';
+    case 'record_type_defn':
+      return 'record';
+    case 'class_type_defn':
+      return 'class';
+    case 'interface_type_defn':
+      return 'interface';
+    default:
+      return 'type';
+  }
+}
+
+function extractFSharpTypeMembers(typeDefn: TreeSitterNode, children: SubDeclaration[]): void {
+  for (let i = 0; i < typeDefn.childCount; i++) {
+    const child = typeDefn.child(i);
+    if (!child) continue;
+
+    if (child.type === 'union_type_case') {
+      const nameNode = findChild(child, 'identifier');
+      if (nameNode) {
+        children.push({
+          name: nameNode.text,
+          kind: 'property',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+    if (child.type === 'record_field') {
+      const nameNode = child.childForFieldName('name') || findChild(child, 'identifier');
+      if (nameNode) {
+        children.push({
+          name: nameNode.text,
+          kind: 'property',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+    // Recurse into containers like union_type_cases
+    if (child.type === 'union_type_cases' || child.type === 'record_fields') {
+      extractFSharpTypeMembers(child, children);
+    }
+  }
+}
+
+function handleImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const moduleNode = findChild(node, 'long_identifier');
+  if (!moduleNode) return;
+
+  const source = moduleNode.text;
+  ctx.imports.push({
+    source,
+    names: [source.split('.').pop() || source],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleApplication(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+
+  if (funcNode.type === 'identifier' || funcNode.type === 'long_identifier') {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  } else if (funcNode.type === 'long_identifier_or_op') {
+    const id = findChild(funcNode, 'identifier') || findChild(funcNode, 'long_identifier');
+    if (id) ctx.calls.push({ name: id.text, line: node.startPosition.row + 1 });
+  }
+}
+
+function handleDotExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const parts: string[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && (child.type === 'identifier' || child.type === 'long_identifier')) {
+      parts.push(child.text);
+    }
+  }
+  if (parts.length >= 2) {
+    const call: Call = {
+      name: parts[parts.length - 1]!,
+      receiver: parts.slice(0, -1).join('.'),
+      line: node.startPosition.row + 1,
+    };
+    ctx.calls.push(call);
+  }
+}

package/src/extractors/gleam.ts

@@ -0,0 +1,246 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine, stripQuotes } from './helpers.js';
+
+/**
+ * Extract symbols from Gleam files.
+ *
+ * Gleam tree-sitter grammar (gleam-lang/tree-sitter-gleam) notes:
+ * - Functions: function with name, parameters, body fields
+ * - Types: type_definition with name, constructors
+ * - Type aliases: type_alias
+ * - Imports: import with module, unqualified_imports
+ * - External functions: external_function
+ * - Constants: constant
+ */
+export function extractGleamSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkGleamNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkGleamNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function':
+      handleFunction(node, ctx);
+      break;
+    case 'type_definition':
+      handleTypeDef(node, ctx);
+      break;
+    case 'type_alias':
+      handleTypeAlias(node, ctx);
+      break;
+    case 'import':
+      handleImport(node, ctx);
+      break;
+    case 'external_function':
+      handleExternalFunction(node, ctx);
+      break;
+    case 'constant':
+      handleConstant(node, ctx);
+      break;
+    case 'function_call':
+    case 'call':
+      handleCall(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkGleamNode(child, ctx);
+  }
+}
+
+function handleFunction(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  const visibility = isPublic(node) ? 'public' : 'private';
+  const params = extractParams(node);
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility,
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function handleExternalFunction(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility: isPublic(node) ? 'public' : 'private',
+  });
+}
+
+function handleTypeDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'type_name');
+  if (!nameNode) return;
+
+  const children: SubDeclaration[] = [];
+  // Extract constructors
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'data_constructor' || child.type === 'type_constructor') {
+      const ctorName = child.childForFieldName('name') || findChild(child, 'constructor_name');
+      if (ctorName) {
+        children.push({ name: ctorName.text, kind: 'property', line: child.startPosition.row + 1 });
+      }
+    }
+    // Recurse into constructors block
+    if (child.type === 'data_constructors' || child.type === 'type_constructors') {
+      for (let j = 0; j < child.childCount; j++) {
+        const ctor = child.child(j);
+        if (!ctor) continue;
+        if (ctor.type === 'data_constructor' || ctor.type === 'type_constructor') {
+          const ctorName = ctor.childForFieldName('name') || findChild(ctor, 'constructor_name');
+          if (ctorName) {
+            children.push({
+              name: ctorName.text,
+              kind: 'property',
+              line: ctor.startPosition.row + 1,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility: isPublic(node) ? 'public' : 'private',
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'type_name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility: isPublic(node) ? 'public' : 'private',
+  });
+}
+
+function handleConstant(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'variable',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility: isPublic(node) ? 'public' : 'private',
+  });
+}
+
+function handleImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const moduleNode =
+    node.childForFieldName('module') || findChild(node, 'module') || findChild(node, 'string');
+  if (!moduleNode) return;
+
+  const source = stripQuotes(moduleNode.text);
+  const names: string[] = [];
+
+  // Check for unqualified imports
+  const unqualified = findChild(node, 'unqualified_imports');
+  if (unqualified) {
+    for (let i = 0; i < unqualified.childCount; i++) {
+      const item = unqualified.child(i);
+      if (item && (item.type === 'unqualified_import' || item.type === 'identifier')) {
+        const nameNode = item.childForFieldName('name') || item;
+        if (nameNode.type !== ',') names.push(nameNode.text);
+      }
+    }
+  }
+
+  // Check for alias (as)
+  const alias = node.childForFieldName('alias') || findChild(node, 'identifier');
+  if (alias && alias !== moduleNode) {
+    names.push(alias.text);
+  }
+
+  ctx.imports.push({
+    source,
+    names: names.length > 0 ? names : [source.split('/').pop() || source],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.childForFieldName('function') || node.child(0);
+  if (!funcNode) return;
+
+  if (funcNode.type === 'identifier' || funcNode.type === 'variable') {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  } else if (funcNode.type === 'field_access' || funcNode.type === 'module_select') {
+    const field = funcNode.childForFieldName('field') || funcNode.childForFieldName('label');
+    const record = funcNode.child(0);
+    if (field) {
+      const call: Call = { name: field.text, line: node.startPosition.row + 1 };
+      if (record && record !== field) call.receiver = record.text;
+      ctx.calls.push(call);
+    }
+  }
+}
+
+function extractParams(funcNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramsNode =
+    funcNode.childForFieldName('parameters') || findChild(funcNode, 'function_parameters');
+  if (!paramsNode) return params;
+
+  for (let i = 0; i < paramsNode.childCount; i++) {
+    const param = paramsNode.child(i);
+    if (!param) continue;
+    if (param.type === 'function_parameter' || param.type === 'parameter') {
+      const nameNode = param.childForFieldName('name') || findChild(param, 'identifier');
+      if (nameNode) {
+        params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      }
+    }
+    if (param.type === 'identifier') {
+      params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
+    }
+  }
+  return params;
+}
+
+function isPublic(node: TreeSitterNode): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'visibility_modifier' || child.text === 'pub') return true;
+  }
+  return false;
+}

package/src/extractors/go.ts

@@ -80,21 +80,9 @@ function handleGoFuncDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleGoMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
-  const receiver = node.childForFieldName('receiver');
   if (!nameNode) return;
-  let receiverType: string | null = null;
-  if (receiver) {
-    for (let i = 0; i < receiver.childCount; i++) {
-      const param = receiver.child(i);
-      if (!param) continue;
-      const typeNode = param.childForFieldName('type');
-      if (typeNode) {
-        receiverType =
-          typeNode.type === 'pointer_type' ? typeNode.text.replace(/^\*/, '') : typeNode.text;
-        break;
-      }
-    }
-  }
+  const receiver = node.childForFieldName('receiver');
+  const receiverType = receiver ? extractGoReceiverType(receiver) : null;
   const fullName = receiverType ? `${receiverType}.${nameNode.text}` : nameNode.text;
   const params = extractGoParameters(node.childForFieldName('parameters'));
   ctx.definitions.push({
@@ -107,6 +95,19 @@ function handleGoMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   });
 }
 
+/** Extract the receiver type name from a method receiver parameter list. */
+function extractGoReceiverType(receiver: TreeSitterNode): string | null {
+  for (let i = 0; i < receiver.childCount; i++) {
+    const param = receiver.child(i);
+    if (!param) continue;
+    const typeNode = param.childForFieldName('type');
+    if (typeNode) {
+      return typeNode.type === 'pointer_type' ? typeNode.text.replace(/^\*/, '') : typeNode.text;
+    }
+  }
+  return null;
+}
+
 function handleGoTypeDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const spec = node.child(i);
@@ -403,13 +404,38 @@ function extractGoParameters(paramListNode: TreeSitterNode | null): SubDeclarati
  * This performs file-local matching (cross-file matching requires build-edges).
  */
 function matchGoStructuralInterfaces(ctx: ExtractorOutput): void {
+  const { interfaceMethods, structMethods, structLines } = collectGoMethodSets(ctx);
+
+  // Match: struct satisfies interface if it has all interface methods (name-only;
+  // signatures are not verified — treat as candidate match, not definitive).
+  // NOTE: embedded interfaces (type_elem nodes) are not resolved — composite
+  // interfaces like `type ReadWriter interface { Reader; Writer }` will have an
+  // empty method set and be silently excluded from matching.
+  for (const [structName, methods] of structMethods) {
+    for (const [ifaceName, ifaceMethods] of interfaceMethods) {
+      if (ifaceMethods.size > 0 && [...ifaceMethods].every((m) => methods.has(m))) {
+        ctx.classes.push({
+          name: structName,
+          implements: ifaceName,
+          line: structLines.get(structName) || 1,
+        });
+      }
+    }
+  }
+}
+
+/** Collect interface and struct method sets from definitions for structural matching. */
+function collectGoMethodSets(ctx: ExtractorOutput): {
+  interfaceMethods: Map<string, Set<string>>;
+  structMethods: Map<string, Set<string>>;
+  structLines: Map<string, number>;
+} {
   const interfaceMethods = new Map<string, Set<string>>();
   const structMethods = new Map<string, Set<string>>();
   const structLines = new Map<string, number>();
-
-  // Collect interface and struct definitions
   const interfaceNames = new Set<string>();
   const structNames = new Set<string>();
+
   for (const def of ctx.definitions) {
     if (def.kind === 'interface') interfaceNames.add(def.name);
     if (def.kind === 'struct') {
@@ -418,7 +444,6 @@ function matchGoStructuralInterfaces(ctx: ExtractorOutput): void {
     }
   }
 
-  // Collect methods grouped by receiver type
   for (const def of ctx.definitions) {
     if (def.kind !== 'method' || !def.name.includes('.')) continue;
     const dotIdx = def.name.indexOf('.');
@@ -435,22 +460,7 @@ function matchGoStructuralInterfaces(ctx: ExtractorOutput): void {
     }
   }
 
-  // Match: struct satisfies interface if it has all interface methods (name-only;
-  // signatures are not verified — treat as candidate match, not definitive).
-  // NOTE: embedded interfaces (type_elem nodes) are not resolved — composite
-  // interfaces like `type ReadWriter interface { Reader; Writer }` will have an
-  // empty method set and be silently excluded from matching.
-  for (const [structName, methods] of structMethods) {
-    for (const [ifaceName, ifaceMethods] of interfaceMethods) {
-      if (ifaceMethods.size > 0 && [...ifaceMethods].every((m) => methods.has(m))) {
-        ctx.classes.push({
-          name: structName,
-          implements: ifaceName,
-          line: structLines.get(structName) || 1,
-        });
-      }
-    }
-  }
+  return { interfaceMethods, structMethods, structLines };
 }
 
 function extractStructFields(structTypeNode: TreeSitterNode): SubDeclaration[] {