@optave/codegraph 3.8.0 → 3.8.1

package/src/extractors/python.ts

@@ -245,35 +245,41 @@ function extractPythonParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   for (let i = 0; i < paramsNode.childCount; i++) {
     const child = paramsNode.child(i);
     if (!child) continue;
-    const t = child.type;
-    if (t === 'identifier') {
-      params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
-    } else if (
-      t === 'typed_parameter' ||
-      t === 'default_parameter' ||
-      t === 'typed_default_parameter'
-    ) {
-      const nameNode = child.childForFieldName('name') || child.child(0);
-      if (nameNode && nameNode.type === 'identifier') {
-        params.push({
-          name: nameNode.text,
-          kind: 'parameter',
-          line: child.startPosition.row + 1,
-        });
-      }
-    } else if (t === 'list_splat_pattern' || t === 'dictionary_splat_pattern') {
-      for (let j = 0; j < child.childCount; j++) {
-        const inner = child.child(j);
-        if (inner && inner.type === 'identifier') {
-          params.push({ name: inner.text, kind: 'parameter', line: child.startPosition.row + 1 });
-          break;
-        }
-      }
-    }
+    const param = extractSinglePyParam(child);
+    if (param) params.push(param);
   }
   return params;
 }
 
+/** Extract a single parameter declaration from a parameter node. */
+function extractSinglePyParam(child: TreeSitterNode): SubDeclaration | null {
+  const t = child.type;
+  if (t === 'identifier') {
+    return { name: child.text, kind: 'parameter', line: child.startPosition.row + 1 };
+  }
+  if (t === 'typed_parameter' || t === 'default_parameter' || t === 'typed_default_parameter') {
+    const nameNode = child.childForFieldName('name') || child.child(0);
+    if (nameNode && nameNode.type === 'identifier') {
+      return { name: nameNode.text, kind: 'parameter', line: child.startPosition.row + 1 };
+    }
+  }
+  if (t === 'list_splat_pattern' || t === 'dictionary_splat_pattern') {
+    return extractSplatParam(child);
+  }
+  return null;
+}
+
+/** Extract the identifier name from a *args or **kwargs splat pattern. */
+function extractSplatParam(node: TreeSitterNode): SubDeclaration | null {
+  for (let j = 0; j < node.childCount; j++) {
+    const inner = node.child(j);
+    if (inner && inner.type === 'identifier') {
+      return { name: inner.text, kind: 'parameter', line: node.startPosition.row + 1 };
+    }
+  }
+  return null;
+}
+
 /** Extract class-level assignment properties from expression statements. */
 function extractClassAssignment(
   child: TreeSitterNode,

package/src/extractors/rust.ts

@@ -138,19 +138,22 @@ function handleRustTraitItem(node: TreeSitterNode, ctx: ExtractorOutput): void {
     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 === 'function_signature_item' || child.type === 'function_item')) {
-        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) extractTraitMethods(body, nameNode.text, ctx);
+}
+
+/** Extract method signatures/definitions from a trait body. */
+function extractTraitMethods(body: TreeSitterNode, traitName: string, ctx: ExtractorOutput): void {
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (child && (child.type === 'function_signature_item' || child.type === 'function_item')) {
+      const methName = child.childForFieldName('name');
+      if (methName) {
+        ctx.definitions.push({
+          name: `${traitName}.${methName.text}`,
+          kind: 'method',
+          line: child.startPosition.row + 1,
+          endLine: child.endPosition.row + 1,
+        });
       }
     }
   }
@@ -185,25 +188,30 @@ function handleRustUseDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleRustCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function');
   if (!fn) return;
