@optave/codegraph 3.10.0 → 3.11.0

package/src/extractors/julia.ts

@@ -83,17 +83,49 @@ function handleModuleDef(node: TreeSitterNode, ctx: ExtractorOutput): string | n
   return nameNode.text;
 }
 
+function qualifyName(base: string, currentModule: string | null): string {
+  // For qualified names (`function Base.show ... end` inside `module Foo`,
+  // or short-form `Foo.bar(x, y) = x + y` inside `module Outer`), the LHS
+  // is a `scoped_identifier` already containing the qualifier — skip the
+  // module prefix to avoid producing `Foo.Base.show` / `Outer.Foo.bar`.
+  if (currentModule && !base.includes('.')) return `${currentModule}.${base}`;
+  return base;
+}
+
+/**
+ * Extract the call_expression from a function/macro definition's signature.
+ *
+ * tree-sitter-julia wraps the signature in a `signature` node whose direct
+ * children include the `call_expression` for the function name and parameters.
+ * `findChild` only inspects direct children, so we unwrap one level explicitly.
+ * Without this step, `findChild(node, 'call_expression')` on a
+ * `function_definition` would match the *body's* first call_expression
+ * (e.g. `println(...)` inside the body) instead of the signature.
+ *
+ * Grammar assumption: every `function_definition` / `macro_definition` emits a
+ * `signature` child in the current tree-sitter-julia grammar. The fallback to
+ * `findChild(node, 'call_expression')` exists only as a defensive measure for
+ * grammar drift — if it ever fires on a real definition, that fallback would
+ * silently match the first body call_expression and mis-record the function
+ * name. Callers must therefore treat a missing `signature` as a parser/grammar
+ * mismatch worth investigating, not as a routine code path.
+ */
+function signatureCall(node: TreeSitterNode): TreeSitterNode | null {
+  const sig = findChild(node, 'signature');
+  if (sig) return findChild(sig, 'call_expression');
+  return findChild(node, 'call_expression');
+}
+
 function handleFunctionDef(
   node: TreeSitterNode,
   ctx: ExtractorOutput,
   currentModule: string | null,
 ): void {
-  // function_definition may have a call_expression child as the signature
-  const callSig = findChild(node, 'call_expression');
+  const callSig = signatureCall(node);
   if (callSig) {
     const funcNameNode = callSig.child(0);
     if (funcNameNode) {
-      const name = currentModule ? `${currentModule}.${funcNameNode.text}` : funcNameNode.text;
+      const name = qualifyName(funcNameNode.text, currentModule);
       const params = extractJuliaParams(callSig);
       ctx.definitions.push({
         name,
@@ -110,9 +142,8 @@ function handleFunctionDef(
   const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
   if (!nameNode) return;
 
-  const name = currentModule ? `${currentModule}.${nameNode.text}` : nameNode.text;
   ctx.definitions.push({
-    name,
+    name: qualifyName(nameNode.text, currentModule),
     kind: 'function',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
@@ -133,11 +164,10 @@ function handleAssignment(
     const funcNameNode = lhs.child(0);
     if (!funcNameNode) return;
 
-    const name = currentModule ? `${currentModule}.${funcNameNode.text}` : funcNameNode.text;
     const params = extractJuliaParams(lhs);
 
     ctx.definitions.push({
-      name,
+      name: qualifyName(funcNameNode.text, currentModule),
       kind: 'function',
       line: node.startPosition.row + 1,
       endLine: nodeEndLine(node),
@@ -146,16 +176,74 @@ function handleAssignment(
   }
 }
 
+/**
+ * Locate the base-name identifier within a `type_head` node.
+ *
+ * Handles plain identifiers, `Name <: Super` binary expressions, and
+ * parameterized forms like `Name{T}` / `Name{T} <: Super{T,1}` by recursing
+ * into wrapper kinds the Julia grammar actually emits for type heads
+ * (binary expressions, parametrized type expressions, parameterized
+ * identifiers). Returns `null` when no identifier can be located — callers
+ * should skip emitting a definition in that case.
+ *
+ * Note: `type_parameter_list` / `type_argument_list` are intentionally
+ * excluded — Julia's grammar uses `curly_expression` for `{T}` constructs,
+ * not those node kinds. Including them would risk recursing into a
+ * type-parameter list and returning a type variable (e.g. `T`) instead of
+ * the struct name if `findBaseName` were ever called on a node lacking a
+ * direct `identifier` child.
+ */
+const TYPE_HEAD_WRAPPERS: ReadonlySet<string> = new Set([
+  'binary_expression',
+  'parametrized_type_expression',
+  'parameterized_identifier',
+]);
+
+function findBaseName(node: TreeSitterNode): TreeSitterNode | null {
+  if (node.type === 'identifier') return node;
+  const direct = findChild(node, 'identifier');
+  if (direct) return direct;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (TYPE_HEAD_WRAPPERS.has(child.type)) {
+      const found = findBaseName(child);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
 function handleStructDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // struct_definition: struct type_head fields... end
+  // type_head wraps the name and optional supertype. The name may be a
+  // bare `identifier`, a parameterized form (e.g. `Vec{T}`), or either
+  // of those nested inside a `binary_expression` (`Name <: Super`).
   const typeHead = findChild(node, 'type_head');
-  const nameNode = typeHead
-    ? (findChild(typeHead, 'identifier') ?? typeHead)
-    : findChild(node, 'identifier');
+  if (!typeHead) return;
+
+  let nameNode: TreeSitterNode | null;
+  let supertypeNode: TreeSitterNode | null = null;
+
+  const binary = findChild(typeHead, 'binary_expression');
+  if (binary) {
+    // Walk into each side of the binary expression to find the base-name
+    // identifier — handles parameterized forms like `Vec{T} <: AbstractArray{T,1}`.
+    const sides: TreeSitterNode[] = [];
+    for (let i = 0; i < binary.childCount; i++) {
+      const c = binary.child(i);
+      if (c && c.type !== 'operator') sides.push(c);
+    }
+    nameNode = sides[0] ? findBaseName(sides[0]) : null;
+    supertypeNode = sides[1] ? findBaseName(sides[1]) : null;
+  } else {
+    nameNode = findBaseName(typeHead);
+  }
+
   if (!nameNode) return;
+  const structName = nameNode.text;
 
   const children: SubDeclaration[] = [];
-  // Fields are typed_expression children of struct_definition
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
@@ -168,33 +256,24 @@ function handleStructDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
           line: child.startPosition.row + 1,
         });
       }
-    }
-    // Plain identifier fields (no type annotation)
-    if (child.type === 'identifier' && child !== nameNode && typeHead && child !== typeHead) {
+    } else if (child.type === 'identifier') {
+      // Plain identifier fields (no type annotation) appear as direct
+      // identifier children of struct_definition. The type_head is a
+      // separate node so there is nothing to filter out here.
       children.push({ name: child.text, kind: 'property', line: child.startPosition.row + 1 });
     }
   }
 
-  // Check for supertype in type_head (Point <: AbstractPoint)
-  if (typeHead) {
-    const subtypeExpr = findChild(typeHead, 'subtype_expression');
-    if (subtypeExpr) {
-      // Find the supertype identifier
-      for (let i = 0; i < subtypeExpr.childCount; i++) {
-        const child = subtypeExpr.child(i);
-        if (child?.type === 'identifier' && i > 0) {
-          ctx.classes.push({
-            name: nameNode.text,
-            extends: child.text,
-            line: node.startPosition.row + 1,
-          });
-        }
-      }
-    }
+  if (supertypeNode) {
+    ctx.classes.push({
+      name: structName,
+      extends: supertypeNode.text,
+      line: node.startPosition.row + 1,
+    });
   }
 
   ctx.definitions.push({
-    name: nameNode.text,
+    name: structName,
     kind: 'struct',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
@@ -203,7 +282,14 @@ function handleStructDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 }
 
 function handleAbstractDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  // abstract_definition: `abstract type` type_head `end`
+  // The identifier is nested inside `type_head` — possibly wrapped in a
+  // `Name <: Super` binary_expression or a `Name{T,...}` parameterized form.
+  // Mirror handleStructDef and skip rather than emit a garbled name when no
+  // base identifier can be located.
+  const typeHead = findChild(node, 'type_head');
+  if (!typeHead) return;
+  const nameNode = findBaseName(typeHead);
   if (!nameNode) return;
 
   ctx.definitions.push({
@@ -219,10 +305,17 @@ function handleMacroDef(
   ctx: ExtractorOutput,
   currentModule: string | null,
 ): void {
-  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  // macro_definition: `macro` signature/call_expression body `end`.
+  // The name lives in the same shape as a function signature — unwrap via
+  // signatureCall so we don't pick up an identifier from the body (e.g.
+  // `macro mymac(x) x end` would otherwise resolve to `@x`).
+  const callSig = signatureCall(node);
+  const nameNode =
+    callSig?.child(0) ?? node.childForFieldName('name') ?? findChild(node, 'identifier');
   if (!nameNode) return;
 
-  const name = currentModule ? `${currentModule}.@${nameNode.text}` : `@${nameNode.text}`;
+  const base = nameNode.text;
+  const name = currentModule ? `${currentModule}.@${base}` : `@${base}`;
   ctx.definitions.push({
     name,
     kind: 'function',
@@ -232,19 +325,40 @@ function handleMacroDef(
 }
 
 function handleImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // tree-sitter-julia shapes:
+  //   `using LinearAlgebra`     → using_statement [ using, identifier ]
+  //   `import Foo.Bar`          → import_statement [ import, scoped_identifier ]
+  //   `import Base: show`       → import_statement [ import, selected_import[Base, show] ]
+  //   `import Foo.Bar: baz`     → import_statement [ import, selected_import[scoped_identifier, baz] ]
   const names: string[] = [];
   let source = '';
 
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (
-      child.type === 'identifier' ||
-      child.type === 'scoped_identifier' ||
-      child.type === 'selected_import'
-    ) {
-      if (!source) source = child.text;
-      names.push(child.text.split('.').pop() || child.text);
+    if (child.type === 'identifier' || child.type === 'scoped_identifier') {
+      const txt = child.text;
+      if (!source) source = txt;
+      names.push(txt.split('.').pop() || txt);
+    } else if (child.type === 'selected_import') {
+      // First identifier-bearing node is the source module; the rest are
+      // imported names. The module may itself be a `scoped_identifier`
+      // (e.g. `import Foo.Bar: baz`) — handle it alongside bare
+      // `identifier` and use the trailing segment as the display name,
+      // mirroring the outer loop.
+      let first = true;
+      for (let j = 0; j < child.childCount; j++) {
+        const part = child.child(j);
+        if (!part) continue;
+        if (part.type !== 'identifier' && part.type !== 'scoped_identifier') continue;
+        const txt = part.text;
+        if (first) {
+          if (!source) source = txt;
+          first = false;
+        } else {
+          names.push(txt.split('.').pop() || txt);
+        }
+      }
     }
   }
 
@@ -260,8 +374,15 @@ function handleImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // Don't record if parent is assignment LHS (that's a function definition)
   if (node.parent?.type === 'assignment' && node === node.parent.child(0)) return;
-  // Don't record if parent is function_definition (that's a signature)
-  if (node.parent?.type === 'function_definition') return;
+  // Skip when this call is the signature of a function/macro definition.
+  // tree-sitter-julia wraps the signature in a `signature` node whose parent
+  // is `function_definition` or `macro_definition`. Body calls (e.g.
+  // `println(name)` inside `function greet ... end`) appear as descendants of
+  // the body, not as direct children of `signature`, so they are unaffected.
+  if (node.parent?.type === 'signature') {
+    const grand = node.parent.parent;
+    if (grand?.type === 'function_definition' || grand?.type === 'macro_definition') return;
+  }
 
   const funcNode = node.child(0);
   if (!funcNode) return;

package/src/extractors/kotlin.ts

@@ -147,11 +147,13 @@ function collectKotlinMethods(node: TreeSitterNode, className: string, ctx: Extr
     if (!child || child.type !== 'function_declaration') continue;
     const methName = findChild(child, 'simple_identifier');
     if (methName) {
+      const params = extractKotlinParameters(child);
       ctx.definitions.push({
         name: `${className}.${methName.text}`,
         kind: 'method',
         line: child.startPosition.row + 1,
         endLine: child.endPosition.row + 1,
+        children: params.length > 0 ? params : undefined,
         visibility: extractModifierVisibility(child),
       });
     }
@@ -214,11 +216,13 @@ function handleKotlinObjectDecl(node: TreeSitterNode, ctx: ExtractorOutput): voi
       if (child && child.type === 'function_declaration') {
         const methName = findChild(child, 'simple_identifier');
         if (methName) {
+          const params = extractKotlinParameters(child);
           ctx.definitions.push({
             name: `${nameNode.text}.${methName.text}`,
             kind: 'method',
             line: child.startPosition.row + 1,
             endLine: child.endPosition.row + 1,
+            children: params.length > 0 ? params : undefined,
             visibility: extractModifierVisibility(child),
           });
         }

package/src/extractors/objc.ts

@@ -55,6 +55,11 @@ function walkObjCNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'preproc_import':
       handleImport(node, ctx);
       break;
+    // tree-sitter-objc v3 emits `module_import` for `@import Foundation;`
+    // statements. Older grammar revisions used `import_declaration`, so we
+    // accept both for forward/backward compatibility and keep behaviour
+    // aligned with `handle_at_import` on the Rust side.
+    case 'module_import':
     case 'import_declaration':
       handleAtImport(node, ctx);
       break;
@@ -87,29 +92,46 @@ function handleClassInterface(node: TreeSitterNode, ctx: ExtractorOutput): void
   const nameNode = node.childForFieldName('name') || findObjCDeclName(node);
   if (!nameNode) return;
   const name = nameNode.text;
+  // Categories declared as `@interface Foo (Cat)` arrive as `class_interface`
+  // with a `category` field (rather than the `category_interface` node type).
+  // Qualify the display name with `(Cat)` so symbols stay grouped per category
+  // and match the Rust extractor.
+  const category = node.childForFieldName('category');
+  const displayName = category ? `${name}(${category.text})` : name;
 
   const members = collectClassMembers(node);
   ctx.definitions.push({
-    name,
+    name: displayName,
     kind: 'class',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
     children: members.length > 0 ? members : undefined,
   });
 
-  // Superclass
+  // Superclass — keyed on the bare class name (categories don't have a superclass).
   const superclass = node.childForFieldName('superclass');
   if (superclass) {
     ctx.classes.push({ name, extends: superclass.text, line: node.startPosition.row + 1 });
   }
 
-  // Protocols
-  const protocols = findChild(node, 'protocol_qualifiers');
+  // Adopted protocols. tree-sitter-objc v3 wraps the adopted-protocol list in
+  // `parameterized_arguments` (not `protocol_qualifiers`, which was the v2
+  // grammar shape). Each child is wrapped in `type_name > type_identifier`;
+  // fall back to a bare `identifier`/`type_identifier` for older grammars.
+  const protocols = findChild(node, 'parameterized_arguments');
   if (protocols) {
     for (let i = 0; i < protocols.childCount; i++) {
       const proto = protocols.child(i);
-      if (proto && proto.type === 'identifier') {
-        ctx.classes.push({ name, implements: proto.text, line: node.startPosition.row + 1 });
+      if (!proto) continue;
+      let protoName: string | null = null;
+      if (proto.type === 'type_name') {
+        const inner = findChild(proto, 'type_identifier') || findChild(proto, 'identifier');
+        if (inner) protoName = inner.text;
+      } else if (proto.type === 'identifier' || proto.type === 'type_identifier') {
+        protoName = proto.text;
+      }
+      if (protoName) {
+        ctx.classes.push({ name, implements: protoName, line: node.startPosition.row + 1 });
       }
     }
   }
@@ -118,9 +140,14 @@ function handleClassInterface(node: TreeSitterNode, ctx: ExtractorOutput): void
 function handleClassImplementation(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name') || findObjCDeclName(node);
   if (!nameNode) return;
+  // Categories declared as `@implementation Foo (Cat)` arrive as
+  // `class_implementation` with a `category` field. Mirror the Rust extractor
+  // and qualify the display name with `(Cat)`.
+  const category = node.childForFieldName('category');
+  const displayName = category ? `${nameNode.text}(${category.text})` : nameNode.text;
 
   ctx.definitions.push({
-    name: nameNode.text,
+    name: displayName,
     kind: 'class',
     line: node.startPosition.row + 1,
     endLine: nodeEndLine(node),
@@ -285,7 +312,20 @@ function handleTypedef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 // ── Call handlers ─────────────────────────────────────────────────────────
 
 function handleCCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
-  const funcNode = node.childForFieldName('function');
+  // tree-sitter-objc does not expose a `function` field on `call_expression`,
+  // so the named-field lookup almost always misses. Fall back to the first
+  // `identifier` / `field_expression` child to mirror `handle_c_call_expr` in
+  // `crates/codegraph-core/src/extractors/objc.rs` and keep engine parity.
+  let funcNode = node.childForFieldName('function');
+  if (!funcNode) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && (child.type === 'identifier' || child.type === 'field_expression')) {
+        funcNode = child;
+        break;
+      }
+    }
+  }
   if (!funcNode) return;
   const call: Call = { name: '', line: node.startPosition.row + 1 };
   if (funcNode.type === 'field_expression') {
@@ -302,10 +342,33 @@ function handleCCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleMessageExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // [receiver selector:arg ...]
   const receiver = node.childForFieldName('receiver');
-  const selector = node.childForFieldName('selector');
-  if (!selector) return;
 
-  const call: Call = { name: selector.text, line: node.startPosition.row + 1 };
+  // tree-sitter-objc v3 does not expose a `selector` field on
+  // `message_expression`; instead every keyword identifier has the `method`
+  // field. Assemble the selector by joining `method` children with `:`,
+  // appending a trailing `:` when the message has at least one colon
+  // (keyword form). Mirrors `build_message_selector` in
+  // `crates/codegraph-core/src/extractors/objc.rs`.
+  const parts: string[] = [];
+  let hasColon = false;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const fieldName = node.fieldNameForChild(i);
+    if (fieldName === 'method') parts.push(child.text);
+    if (child.type === ':') hasColon = true;
+  }
+  let name: string;
+  if (parts.length > 0) {
+    name = hasColon ? `${parts.join(':')}:` : parts.join(':');
+  } else {
+    // Fallback: some grammar revisions expose a `selector` field.
+    const selector = node.childForFieldName('selector');
+    if (!selector) return;
+    name = selector.text;
+  }
+
+  const call: Call = { name, line: node.startPosition.row + 1 };
   if (receiver) call.receiver = receiver.text;
   ctx.calls.push(call);
 }
@@ -313,29 +376,25 @@ function handleMessageExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
 // ── Helpers ───────────────────────────────────────────────────────────────
 
 function buildSelector(methodNode: TreeSitterNode): string | null {
-  const selector = methodNode.childForFieldName('selector');
-  if (selector) return selector.text;
-
-  // Build selector from keyword children: initWith:name:
+  // tree-sitter-objc v3 does not expose a `selector` field; the selector is
+  // assembled from the leading `identifier` keywords. Multi-keyword forms
+  // look like `setName:(...)x age:(...)y` and appear as flat
+  // `identifier` + `method_parameter` children directly under the method
+  // node (not wrapped in `keyword_selector`). Mirrors `build_selector` in
+  // `crates/codegraph-core/src/extractors/objc.rs`.
   const parts: string[] = [];
+  let hasParams = false;
   for (let i = 0; i < methodNode.childCount; i++) {
     const child = methodNode.child(i);
     if (!child) continue;
-    if (child.type === 'keyword_selector') {
-      for (let j = 0; j < child.childCount; j++) {
-        const kw = child.child(j);
-        if (kw && kw.type === 'keyword_declarator') {
-          const kwName = kw.childForFieldName('keyword');
-          if (kwName) parts.push(kwName.text);
-        }
-      }
-    }
-    if (child.type === 'identifier' && i === 1) {
-      // Simple unary selector
-      return child.text;
+    if (child.type === 'identifier') {
+      parts.push(child.text);
+    } else if (child.type === 'method_parameter') {
+      hasParams = true;
     }
   }
-  return parts.length > 0 ? `${parts.join(':')}:` : null;
+  if (parts.length === 0) return null;
+  return hasParams ? `${parts.join(':')}:` : parts.join(':');
 }
 
 function findObjCParentClass(node: TreeSitterNode): string | null {
@@ -349,7 +408,14 @@ function findObjCParentClass(node: TreeSitterNode): string | null {
       current.type === 'category_implementation'
     ) {
       const nameNode = current.childForFieldName('name') || findObjCDeclName(current);
-      return nameNode ? nameNode.text : null;
+      if (!nameNode) return null;
+      // Categories: include `(Cat)` so methods are grouped per category.
+      // Two categories on the same class can declare same-named methods, so
+      // qualifying the parent name keeps the symbols disambiguated. Mirrors
+      // `find_objc_parent_class` in `crates/codegraph-core/src/extractors/objc.rs`.
+      const category = current.childForFieldName('category');
+      if (category) return `${nameNode.text}(${category.text})`;
+      return nameNode.text;
     }
     current = current.parent;
   }
@@ -381,32 +447,65 @@ function collectClassMembers(classNode: TreeSitterNode): SubDeclaration[] {
       }
     }
     if (child.type === 'property_declaration') {
-      const propName = child.childForFieldName('name');
+      const propName = extractPropertyName(child);
       if (propName) {
-        members.push({ name: propName.text, kind: 'property', line: child.startPosition.row + 1 });
+        members.push({ name: propName, kind: 'property', line: child.startPosition.row + 1 });
       }
     }
   }
   return members;
 }
 
+/**
+ * Extract the property name from `@property (...) Type *foo;`. The v3 grammar
+ * does not expose `name` as a named field on `property_declaration`; instead
+ * the identifier nests under `struct_declaration > struct_declarator >
+ * [pointer_declarator >] identifier`. Mirrors `extract_property_name` in
+ * `crates/codegraph-core/src/extractors/objc.rs`.
+ */
+function extractPropertyName(propNode: TreeSitterNode): string | null {
+  const structDecl = findChild(propNode, 'struct_declaration');
+  if (!structDecl) return null;
+  for (let i = 0; i < structDecl.childCount; i++) {
+    const child = structDecl.child(i);
+    if (!child || child.type !== 'struct_declarator') continue;
+    const id = findIdentifierDeep(child);
+    if (id) return id.text;
+  }
+  return null;
+}
+
+function findIdentifierDeep(node: TreeSitterNode): TreeSitterNode | null {
+  if (node.type === 'identifier') return node;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const found = findIdentifierDeep(child);
+    if (found) return found;
+  }
+  return null;
+}
+
 function extractMethodParams(methodNode: TreeSitterNode): SubDeclaration[] {
+  // The v3 grammar emits flat `method_parameter` children under the method
+  // node; the parameter name is the last `identifier` inside each
+  // `method_parameter`. Mirrors `extract_method_params` in
+  // `crates/codegraph-core/src/extractors/objc.rs`.
   const params: SubDeclaration[] = [];
   for (let i = 0; i < methodNode.childCount; i++) {
     const child = methodNode.child(i);
-    if (!child || child.type !== 'keyword_selector') continue;
+    if (!child || child.type !== 'method_parameter') continue;
+    let nameNode: TreeSitterNode | null = null;
     for (let j = 0; j < child.childCount; j++) {
-      const kw = child.child(j);
-      if (kw && kw.type === 'keyword_declarator') {
-        const nameNode = kw.childForFieldName('name');
-        if (nameNode) {
-          params.push({
-            name: nameNode.text,
-            kind: 'parameter',
-            line: nameNode.startPosition.row + 1,
-          });
-        }
-      }
+      const inner = child.child(j);
+      if (inner && inner.type === 'identifier') nameNode = inner;
+    }
+    if (nameNode) {
+      params.push({
+        name: nameNode.text,
+        kind: 'parameter',
+        line: nameNode.startPosition.row + 1,
+      });
     }
   }
   return params;
@@ -420,12 +519,37 @@ function extractCParams(paramListNode: TreeSitterNode | null): SubDeclaration[]
     if (!param || param.type !== 'parameter_declaration') continue;
     const nameNode = param.childForFieldName('declarator');
     if (nameNode) {
-      const name =
-        nameNode.type === 'identifier'
-          ? nameNode.text
-          : (findChild(nameNode, 'identifier')?.text ?? nameNode.text);
+      const name = unwrapObjCDeclaratorName(nameNode);
       params.push({ name, kind: 'parameter', line: param.startPosition.row + 1 });
     }
   }
   return params;
 }
+
+const OBJC_DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'reference_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+  'function_declarator',
+]);
+
+/**
+ * Drill through pointer/array/reference/parenthesized/function declarator
+ * wrappers to recover the bare parameter identifier. Without this the WASM
+ * extractor emitted raw declarator text (e.g. `*argv[]` or `callback(int x)`)
+ * while native unwrapped to `argv` / `callback`, producing cross-engine
+ * `contains` divergence on C-style parameters such as
+ * `int main(int argc, const char *argv[])` and function-type parameters such
+ * as `void process(int callback(int))`.
+ */
+function unwrapObjCDeclaratorName(node: TreeSitterNode): string {
+  let current: TreeSitterNode | null = node;
+  while (current && OBJC_DECLARATOR_WRAPPERS.has(current.type)) {
+    current = current.childForFieldName('declarator');
+  }
+  if (current?.type === 'identifier' || current?.type === 'field_identifier') {
+    return current.text;
+  }
+  return current?.text ?? node.text;
+}