@optave/codegraph 3.10.0 → 3.11.1

package/src/extractors/scala.ts

@@ -1,5 +1,6 @@
 import type {
   Call,
+  Definition,
   ExtractorOutput,
   SubDeclaration,
   TreeSitterNode,
@@ -59,52 +60,37 @@ function walkScalaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
 function handleScalaClassDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = node.childForFieldName('name');
-  if (!nameNode) return;
-  const name = nameNode.text;
-  const children = extractScalaBodyMembers(node, name, ctx);
-
-  ctx.definitions.push({
-    name,
-    kind: 'class',
-    line: node.startPosition.row + 1,
-    endLine: nodeEndLine(node),
-    children: children.length > 0 ? children : undefined,
-  });
-
-  extractScalaInheritance(node, name, ctx);
+  emitScalaTypeDef(node, ctx, 'class');
 }
 
 function handleScalaTraitDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = node.childForFieldName('name');
-  if (!nameNode) return;
-  const name = nameNode.text;
-  const children = extractScalaBodyMembers(node, name, ctx);
-
-  ctx.definitions.push({
-    name,
-    kind: 'interface',
-    line: node.startPosition.row + 1,
-    endLine: nodeEndLine(node),
-    children: children.length > 0 ? children : undefined,
-  });
-
-  extractScalaInheritance(node, name, ctx);
+  emitScalaTypeDef(node, ctx, 'interface');
 }
 
 function handleScalaObjectDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  emitScalaTypeDef(node, ctx, 'class');
+}
+
+function emitScalaTypeDef(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  kind: 'class' | 'interface',
+): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const name = nameNode.text;
-  const children = extractScalaBodyMembers(node, name, ctx);
+  const { children, methods } = collectScalaBodyMembers(node, name);
 
+  // Push the type def before its methods so the definition order follows
+  // source-line order (matches native, which walks depth-first).
   ctx.definitions.push({
     name,
-    kind: 'class',
+    kind,
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
     children: children.length > 0 ? children : undefined,
   });
+  for (const m of methods) ctx.definitions.push(m);
 
   extractScalaInheritance(node, name, ctx);
 }
