fix(extractor): narrow .call/.apply/.bind skip in extractCallbackReferenceCalls

For .call()/.apply(): the first argument is the this-context and is now
skipped; subsequent identifier arguments are emitted as genuine callbacks.
e.g. forEach.call(arr, handler) → emits handler, not arr.

For .bind(): all arguments are absorbed into the partially-applied function
and none are direct callbacks — return [] immediately.

Closes #1406

Author: carlos-alm

src/extractors/javascript.ts

@@ -2726,12 +2726,24 @@ function firstArgIsStringLiteral(argsNode: TreeSitterNode): boolean {
  * member-expr args are only emitted when the first argument is a string
  * literal route path — matching Express/router shape and skipping
  * `cache.get(user.id)`-style calls.
+ *
+ * `.call()`/`.apply()`: the first argument is the `this` context (not a
+ * callback). Subsequent identifier arguments are genuine callbacks of the
+ * enclosing scope — e.g. `Array.prototype.forEach.call(arr, handler)` emits
+ * `handler`. `.bind()` returns a new partially-applied function; all
+ * arguments are absorbed and none are direct callbacks.
  */
 function extractCallbackReferenceCalls(callNode: TreeSitterNode): Call[] {
   const args = callNode.childForFieldName('arguments') || findChild(callNode, 'arguments');
   if (!args) return [];
 
   const calleeName = extractCalleeName(callNode);
+
+  // .bind() absorbs all arguments into a partially-applied function — no direct callbacks.
+  if (calleeName === 'bind') return [];
+
+  const skipFirstArg = calleeName === 'call' || calleeName === 'apply';
+
   let memberExprArgsAllowed = calleeName !== null && CALLBACK_ACCEPTING_CALLEES.has(calleeName);
   if (memberExprArgsAllowed && calleeName !== null && HTTP_VERB_CALLEES.has(calleeName)) {
     // HTTP verbs require a string-literal route path to be treated as a
@@ -2742,10 +2754,18 @@ function extractCallbackReferenceCalls(callNode: TreeSitterNode): Call[] {
 
   const result: Call[] = [];
   const callLine = nodeStartLine(callNode);
+  let realArgIndex = 0;
 
   for (let i = 0; i < args.childCount; i++) {
     const child = args.child(i);
     if (!child) continue;
+    if (child.type === '(' || child.type === ')' || child.type === ',') continue;
+
+    if (skipFirstArg && realArgIndex === 0) {
+      realArgIndex++;
+      continue;
+    }
+    realArgIndex++;
 
     if (child.type === 'identifier') {
       result.push({ name: child.text, line: callLine, dynamic: true });

tests/benchmarks/resolution/fixtures/javascript/bind-call-apply.js

@@ -22,3 +22,13 @@ export function runCall() {
 export function runApply() {
   return greet.apply(user, ['Hey']);
 }
+
+// .call() with a callback identifier after the this-context
+function processItem(item) {
+  return item;
+}
+var items = [1, 2, 3];
+
+export function runCallWithCallback() {
+  items.forEach.call(items, processItem);
+}

tests/benchmarks/resolution/fixtures/javascript/expected-edges.json

@@ -192,6 +192,13 @@
       "mode": "dynamic",
       "notes": "greet.apply(user, ['Hey']) — .apply() extracts greet as the callee"
     },
+    {
+      "source": { "name": "runCallWithCallback", "file": "bind-call-apply.js" },
+      "target": { "name": "processItem", "file": "bind-call-apply.js" },
+      "kind": "calls",
+      "mode": "dynamic",
+      "notes": "forEach.call(items, processItem) — processItem is a genuine callback after the this-context; items is NOT emitted as a call"
+    },
     {
       "source": { "name": "Dog.speak", "file": "inheritance.js" },
       "target": { "name": "Animal.speak", "file": "inheritance.js" },

tests/benchmarks/resolution/resolution-benchmark.test.ts

@@ -121,7 +121,8 @@ const THRESHOLDS: Record<string, { precision: number; recall: number }> = {
   //   adds bind/call/apply resolution (3 new edges in bind-call-apply.js), total expected now 33.
   //   Phase 8.3f adds Object.defineProperty accessor this-dispatch (#1335): getter→baz in
   //   define-property.js and accessorGetter→accessorTarget.accessMethod in define-property-accessor.js,
-  //   total expected now 35.
+  //   total expected now 35. #1406 adds runCallWithCallback→processItem (forEach.call callback),
+  //   total expected now 36.
   javascript: { precision: 1.0, recall: 0.9 },
   // TS 0.72: Phase 8.3e adds this.method() same-class resolution (Shape.describe → Shape.area),
   //   lifting recall from 69.4% to 72.2%.  Remaining gap (interface-dispatch, CHA) is tracked

tests/parsers/javascript.test.ts

@@ -800,6 +800,35 @@ describe('JavaScript parser', () => {
       expect(def.line).toBe(2);
       expect(def.endLine).toBe(4);
     });
+
+    // .call/.apply/.bind narrowing (#1406)
+    it('emits identifier args after the this-context for .call()', () => {
+      const symbols = parseJS(`Array.prototype.forEach.call(collection, handler);`);
+      expect(symbols.calls).toContainEqual(
+        expect.objectContaining({ name: 'handler', dynamic: true }),
+      );
+      expect(symbols.calls).not.toContainEqual(expect.objectContaining({ name: 'collection' }));
+    });
+
+    it('emits identifier args after the this-context for .apply()', () => {
+      const symbols = parseJS(`fn.apply(ctx, handler);`);
+      expect(symbols.calls).toContainEqual(
+        expect.objectContaining({ name: 'handler', dynamic: true }),
+      );
+      expect(symbols.calls).not.toContainEqual(expect.objectContaining({ name: 'ctx' }));
+    });
+
+    it('emits nothing for .call() with only the this-context arg', () => {
+      const symbols = parseJS(`fn.call(ctx);`);
+      const callbackCalls = symbols.calls.filter((c) => c.name === 'ctx');
+      expect(callbackCalls).toHaveLength(0);
+    });
+
+    it('emits nothing for .bind() — all args are absorbed into the partial application', () => {
+      const symbols = parseJS(`Promise.resolve.bind(null, transform);`);
+      expect(symbols.calls).not.toContainEqual(expect.objectContaining({ name: 'transform' }));
+      expect(symbols.calls).not.toContainEqual(expect.objectContaining({ name: 'null' }));
+    });
   });
 
   describe('Phase 8.3f: object-destructuring rest parameter binding extraction', () => {