@optave/codegraph 3.8.0 → 3.9.0

package/src/extractors/go.ts

@@ -80,21 +80,9 @@ function handleGoFuncDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
 function handleGoMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
-  const receiver = node.childForFieldName('receiver');
   if (!nameNode) return;
-  let receiverType: string | null = null;
-  if (receiver) {
-    for (let i = 0; i < receiver.childCount; i++) {
-      const param = receiver.child(i);
-      if (!param) continue;
-      const typeNode = param.childForFieldName('type');
-      if (typeNode) {
-        receiverType =
-          typeNode.type === 'pointer_type' ? typeNode.text.replace(/^\*/, '') : typeNode.text;
-        break;
-      }
-    }
-  }
+  const receiver = node.childForFieldName('receiver');
+  const receiverType = receiver ? extractGoReceiverType(receiver) : null;
   const fullName = receiverType ? `${receiverType}.${nameNode.text}` : nameNode.text;
   const params = extractGoParameters(node.childForFieldName('parameters'));
   ctx.definitions.push({
@@ -107,6 +95,19 @@ function handleGoMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   });
 }
 
+/** Extract the receiver type name from a method receiver parameter list. */
+function extractGoReceiverType(receiver: TreeSitterNode): string | null {
+  for (let i = 0; i < receiver.childCount; i++) {
+    const param = receiver.child(i);
+    if (!param) continue;
+    const typeNode = param.childForFieldName('type');
+    if (typeNode) {
+      return typeNode.type === 'pointer_type' ? typeNode.text.replace(/^\*/, '') : typeNode.text;
+    }
+  }
+  return null;
+}
+
 function handleGoTypeDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const spec = node.child(i);