@@ -224,14 +210,14 @@ function extractScalaInheritance(node: TreeSitterNode, name: string, ctx: Extrac
 
 // ── Body member extraction ──────────────────────────────────────────────────
 
-function extractScalaBodyMembers(
+function collectScalaBodyMembers(
   parentNode: TreeSitterNode,
   parentName: string,
-  ctx: ExtractorOutput,
-): SubDeclaration[] {
+): { children: SubDeclaration[]; methods: Definition[] } {
   const children: SubDeclaration[] = [];
+  const methods: Definition[] = [];
   const body = findChild(parentNode, 'template_body');
-  if (!body) return children;
+  if (!body) return { children, methods };
 
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
@@ -240,12 +226,14 @@ function extractScalaBodyMembers(
     if (member.type === 'function_definition') {
       const methName = member.childForFieldName('name');
       if (methName) {
-        ctx.definitions.push({
+        const params = extractScalaParameters(member);
+        methods.push({
           name: `${parentName}.${methName.text}`,
           kind: 'method',
           line: member.startPosition.row + 1,
           endLine: member.endPosition.row + 1,
           visibility: extractModifierVisibility(member),
+          children: params.length > 0 ? params : undefined,
         });
       }
     } else if (member.type === 'val_definition' || member.type === 'var_definition') {
@@ -264,7 +252,7 @@ function extractScalaBodyMembers(
     }
   }
 
-  return children;
+  return { children, methods };
 }
 
 // ── Parameter extraction ────────────────────────────────────────────────────

package/src/extractors/solidity.ts

@@ -1,15 +1,14 @@
-import type {
-  Call,
-  ExtractorOutput,
-  SubDeclaration,
-  TreeSitterNode,
-  TreeSitterTree,
-} from '../types.js';
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
 import {
   extractModifierVisibility,
+  extractSimpleParameters,
   findChild,
+  findFirstChildOfTypes,
   findParentNode,
   nodeEndLine,
+  nodeStartLine,
+  pushCall,
+  pushImport,
   stripQuotes,
 } from './helpers.js';
 
@@ -103,7 +102,7 @@ function handleContractDecl(
   ctx.definitions.push({
     name,
     kind,
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: members.length > 0 ? members : undefined,
   });
@@ -125,7 +124,7 @@ function extractContractMembers(body: TreeSitterNode): SubDeclaration[] {
 
 /** Map a single contract body child to a SubDeclaration, or null if not a recognized member. */
 function extractContractMember(child: TreeSitterNode): SubDeclaration | null {
-  const line = child.startPosition.row + 1;
+  const line = nodeStartLine(child);
   switch (child.type) {
     case 'function_definition': {
       const fnName = child.childForFieldName('name');
@@ -156,15 +155,24 @@ function extractContractMember(child: TreeSitterNode): SubDeclaration | null {
   }
 }
 
-/** Extract inheritance (extends) relationships from a contract node. */
+/**
+ * Extract inheritance (extends) relationships from a contract node.
+ *
+ * Each parent in `contract A is B, C, D { }` is its own `inheritance_specifier`
+ * sibling under the contract node (see tree-sitter-solidity grammar:
+ * `_class_heritage: "is" commaSep1($.inheritance_specifier)`), so we must walk
+ * all direct children rather than stopping at the first match.
+ */
 function extractInheritance(node: TreeSitterNode, name: string, ctx: ExtractorOutput): void {
-  const inheritance = findChild(node, 'inheritance_specifier');
-  if (!inheritance) return;
-  for (let i = 0; i < inheritance.childCount; i++) {
-    const child = inheritance.child(i);
-    if (!child) continue;
-    if (child.type === 'user_defined_type' || child.type === 'identifier') {
-      ctx.classes.push({ name, extends: child.text, line: node.startPosition.row + 1 });
+  for (let i = 0; i < node.childCount; i++) {
+    const inheritance = node.child(i);
+    if (!inheritance || inheritance.type !== 'inheritance_specifier') continue;
+    for (let j = 0; j < inheritance.childCount; j++) {
+      const child = inheritance.child(j);
+      if (!child) continue;
+      if (child.type === 'user_defined_type' || child.type === 'identifier') {
+        ctx.classes.push({ name, extends: child.text, line: nodeStartLine(node) });
+      }
     }
   }
 }
@@ -182,19 +190,16 @@ function handleStructDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
         members.push({
           name: memberName.text,
           kind: 'property',
-          line: child.startPosition.row + 1,
+          line: nodeStartLine(child),
         });
       }
     }
   }
 
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'struct',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: members.length > 0 ? members : undefined,
   });
@@ -208,17 +213,14 @@ function handleEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child && child.type === 'enum_value') {
-      members.push({ name: child.text, kind: 'constant', line: child.startPosition.row + 1 });
+      members.push({ name: child.text, kind: 'constant', line: nodeStartLine(child) });
     }
   }
 
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'enum',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: members.length > 0 ? members : undefined,
   });
@@ -235,7 +237,7 @@ function handleFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: fullName,
     kind,
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: params.length > 0 ? params : undefined,
     visibility: extractSolVisibility(node),
@@ -245,13 +247,10 @@ function handleFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleModifierDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'function',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     decorators: ['modifier'],
   });
@@ -260,13 +259,10 @@ function handleModifierDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleEventDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'type',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     decorators: ['event'],
   });
@@ -275,13 +271,10 @@ function handleEventDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleErrorDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'type',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     decorators: ['error'],
   });
@@ -290,18 +283,21 @@ function handleErrorDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleStateVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'variable',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     visibility: extractSolVisibility(node),
   });
 }
 
+/** Qualify `name` with the nearest contract/interface/library, if any. */
+function qualifyWithParent(node: TreeSitterNode, name: string): string {
+  const parent = findParentNode(node, SOL_PARENT_TYPES);
+  return parent ? `${parent}.${name}` : name;
+}
+
 function handleImportDirective(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // import "path"; or import { X } from "path"; or import "path" as Alias;
   for (let i = 0; i < node.childCount; i++) {
@@ -319,22 +315,17 @@ function handleImportDirective(node: TreeSitterNode, ctx: ExtractorOutput): void
           if (id) names.push(id.text);
         }
       }