-  if (fn.type === 'identifier') {
-    ctx.calls.push({ name: fn.text, line: node.startPosition.row + 1 });
-  } else if (fn.type === 'field_expression') {
+  const call = extractRustCallInfo(fn, node.startPosition.row + 1);
+  if (call) ctx.calls.push(call);
+}
+
+/** Extract call info from a Rust call function node. */
+function extractRustCallInfo(fn: TreeSitterNode, line: number): Call | null {
+  if (fn.type === 'identifier') return { name: fn.text, line };
+  if (fn.type === 'field_expression') {
     const field = fn.childForFieldName('field');
-    if (field) {
-      const value = fn.childForFieldName('value');
-      const call: Call = { name: field.text, line: node.startPosition.row + 1 };
-      if (value) call.receiver = value.text;
-      ctx.calls.push(call);
-    }
-  } else if (fn.type === 'scoped_identifier') {
+    if (!field) return null;
+    const value = fn.childForFieldName('value');
+    const call: Call = { name: field.text, line };
+    if (value) call.receiver = value.text;
+    return call;
+  }
+  if (fn.type === 'scoped_identifier') {
     const name = fn.childForFieldName('name');
-    if (name) {
-      const path = fn.childForFieldName('path');
-      const call: Call = { name: name.text, line: node.startPosition.row + 1 };
-      if (path) call.receiver = path.text;
-      ctx.calls.push(call);
-    }
+    if (!name) return null;
+    const path = fn.childForFieldName('path');
+    const call: Call = { name: name.text, line };
+    if (path) call.receiver = path.text;
+    return call;
   }
+  return null;
 }
 
 function handleRustMacroInvocation(node: TreeSitterNode, ctx: ExtractorOutput): void {

package/src/extractors/solidity.ts

@@ -97,60 +97,8 @@ function handleContractDecl(
   if (!nameNode) return;
   const name = nameNode.text;
 
-  const members: SubDeclaration[] = [];
   const body = node.childForFieldName('body') || findChild(node, 'contract_body');
-  if (body) {
-    for (let i = 0; i < body.childCount; i++) {
-      const child = body.child(i);
-      if (!child) continue;
-      if (child.type === 'function_definition') {
-        const fnName = child.childForFieldName('name');
-        if (fnName) {
-          members.push({ name: fnName.text, kind: 'method', line: child.startPosition.row + 1 });
-        }
-      } else if (child.type === 'state_variable_declaration') {
-        const varName = child.childForFieldName('name');
-        if (varName) {
-          members.push({
-            name: varName.text,
-            kind: 'property',
-            line: child.startPosition.row + 1,
-            visibility: extractSolVisibility(child),
-          });
-        }
-      } else if (child.type === 'event_definition') {
-        const evName = child.childForFieldName('name');
-        if (evName) {
-          members.push({
-            name: evName.text,
-            kind: 'property',
-            decorators: ['event'],
-            line: child.startPosition.row + 1,
-          });
-        }
-      } else if (child.type === 'error_declaration') {
-        const errName = child.childForFieldName('name');
-        if (errName) {
-          members.push({
-            name: errName.text,
-            kind: 'property',
-            decorators: ['error'],
-            line: child.startPosition.row + 1,
-          });
-        }
-      } else if (child.type === 'modifier_definition') {
-        const modName = child.childForFieldName('name');
-        if (modName) {
-          members.push({
-            name: modName.text,
-            kind: 'method',
-            decorators: ['modifier'],
-            line: child.startPosition.row + 1,
-          });
-        }
-      }
-    }
-  }
+  const members = body ? extractContractMembers(body) : [];
 
   ctx.definitions.push({
     name,
@@ -160,15 +108,63 @@ function handleContractDecl(
     children: members.length > 0 ? members : undefined,
   });
 
-  // Inheritance
+  extractInheritance(node, name, ctx);
+}
+
+/** Extract member declarations from a contract body node. */
+function extractContractMembers(body: TreeSitterNode): SubDeclaration[] {
+  const members: SubDeclaration[] = [];
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child) continue;
+    const member = extractContractMember(child);
+    if (member) members.push(member);
+  }
+  return members;
+}
+
+/** 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;
+  switch (child.type) {
+    case 'function_definition': {
+      const fnName = child.childForFieldName('name');
+      return fnName ? { name: fnName.text, kind: 'method', line } : null;
+    }
+    case 'state_variable_declaration': {
+      const varName = child.childForFieldName('name');
+      return varName
+        ? { name: varName.text, kind: 'property', line, visibility: extractSolVisibility(child) }
+        : null;
+    }
+    case 'event_definition': {
+      const evName = child.childForFieldName('name');
+      return evName ? { name: evName.text, kind: 'property', decorators: ['event'], line } : null;
+    }
+    case 'error_declaration': {
+      const errName = child.childForFieldName('name');
+      return errName ? { name: errName.text, kind: 'property', decorators: ['error'], line } : null;
+    }
+    case 'modifier_definition': {
+      const modName = child.childForFieldName('name');
+      return modName
+        ? { name: modName.text, kind: 'method', decorators: ['modifier'], line }
+        : null;
+    }
+    default:
+      return null;
+  }
+}
+
+/** Extract inheritance (extends) relationships from a contract node. */
+function extractInheritance(node: TreeSitterNode, name: string, ctx: ExtractorOutput): void {
   const inheritance = findChild(node, 'inheritance_specifier');
-  if (inheritance) {
-    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 });
-      }
+  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 });
     }
   }
 }

