@optave/codegraph 3.10.0 → 3.11.1

package/src/extractors/gleam.ts

@@ -1,11 +1,13 @@
-import type {
-  Call,
-  ExtractorOutput,
-  SubDeclaration,
-  TreeSitterNode,
-  TreeSitterTree,
-} from '../types.js';
-import { findChild, nodeEndLine, stripQuotes } from './helpers.js';
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import {
+  findChild,
+  findFirstChildOfTypes,
+  nodeEndLine,
+  nodeStartLine,
+  pushCall,
+  pushImport,
+  stripQuotes,
+} from './helpers.js';
 
 /**
  * Extract symbols from Gleam files.
@@ -74,7 +76,7 @@ function handleFunction(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'function',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     visibility,
     children: params.length > 0 ? params : undefined,
@@ -85,12 +87,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,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     visibility: isPublic(node) ? 'public' : 'private',
+    children: params.length > 0 ? params : undefined,
   });
 }
 
@@ -104,10 +109,7 @@ function handleTypeDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
     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 });
-      }
+      pushConstructor(child, children);
     }
     // Recurse into constructors block
     if (child.type === 'data_constructors' || child.type === 'type_constructors') {
@@ -115,14 +117,7 @@ function handleTypeDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
         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,
-            });
-          }
+          pushConstructor(ctor, children);
         }
       }
     }
@@ -131,13 +126,20 @@ function handleTypeDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'type',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     visibility: isPublic(node) ? 'public' : 'private',
     children: children.length > 0 ? children : undefined,
   });
 }
 
+function pushConstructor(ctorNode: TreeSitterNode, out: SubDeclaration[]): void {
+  const ctorName = ctorNode.childForFieldName('name') || findChild(ctorNode, 'constructor_name');
+  if (ctorName) {
+    out.push({ name: ctorName.text, kind: 'property', line: nodeStartLine(ctorNode) });
+  }
+}
+
 function handleTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name') || findChild(node, 'type_name');
   if (!nameNode) return;
@@ -145,7 +147,7 @@ function handleTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'type',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     visibility: isPublic(node) ? 'public' : 'private',
   });
@@ -158,7 +160,7 @@ function handleConstant(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'variable',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     visibility: isPublic(node) ? 'public' : 'private',
   });
@@ -166,7 +168,7 @@ function handleConstant(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const moduleNode =
-    node.childForFieldName('module') || findChild(node, 'module') || findChild(node, 'string');
+    node.childForFieldName('module') || findFirstChildOfTypes(node, ['module', 'string']);
   if (!moduleNode) return;
 
   const source = stripQuotes(moduleNode.text);
@@ -190,26 +192,25 @@ function handleImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
     names.push(alias.text);
   }
 
-  ctx.imports.push({
-    source,
-    names: names.length > 0 ? names : [source.split('/').pop() || source],
-    line: node.startPosition.row + 1,
-  });
+  // `pushImport` falls back to the source basename when `names` is empty,
+  // preserving the previous `source.split('/').pop() || source` default.
+  pushImport(ctx, node, source, names);
 }
 
 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 });
+    pushCall(ctx, node, funcNode.text);
   } 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;
-      ctx.calls.push(call);
+      const receiver = record && record !== field ? record.text : undefined;
+      pushCall(ctx, node, field.text, receiver !== undefined ? { receiver } : {});
     }
   }
 }
@@ -226,11 +227,11 @@ function extractParams(funcNode: TreeSitterNode): SubDeclaration[] {
     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 });
+        params.push({ name: nameNode.text, kind: 'parameter', line: nodeStartLine(param) });
       }
     }
     if (param.type === 'identifier') {
-      params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      params.push({ name: param.text, kind: 'parameter', line: nodeStartLine(param) });
     }
   }
   return params;

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;

package/src/extractors/helpers.ts

@@ -1,4 +1,11 @@
-import type { SubDeclaration, TreeSitterNode, TypeMapEntry } from '../types.js';
+import type {
+  Call,
+  ExtractorOutput,
+  Import,
+  SubDeclaration,
+  TreeSitterNode,
+  TypeMapEntry,
+} from '../types.js';
 
 /**
  * Maximum recursion depth for tree-sitter AST walkers.
@@ -6,6 +13,11 @@ import type { SubDeclaration, TreeSitterNode, TypeMapEntry } from '../types.js';
  */
 export const MAX_WALK_DEPTH = 200;
 