@@ -403,13 +404,38 @@ function extractGoParameters(paramListNode: TreeSitterNode | null): SubDeclarati
  * This performs file-local matching (cross-file matching requires build-edges).
  */
 function matchGoStructuralInterfaces(ctx: ExtractorOutput): void {
+  const { interfaceMethods, structMethods, structLines } = collectGoMethodSets(ctx);
+
+  // Match: struct satisfies interface if it has all interface methods (name-only;
+  // signatures are not verified — treat as candidate match, not definitive).
+  // NOTE: embedded interfaces (type_elem nodes) are not resolved — composite
+  // interfaces like `type ReadWriter interface { Reader; Writer }` will have an
+  // empty method set and be silently excluded from matching.
+  for (const [structName, methods] of structMethods) {
+    for (const [ifaceName, ifaceMethods] of interfaceMethods) {
+      if (ifaceMethods.size > 0 && [...ifaceMethods].every((m) => methods.has(m))) {
+        ctx.classes.push({
+          name: structName,
+          implements: ifaceName,
+          line: structLines.get(structName) || 1,
+        });
+      }
+    }
+  }
+}
+
+/** Collect interface and struct method sets from definitions for structural matching. */
+function collectGoMethodSets(ctx: ExtractorOutput): {
+  interfaceMethods: Map<string, Set<string>>;
+  structMethods: Map<string, Set<string>>;
+  structLines: Map<string, number>;
+} {
   const interfaceMethods = new Map<string, Set<string>>();
   const structMethods = new Map<string, Set<string>>();
   const structLines = new Map<string, number>();
-
-  // Collect interface and struct definitions
   const interfaceNames = new Set<string>();
   const structNames = new Set<string>();
+
   for (const def of ctx.definitions) {
     if (def.kind === 'interface') interfaceNames.add(def.name);
     if (def.kind === 'struct') {
@@ -418,7 +444,6 @@ function matchGoStructuralInterfaces(ctx: ExtractorOutput): void {
     }
   }
 
-  // Collect methods grouped by receiver type
   for (const def of ctx.definitions) {
     if (def.kind !== 'method' || !def.name.includes('.')) continue;
     const dotIdx = def.name.indexOf('.');
@@ -435,22 +460,7 @@ function matchGoStructuralInterfaces(ctx: ExtractorOutput): void {
     }
   }
 
-  // Match: struct satisfies interface if it has all interface methods (name-only;
-  // signatures are not verified — treat as candidate match, not definitive).
-  // NOTE: embedded interfaces (type_elem nodes) are not resolved — composite
-  // interfaces like `type ReadWriter interface { Reader; Writer }` will have an
-  // empty method set and be silently excluded from matching.
-  for (const [structName, methods] of structMethods) {
-    for (const [ifaceName, ifaceMethods] of interfaceMethods) {
-      if (ifaceMethods.size > 0 && [...ifaceMethods].every((m) => methods.has(m))) {
-        ctx.classes.push({
-          name: structName,
-          implements: ifaceName,
-          line: structLines.get(structName) || 1,
-        });
-      }
-    }
-  }
+  return { interfaceMethods, structMethods, structLines };
 }
 
 function extractStructFields(structTypeNode: TreeSitterNode): SubDeclaration[] {

package/src/extractors/helpers.ts

@@ -110,6 +110,20 @@ export function findParentNode(
   return null;
 }
 
+/**
+ * Resolve a container's body node by trying each field name in order.
+ */
+function resolveBodyNode(
+  containerNode: TreeSitterNode,
+  bodyFields: readonly string[],
+): TreeSitterNode | null {
+  for (const field of bodyFields) {
+    const body = containerNode.childForFieldName(field) || findChild(containerNode, field);
+    if (body) return body;
+  }
+  return null;
+}
+
 /**
  * Extract child declarations from a container node's body.
  * Finds the body via `bodyFields` (tries childForFieldName then findChild for each),
@@ -126,22 +140,17 @@ export function extractBodyMembers(
   nameField: string = 'name',
   visibility?: (member: TreeSitterNode) => SubDeclaration['visibility'],
 ): SubDeclaration[] {
+  const body = resolveBodyNode(containerNode, bodyFields);
+  if (!body) return [];
   const members: SubDeclaration[] = [];
-  let body: TreeSitterNode | null = null;
-  for (const field of bodyFields) {
-    body = containerNode.childForFieldName(field) || findChild(containerNode, field);
-    if (body) break;
-  }
-  if (!body) return members;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
     if (!member || member.type !== memberType) continue;
     const nn = member.childForFieldName(nameField);
-    if (nn) {
-      const entry: SubDeclaration = { name: nn.text, kind, line: member.startPosition.row + 1 };
-      if (visibility) entry.visibility = visibility(member);
-      members.push(entry);
-    }
+    if (!nn) continue;
+    const entry: SubDeclaration = { name: nn.text, kind, line: member.startPosition.row + 1 };
+    if (visibility) entry.visibility = visibility(member);
+    members.push(entry);
   }
   return members;
 }
@@ -162,24 +171,29 @@ export function lastPathSegment(path: string, separator: string = '/'): string {
   return path.split(separator).pop() ?? path;
 }
 
+/**
+ * Parse visibility from a modifier node's text content.
+ */
+function parseModifierText(text: string): 'public' | 'private' | 'protected' | undefined {
+  if (VISIBILITY_KEYWORDS.has(text)) return text as 'public' | 'private' | 'protected';
+  // C# 'private protected' — accessible to derived types in same assembly → protected
+  if (text === 'private protected') return 'protected';
+  // Compound modifiers node (Java: "public static") — scan its text for a keyword
+  for (const kw of VISIBILITY_KEYWORDS) {
+    if (text.includes(kw)) return kw as 'public' | 'private' | 'protected';
+  }
+  return undefined;
+}
+
 export function extractModifierVisibility(
   node: TreeSitterNode,
   modifierTypes: Set<string> = DEFAULT_MODIFIER_TYPES,
 ): 'public' | 'private' | 'protected' | undefined {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
-    if (!child) continue;
-    // Direct keyword match (e.g., PHP visibility_modifier = "public")
-    if (modifierTypes.has(child.type)) {
-      const text = child.text;
-      if (VISIBILITY_KEYWORDS.has(text)) return text as 'public' | 'private' | 'protected';
-      // C# 'private protected' — accessible to derived types in same assembly → protected
-      if (text === 'private protected') return 'protected';
-      // Compound modifiers node (Java: "public static") — scan its text for a keyword
-      for (const kw of VISIBILITY_KEYWORDS) {
-        if (text.includes(kw)) return kw as 'public' | 'private' | 'protected';
-      }
-    }
+    if (!child || !modifierTypes.has(child.type)) continue;
+    const result = parseModifierText(child.text);
+    if (result) return result;
   }
   return undefined;
 }

package/src/extractors/java.ts

@@ -83,27 +83,7 @@ function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
     children: classChildren.length > 0 ? classChildren : undefined,
   });
 