-      ctx.imports.push({
-        source,
-        names: names.length > 0 ? names : ['*'],
-        line: node.startPosition.row + 1,
-      });
+      // Preserve the explicit `['*']` fallback — pushImport's default uses the
+      // source basename, but Solidity's convention here is to mark unqualified
+      // imports as `*`.
+      pushImport(ctx, node, source, names.length > 0 ? names : ['*']);
       return;
     }
     // source_import: handles `import * as X from "path"`
     if (child.type === 'source_import' || child.type === 'import_clause') {
-      const strNode = findChild(child, 'string') || findChild(child, 'string_literal');
+      const strNode = findFirstChildOfTypes(child, ['string', 'string_literal']);
       if (strNode) {
-        ctx.imports.push({
-          source: stripQuotes(strNode.text),
-          names: ['*'],
-          line: node.startPosition.row + 1,
-        });
+        pushImport(ctx, node, stripQuotes(strNode.text), ['*']);
         return;
       }
     }
@@ -345,35 +336,25 @@ function handleCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void
   const funcNode = node.childForFieldName('function') || node.childForFieldName('callee');
   if (!funcNode) return;
 
-  const call: Call = { name: '', line: node.startPosition.row + 1 };
+  let name = '';
+  let receiver: string | undefined;
   if (funcNode.type === 'member_expression' || funcNode.type === 'member_access') {
     const prop = funcNode.childForFieldName('property') || funcNode.childForFieldName('member');
     const obj = funcNode.childForFieldName('object') || funcNode.childForFieldName('expression');
-    if (prop) call.name = prop.text;
-    if (obj) call.receiver = obj.text;
+    if (prop) name = prop.text;
+    if (obj) receiver = obj.text;
   } else {
-    call.name = funcNode.text;
+    name = funcNode.text;
   }
-  if (call.name) ctx.calls.push(call);
+  if (name) pushCall(ctx, node, name, receiver !== undefined ? { receiver } : {});
 }
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
 function extractSolParams(funcNode: TreeSitterNode): SubDeclaration[] {
-  const params: SubDeclaration[] = [];
   const paramList =
     funcNode.childForFieldName('parameters') || findChild(funcNode, 'parameter_list');
-  if (!paramList) return params;
-
-  for (let i = 0; i < paramList.childCount; i++) {
-    const param = paramList.child(i);
-    if (!param || param.type !== 'parameter') continue;
-    const nameNode = param.childForFieldName('name');
-    if (nameNode) {
-      params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
-    }
-  }
-  return params;
+  return extractSimpleParameters(paramList, { paramTypes: ['parameter'] });
 }
 
 function extractSolVisibility(

package/src/extractors/verilog.ts

@@ -99,27 +99,60 @@ function handlePackageDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = node.childForFieldName('name');
-  if (!nameNode) return;
+  // tree-sitter-verilog exposes no field names on `class_declaration`. The
+  // class name lives under a `class_identifier > simple_identifier` chain, and
+  // the superclass appears as a `class_type` child (no `superclass` field).
+  // The Rust extractor in `crates/codegraph-core/src/extractors/verilog.rs`
+  // uses the same structural lookups so both engines emit identical class
+  // definitions and `extends` relations.
+  const name = findClassName(node);
+  if (!name) return;
 
   ctx.definitions.push({
-    name: nameNode.text,
+    name,
     kind: 'class',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
   });
 
-  // Superclass via extends
-  const superclass = node.childForFieldName('superclass');
+  const superclass = findClassSuperclass(node);
   if (superclass) {
     ctx.classes.push({
-      name: nameNode.text,
-      extends: superclass.text,
+      name,
+      extends: superclass,
       line: node.startPosition.row + 1,
     });
   }
 }
 
+function findClassName(node: TreeSitterNode): string | null {
+  const fieldName = node.childForFieldName('name');
+  if (fieldName) return fieldName.text;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'class_identifier') {
+      const simple = findChild(child, 'simple_identifier');
+      return (simple ?? child).text.trim();
+    }
+  }
+  return null;
+}
+
+function findClassSuperclass(node: TreeSitterNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'class_type') {
+      const id = findChild(child, 'class_identifier');
+      if (id) {
+        const simple = findChild(id, 'simple_identifier');
+        return (simple ?? id).text.trim();
+      }
+      return child.text.trim();
+    }
+  }
+  return null;
+}
+
 function handleFunctionDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = findFunctionOrTaskName(node, 'function_identifier');
   if (!nameNode) return;
