@optave/codegraph 3.9.6 → 3.11.0

package/src/extractors/erlang.ts

@@ -70,7 +70,10 @@ function walkErlangNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleModuleAttr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // module_attribute: - module ( atom ) .
-  const nameNode = findChild(node, 'atom');
+  // Prefer the named `name` field exposed by tree-sitter-erlang so we don't
+  // accidentally pick up the `module` keyword if a future grammar exposes it
+  // as a named `atom` child.
+  const nameNode = node.childForFieldName('name') ?? findChild(node, 'atom');
   if (!nameNode) return;
 
   ctx.definitions.push({
@@ -83,7 +86,10 @@ function handleModuleAttr(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleRecordDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // record_decl: - record ( atom , { record_field, ... } ) .
-  const nameNode = findChild(node, 'atom');
+  // Prefer the named `name` field exposed by tree-sitter-erlang; fall back to
+  // the first atom child for grammar versions that don't expose it. Mirrors
+  // the Rust `handle_record_decl` defensive pattern.
+  const nameNode = node.childForFieldName('name') ?? findChild(node, 'atom');
   if (!nameNode) return;
 
   const children: SubDeclaration[] = [];
@@ -112,7 +118,14 @@ function handleRecordDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = findChild(node, 'atom');
+  // type_alias: -type name(...) :: ty.
+  // Name is typically wrapped in a `type_name` node containing an `atom`.
+  // Mirrors the Rust `handle_type_alias` fallback so the two engines agree
+  // even when the grammar nests the name inside `type_name`.
+  const directAtom = findChild(node, 'atom');
+  const typeNameNode = !directAtom ? findChild(node, 'type_name') : null;
+  const wrappedAtom = typeNameNode ? findChild(typeNameNode, 'atom') : null;
+  const nameNode = directAtom ?? wrappedAtom;
   if (!nameNode) return;
 
   ctx.definitions.push({
@@ -134,13 +147,22 @@ function handleFunDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleFunctionClause(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // function_clause: atom expr_args clause_body
-  const nameNode = findChild(node, 'atom');
+  const nameNode = node.childForFieldName('name') ?? 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);
+  const arity = params.length;
+
+  // Don't duplicate if we already have this function at the same arity.
+  // Erlang overloads by arity, so `foo/1` and `foo/2` are distinct definitions.
+  if (
+    ctx.definitions.some(
+      (d) =>
+        d.name === nameNode.text && d.kind === 'function' && (d.children?.length ?? 0) === arity,
+    )
+  ) {
+    return;
+  }
 
   ctx.definitions.push({
     name: nameNode.text,
@@ -154,31 +176,42 @@ function handleFunctionClause(node: TreeSitterNode, ctx: ExtractorOutput): void
 
 function extractErlangParams(clauseNode: TreeSitterNode): SubDeclaration[] {
   const params: SubDeclaration[] = [];
-  const argsNode = findChild(clauseNode, 'expr_args');
+  const argsNode = clauseNode.childForFieldName('args') ?? findChild(clauseNode, 'expr_args');
   if (!argsNode) return params;
 
-  for (let i = 0; i < argsNode.childCount; i++) {
-    const child = argsNode.child(i);
+  // Iterate named children so every argument pattern counts as one parameter,
+  // independent of whether it is a bare `var`/`atom` or a complex destructuring
+  // pattern (tuple, list, binary, etc.). Punctuation tokens are anonymous and
+  // therefore excluded automatically.
+  for (let i = 0; i < argsNode.namedChildCount; i++) {
+    const child = argsNode.namedChild(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 });
-    }
+    const label =
+      child.type === 'var' || child.type === 'atom'
+        ? child.text
+        : // Placeholder for complex patterns so arity is preserved.
+          `_${i}`;
+    params.push({ name: label, kind: 'parameter', line: child.startPosition.row + 1 });
   }
   return params;
 }
 
 function handleDefine(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // pp_define: -define(NAME, value).
+  // For parametric macros, the grammar wraps the name in a `macro_lhs(name, args)`
+  // node. Inside `macro_lhs` the name comes first, followed by `(`, the argument
+  // `var` children, and `)`. We must therefore try `atom` (lowercase macros,
+  // e.g. `-define(foo(X), X+1)`) before `var` (uppercase macros, e.g.
+  // `-define(FOO(X), X+1)`) — otherwise `findChild(.., 'var')` skips the leading
+  // atom and lands on the first argument variable, mislabeling the definition.
+  // Mirrors the Rust `handle_define` so both engines agree.
   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)
+      ? (findChild(nameNode, 'atom')?.text ?? findChild(nameNode, 'var')?.text ?? nameNode.text)
       : nameNode.text;
 
   ctx.definitions.push({
@@ -194,9 +227,15 @@ function handleInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
   if (!strNode) return;
 
   const source = strNode.text.replace(/^"|"$/g, '');
+  // Preserve the distinction between local includes (`-include("foo.hrl")`)
+  // and OTP library includes (`-include_lib("kernel/include/file.hrl")`) so
+  // downstream consumers can apply the correct path-resolution strategy
+  // (local: relative to the source file; lib: relative to an OTP app root).
+  // Mirrors the Rust `handle_include` so both engines agree.
+  const kind = node.type === 'pp_include_lib' ? 'include_lib' : 'include';
   ctx.imports.push({
     source,
-    names: ['include'],
+    names: [kind],
     line: node.startPosition.row + 1,
   });
 }
@@ -224,8 +263,12 @@ function handleImportAttr(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  // call: first child is function ref (atom or remote), then expr_args
-  const funcNode = node.child(0);
+  // call: first named child is function ref (atom or remote), then expr_args.
+  // Using `namedChild(0)` rather than `child(0)` skips anonymous tokens
+  // (punctuation, keywords) so a future grammar revision that inserts a
+  // leading anonymous node won't silently drop the call. Mirrors the Rust
+  // `handle_call` so both engines emit the same set of calls.
+  const funcNode = node.namedChild(0);
   if (!funcNode) return;
 
   if (funcNode.type === 'atom' || funcNode.type === 'identifier') {

package/src/extractors/fsharp.ts

@@ -10,6 +10,13 @@ import { findChild, nodeEndLine } from './helpers.js';
 /**
  * Extract symbols from F# files.
  *
+ * Grammar source: `tree-sitter-fsharp` v0.3.0 installed via a pinned GitHub
+ * tarball in `package.json` because the ionide/tree-sitter-fsharp project has
+ * no v0.3.0 release published to the npm registry. The cargo crate the native
+ * engine uses is also v0.3.0; both engines must stay aligned. Upgrading
+ * requires a manual edit of the tarball URL in `package.json` and
+ * `package-lock.json` — `npm update` will not bump this entry.
+ *
  * tree-sitter-fsharp grammar notes:
  * - named_module: top-level module declaration
  * - function_declaration_left: LHS of `let name params = ...`
@@ -42,6 +49,14 @@ function walkFSharpNode(
     case 'named_module':
       nextModule = handleNamedModule(node, ctx);
       break;
+    case 'module_defn':
+      // Nested signature module (`module Foo = ...`) in `.fsi` files,
+      // emitted by both the WASM (npm ionide tarball v0.3.0) and cargo
+      // v0.3.0 tree-sitter-fsharp signature grammars. Accumulate the
+      // dotted module path so nested `val` declarations are qualified
+      // as `Outer.Inner.foo` in parity with the native engine.
+      nextModule = handleModuleDefn(node, ctx, currentModule);
+      break;
     case 'function_declaration_left':
       handleFunctionDecl(node, ctx, currentModule);
       break;
@@ -57,6 +72,9 @@ function walkFSharpNode(
     case 'dot_expression':
       handleDotExpression(node, ctx);
       break;
+    case 'value_definition':
+      handleValueDefinition(node, ctx, currentModule);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -79,6 +97,27 @@ function handleNamedModule(node: TreeSitterNode, ctx: ExtractorOutput): string |
   return nameNode.text;
 }
 
+function handleModuleDefn(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): string | null {
+  // `module_defn` (cargo 0.3.0 signature grammar) wraps `module Foo = ...`
+  // sections inside an outer `namespace` or another module. The name is a
+  // direct `identifier` child.
+  const nameNode = findChild(node, 'identifier');
+  if (!nameNode) return currentModule;
+
+  const qualified = currentModule ? `${currentModule}.${nameNode.text}` : nameNode.text;
+  ctx.definitions.push({
+    name: qualified,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+  return qualified;
+}
+
 function handleFunctionDecl(
   node: TreeSitterNode,
   ctx: ExtractorOutput,
@@ -251,3 +290,68 @@ function handleDotExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
     ctx.calls.push(call);
   }
 }
+
+// Handle `val name : type` declarations in `.fsi` signature files.
+// The signature grammar reuses `value_definition` for `val` bindings,
+// distinguished from the source grammar's `let` bindings by the first
+// child being the literal `val` keyword. Source-file `value_definition`
+// nodes (which start with `let`) are intentionally ignored to preserve
+// `.fs` extractor parity.
+function handleValueDefinition(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  const first = node.child(0);
+  if (!first || first.type !== 'val') return;
+
+  const declLeft = findChild(node, 'value_declaration_left');
+  if (!declLeft) return;
+
+  const pattern = findChild(declLeft, 'identifier_pattern');
+  if (!pattern) return;
+
+  const ident =
+    findChild(findChild(pattern, 'long_identifier_or_op') ?? pattern, 'identifier') ??
+    findChild(pattern, 'identifier');
+  if (!ident) return;
+
+  // The npm and cargo tree-sitter-fsharp 0.3.0 grammars — though sharing a
+  // version tag — emit type signatures with different node shapes:
+  //   • WASM (npm 0.3.0 ionide tarball): `function_type` is the explicit
+  //     function-type kind, present as a direct child of `value_definition`
+  //     for `a -> b` types; plain values (e.g. `val pi : float`) appear as
+  //     `simple_type`.
+  //   • Native (cargo 0.3.0): every type signature is wrapped in
+  //     `curried_spec`. A function type contains one or more `arguments_spec`
+  //     children; a plain value wraps a single `simple_type`.
+  // Classify as a function whenever `function_type` appears OR a
+  // `curried_spec` contains an `arguments_spec` child, so both engines stay
+  // in parity until the grammars converge.
+  let hasFunctionType = false;
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (!c) continue;
+    if (c.type === 'function_type') {
+      hasFunctionType = true;
+      break;
+    }
+    if (c.type === 'curried_spec') {
+      for (let j = 0; j < c.childCount; j++) {
+        if (c.child(j)?.type === 'arguments_spec') {
+          hasFunctionType = true;
+          break;
+        }
+      }
+      if (hasFunctionType) break;
+    }
+  }
+
+  const name = currentModule ? `${currentModule}.${ident.text}` : ident.text;
+  ctx.definitions.push({
+    name,
+    kind: hasFunctionType ? 'function' : 'variable',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}

package/src/extractors/gleam.ts

@@ -85,12 +85,15 @@ function handleExternalFunction(node: TreeSitterNode, ctx: ExtractorOutput): voi
   const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
   if (!nameNode) return;
 
+  const params = extractParams(node);
+
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'function',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
     visibility: isPublic(node) ? 'public' : 'private',
+    children: params.length > 0 ? params : undefined,
   });
 }
 
@@ -198,14 +201,16 @@ function handleImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const funcNode = node.childForFieldName('function') || node.child(0);
+  const funcNode = node.childForFieldName('function') || node.namedChild(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);
+    // Prefer the `record` field; fall back to first named child to skip
+    // anonymous punctuation tokens (the `.` between record and field).
+    const record = funcNode.childForFieldName('record') || funcNode.namedChild(0);
     if (field) {
       const call: Call = { name: field.text, line: node.startPosition.row + 1 };
       if (record && record !== field) call.receiver = record.text;

package/src/extractors/groovy.ts

@@ -68,6 +68,7 @@ function walkGroovyNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'method_invocation':
     case 'call_expression':
     case 'function_call':
+    case 'juxt_function_call':
       handleGroovyCallExpr(node, ctx);
       break;
     case 'object_creation_expression':
@@ -140,14 +141,57 @@ function handleGroovyClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
 function handleGroovyInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
+  const ifaceName = nameNode.text;
 
   ctx.definitions.push({
-    name: nameNode.text,
+    name: ifaceName,
     kind: 'interface',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
     visibility: extractModifierVisibility(node),
   });
+
+  // `interface X extends Y, Z` — tree-sitter-groovy 0.1.x exposes parent
+  // interfaces via an unnamed `extends_interfaces` child (not a field), which
+  // wraps a `type_list` of `_type` nodes. Mirrors the Rust extractor.
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'extends_interfaces') {
+      collectGroovyParentInterfaces(child, ifaceName, ctx);
+      break;
+    }
+  }
+}
+
+function collectGroovyParentInterfaces(
+  parent: TreeSitterNode,
+  name: string,
+  ctx: ExtractorOutput,
+): void {
+  // Use the current node's start line at each recursion level — matches the
+  // Rust `collect_interfaces` helper, which re-evaluates `start_line(interfaces)`
+  // for whatever node (`extends_interfaces` → `type_list`) is being processed.
+  const line = parent.startPosition.row + 1;
+  for (let i = 0; i < parent.childCount; i++) {
+    const child = parent.child(i);
+    if (!child) continue;
+    switch (child.type) {
+      case 'type_identifier':
+      case 'identifier':
+      case 'scoped_type_identifier': {
+        ctx.classes.push({ name, implements: child.text, line });
+        break;
+      }
+      case 'generic_type': {
+        const inner = child.child(0)?.text;
+        if (inner) ctx.classes.push({ name, implements: inner, line });
+        break;
+      }
+      case 'type_list':
+        collectGroovyParentInterfaces(child, name, ctx);
+        break;
+    }
+  }
 }
 
 function handleGroovyEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {

package/src/extractors/haskell.ts

@@ -81,19 +81,60 @@ function extractHaskellParams(funcNode: TreeSitterNode): SubDeclaration[] {
     if (child.type === 'patterns' || child.type === 'parameter') {
       for (let j = 0; j < child.childCount; j++) {
         const pat = child.child(j);
-        if (pat && (pat.type === 'variable' || pat.type === 'identifier')) {
-          params.push({ name: pat.text, kind: 'parameter', line: pat.startPosition.row + 1 });
-        }
+        if (pat) collectHaskellPatternBindings(pat, params);
       }
     }
     if (child.type === 'variable' && i > 0) {
-      // Pattern parameters after the function name
+      // Pattern parameters after the function name (no enclosing `patterns` node)
       params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
     }
   }
   return params;
 }
 
+// Walk a pattern node and emit each bound variable (and `_` for wildcards) as a parameter.
+// Container patterns — parens, constructor application, infix (cons), tuple, list, as, strict,
+// irrefutable, qualified — are transparent: descend into their children. `record` is special:
+// only the right-hand-side of each `field_pattern` is bound (the field name is not).
+// Literals, bare constructors, and operators do not bind.
+function collectHaskellPatternBindings(node: TreeSitterNode, out: SubDeclaration[]): void {
+  switch (node.type) {
+    case 'variable':
+    case 'identifier':
+      out.push({ name: node.text, kind: 'parameter', line: node.startPosition.row + 1 });
+      return;
+    case 'wildcard':
+      out.push({ name: '_', kind: 'parameter', line: node.startPosition.row + 1 });
+      return;
+    case 'parens':
+    case 'apply':
+    case 'infix':
+    case 'tuple':
+    case 'list':
+    case 'strict':
+    case 'irrefutable':
+    case 'as':
+    case 'qualified':
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c) collectHaskellPatternBindings(c, out);
+      }
+      return;
+    case 'record':
+      for (let i = 0; i < node.childCount; i++) {
+        const fp = node.child(i);
+        if (!fp || fp.type !== 'field_pattern') continue;
+        for (let j = 0; j < fp.childCount; j++) {
+          const g = fp.child(j);
+          if (g && g.type !== 'field_name') collectHaskellPatternBindings(g, out);
+        }
+      }
+      return;
+    default:
+      return;
+  }
+}
+
 function handleHaskellBind(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;