package/src/extractors/swift.ts

@@ -73,49 +73,7 @@ function handleSwiftClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
 
   const kind = isEnum ? 'enum' : isStruct ? 'struct' : 'class';
 
-  const children: SubDeclaration[] = [];
-
-  if (isEnum) {
-    // Enum cases: enum_entry > simple_identifier, inside enum_class_body
-    const body = findChild(node, 'enum_class_body');
-    if (body) {
-      for (let i = 0; i < body.childCount; i++) {
-        const child = body.child(i);
-        if (child && child.type === 'enum_entry') {
-          const entryName = findChild(child, 'simple_identifier');
-          if (entryName) {
-            children.push({
-              name: entryName.text,
-              kind: 'constant',
-              line: child.startPosition.row + 1,
-            });
-          }
-        }
-      }
-    }
-  } else {
-    // Extract properties from class_body
-    const body = findChild(node, 'class_body');
-    if (body) {
-      for (let i = 0; i < body.childCount; i++) {
-        const child = body.child(i);
-        if (child && child.type === 'property_declaration') {
-          const pattern = findChild(child, 'pattern');
-          if (pattern) {
-            const propName = findChild(pattern, 'simple_identifier');
-            if (propName) {
-              children.push({
-                name: propName.text,
-                kind: 'property',
-                line: child.startPosition.row + 1,
-                visibility: extractModifierVisibility(child),
-              });
-            }
-          }
-        }
-      }
-    }
-  }
+  const children = isEnum ? collectSwiftEnumEntries(node) : collectSwiftProperties(node);
 
   ctx.definitions.push({
     name,
@@ -125,52 +83,95 @@ function handleSwiftClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
     children: children.length > 0 ? children : undefined,
   });
 
