feat(resolver): Phase 8.3f — object destructuring rest parameter resolution (WASM + native) (#1355)

* 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(extractor): use slice(1, -1) instead of global regex in rest-param binding walk (#1355)

* fix(tests): restore integration tests and jelly-micro fixtures dropped in prior merge (#1355)

Re-add func-prop-this-dispatch.test.ts, prototype-method-resolution.test.ts,
and jelly-micro benchmark fixtures (this/, spread/, more1/) that were
accidentally excluded when resolving an earlier merge conflict with main.

These files were introduced in main via PR #1331 and provide integration-level
coverage for features #1334 and #1317. Their absence meant regressions in
this-dispatch and prototype method resolution would not be caught by CI.

* fix(extractor): guard against computed property keys in rest-param binding walk (#1355)

Author: carlos-alm

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

@@ -709,6 +709,98 @@ function buildFnRefBindingsPtsPostPass(
   }
 }
 
+/**
+ * Phase 8.3f post-pass for the native call-edge path.
+ *
+ * The native Rust engine builds call edges without knowledge of
+ * objectRestParamBindings, so `rest.method()` calls inside functions with
+ * object-destructuring rest parameters are not resolved via the typeMap chain.
+ * The Rust engine already resolves same-file and directly-imported callees
+ * (via steps 1–2 of its resolution logic), so this post-pass only adds edges
+ * that require the typeMap-chain path:
+ *   typeMap[restName] → argName → typeMap[argName.method] → target
+ *
+ * Mirrors the seeding in buildCallEdgesJS (Phase 8.3f) to ensure both engine
+ * paths produce identical results for receiver-typed rest-param calls.
+ */
+function buildObjectRestParamPostPass(
+  ctx: PipelineContext,
+  getNodeIdStmt: NodeIdStmt,
+  allEdgeRows: EdgeRowTuple[],
+  sharedLookup?: CallNodeLookup,
+): void {
+  const filesWithRestBindings = [...ctx.fileSymbols].filter(
+    ([, symbols]) =>
+      symbols.objectRestParamBindings &&
+      symbols.objectRestParamBindings.length > 0 &&
+      symbols.paramBindings &&
+      symbols.paramBindings.length > 0,
+  );
+  if (filesWithRestBindings.length === 0) return;
+
+  const seenByPair = new Set<string>();
+  for (const [srcId, tgtId] of allEdgeRows) {
+    seenByPair.add(`${srcId}|${tgtId}`);
+  }
+
+  const { barrelOnlyFiles, rootDir } = ctx;
+  const lookup = sharedLookup ?? makeContextLookup(ctx, getNodeIdStmt);
+
+  for (const [relPath, symbols] of filesWithRestBindings) {
+    if (barrelOnlyFiles.has(relPath)) continue;
+    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (!fileNodeRow) continue;
+
+    const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
+    const typeMap: Map<string, TypeMapEntry | string> = new Map(
+      symbols.typeMap instanceof Map ? symbols.typeMap : [],
+    );
+
+    // Seed typeMap[restName] = { type: argName } for each matching pair.
+    // Mirrors the seeding in buildCallEdgesJS Phase 8.3f.
+    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);
+          }
+        }
+      }
+    }
+    if (restNames.size === 0) continue;
+
+    for (const call of symbols.calls) {
+      // Only process calls whose receiver is a known rest-binding name.
+      if (!call.receiver || !restNames.has(call.receiver)) continue;
+
+      const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
+
+      // Resolve with the enriched typeMap (typeMap[restName] = { type: argName } is seeded above).
+      // seenByPair deduplicates edges the native engine already emitted.
+      const { targets, importedFrom } = resolveCallTargets(
+        lookup,
+        call,
+        relPath,
+        importedNames,
+        typeMap as Map<string, unknown>,
+      );
+      for (const t of targets) {
+        const edgeKey = `${caller.id}|${t.id}`;
+        if (t.id !== caller.id && !seenByPair.has(edgeKey)) {
+          const conf =
+            computeConfidence(relPath, t.file, importedFrom ?? null) - PROPAGATION_HOP_PENALTY;
+          if (conf > 0) {
+            seenByPair.add(edgeKey);
+            allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'points-to']);
+          }
+        }
+      }
+    }
+  }
+}
+
 /**
  * Object.defineProperty accessor post-pass for the native call-edge path.
  *
@@ -923,7 +1015,26 @@ function buildCallEdgesJS(
     if (!fileNodeRow) continue;
 
     const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
-    const typeMap: Map<string, TypeMapEntry | string> = symbols.typeMap || new Map();
+    const typeMap: Map<string, TypeMapEntry | string> = new Map(
+      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'].
+    if (symbols.objectRestParamBindings?.length && symbols.paramBindings?.length) {
+      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 seenCallEdges = new Set<string>();
     const ptsMap = buildPointsToMapForFile(symbols, importedNames);
 
@@ -1679,6 +1790,9 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       // (e.g. `const f = fn.bind(ctx)`), so calls to bind-created aliases are
       // not resolved to their original function on the native path.
       buildFnRefBindingsPtsPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
+      // Phase 8.3f post-pass: augment native call edges with object rest-param
+      // receiver resolution — typeMap[restName] → argName → typeMap[argName.method].
+      buildObjectRestParamPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
       // Object.defineProperty accessor post-pass: resolve this-dispatch inside
       // getter/setter functions registered via Object.defineProperty.
       buildDefinePropertyPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);

src/extractors/javascript.ts

@@ -2293,60 +2293,108 @@ function extractSpreadForOfWalk(
 }
 
 /**
- * Phase 8.3f: collect object-rest parameter bindings.
+ * Phase 8.3f: record object-destructuring rest-parameter bindings from function definitions.
  *
- * `function f({ a, ...rest }) {}` → `{ callee: "f", restName: "rest", argIndex: 0 }`
- *
- * Enables resolving `rest.prop()` when a known object is passed as that parameter.
+ * For each `function f({ a, ...rest })` (or arrow/function-expression equivalent),
+ * records { callee: 'f', restName: 'rest', argIndex: N }. Also covers class methods
+ * (`callee: 'ClassName.method'`) and object-literal methods (`callee: 'method'`).
+ * The edge builder uses these to seed typeMap[rest] = { type: argName } when f(obj)
+ * is called with an identifier, enabling `rest.method()` calls to resolve.
  */
 function extractObjectRestParamBindingsWalk(
   rootNode: TreeSitterNode,
   bindings: ObjectRestParamBinding[],
 ): void {
-  function walk(node: TreeSitterNode, depth: number): void {
+  function walk(node: TreeSitterNode, depth: number, currentClass: string | null): void {
     if (depth >= MAX_WALK_DEPTH) return;
     const t = node.type;
-    if (t === 'function_declaration' || t === 'function_expression' || t === 'arrow_function') {
-      // `function_declaration` has a `name` field; `arrow_function` and
-      // `function_expression` do not — get the name from the enclosing
-      // `variable_declarator` instead (e.g. `const f3 = ({ ...rest }) => {}`).
-      const nameNode =
-        node.childForFieldName('name') ??
-        (node.parent?.type === 'variable_declarator'
-          ? node.parent.childForFieldName('name')
-          : null);
-      const funcName = nameNode?.text;
-      if (funcName) {
-        const paramsNode =
-          node.childForFieldName('parameters') || findChild(node, 'formal_parameters');
-        if (paramsNode) {
-          let argIndex = 0;
-          for (let i = 0; i < paramsNode.childCount; i++) {
-            const param = paramsNode.child(i);
-            if (!param) continue;
-            const pt = param.type;
-            if (pt === ',' || pt === '(' || pt === ')') continue;
-            if (pt === 'object_pattern') {
-              for (let j = 0; j < param.childCount; j++) {
-                const child = param.child(j);
-                if (!child) continue;
-                if (child.type !== 'rest_pattern' && child.type !== 'rest_element') continue;
-                const restNameNode = child.child(1) ?? child.childForFieldName('name');
-                if (restNameNode?.type === 'identifier') {
-                  bindings.push({ callee: funcName, restName: restNameNode.text, argIndex });
-                }
+    let fnName: string | null = null;
+    let paramsNode: TreeSitterNode | null = null;
+
+    if (t === 'function_declaration' || t === 'generator_function_declaration') {
+      const nameN = node.childForFieldName('name');
+      if (nameN?.type === 'identifier') fnName = nameN.text;
+      paramsNode = node.childForFieldName('parameters') ?? findChild(node, 'formal_parameters');
+    } else if (t === 'variable_declarator') {
+      const nameN = node.childForFieldName('name');
+      const valueN = node.childForFieldName('value');
+      if (nameN?.type === 'identifier' && valueN) {
+        const vt = valueN.type;
+        if (
+          vt === 'arrow_function' ||
+          vt === 'function_expression' ||
+          vt === 'generator_function'
+        ) {
+          fnName = nameN.text;
+          paramsNode =
+            valueN.childForFieldName('parameters') ?? findChild(valueN, 'formal_parameters');
+        }
+      }
+    } else if (t === 'method_definition') {
+      // class method: `class Foo { bar({ a, ...rest }) {} }`
+      // object-literal shorthand method: `{ bar({ a, ...rest }) {} }`
+      const nameN = node.childForFieldName('name');
+      if (nameN) {
+        fnName = currentClass ? `${currentClass}.${nameN.text}` : nameN.text;
+        paramsNode = node.childForFieldName('parameters') ?? findChild(node, 'formal_parameters');
+      }
+    } else if (t === 'pair') {
+      // object-literal method: `{ bar: function({ a, ...rest }) {} }`
+      // Skip computed property keys (e.g. `{ [Symbol.iterator]: function({ ...rest }) {} }`)
+      // because `callee: '[Symbol.iterator]'` can never match a paramBinding callee.
+      const keyN = node.childForFieldName('key');
+      const valueN = node.childForFieldName('value');
+      if (keyN && valueN && keyN.type !== 'computed_property_name') {
+        const vt = valueN.type;
+        if (
+          vt === 'arrow_function' ||
+          vt === 'function_expression' ||
+          vt === 'generator_function'
+        ) {
+          fnName = keyN.type === 'string' ? keyN.text.slice(1, -1) : keyN.text;
+          paramsNode =
+            valueN.childForFieldName('parameters') ?? findChild(valueN, 'formal_parameters');
+        }
+      }
+    }
+
+    if (fnName && paramsNode) {
+      let paramIdx = 0;
+      for (let i = 0; i < paramsNode.childCount; i++) {
+        const child = paramsNode.child(i);
+        if (!child) continue;
+        const ct = child.type;
+        if (ct === ',' || ct === '(' || ct === ')') continue;
+        if (ct === 'object_pattern') {
+          for (let j = 0; j < child.childCount; j++) {
+            const inner = child.child(j);
+            if (!inner) continue;
+            if (inner.type === 'rest_pattern' || inner.type === 'rest_element') {
+              // rest_pattern node: `...identifier` — the identifier is at child index 1
+              const restId = inner.child(1) ?? inner.childForFieldName('name');
+              if (restId?.type === 'identifier') {
+                bindings.push({ callee: fnName, restName: restId.text, argIndex: paramIdx });
               }
             }
-            argIndex++;
           }
         }
+        paramIdx++;
       }
     }
+
+    // Thread class name into class_body children; reset for all other contexts.
+    let childClass: string | null = null;
+    if (t === 'class_declaration' || t === 'class') {
+      childClass = node.childForFieldName('name')?.text ?? null;
+    } else if (t === 'class_body') {
+      childClass = currentClass;
+    }
+
     for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i)!, depth + 1);
+      walk(node.child(i)!, depth + 1, childClass);
     }
   }
-  walk(rootNode, 0);
+  walk(rootNode, 0, null);
 }
 
 /**

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

@@ -0,0 +1,95 @@
+/**
+ * Integration test for #1336 + #1349: resolve property calls on object
+ * destructuring rest parameters — both WASM and native engines.
+ *
+ * When a function parameter uses object destructuring with a rest element (`...rest`),
+ * and the rest object's property is then called, codegraph should resolve the callee.
+ *
+ * Pattern:
+ *   function f3({ e1: eee1, ...eerest }) { eerest.e4(); }
+ *   f3(obj);
+ *
+ * Resolution chain (Phase 8.3f):
+ *   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.
+ *
+ * WASM: resolved via Phase 8.3f typeMap chain in buildCallEdgesJS.
+ * Native: resolved via same-file name lookup (step 2 in Rust resolve_call_targets);
+ *         the Phase 8.3f post-pass (buildObjectRestParamPostPass) provides the typeMap-chain
+ *         fallback for cross-file cases not directly imported.
+ */
+
+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 e1() { console.log('31'); }
+function e4() { console.log('34'); }
+
+var obj = { e1, e4 };
+
+function f3({ e1: eee1, ...eerest }) {
+  eee1(); // call through named destructuring alias
+  eerest.e4(); // call through rest binding — expected edge: f3 → e4
+}
+f3(obj);
+`;
+
+let tmpWasm: string;
+let tmpNative: string;
+
+beforeAll(async () => {
+  tmpWasm = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-1336-wasm-'));
+  fs.writeFileSync(path.join(tmpWasm, 'rest.js'), FIXTURE_CODE);
+  await buildGraph(tmpWasm, { engine: 'wasm', incremental: false, skipRegistry: true });
+
+  tmpNative = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-1336-native-'));
+  fs.writeFileSync(path.join(tmpNative, 'rest.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, e.kind, e.dynamic
+         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; kind: string; dynamic: number }>;
+  } finally {
+    db.close();
+  }
+}
+
+describe('Issue #1336 + #1349: object destructuring rest parameter call resolution', () => {
+  it('WASM: emits a calls edge from f3 to e4 via eerest.e4() rest-receiver resolution', () => {
+    const edges = readCallEdges(path.join(tmpWasm, '.codegraph', 'graph.db'));
+    const edge = edges.find((e) => e.src === 'f3' && e.tgt === 'e4');
+    expect(edge).toBeDefined();
+    expect(edge!.dynamic).toBe(0);
+  });
+
+  it('Native: emits a calls edge from f3 to e4 via eerest.e4() rest-receiver resolution', () => {
+    const edges = readCallEdges(path.join(tmpNative, '.codegraph', 'graph.db'));
+    const edge = edges.find((e) => e.src === 'f3' && e.tgt === 'e4');
+    expect(edge).toBeDefined();
+    expect(edge!.dynamic).toBe(0);
+  });
+});