-  const superclass = node.childForFieldName('superclass');
-  if (superclass) {
-    for (let i = 0; i < superclass.childCount; i++) {
-      const child = superclass.child(i);
-      if (
-        child &&
-        (child.type === 'type_identifier' ||
-          child.type === 'identifier' ||
-          child.type === 'generic_type')
-      ) {
-        const superName = child.type === 'generic_type' ? child.child(0)?.text : child.text;
-        if (superName)
-          ctx.classes.push({
-            name: nameNode.text,
-            extends: superName,
-            line: node.startPosition.row + 1,
-          });
-        break;
-      }
-    }
-  }
+  extractJavaSuperclass(node, nameNode.text, ctx);
 
   const interfaces = node.childForFieldName('interfaces');
   if (interfaces) {
@@ -111,6 +91,32 @@ function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/** Extract the superclass (extends) relationship from a Java class declaration. */
+function extractJavaSuperclass(
+  node: TreeSitterNode,
+  className: string,
+  ctx: ExtractorOutput,
+): void {
+  const superclass = node.childForFieldName('superclass');
+  if (!superclass) return;
+  const superName = findJavaSuperTypeName(superclass);
+  if (superName) {
+    ctx.classes.push({ name: className, extends: superName, line: node.startPosition.row + 1 });
+  }
+}
+
+/** Find the type name from a superclass node (handles generic_type unwrapping). */
+function findJavaSuperTypeName(superclass: TreeSitterNode): string | undefined {
+  for (let i = 0; i < superclass.childCount; i++) {
+    const child = superclass.child(i);
+    if (!child) continue;
+    if (JAVA_TYPE_NODE_TYPES.has(child.type)) {
+      return resolveJavaIfaceName(child);
+    }
+  }
+  return undefined;
+}
+
 const JAVA_TYPE_NODE_TYPES = new Set(['type_identifier', 'identifier', 'generic_type']);
 
 /** Resolve interface name from a type node (handles generic_type unwrapping). */
@@ -161,19 +167,26 @@ function handleJavaInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): vo
     endLine: nodeEndLine(node),
   });
   const body = node.childForFieldName('body');