-  // Methods inside class_body or enum_class_body
+  collectSwiftMethods(node, name, ctx);
+  collectSwiftInheritance(node, name, ctx);
+}
+
+/** Collect enum constant entries from an enum_class_body. */
+function collectSwiftEnumEntries(node: TreeSitterNode): SubDeclaration[] {
+  const entries: SubDeclaration[] = [];
+  const body = findChild(node, 'enum_class_body');
+  if (!body) return entries;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'enum_entry') continue;
+    const entryName = findChild(child, 'simple_identifier');
+    if (entryName) {
+      entries.push({
+        name: entryName.text,
+        kind: 'constant',
+        line: child.startPosition.row + 1,
+      });
+    }
+  }
+  return entries;
+}
+
+/** Collect property declarations from a class_body. */
+function collectSwiftProperties(node: TreeSitterNode): SubDeclaration[] {
+  const props: SubDeclaration[] = [];
+  const body = findChild(node, 'class_body');
+  if (!body) return props;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'property_declaration') continue;
+    const pattern = findChild(child, 'pattern');
+    if (!pattern) continue;
+    const propName = findChild(pattern, 'simple_identifier');
+    if (propName) {
+      props.push({
+        name: propName.text,
+        kind: 'property',
+        line: child.startPosition.row + 1,
+        visibility: extractModifierVisibility(child),
+      });
+    }
+  }
+  return props;
+}
+
+/** Collect method declarations from class_body or enum_class_body. */
+function collectSwiftMethods(node: TreeSitterNode, className: string, ctx: ExtractorOutput): void {
   const body = findChild(node, 'class_body') || findChild(node, 'enum_class_body');
-  if (body) {
-    for (let i = 0; i < body.childCount; i++) {
-      const child = body.child(i);
-      if (child && child.type === 'function_declaration') {
-        const methName = findChild(child, 'simple_identifier');
-        if (methName) {
-          ctx.definitions.push({
-            name: `${name}.${methName.text}`,
-            kind: 'method',
-            line: child.startPosition.row + 1,
-            endLine: child.endPosition.row + 1,
-            visibility: extractModifierVisibility(child),
-          });
-        }
-      }
+  if (!body) return;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'function_declaration') continue;
+    const methName = findChild(child, 'simple_identifier');
+    if (methName) {
+      ctx.definitions.push({
+        name: `${className}.${methName.text}`,
+        kind: 'method',
+        line: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1,
+        visibility: extractModifierVisibility(child),
+      });
     }
   }
+}
 
-  // Inheritance: inheritance_specifier nodes are DIRECT children of class_declaration
-  // First specifier is the superclass (extends), rest are protocol conformances (implements)
+/** Collect inheritance from inheritance_specifier children. First = extends, rest = implements. */
+function collectSwiftInheritance(
+  node: TreeSitterNode,
+  className: string,
+  ctx: ExtractorOutput,
+): void {
   let first = true;
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child || child.type !== 'inheritance_specifier') continue;
-    // inheritance_specifier > user_type > type_identifier
     const userType = findChild(child, 'user_type');
-    if (userType) {
-      const typeId = findChild(userType, 'type_identifier');
-      if (typeId) {
-        if (first) {
-          ctx.classes.push({
-            name,
-            extends: typeId.text,
-            line: node.startPosition.row + 1,
-          });
-          first = false;
-        } else {
-          ctx.classes.push({
-            name,
-            implements: typeId.text,
-            line: node.startPosition.row + 1,
-          });
-        }
-      }
+    const typeId = userType ? findChild(userType, 'type_identifier') : null;
+    if (!typeId) continue;
+    if (first) {
+      ctx.classes.push({ name: className, extends: typeId.text, line: node.startPosition.row + 1 });
+      first = false;
+    } else {
+      ctx.classes.push({
+        name: className,
+        implements: typeId.text,
+        line: node.startPosition.row + 1,
+      });
     }
   }
 }

package/src/extractors/zig.ts

