fix(resolver): scope Phase 8.3f typeMap key by callee to avoid same-name rest-param collision (#1368)

* feat(resolver): resolve property calls on object destructuring rest parameters (JS)

When a function parameter uses object destructuring with a rest element
(`...rest`) and the rest object's property is then called, codegraph now
resolves the callee.

Resolution chain (Phase 8.3f):
1. JS extractor seeds typeMap['obj.X'] = { type: 'X' } for shorthand
   properties in object literals (`var obj = { e4 }`).
2. New extractObjectRestParamBindingsWalk records objectRestParamBinding
   { callee, argIndex, restName } from `function f({ a, ...rest })`.
3. build-edges.ts cross-references with paramBindings from f(obj) calls
   to seed typeMap[restName] = { type: argName, confidence: 0.65 }.
4. resolveByMethodOrGlobal: typeMap[restName] → obj; typeMap[obj.method]
   → method → resolved edge.

Adds:
- ObjectRestParamBinding type + ExtractorOutput.objectRestParamBindings field
- objectRestParamBindings serialised through WASM worker boundary
- extractObjectRestParamBindingsWalk in javascript.ts
- Object literal shorthand property seeding in handleVarDeclaratorTypeMap
- Phase 8.3f typeMap seeding in buildCallEdgesJS
- 6 unit tests in tests/parsers/javascript.test.ts
- Integration test (WASM engine) in issue-1336-object-rest-param-resolution.test.ts
- Jelly micro-test fixture tests/benchmarks/resolution/fixtures/jelly-micro/rest/

Files issue #1348 (missing WASM worker serialisation for paramBindings/
returnTypeMap/callAssignments) and #1349 (native engine parity) as follow-ups.

Closes #1336

* fix(native): add object destructuring rest-parameter resolution (Phase 8.3f parity)

Add buildObjectRestParamPostPass to the native call-edge path, mirroring the
Phase 8.3f seeding already present in buildCallEdgesJS (WASM path).

The post-pass seeds typeMap[restName] = { type: argName } by cross-referencing
objectRestParamBindings (which formal param uses a rest binding) with
paramBindings (which call-site arg was passed). It then resolves calls whose
receiver is the rest-binding name via resolveCallTargets with the enriched
typeMap, adding any edges the native Rust engine missed.

For same-file and directly-imported callees, the native Rust engine already
resolves via its own same-file (step 2) and import-aware (step 1) lookups;
seenByPair prevents duplicate edges. The post-pass provides the typeMap-chain
fallback for the cross-file non-imported case where the chain
typeMap[restName] → argName → typeMap[argName.method] → target resolves
a callee the Rust engine cannot find.

Also updates the #1336 integration test to assert both WASM and native engines
produce the f3 → e4 edge.

Closes #1349

