@optave/codegraph 3.10.0 → 3.11.1

package/src/extractors/cuda.ts

@@ -265,10 +265,10 @@ function extractCudaParameters(paramListNode: TreeSitterNode | null): SubDeclara
     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);
+      // Reuse the field-name drill helper so function-type parameters like
+      // `void process(int callback(int))` yield the bare name `callback`
+      // instead of the raw declarator text, matching the native unwrap path.
+      const name = extractCudaFieldName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
@@ -284,22 +284,96 @@ function extractCudaClassFields(classNode: TreeSitterNode): SubDeclaration[] {
     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),
-      });
-    }
+    if (!nameNode) continue;
+    // Skip method declarations — a `field_declaration` whose declarator
+    // (after unwrapping pointer/reference/array) is a `function_declarator`
+    // is a method signature in a header, not a data field. Native and WASM
+    // previously diverged on how to format these (native stripped the `*`
+    // from pointer-return types, WASM kept it), and both produced
+    // method-signature-shaped "property" entries that are not real fields.
+    if (isCudaMethodDeclarator(nameNode)) continue;
+    const name = extractCudaFieldName(nameNode);
+    fields.push({
+      name,
+      kind: 'property',
+      line: member.startPosition.row + 1,
+      visibility: extractModifierVisibility(member),
+    });
   }
   return fields;
 }
 
+const CUDA_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'reference_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+]);
+
+function isCudaMethodDeclarator(node: TreeSitterNode): boolean {
+  let current: TreeSitterNode | null = node;
+  while (current && CUDA_DECLARATOR_WRAPPERS.has(current.type)) {
+    current = current.childForFieldName('declarator');
+  }
+  if (current?.type !== 'function_declarator') return false;
+  // A `function_declarator` whose inner declarator is a `parenthesized_declarator`
+  // is a function-pointer (or function-reference) field — e.g. `void (*cb)(int)`
+  // parses as function_declarator > parenthesized_declarator > pointer_declarator >
+  // field_identifier. Those are real data fields, not method declarations.
+  const inner = current.childForFieldName('declarator');
+  return inner?.type !== 'parenthesized_declarator';
+}
+
+/**
+ * Resolve the identifier of a declarator by walking through any combination of
+ * pointer/reference/array/parenthesized wrappers and `function_declarator`
+ * nodes. Used by both class-field extraction (where `function_declarator`
+ * indicates a function-pointer field after method declarations have been
+ * filtered out) and parameter extraction (where `function_declarator` wraps a
+ * bare function-type parameter name like `callback` in
+ * `void process(int callback(int))`).
+ */
+function extractCudaFieldName(decl: TreeSitterNode): string {
+  let current: TreeSitterNode | null = decl;
+  while (current) {
+    if (current.type === 'identifier' || current.type === 'field_identifier') {
+      return current.text;
+    }
+    if (CUDA_DECLARATOR_WRAPPERS.has(current.type) || current.type === 'function_declarator') {
+      const next = innerCudaDeclarator(current);
+      if (!next) break;
+      current = next;
+      continue;
+    }
+    break;
+  }
+  return decl.text;
+}
+
+/**
+ * Find the inner declarator of a wrapper node. Most C++ declarator wrappers
+ * expose it via the `declarator` field, but some (e.g. `parenthesized_declarator`
+ * and `reference_declarator` in tree-sitter-cuda) have unnamed children — so
+ * fall back to scanning children for a declarator-shaped node.
+ */
+function innerCudaDeclarator(node: TreeSitterNode): TreeSitterNode | null {
+  const named = node.childForFieldName('declarator');
+  if (named) return named;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'identifier' ||
+      child.type === 'field_identifier' ||
+      child.type === 'function_declarator' ||
+      CUDA_DECLARATOR_WRAPPERS.has(child.type)
+    ) {
+      return child;
+    }
+  }
+  return null;
+}
+
 function extractCudaEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   const entries: SubDeclaration[] = [];
   const body = findChild(enumNode, 'enumerator_list');

package/src/extractors/elixir.ts