@@ -100,78 +100,75 @@ function handleZigVariable(node: TreeSitterNode, ctx: ExtractorOutput): void {
   if (!nameNode) return;
   const name = nameNode.text;
 
-  // Check if this is a struct/enum/union definition
+  if (tryHandleZigContainerDecl(node, name, ctx)) return;
+  if (tryHandleZigImportDecl(node, name, ctx)) return;
+
+  // Regular constant/variable
+  const isConst = hasChildText(node, 'const');
+  ctx.definitions.push({
+    name,
+    kind: isConst ? 'constant' : 'variable',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+/** Try to handle a variable_declaration as a struct/enum/union. Returns true if handled. */
+function tryHandleZigContainerDecl(
+  node: TreeSitterNode,
+  name: string,
+  ctx: ExtractorOutput,
+): boolean {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
+    const containerKind = zigContainerKind(child.type);
+    if (!containerKind) continue;
 
-    if (child.type === 'struct_declaration') {
-      const members = extractZigContainerFields(child);
-      ctx.definitions.push({
-        name,
-        kind: 'struct',
-        line: node.startPosition.row + 1,
-        endLine: nodeEndLine(node),
-        children: members.length > 0 ? members : undefined,
-        visibility: isZigPub(node) ? 'public' : undefined,
-      });
-      extractZigContainerMethods(child, name, ctx);
-      return;
-    }
-    if (child.type === 'enum_declaration') {
-      ctx.definitions.push({
-        name,
-        kind: 'enum',
-        line: node.startPosition.row + 1,
-        endLine: nodeEndLine(node),
-        visibility: isZigPub(node) ? 'public' : undefined,
-      });
-      return;
-    }
-    if (child.type === 'union_declaration') {
-      ctx.definitions.push({
-        name,
-        kind: 'struct',
-        line: node.startPosition.row + 1,
-        endLine: nodeEndLine(node),
-        visibility: isZigPub(node) ? 'public' : undefined,
-      });
-      return;
-    }
+    const members = child.type === 'struct_declaration' ? extractZigContainerFields(child) : [];
+    ctx.definitions.push({
+      name,
+      kind: containerKind,
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: members.length > 0 ? members : undefined,
+      visibility: isZigPub(node) ? 'public' : undefined,
+    });
+    if (child.type === 'struct_declaration') extractZigContainerMethods(child, name, ctx);
+    return true;
   }
+  return false;
+}
 
-  // Check for @import
+/** Map a Zig container node type to a definition kind, or undefined if not a container. */
+function zigContainerKind(nodeType: string): 'struct' | 'enum' | undefined {
+  if (nodeType === 'struct_declaration' || nodeType === 'union_declaration') return 'struct';
+  if (nodeType === 'enum_declaration') return 'enum';
+  return undefined;
+}
+
+/** Try to handle a variable_declaration as an @import. Returns true if handled. */
+function tryHandleZigImportDecl(node: TreeSitterNode, name: string, ctx: ExtractorOutput): boolean {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
-    if (!child) continue;
-    if (child.type === 'builtin_function') {
-      const builtinId = findChild(child, 'builtin_identifier');
-      if (builtinId?.text === '@import') {
-        const args = findChild(child, 'arguments');
-        if (args) {
-          const strArg = findChild(args, 'string_literal') || findChild(args, 'string');
-          if (strArg) {
-            const source = strArg.text.replace(/^"|"$/g, '');
-            ctx.imports.push({
-              source,
-              names: [name],
-              line: node.startPosition.row + 1,
-            });
-            return;
-          }
-        }
-      }
+    if (!child || child.type !== 'builtin_function') continue;
+    const source = extractZigImportSource(child);
+    if (source) {
+      ctx.imports.push({ source, names: [name], line: node.startPosition.row + 1 });
+      return true;
     }
   }
+  return false;
+}
 
-  // Regular constant/variable
-  const isConst = hasChildText(node, 'const');
-  ctx.definitions.push({
-    name,
-    kind: isConst ? 'constant' : 'variable',
-    line: node.startPosition.row + 1,
-    endLine: nodeEndLine(node),
-  });
+/** Extract the import source path from a builtin_function node if it is @import. */
+function extractZigImportSource(builtinNode: TreeSitterNode): string | null {
+  const builtinId = findChild(builtinNode, 'builtin_identifier');
+  if (builtinId?.text !== '@import') return null;
+  const args = findChild(builtinNode, 'arguments');
+  if (!args) return null;
+  const strArg = findChild(args, 'string_literal') || findChild(args, 'string');
+  return strArg ? strArg.text.replace(/^"|"$/g, '') : null;
 }
 
 function extractZigContainerFields(container: TreeSitterNode): SubDeclaration[] {