@@ -151,8 +184,12 @@ function handleTaskDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleModuleInstantiation(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  // Module instantiations are like function calls: `ModuleName instance_name(...);`
-  const moduleType = node.childForFieldName('type') || node.child(0);
+  // Module instantiations are like function calls: `ModuleName instance_name(...);`.
+  // The module type identifier is the first *named* child; using
+  // `namedChild(0)` (instead of `child(0)`) skips anonymous tokens like a
+  // leading `#` parameter-override punctuation so we never capture that as a
+  // call name. The Rust extractor uses the same lookup for parity.
+  const moduleType = node.childForFieldName('type') ?? node.namedChild(0);
   if (!moduleType) return;
 
   ctx.calls.push({
@@ -169,7 +206,10 @@ function handlePackageImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
     if (child.type === 'package_import_item') {
       const text = child.text;
       const parts = text.split('::');
-      const pkg = parts[0] ?? text;
+      // `String.split('::')` always yields at least one element — when the
+      // delimiter is absent the whole string is the sole item, so the
+      // empty-string fallback is unreachable in practice.
+      const pkg = parts[0] ?? '';
       const item = parts[1] ?? '*';
       ctx.imports.push({
         source: pkg,
@@ -182,9 +222,18 @@ function handlePackageImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleIncludeDirective(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // `include "file.vh"
+  // Mirrors the Rust `handle_include_directive` which checks all three node
+  // kinds — tree-sitter-verilog has emitted `double_quoted_string` in some
+  // grammar revisions, and missing it would silently drop the import in WASM
+  // while the native engine still records it.
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
-    if (child && (child.type === 'string_literal' || child.type === 'quoted_string')) {
+    if (
+      child &&
+      (child.type === 'string_literal' ||
+        child.type === 'quoted_string' ||
+        child.type === 'double_quoted_string')
+    ) {
       const source = child.text.replace(/^["']|["']$/g, '');
       ctx.imports.push({
         source,
@@ -266,8 +315,14 @@ function findVerilogParent(node: TreeSitterNode): string | null {
       current.type === 'package_declaration' ||
       current.type === 'class_declaration'
     ) {
-      const name = findDeclName(current) || findModuleName(current);
-      return name ? name.text : null;
+      // `class_declaration` wraps its name in `class_identifier >
+      // simple_identifier`; `findDeclName` / `findModuleName` only look at
+      // bare `simple_identifier`/`identifier` children, so they miss it.
+      // `findClassName` already handles the wrapper, so consult it last to
+      // qualify tasks/functions nested inside a SystemVerilog class.
+      const nameNode = findDeclName(current) || findModuleName(current);
+      if (nameNode) return nameNode.text;
+      return findClassName(current);
     }
     current = current.parent;
   }
@@ -292,17 +347,30 @@ function extractPorts(moduleNode: TreeSitterNode): SubDeclaration[] {
       ) {
         const nameNode =
           child.childForFieldName('name') ||
+          findChild(child, 'port_identifier') ||
           findChild(child, 'simple_identifier') ||
           findChild(child, 'identifier');
         if (nameNode) {
-          ports.push({ name: nameNode.text, kind: 'property', line: child.startPosition.row + 1 });
+          // `port_identifier` wraps a `simple_identifier`; descend to the
+          // innermost identifier for a clean, whitespace-free name.
+          const inner =
+            findChild(nameNode, 'simple_identifier') ||
+            findChild(nameNode, 'identifier') ||
+            nameNode;
+          ports.push({ name: inner.text, kind: 'property', line: child.startPosition.row + 1 });
         }
       }
 
-      // Recurse into port list containers
+      // Recurse into port list containers. `module_ansi_header` wraps the
+      // ANSI-style declarations emitted by tree-sitter-verilog (e.g.
+      // `module top(input clk, output reg q);`) — without this branch the
+      // WASM engine returns an empty children array while the native engine
+      // (which includes the same kind in its CONTAINER_KINDS list) returns
+      // the correct ports, breaking engine parity.
       if (
         child.type === 'list_of_port_declarations' ||
         child.type === 'module_header' ||
+        child.type === 'module_ansi_header' ||
         child.type === 'port_declaration_list'
       ) {
         collectFromNode(child);