@@ -5,7 +5,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { findChild, nodeEndLine } from './helpers.js';
+import { findChild, iterChildren, nodeEndLine, PUNCTUATION_TOKENS } from './helpers.js';
 
 /**
  * Extract symbols from Elixir files.
@@ -190,14 +190,113 @@ function extractElixirParams(defCallNode: TreeSitterNode): SubDeclaration[] {
     for (let j = 0; j < innerArgs.childCount; j++) {
       const param = innerArgs.child(j);
       if (!param) continue;
-      if (param.type === 'identifier') {
-        params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
-      }
+      collectElixirParamIdentifiers(param, params);
     }
   }
   return params;
 }
 
+/**
+ * Walk a parameter pattern and emit each bound identifier as a `parameter`
+ * child. Handles bare identifiers, default-value `a \\ default`, list-cons
+ * `[head | tail]`, list `[a, b, c]`, tuple `{x, y}`, and map / struct
+ * destructuring (`%{k: v}`, `%Foo{k: v}`).
+ *
+ * Implemented as an iterative worklist (rather than recursion + helpers) so
+ * the call graph has no function-level cycle: only one function performs the
+ * traversal and it invokes only leaf helpers (`pushSubNodes`, `pushMapValues`).
+ */
+function collectElixirParamIdentifiers(root: TreeSitterNode, out: SubDeclaration[]): void {
+  const stack: TreeSitterNode[] = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    switch (node.type) {
+      case 'identifier':
+        out.push({ name: node.text, kind: 'parameter', line: node.startPosition.row + 1 });
+        break;
+      case 'binary_operator':
+        pushElixirBinaryOperatorOperands(node, stack);
+        break;
+      case 'list':
+      case 'tuple':
+        pushElixirSequenceItems(node, stack);
+        break;
+      case 'map':
+        pushElixirMapValues(node, stack);
+        break;
+    }
+  }
+}
+
+/**
+ * Push the binding-relevant operands of a `binary_operator` parameter onto the
+ * worklist:
+ * - `name \\ default` (default-value) binds the left operand only.
+ * - `head | tail`     (list-cons, appears inside a `list` pattern) binds both.
+ */
+function pushElixirBinaryOperatorOperands(node: TreeSitterNode, stack: TreeSitterNode[]): void {
+  const op = node.child(1);
+  if (!op) return;
+  if (op.type === '\\\\') {
+    const left = node.child(0);
+    if (left) stack.push(left);
+    return;
+  }
+  if (op.type === '|') {
+    const right = node.child(2);
+    const left = node.child(0);
+    if (right) stack.push(right);
+    if (left) stack.push(left);
+  }
+}
+
+/**
+ * Push the binding-relevant elements of a `list` or `tuple` parameter onto
+ * the worklist, skipping punctuation tokens.
+ *
+ * Items are pushed in reverse document order so that, with a LIFO stack, they
+ * are processed left-to-right — preserving the source ordering of bound names.
+ */
+function pushElixirSequenceItems(node: TreeSitterNode, stack: TreeSitterNode[]): void {
+  const items: TreeSitterNode[] = [...iterChildren(node, PUNCTUATION_TOKENS)];
+  for (let i = items.length - 1; i >= 0; i--) {
+    stack.push(items[i] as TreeSitterNode);
+  }
+}
+
+/**
+ * Push the value side of every pair in a `map` or `%Foo{...}` parameter onto
+ * the worklist. The struct alias (`Foo`) is a type, not a bound identifier, so
+ * the leading `struct` child is intentionally skipped.
+ *
+ * Items are collected in document order and pushed in reverse so that, with a
+ * LIFO stack, they are processed left-to-right — preserving source ordering.
+ */
+function pushElixirMapValues(node: TreeSitterNode, stack: TreeSitterNode[]): void {
+  const parts: TreeSitterNode[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const content = node.child(i);
+    if (!content || content.type !== 'map_content') continue;
+    for (let j = 0; j < content.childCount; j++) {
+      const kws = content.child(j);
+      if (!kws || kws.type !== 'keywords') continue;
+      for (let k = 0; k < kws.childCount; k++) {
+        const pair = kws.child(k);
+        if (!pair || pair.type !== 'pair') continue;
+        for (let p = 0; p < pair.childCount; p++) {
+          const part = pair.child(p);
+          if (!part || part.type === 'keyword') continue;
+          parts.push(part);
+        }
+      }
+    }
+  }
+  for (let i = parts.length - 1; i >= 0; i--) {
+    stack.push(parts[i] as TreeSitterNode);
+  }
+}
+
 function handleDefprotocol(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const args = findChild(node, 'arguments');
   if (!args) return;

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