-  if (body) {
-    for (let i = 0; i < body.childCount; i++) {
-      const child = body.child(i);
-      if (child && child.type === 'method_declaration') {
-        const methName = child.childForFieldName('name');
-        if (methName) {
-          ctx.definitions.push({
-            name: `${nameNode.text}.${methName.text}`,
-            kind: 'method',
-            line: child.startPosition.row + 1,
-            endLine: child.endPosition.row + 1,
-          });
-        }
+  if (body) extractJavaInterfaceMethods(body, nameNode.text, ctx);
+}
+
+/** Extract method declarations from a Java interface body. */
+function extractJavaInterfaceMethods(
+  body: TreeSitterNode,
+  ifaceName: string,
+  ctx: ExtractorOutput,
+): void {
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (child && child.type === 'method_declaration') {
+      const methName = child.childForFieldName('name');
+      if (methName) {
+        ctx.definitions.push({
+          name: `${ifaceName}.${methName.text}`,
+          kind: 'method',
+          line: child.startPosition.row + 1,
+          endLine: child.endPosition.row + 1,
+        });
       }
     }
   }
@@ -321,23 +334,29 @@ function extractClassFields(classNode: TreeSitterNode): SubDeclaration[] {
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
     if (!member || member.type !== 'field_declaration') continue;
-    for (let j = 0; j < member.childCount; j++) {
-      const child = member.child(j);
-      if (!child || child.type !== 'variable_declarator') continue;
-      const nameNode = child.childForFieldName('name');
-      if (nameNode) {
-        fields.push({
-          name: nameNode.text,
-          kind: 'property',
-          line: member.startPosition.row + 1,
-          visibility: extractModifierVisibility(member),
-        });
-      }
-    }
+    extractFieldDeclarators(member, fields);
   }
   return fields;
 }
 
+/** Extract variable_declarator names from a field_declaration node. */
+function extractFieldDeclarators(member: TreeSitterNode, fields: SubDeclaration[]): void {
+  const vis = extractModifierVisibility(member);
+  for (let j = 0; j < member.childCount; j++) {
+    const child = member.child(j);
+    if (!child || child.type !== 'variable_declarator') continue;
+    const nameNode = child.childForFieldName('name');
+    if (nameNode) {
+      fields.push({
+        name: nameNode.text,
+        kind: 'property',
+        line: member.startPosition.row + 1,
+        visibility: vis,
+      });
+    }
+  }
+}
+
 function extractEnumConstants(enumNode: TreeSitterNode): SubDeclaration[] {
   return extractBodyMembers(enumNode, ['body', 'enum_body'], 'enum_constant', 'constant');
 }

package/src/extractors/javascript.ts

@@ -328,34 +328,7 @@ function extractConstantsWalk(node: TreeSitterNode, definitions: Definition[]):
       if (inner) declNode = inner;
     }
 
-    const t = declNode.type;
-    if (t === 'lexical_declaration' || t === 'variable_declaration') {
-      if (declNode.text.startsWith('const ')) {
-        for (let j = 0; j < declNode.childCount; j++) {
-          const declarator = declNode.child(j);
-          if (!declarator || declarator.type !== 'variable_declarator') continue;
-          const nameN = declarator.childForFieldName('name');
-          const valueN = declarator.childForFieldName('value');
-          if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
-          // Skip functions — already captured by query patterns
-          const valType = valueN.type;
-          if (
-            valType === 'arrow_function' ||
-            valType === 'function_expression' ||
-            valType === 'function'
-          )
-            continue;
-          if (isConstantValue(valueN)) {
-            definitions.push({
-              name: nameN.text,
-              kind: 'constant',
-              line: declNode.startPosition.row + 1,
-              endLine: nodeEndLine(declNode),
-            });
-          }
-        }
-      }
-    }
+    extractConstDeclarators(declNode, definitions);
 
     // Recurse into non-function, non-export-statement children (blocks, if-statements, etc.)
     if (child.type !== 'export_statement') {
@@ -364,6 +337,33 @@ function extractConstantsWalk(node: TreeSitterNode, definitions: Definition[]):
   }
 }
 