+/** Convert a tree-sitter node's start row to a 1-based source line. */
+export function nodeStartLine(node: TreeSitterNode): number {
+  return node.startPosition.row + 1;
+}
+
 export function nodeEndLine(node: TreeSitterNode): number {
   return node.endPosition.row + 1;
 }
@@ -18,6 +30,56 @@ export function findChild(node: TreeSitterNode, type: string): TreeSitterNode |
   return null;
 }
 
+/**
+ * Find the first child whose type is in `types`. Useful when several grammar
+ * variants name the same conceptual node differently (e.g. `string` vs
+ * `string_literal`). Returns the first match in document order, or null.
+ */
+export function findFirstChildOfTypes(
+  node: TreeSitterNode,
+  types: readonly string[],
+): TreeSitterNode | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && types.includes(child.type)) return child;
+  }
+  return null;
+}
+
+/**
+ * Iterate the direct children of `node` in document order, skipping nulls and
+ * tokens whose type appears in `skipTypes`. Mirrors the common
+ * `for (let i = 0; i < node.childCount; i++) { const c = node.child(i); if (...) continue; ... }`
+ * idiom while letting callers filter out grammar punctuation (`,`, `(`, `{`, etc.).
+ */
+export function* iterChildren(
+  node: TreeSitterNode,
+  skipTypes: ReadonlySet<string> = EMPTY_SKIP_SET,
+): Generator<TreeSitterNode> {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (skipTypes.has(child.type)) continue;
+    yield child;
+  }
+}
+
+const EMPTY_SKIP_SET: ReadonlySet<string> = new Set();
+
+/** Common punctuation tokens — handy as a `skipTypes` set for `iterChildren`. */
+export const PUNCTUATION_TOKENS: ReadonlySet<string> = new Set([
+  ',',
+  ';',
+  '(',
+  ')',
+  '[',
+  ']',
+  '{',
+  '}',
+  ':',
+  '.',
+]);
+
 /**
  * Merge a type-map entry, keeping the higher-confidence one.
  * Shared across all language extractors that build type maps for call resolution.
@@ -197,3 +259,145 @@ export function extractModifierVisibility(
   }
   return undefined;
 }
+
+// ── Output-push helpers ────────────────────────────────────────────────────
+//
+// Most extractors finish with `ctx.calls.push({ name, line: node.startPosition.row + 1 })`
+// or `ctx.imports.push({ source, names, line: node.startPosition.row + 1 })`.
+// Centralising the construction keeps `line` derivation consistent and removes
+// the ~108 hand-rolled `startPosition.row + 1` literals scattered across
+// language extractors.
+
+/**
+ * Append a `Call` to the extractor output. `line` defaults to the start line of
+ * `node`; pass `extra` for `receiver` / `dynamic` flags.
+ */
+export function pushCall(
+  ctx: ExtractorOutput,
+  node: TreeSitterNode,
+  name: string,
+  extra: { receiver?: string; dynamic?: boolean } = {},
+): void {
+  if (!name) return;
+  const call: Call = { name, line: nodeStartLine(node) };
+  if (extra.receiver !== undefined) call.receiver = extra.receiver;
+  if (extra.dynamic !== undefined) call.dynamic = extra.dynamic;
+  ctx.calls.push(call);
+}
+
+/**
+ * Append an `Import` to the extractor output. `line` defaults to the start
+ * line of `node`. If `names` is empty, the source basename (split on `/`) is
+ * used as a single-name fallback — matching the convention in gleam, julia,
+ * and similar module-path imports.
+ */
+export function pushImport(
+  ctx: ExtractorOutput,
+  node: TreeSitterNode,
+  source: string,
+  names: string[],
+  flags: Partial<Omit<Import, 'source' | 'names' | 'line'>> = {},
+): void {
+  if (!source) return;
+  const resolved = names.length > 0 ? names : [lastPathSegment(source, '/') || source];
+  const entry: Import = { source, names: resolved, line: nodeStartLine(node) };
+  Object.assign(entry, flags);
+  ctx.imports.push(entry);
+}
+
+// ── Parameter extraction ───────────────────────────────────────────────────
+
+/**
+ * Options for {@link extractSimpleParameters}.
+ */
+export interface ExtractParametersOptions {
+  /** Tree-sitter types that mark a single parameter node (e.g. `formal_parameter`). */
+  paramTypes: readonly string[];
+  /**
+   * Field name on each parameter that holds the bound identifier. Defaults to
+   * `'name'`. Pass `null` to use the parameter node itself when its type is in
+   * `paramTypes` and it has no `name` field (e.g. R's bare `identifier`).
+   */
+  nameField?: string | null;
+  /**
+   * If true, when `nameField` lookup fails fall back to the first `identifier`
+   * child of the parameter. Useful for Gleam / Solidity-style grammars.
+   */
+  fallbackToIdentifier?: boolean;
+  /**
+   * Optional type-map sink. When provided, the parameter's `type` field text
+   * (if present) is recorded with the given confidence.
+   */
+  typeMap?: Map<string, TypeMapEntry>;
+  /** Confidence used when writing into `typeMap`. Defaults to `0.9`. */
+  typeMapConfidence?: number;
+  /**
+   * Optional callback to derive the type text from the parameter's `type`
+   * field node. Defaults to `node.text`. Use this for languages where the
+   * `type` field is wrapped (e.g. Java `generic_type` → first child).
+   */
+  resolveType?: (typeNode: TreeSitterNode) => string | undefined;
+}
+
+/**
+ * Extract parameters from a parameter-list node using a uniform pattern.
+ *
+ * This collapses the boilerplate in `extract*Params` helpers across
+ * Java/Julia/Gleam/Solidity/R/etc. — each one walks the parameter list,
+ * matches a parameter node type, reads the `name` field, and pushes a
+ * `SubDeclaration` with `kind: 'parameter'`.
+ */
+export function extractSimpleParameters(
+  paramListNode: TreeSitterNode | null,
+  options: ExtractParametersOptions,
+): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  if (!paramListNode) return params;
+  const { paramTypes, nameField = 'name', fallbackToIdentifier = false } = options;
+
+  for (let i = 0; i < paramListNode.childCount; i++) {
+    const param = paramListNode.child(i);
+    if (!param || !paramTypes.includes(param.type)) continue;
+    const nameNode = resolveParamName(param, nameField, fallbackToIdentifier);
+    if (!nameNode) continue;
+    params.push({ name: nameNode.text, kind: 'parameter', line: nodeStartLine(param) });
+    recordParamType(param, nameNode.text, options);
+  }
+  return params;
+}
+
+/** Record a parameter's declared type into the type-map sink, if configured. */
+function recordParamType(
+  param: TreeSitterNode,
+  paramName: string,
+  options: ExtractParametersOptions,
+): void {
+  const { typeMap, resolveType, typeMapConfidence = 0.9 } = options;
+  if (!typeMap) return;
+  const typeNode = param.childForFieldName('type');
+  if (!typeNode) return;
+  const typeText = resolveType ? resolveType(typeNode) : typeNode.text;
+  if (!typeText) return;
+  setTypeMapEntry(typeMap, paramName, typeText, typeMapConfidence);
+}
+
+/**
+ * Resolve the identifier node that names a parameter. Used by
+ * {@link extractSimpleParameters}; exposed so language-specific extractors
+ * can reuse the same lookup logic in custom loops.
+ */
+export function resolveParamName(
+  paramNode: TreeSitterNode,
+  nameField: string | null,
+  fallbackToIdentifier: boolean,
+): TreeSitterNode | null {
+  if (nameField === null) {
+    return paramNode;
+  }
+  const named = paramNode.childForFieldName(nameField);
+  if (named) return named;
+  if (fallbackToIdentifier) {
+    return findChild(paramNode, 'identifier');
+  }
+  return null;
+}