fix(extractors): align JS ObjC engine with native for v3 grammar (#1106)

The v3 tree-sitter-objc grammar emits flat 'identifier' + 'method_parameter'
children directly under method nodes (no 'keyword_selector' wrapper) and
nests property names under 'struct_declaration > struct_declarator >
[pointer_declarator >] identifier' rather than exposing a 'name' field. The
JS extractor was still following the old grammar shape, which silently
dropped multi-keyword method definitions, never populated parameter
children, and omitted all '@Property' members from class children.

- buildSelector: assemble selector from flat 'identifier'+'method_parameter'
  children directly under the method node, matching build_selector in
  crates/codegraph-core/src/extractors/objc.rs.
- extractMethodParams: iterate 'method_parameter' children directly and use
  the last 'identifier' child as the parameter name (mirrors
  extract_method_params in the Rust extractor).
- collectClassMembers: extract '@Property' names via a deep identifier walk
  under 'struct_declaration > struct_declarator' (mirrors
  extract_property_name in the Rust extractor).

Added three regression tests covering keyword method definitions with
parameters, and pointer + non-pointer '@Property' member names.

Author: carlos-alm

src/extractors/objc.ts

@@ -365,29 +365,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 {
@@ -440,32 +436,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;

tests/parsers/objc.test.ts

@@ -90,4 +90,44 @@ describe('Objective-C parser', () => {
       expect.objectContaining({ name: 'initWithName:age:', receiver: 'obj' }),
     );
   });
+
+  it('extracts keyword-selector method definitions with parameter names', () => {
+    // The v3 grammar emits flat `identifier`+`method_parameter` children under
+    // `method_definition` rather than wrapping them in `keyword_selector`. The
+    // JS extractor must mirror `build_selector` / `extract_method_params` in
+    // `crates/codegraph-core/src/extractors/objc.rs` so multi-keyword selectors
+    // like `setName:age:` appear in `definitions` with their parameter names
+    // populated. Otherwise these methods are silently dropped on the JS side.
+    const symbols = parseObjC(`@implementation Foo
+- (void)setName:(NSString *)name age:(int)age {
+}
+@end`);
+    const method = symbols.definitions.find((d) => d.name === 'Foo.setName:age:');
+    expect(method).toBeDefined();
+    expect(method?.kind).toBe('method');
+    expect(method?.children).toEqual([
+      expect.objectContaining({ name: 'name', kind: 'parameter' }),
+      expect.objectContaining({ name: 'age', kind: 'parameter' }),
+    ]);
+  });
+
+  it('extracts @property names nested under struct_declarator', () => {
+    // The v3 grammar does not expose `name` as a named field on
+    // `property_declaration`; the identifier nests under
+    // `struct_declaration > struct_declarator > [pointer_declarator >]
+    // identifier`. Mirror `extract_property_name` in the Rust extractor so
+    // pointer and non-pointer properties both surface as class children.
+    const symbols = parseObjC(`@interface Foo : NSObject
+@property (nonatomic, strong) NSString *name;
+@property (nonatomic) int age;
+@end`);
+    const foo = symbols.definitions.find((d) => d.name === 'Foo');
+    expect(foo).toBeDefined();
+    expect(foo?.children).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: 'name', kind: 'property' }),
+        expect.objectContaining({ name: 'age', kind: 'property' }),
+      ]),
+    );
+  });
 });