fix(objc): resolve dot-syntax property access and @selector() calls (#1475)

[guyoron1]

Summary

• Add field_expression handler in walk_calls so dot-syntax property access (self.name, self.product.name) produces calls edges — previously invisible because the grammar emits field_identifier, not a message send
• Add selector_expression handler so @selector(method) compile-time references produce calls edges — previously unhandled node type
• Both use the same suffix-match resolution strategy as the existing message_expression handler

Closes the remaining two sub-bugs from #1475 (Bug 5: dot-syntax, Bug 6: @selector).

Test plan

• test_objc_dot_syntax_property_calls_edge — verifies self.name resolves to a calls edge
• test_objc_selector_expression_calls_edge — verifies @selector(fetch) resolves to a calls edge
• All 17 ObjC tests pass
• Full test suite: 269 passed, 13 skipped, 0 failures

[safishamsi]

Thanks for tackling the two deferred ObjC follow-ups. A few changes needed before this can land.

1. Drop the #1308 commit from this PR. It re-includes the workspace exports-map work, but that already shipped on v8 (e8dabad, from your #1541) — and the merged version has two things this copy is missing: a package-dir containment guard (so an exports target like "./x": "../../../etc/..." can't resolve outside the package) and default consulted last in the condition order. The duplicate is also what's causing all the merge conflicts here. Please rebase on current v8 and reduce this PR to the ObjC changes only.

2. The dot-syntax / @selector resolution needs a scoping guard — this is the blocker. These two were deferred specifically because resolving an untyped name globally floods false edges. Right now the resolution suffix-matches the property/selector name against every method id, with no receiver-type restriction and no single-definition check. On a fixture with two classes that each declare a property named name, one self.product.name access fans out to both -name methods (plus the product class node) — four edges from one access. @selector(doThing) with two doThing methods resolves to both. That's the god-node inflation (#543/#1219) the deferral was meant to avoid.

Please resolve only to an unambiguous, in-scope definition:

• for self.<prop>, restrict to the current class's own declared properties / the known receiver type;
• for @selector(...), emit only when exactly one method matches;
• skip emission entirely when 0 or >1 candidates match (and don't match property names against class node ids).

3. Use accesses for dot-syntax, not calls. The issue scopes self.product.name to a property-access edge; the PR currently emits calls.

4. Add a fan-out regression test. The current tests are happy-path (one uniquely-named method, any(... in ...) assertions) and wouldn't catch the flooding above. Please add a two-same-named-property fixture asserting the exact edge count (no fan-out), plus an unresolvable-property case asserting zero edges, and the same for a two-same-named @selector.

For reference, the alloc/init reference edges that just landed (#1475 on v8) use the unique-stub guard (ensure_named_node + _rewire_unique_stub_nodes, which only resolves when exactly one class of that name exists) — the same "resolve only when unambiguous" idea applies here. The new walk_calls branches otherwise coexist fine with that change, so once the guard and the rebase are in, this should be a clean ObjC-only PR. Thanks again.

[guyoron1]

Hey !!!
Thank you so much the detailed review!
All four points are now addressed:

1. Dropped TypeScript workspace imports do not resolve package subpath exports #1308 commit — rebased on current v8. The PR is now a single ObjC-only commit.

2. Scoping guard added — the blocker is fixed:

   • self.<prop> (field_expression): resolution is restricted to sibling methods within the same class (via a class_method_nids index built from the method_bodies container). Emits only when exactly 1 sibling matches; skips on 0 or >1.
   • @selector(...) (selector_expression): emits only when exactly 1 method matches across the entire file; skips on 0 or >1.
   • Neither handler matches property names against class node IDs.

3. accesses for dot-syntax — field_expression edges use relation: "accesses" (not calls). @selector keeps calls with context: "call".

4. Fan-out regression tests added — five new tests:

   • test_objc_dot_syntax_property_accesses_edge — happy path, exactly 1 accesses edge
   • test_objc_dot_syntax_no_fanout_two_same_named_properties — two classes with -name, asserts exactly 2 scoped accesses (one per class), no cross-class fan-out
   • test_objc_dot_syntax_unresolvable_property_zero_edges — self.missing → 0 edges
   • test_objc_selector_expression_calls_edge — unique @selector(fetch) → 1 calls edge
   • test_objc_selector_no_fanout_two_same_named_methods — @selector(doThing) with 2 classes having -doThing → 0 edges

All tests pass.

[safishamsi]

Merged into v8 (0792b41) with your authorship — thanks for the rework. The scoping (sibling-only for dot-syntax, unique-match for @selector) and the move to accesses are exactly right.

One change I made on top: the resolver matched the method node id by endswith (suffix substring), which had two bugs your fixtures didn't cover — self.name would falsely resolve to a sibling -surname (...surname ends with name), and a substring-colliding sibling would suppress the correct edge. Since a method id is _make_id(container, name), I switched both branches to exact-id matching and added substring-collision regression tests (-name/-surname, -doThing/-reallyDoThing). Verified end-to-end. Ships next release.