* feat(extractor): extend rest-param binding walk to class and object-literal methods (#1357)

docs check acknowledged

* fix(resolver): defensive-copy typeMap in buildCallEdgesJS Phase 8.3f block

Native buildObjectRestParamPostPass already clones symbols.typeMap before seeding
(line 755); the WASM path buildCallEdgesJS was taking a direct reference, causing
Phase 8.3f seeds to persist into symbols.typeMap across watch/incremental builds
and blocking correct re-seeding when call-site arguments changed.

Tracks rest-param scoping gap (two functions with same restName in one file) in
issue #1358.

* test(1336): add dynamic:0 assertion to native engine integration test

Native test for the rest-receiver edge (f3 → e4) was only checking that the
edge exists; it now also asserts dynamic===0, matching the WASM test. This
ensures a dynamic-dispatch fallback in the native engine is caught as a
regression.

* fix(resolver): scope Phase 8.3f typeMap key by callee — avoid rest-param name collision (#1358)

Two functions in the same file both using `...rest` as their rest-binding name
caused the first seeding to win via the `!typeMap.has(restName)` guard, so the
second function resolved via the wrong argument type.

Fix: key the typeMap entry as `callee::restName` (e.g. `f2::rest`) in both the
WASM seeding (buildCallEdgesJS) and the native post-pass (buildObjectRestParamPostPass).
resolveByMethodOrGlobal gains a third fallback that tries the scoped key via
callerName when the unscoped lookup misses. The native post-pass now passes
caller.callerName to resolveCallTargets so the scoped lookup has the context it needs.

Also moves restNames.add() outside the guard in the native post-pass so that all
rest-binding names — not just the first per name — are registered for the receiver
filter, enabling calls from both f1 and f2 to pass through to resolution.

Closes #1358

* fix(resolver): unscoped fallback for null-callerName; negative cross-edge assertions (#1358)

When only one callee uses a given rest name, also seed the unscoped key alongside
the scoped `callee::restName` key. This preserves resolution when callerName is null
(e.g. enclosing function node not in DB during incremental rebuild) — no collision
risk since there is only one callee using that rest name.

When two or more callees share a rest name, only scoped keys are seeded (the
ambiguous collision case — unscoped would point to the wrong type).

Also adds negative assertions to the #1358 test: verifies f1→m2 and f2→m1 are
absent, guarding against false cross-edges from the pre-fix collision.

Tracks incremental-path callerName gap in #1369.

Impact: 2 functions changed, 3 affected

* docs(test): correct resolution-path comment in issue-1336 test (#1368)

Step 5 previously described resolution via the scoped key 'f3::eerest', but
since f3 is the only callee using 'eerest', the single-callee shortcut also
seeds the unscoped key 'eerest', which resolveByMethodOrGlobal hits first.
The scoped key is a no-op in the single-callee case but is the active path
when two functions share the same rest-param name.

* fix: remove extra blank line in javascript.ts (biome format) (#1368)

* fix(wasm-worker): remove duplicate objectRestParamBindings spread (#1368)

Author: carlos-alm

src/domain/graph/builder/call-resolver.ts

@@ -72,7 +72,10 @@ export function resolveByMethodOrGlobal(
     const effectiveReceiver = call.receiver.startsWith('this.')
       ? call.receiver.slice('this.'.length)
       : call.receiver;
-    const typeEntry = typeMap.get(effectiveReceiver) ?? typeMap.get(call.receiver);
+    const typeEntry =
+      typeMap.get(effectiveReceiver) ??
+      typeMap.get(call.receiver) ??
+      (callerName ? typeMap.get(`${callerName}::${effectiveReceiver}`) : undefined);
     let typeName = typeEntry
       ? typeof typeEntry === 'string'
         ? typeEntry

src/domain/graph/builder/stages/build-edges.ts

@@ -756,16 +756,30 @@ function buildObjectRestParamPostPass(
       symbols.typeMap instanceof Map ? symbols.typeMap : [],
     );
 
-    // Seed typeMap[restName] = { type: argName } for each matching pair.
-    // Mirrors the seeding in buildCallEdgesJS Phase 8.3f.
+    // Seed typeMap[callee::restName] = { type: argName } for each matching pair.
+    // Mirrors the seeding in buildCallEdgesJS Phase 8.3f. Keys are scoped by
+    // callee so two functions with the same rest-param name (e.g. `...rest`) in
+    // the same file don't collide (#1358).
+    // When only one callee uses a given rest name, also seed the unscoped key
+    // as a null-callerName fallback so edges aren't silently dropped if
+    // findCaller can't identify the enclosing function (#1358).
+    const restNameCallees = new Map<string, Set<string>>();
+    for (const orpb of symbols.objectRestParamBindings!) {
+      if (!restNameCallees.has(orpb.restName)) restNameCallees.set(orpb.restName, new Set());
+      restNameCallees.get(orpb.restName)!.add(orpb.callee);
+    }
     const restNames = new Set<string>();
     for (const orpb of symbols.objectRestParamBindings!) {
       for (const pb of symbols.paramBindings!) {
         if (pb.callee === orpb.callee && pb.argIndex === orpb.argIndex) {
-          if (!typeMap.has(orpb.restName)) {
-            typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
-            restNames.add(orpb.restName);
+          const scopedKey = `${orpb.callee}::${orpb.restName}`;
+          if (!typeMap.has(scopedKey)) {
+            typeMap.set(scopedKey, { type: pb.argName, confidence: 0.65 });
+            if (restNameCallees.get(orpb.restName)!.size === 1 && !typeMap.has(orpb.restName)) {
+              typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
+            }
           }
+          restNames.add(orpb.restName);
         }
       }
     }
@@ -777,14 +791,16 @@ function buildObjectRestParamPostPass(
 
       const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
 
-      // Resolve with the enriched typeMap (typeMap[restName] = { type: argName } is seeded above).
+      // Resolve with the enriched typeMap. callerName is passed so
+      // resolveByMethodOrGlobal can look up the scoped key callee::restName (#1358).
       // seenByPair deduplicates edges the native engine already emitted.
       const { targets, importedFrom } = resolveCallTargets(
         lookup,
         call,
         relPath,
         importedNames,
         typeMap as Map<string, unknown>,
+        caller.callerName,
       );
       for (const t of targets) {
         const edgeKey = `${caller.id}|${t.id}`;
@@ -1019,16 +1035,26 @@ function buildCallEdgesJS(
       symbols.typeMap instanceof Map ? symbols.typeMap : [],
     );
 
-    // Phase 8.3f: seed typeMap[restName] = { type: argName } for each object-destructuring
-    // rest parameter binding cross-referenced with call-site argument bindings.
-    // e.g. function f({ a, ...rest }) called as f(obj) → typeMap['rest'] = { type: 'obj' }
-    // so that `rest.method()` resolves via typeMap['obj.method'].
+    // Phase 8.3f: seed typeMap[callee::restName] = { type: argName } for each
+    // object-destructuring rest parameter binding × call-site argument binding.
+    // Keys are scoped so two functions with the same rest-param name in the same
+    // file don't collide (#1358). When only one callee uses a given rest name,
+    // also seed the unscoped key as a null-callerName fallback.
     if (symbols.objectRestParamBindings?.length && symbols.paramBindings?.length) {
+      const restNameCallees = new Map<string, Set<string>>();
+      for (const orpb of symbols.objectRestParamBindings) {
+        if (!restNameCallees.has(orpb.restName)) restNameCallees.set(orpb.restName, new Set());
+        restNameCallees.get(orpb.restName)!.add(orpb.callee);
+      }
       for (const orpb of symbols.objectRestParamBindings) {
         for (const pb of symbols.paramBindings) {
           if (pb.callee === orpb.callee && pb.argIndex === orpb.argIndex) {
-            if (!typeMap.has(orpb.restName)) {
-              typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
+            const scopedKey = `${orpb.callee}::${orpb.restName}`;
+            if (!typeMap.has(scopedKey)) {
+              typeMap.set(scopedKey, { type: pb.argName, confidence: 0.65 });
+              if (restNameCallees.get(orpb.restName)!.size === 1 && !typeMap.has(orpb.restName)) {
+                typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
+              }
             }
           }
         }

tests/benchmarks/resolution/fixtures/jelly-micro/rest/expected-edges.json

@@ -7,7 +7,8 @@
       "source": { "name": "f3", "file": "rest.js" },
       "target": { "name": "e4", "file": "rest.js" },
       "kind": "calls",
-      "mode": "pts-obj-rest"
+      "mode": "pts-obj-rest",
+      "notes": "eerest.e4() where eerest is the rest binding of f3's first param; arg obj has e4 as a shorthand property"
     }
   ]
 }

tests/benchmarks/resolution/fixtures/jelly-micro/rest/rest.js

@@ -1,14 +1,26 @@
-// Jelly micro-test: rest — object destructuring rest parameter dispatch
+// Jelly micro-test: object destructuring rest parameters
+// Tests call resolution via eerest.method() where eerest is a rest binding
+// of an object destructuring parameter and the argument is a known object.
 
-function e1() {}
-function e2() {}
-function e3() {}
-function e4() {}
+function e1() {
+  console.log('31');
+}
+function e2() {
+  console.log('32');
+}
+function e3() {
+  console.log('33');
+}
+function e4() {
+  console.log('34');
+}
 
-const obj = { e1, e2, e3, e4 };
+var obj = { e1, e2, e3, e4 };
 
+// f3's first param destructures obj: eee1 = obj.e1, eerest = { e2, e3, e4 }.
+// eerest.e4() should resolve to e4.
 function f3({ e1: eee1, ...eerest }) {
-  eee1();
-  eerest.e4(); // eerest.e4 === obj.e4 === e4 when called as f3(obj)
+  eee1(); // direct call to destructured-alias — resolves to e1
+  eerest.e4(); // rest-receiver call — expected edge: f3 → e4
 }
 f3(obj);

tests/integration/issue-1336-object-rest-param-resolution.test.ts

@@ -13,8 +13,12 @@
  *   1. Extractor seeds typeMap['obj.e4'] = { type: 'e4' } from `var obj = { e4 }`.
  *   2. Extractor records objectRestParamBinding { callee: 'f3', argIndex: 0, restName: 'eerest' }.
  *   3. Extractor records paramBinding { callee: 'f3', argIndex: 0, argName: 'obj' } from f3(obj).
- *   4. Phase 8.3f seeds typeMap['eerest'] = { type: 'obj' }.
- *   5. resolveByMethodOrGlobal: typeMap['eerest'] → obj; typeMap['obj.e4'] → e4 → resolved.
+ *   4. Phase 8.3f seeds typeMap['f3::eerest'] = { type: 'obj' } (scoped by callee, #1358).
+ *      Because f3 is the only callee using 'eerest', the unscoped key typeMap['eerest'] is
+ *      also seeded as a null-callerName fallback (single-callee shortcut, #1358).
+ *   5. resolveByMethodOrGlobal: typeMap['eerest'] (unscoped, single-callee fallback) → obj;
+ *      typeMap['obj.e4'] → e4 → resolved. The scoped key 'f3::eerest' is a no-op here but
+ *      would be the active path if a second function also declared '...eerest'.
  *
  * WASM: resolved via Phase 8.3f typeMap chain in buildCallEdgesJS.
  * Native: resolved via same-file name lookup (step 2 in Rust resolve_call_targets);

tests/integration/issue-1358-rest-param-name-collision.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Integration test for #1358: two functions in the same file both use `...rest`
+ * as their rest-binding name. Without scoped typeMap keys the first seeding wins
+ * and the second function resolves via the wrong type.
+ *
+ * Pattern:
+ *   function f1({ a, ...rest }) { rest.m1(); }
+ *   function f2({ b, ...rest }) { rest.m2(); }
+ *   f1(obj1);  // obj1 has m1
+ *   f2(obj2);  // obj2 has m2
+ *
+ * Expected edges: f1 → m1, f2 → m2.
+ * Broken (pre-fix): both resolve through obj1, so f2 → m2 is missing.
+ *
+ * Fix (Phase 8.3f, #1358): typeMap keys are scoped to `callee::restName`
+ * (e.g. `f1::rest`, `f2::rest`) so each function's binding is independent.
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import Database from 'better-sqlite3';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { buildGraph } from '../../src/domain/graph/builder.js';
+
+const FIXTURE_CODE = `
+function m1() {}
+function m2() {}
+
+var obj1 = { m1 };
+var obj2 = { m2 };
+
+function f1({ a, ...rest }) {
+  rest.m1();
+}
+
+function f2({ b, ...rest }) {
+  rest.m2();
+}
+
+f1(obj1);
+f2(obj2);
+`;
+
+let tmpWasm: string;
+let tmpNative: string;
+
+beforeAll(async () => {
+  tmpWasm = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-1358-wasm-'));
+  fs.writeFileSync(path.join(tmpWasm, 'collision.js'), FIXTURE_CODE);
+  await buildGraph(tmpWasm, { engine: 'wasm', incremental: false, skipRegistry: true });
+
+  tmpNative = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-1358-native-'));
+  fs.writeFileSync(path.join(tmpNative, 'collision.js'), FIXTURE_CODE);
+  await buildGraph(tmpNative, { incremental: false, skipRegistry: true });
+});
+
+afterAll(() => {
+  fs.rmSync(tmpWasm, { recursive: true, force: true });
+  fs.rmSync(tmpNative, { recursive: true, force: true });
+});
+
+function readCallEdges(dbPath: string) {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    return db
+      .prepare(
+        `SELECT n1.name AS src, n2.name AS tgt
+         FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         JOIN nodes n2 ON e.target_id = n2.id
+         WHERE e.kind = 'calls'
+         ORDER BY n1.name, n2.name`,
+      )
+      .all() as Array<{ src: string; tgt: string }>;
+  } finally {
+    db.close();
+  }
+}
+
+describe('Issue #1358: same rest-param name in two functions — scoped typeMap key', () => {
+  it('WASM: f1 → m1 and f2 → m2 both resolve independently without cross-edges', () => {
+    const edges = readCallEdges(path.join(tmpWasm, '.codegraph', 'graph.db'));
+    expect(edges.find((e) => e.src === 'f1' && e.tgt === 'm1')).toBeDefined();
+    expect(edges.find((e) => e.src === 'f2' && e.tgt === 'm2')).toBeDefined();
+    expect(edges.find((e) => e.src === 'f1' && e.tgt === 'm2')).toBeUndefined();
+    expect(edges.find((e) => e.src === 'f2' && e.tgt === 'm1')).toBeUndefined();
+  });
+
+  it('Native: f1 → m1 and f2 → m2 both resolve independently without cross-edges', () => {
+    const edges = readCallEdges(path.join(tmpNative, '.codegraph', 'graph.db'));
+    expect(edges.find((e) => e.src === 'f1' && e.tgt === 'm1')).toBeDefined();
+    expect(edges.find((e) => e.src === 'f2' && e.tgt === 'm2')).toBeDefined();
+    expect(edges.find((e) => e.src === 'f1' && e.tgt === 'm2')).toBeUndefined();
+    expect(edges.find((e) => e.src === 'f2' && e.tgt === 'm1')).toBeUndefined();
+  });
+});