+/** Extract constant definitions from a `const` declaration node. */
+function extractConstDeclarators(declNode: TreeSitterNode, definitions: Definition[]): void {
+  const t = declNode.type;
+  if (t !== 'lexical_declaration' && t !== 'variable_declaration') return;
+  if (!declNode.text.startsWith('const ')) return;
+
+  for (let j = 0; j < declNode.childCount; j++) {
+    const declarator = declNode.child(j);
+    if (!declarator || declarator.type !== 'variable_declarator') continue;
+    const nameN = declarator.childForFieldName('name');
+    const valueN = declarator.childForFieldName('value');
+    if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
+    // Skip functions — already captured by query patterns
+    const valType = valueN.type;
+    if (valType === 'arrow_function' || valType === 'function_expression' || valType === 'function')
+      continue;
+    if (isConstantValue(valueN)) {
+      definitions.push({
+        name: nameN.text,
+        kind: 'constant',
+        line: declNode.startPosition.row + 1,
+        endLine: nodeEndLine(declNode),
+      });
+    }
+  }
+}
+
 /**
  * Recursive walk to find dynamic import() calls.
  * Query patterns match call_expression with identifier/member_expression/subscript_expression
@@ -678,24 +678,7 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function');
   if (!fn) return;
   if (fn.type === 'import') {
-    const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
-    if (args) {
-      const strArg = findChild(args, 'string');
-      if (strArg) {
-        const modPath = strArg.text.replace(/['"]/g, '');
-        const names = extractDynamicImportNames(node);
-        ctx.imports.push({
-          source: modPath,
-          names,
-          line: node.startPosition.row + 1,
-          dynamicImport: true,
-        });
-      } else {
-        debug(
-          `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
-        );
-      }
-    }
+    handleDynamicImportCall(node, ctx.imports);
   } else {
     const callInfo = extractCallInfo(fn, node);
     if (callInfo) ctx.calls.push(callInfo);
@@ -706,6 +689,22 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/** Handle a dynamic import() call expression and add to imports if static. */
+function handleDynamicImportCall(node: TreeSitterNode, imports: Import[]): void {
+  const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
+  if (!args) return;
+  const strArg = findChild(args, 'string');
+  if (strArg) {
+    const modPath = strArg.text.replace(/['"]/g, '');
+    const names = extractDynamicImportNames(node);
+    imports.push({ source: modPath, names, line: node.startPosition.row + 1, dynamicImport: true });
+  } else {
+    debug(
+      `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
+    );
+  }
+}
+
 function handleImportStmt(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const isTypeOnly = node.text.startsWith('import type');
   const source = node.childForFieldName('source') || findChild(node, 'string');
@@ -998,21 +997,34 @@ function handleVarDeclaratorTypeMap(
   const nameN = node.childForFieldName('name');
   if (!nameN || nameN.type !== 'identifier') return;
 
-  // Type annotation: const x: Foo = …
   const typeAnno = findChild(node, 'type_annotation');
+  const valueN = node.childForFieldName('value');
+
+  // Constructor on the same declaration wins over annotation: the runtime type is
+  // what matters for call resolution (e.g. `const x: Base = new Derived()` should
+  // resolve `x.render()` to `Derived.render`, not `Base.render`).
+  // When no constructor is present, annotation still takes precedence over factory.
+  if (valueN?.type === 'new_expression') {
+    const ctorType = extractNewExprTypeName(valueN);
+    if (ctorType) {
+      setTypeMapEntry(typeMap, nameN.text, ctorType, 1.0);
+      return;
+    }
+  }
+
+  // Type annotation: const x: Foo = … → confidence 0.9
   if (typeAnno) {
     const typeName = extractSimpleTypeName(typeAnno);
-    if (typeName) setTypeMapEntry(typeMap, nameN.text, typeName, 0.9);
+    if (typeName) {
+      setTypeMapEntry(typeMap, nameN.text, typeName, 0.9);
+      return;
+    }
   }
 
-  const valueN = node.childForFieldName('value');
   if (!valueN) return;
 
-  // Constructor: const x = new Foo() → confidence 1.0
-  if (valueN.type === 'new_expression') {
-    const ctorType = extractNewExprTypeName(valueN);
-    if (ctorType) setTypeMapEntry(typeMap, nameN.text, ctorType, 1.0);
-  }
+  // Constructor already handled above — only factory path remains.
+  if (valueN.type === 'new_expression') return;
   // Factory method: const x = Foo.create() → confidence 0.7
   else if (valueN.type === 'call_expression') {
     const fn = valueN.childForFieldName('function');