@optave/codegraph 3.11.0 → 3.11.2

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,
@@ -90,7 +92,7 @@ function handleExternalFunction(node: TreeSitterNode, ctx: ExtractorOutput): voi
   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,
@@ -107,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') {
@@ -118,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);
         }
       }
     }
@@ -134,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;
@@ -148,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',
   });
@@ -161,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',
   });
@@ -169,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);
@@ -193,11 +192,9 @@ 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 {
@@ -205,16 +202,15 @@ function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   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');
     // 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 } : {});
     }
   }
 }
@@ -231,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/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;
+}

package/src/extractors/java.ts

@@ -1,5 +1,4 @@
 import type {
-  Call,
   ExtractorOutput,
   SubDeclaration,
   TreeSitterNode,
@@ -9,10 +8,14 @@ import type {
 import {
   extractBodyMembers,
   extractModifierVisibility,
+  extractSimpleParameters,
   findChild,
   findParentNode,
   lastPathSegment,
   nodeEndLine,
+  nodeStartLine,
+  pushCall,
+  pushImport,
 } from './helpers.js';
 
 /**
@@ -78,7 +81,7 @@ function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'class',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: classChildren.length > 0 ? classChildren : undefined,
   });
@@ -87,7 +90,7 @@ function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
   const interfaces = node.childForFieldName('interfaces');
   if (interfaces) {
-    extractJavaInterfaces(interfaces, nameNode.text, node.startPosition.row + 1, ctx);
+    extractJavaInterfaces(interfaces, nameNode.text, nodeStartLine(node), ctx);
   }
 }
 
@@ -101,7 +104,7 @@ function extractJavaSuperclass(
   if (!superclass) return;
   const superName = findJavaSuperTypeName(superclass);
   if (superName) {
-    ctx.classes.push({ name: className, extends: superName, line: node.startPosition.row + 1 });
+    ctx.classes.push({ name: className, extends: superName, line: nodeStartLine(node) });
   }
 }
 
@@ -163,7 +166,7 @@ function handleJavaInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): vo
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'interface',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
   });
   const body = node.childForFieldName('body');
@@ -184,8 +187,8 @@ function extractJavaInterfaceMethods(
         ctx.definitions.push({
           name: `${ifaceName}.${methName.text}`,
           kind: 'method',
-          line: child.startPosition.row + 1,
-          endLine: child.endPosition.row + 1,
+          line: nodeStartLine(child),
+          endLine: nodeEndLine(child),
         });
       }
     }
@@ -199,7 +202,7 @@ function handleJavaEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: nameNode.text,
     kind: 'enum',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: enumChildren.length > 0 ? enumChildren : undefined,
   });
@@ -216,7 +219,7 @@ function handleJavaMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
   ctx.definitions.push({
     name: fullName,
     kind: 'method',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: params.length > 0 ? params : undefined,
     visibility: extractModifierVisibility(node),
@@ -232,7 +235,7 @@ function handleJavaConstructorDecl(node: TreeSitterNode, ctx: ExtractorOutput):
   ctx.definitions.push({
     name: fullName,
     kind: 'method',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: params.length > 0 ? params : undefined,
     visibility: extractModifierVisibility(node),
@@ -245,12 +248,7 @@ function handleJavaImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
     if (child && (child.type === 'scoped_identifier' || child.type === 'identifier')) {
       const fullPath = child.text;
       const lastName = lastPathSegment(fullPath, '.');
-      ctx.imports.push({
-        source: fullPath,
-        names: [lastName],
-        line: node.startPosition.row + 1,
-        javaImport: true,
-      });
+      pushImport(ctx, node, fullPath, [lastName], { javaImport: true });
     }
     if (child && child.type === 'asterisk') {
       const lastImport = ctx.imports[ctx.imports.length - 1];
@@ -263,21 +261,25 @@ function handleJavaMethodInvocation(node: TreeSitterNode, ctx: ExtractorOutput):
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const obj = node.childForFieldName('object');
-  const call: Call = { name: nameNode.text, line: node.startPosition.row + 1 };
-  if (obj) call.receiver = obj.text;
-  ctx.calls.push(call);
+  pushCall(ctx, node, nameNode.text, obj ? { receiver: obj.text } : {});
 }
 
 function handleJavaLocalVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type');
   if (!typeNode) return;
-  const typeName = typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
+  const typeName = resolveJavaTypeText(typeNode);
   if (!typeName) return;
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child?.type === 'variable_declarator') {
       const nameNode = child.childForFieldName('name');
-      if (nameNode) ctx.typeMap?.set(nameNode.text, { type: typeName, confidence: 0.9 });
+      // Use direct Map.set (last-wins) for local variable declarations.
+      // Local variable types are method-scoped and should override any
+      // prior entry (e.g. a same-named constructor parameter). Using
+      // setTypeMapEntry (first-wins on tie) would let a constructor
+      // parameter type block a local variable's more-specific concrete type.
+      if (nameNode && ctx.typeMap)
+        ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
     }
   }
 }
@@ -285,8 +287,17 @@ function handleJavaLocalVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): voi
 function handleJavaObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type');
   if (!typeNode) return;
-  const typeName = typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
-  if (typeName) ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
+  const typeName = resolveJavaTypeText(typeNode);
+  if (typeName) pushCall(ctx, node, typeName);
+}
+
+/**
+ * Resolve a Java type node's text, unwrapping `generic_type` to its base name.
+ * Used wherever we need the bare type identifier (local var decls, object
+ * creation, parameter types).
+ */
+function resolveJavaTypeText(typeNode: TreeSitterNode): string | undefined {
+  return typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
 }
 
 const JAVA_PARENT_TYPES = [
@@ -300,31 +311,17 @@ function findJavaParentClass(node: TreeSitterNode): string | null {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
+const JAVA_PARAM_TYPES = ['formal_parameter', 'spread_parameter'] as const;
+
 function extractJavaParameters(
   paramListNode: TreeSitterNode | null,
   typeMap?: Map<string, TypeMapEntry>,
 ): SubDeclaration[] {
-  const params: SubDeclaration[] = [];
-  if (!paramListNode) return params;
-  for (let i = 0; i < paramListNode.childCount; i++) {
-    const param = paramListNode.child(i);
-    if (!param) continue;
-    if (param.type === 'formal_parameter' || param.type === 'spread_parameter') {
-      const nameNode = param.childForFieldName('name');
-      if (nameNode) {
-        params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
-        if (typeMap) {
-          const typeNode = param.childForFieldName('type');
-          if (typeNode) {
-            const typeName =
-              typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
-            if (typeName) typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
-          }
-        }
-      }
-    }
-  }
-  return params;
+  return extractSimpleParameters(paramListNode, {
+    paramTypes: JAVA_PARAM_TYPES,
+    typeMap,
+    resolveType: resolveJavaTypeText,
+  });
 }
 
 function extractClassFields(classNode: TreeSitterNode): SubDeclaration[] {
@@ -350,7 +347,7 @@ function extractFieldDeclarators(member: TreeSitterNode, fields: SubDeclaration[
       fields.push({
         name: nameNode.text,
         kind: 'property',
-        line: member.startPosition.row + 1,
+        line: nodeStartLine(member),
         visibility: vis,
       });
     }