fix: restore reflection dynamicKind for .call/.apply/.bind (docs check acknowledged)

Issue #1778: /parity found WASM emits dyn=0 (plain static call) while native
emits dyn=1/dynamicKind='reflection' for identifier.call(...)/.apply(...)/
.bind(...) call sites, even though both fully resolve the target (confidence
1). Root cause: PR #1693 (closing #1687) made the WASM extractor
unconditionally drop dynamic/dynamicKind for these calls on identifier
receivers, to fix a narrow dedup-collision bug in build-edges.ts's
dynZeroEdgeRows upgrade path. That fix overcorrected — it silenced the
`reflection` DynamicKind for every identifier-based .call/.apply/.bind, not
just the collision case, diverging from native (which never changed).

Chose Option A (revert + fix narrowly), not Option B (mirror WASM's drop in
Rust): ADR-002 defines `reflection` as informational metadata independent of
resolution/confidence, queryable via `codegraph roles --dynamic` — dropping it
for .call/.apply/.bind would erase real information about a genuinely
reflective invocation mechanism, and native's classification was never wrong.

Changes:
- src/extractors/javascript.ts: extractMemberExprCallInfo once again tags
  .call/.apply/.bind on identifier receivers as dynamic:true,
  dynamicKind:'reflection', matching the member-expression branch and native.
- src/domain/graph/builder/stages/build-edges.ts: emitDirectCallEdgesForCall's
  dyn=0 -> dyn=1 upgrade (dynZeroEdgeRows) now compares source lines instead
  of firing on any dynamicKind-tagged collision. It only upgrades when the
  incoming call's line is EARLIER than the recorded dyn=0 call's line — which
  only happens when the query path's two-phase collection (query matches,
  then a supplementary walk pass for bare decorators, #1683) reorders a
  genuinely-earlier call to arrive later. A later .call/.apply/.bind to an
  already-called target is collected in the same phase as the direct call
  (true source order already holds), so it must not flip an established dyn=0
  edge — matching native's plain first-recorded-wins dedup.
- crates/codegraph-core/src/extractors/javascript.rs: no behavior change
  (native was already correct); added 4 unit tests pinning the
  identifier/member-expression reflection tagging so this doesn't regress.
- tests/parsers/javascript.test.ts, tests/engines/dynamic-call-ffi.test.ts:
  updated to assert the restored dynamic/reflection tagging at the parser
  level.
- tests/integration/issue-1778-reflection-dynamic-kind-parity.test.ts: new
  engine-parity tests (wasm + native) covering the #1778 minimal repro (no
  prior direct call -> dyn=1), the original #1687 dedup scenario (direct call
  then .call() -> single dyn=0 edge), the reverse-order case, and a #1683
  regression guard (bare decorator before call-expression decorator still
  upgrades to dyn=1).

Verified: `node scripts/parity-compare.mjs` shows zero edge diffs across all
42 fixtures (previously 6/8/12 diffs on dynamic-javascript/javascript/
jelly-micro). Resolution-benchmark precision/recall unchanged for every
language. Full npm test suite green (3589 passed). cargo test green (479
passed, +4 new).

Fixes #1778

Impact: 6 functions changed, 13 affected

Author: carlos-alm

crates/codegraph-core/src/extractors/javascript.rs

@@ -4246,6 +4246,50 @@ mod tests {
         assert!(dynamic_calls.is_empty());
     }
 
+    // ── #1778: .call/.apply/.bind reflection tagging (parity pin) ───────────
+    //
+    // Pins the native extractor's classification of `.call/.apply/.bind` on both
+    // identifier and member-expression receivers as dynamic/reflection. This is
+    // the Option-A semantic from #1778: the WASM extractor previously stripped
+    // this tag for identifier receivers only, diverging from native. These tests
+    // guard against either engine's classification drifting again — the
+    // dedup-collision case that originally motivated the WASM regression (#1687)
+    // is a downstream build-edges.ts concern, not an extraction concern, so it is
+    // deliberately NOT re-tested here (see the JS-side pins in
+    // tests/integration for that).
+
+    #[test]
+    fn call_on_identifier_receiver_tags_reflection() {
+        let s = parse_js("function test(ctx) { greet.call(ctx, 'world'); }");
+        let c = s.calls.iter().find(|c| c.name == "greet").unwrap();
+        assert_eq!(c.dynamic, Some(true));
+        assert_eq!(c.dynamic_kind.as_deref(), Some("reflection"));
+    }
+
+    #[test]
+    fn apply_on_identifier_receiver_tags_reflection() {
+        let s = parse_js("function test(ctx) { greet.apply(ctx, ['world']); }");
+        let c = s.calls.iter().find(|c| c.name == "greet").unwrap();
+        assert_eq!(c.dynamic, Some(true));
+        assert_eq!(c.dynamic_kind.as_deref(), Some("reflection"));
+    }
+
+    #[test]
+    fn bind_on_identifier_receiver_tags_reflection() {
+        let s = parse_js("var bound = greet.bind(ctx);");
+        let c = s.calls.iter().find(|c| c.name == "greet").unwrap();
+        assert_eq!(c.dynamic, Some(true));
+        assert_eq!(c.dynamic_kind.as_deref(), Some("reflection"));
+    }
+
+    #[test]
+    fn call_on_member_expression_receiver_tags_reflection() {
+        let s = parse_js("obj.method.call({});");
+        let c = s.calls.iter().find(|c| c.name == "method").unwrap();
+        assert_eq!(c.dynamic, Some(true));
+        assert_eq!(c.dynamic_kind.as_deref(), Some("reflection"));
+    }
+
     // ── #1771: object-literal value-ref extraction ──────────────────────────
 
     #[test]

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

@@ -66,6 +66,18 @@ import { getResolved, isBarrelFile, resolveBarrelExportCached } from './resolve-
 type EdgeRowTuple = [number, number, string, number, number, string | null, string | null];
 //                   src    tgt    kind   conf   dyn   technique             dynamic_kind
 
+/**
+ * Tracks a dyn=0 direct-call edge row so a later dynamicKind-tagged call to the
+ * same (caller, target) pair can decide whether to upgrade it in-place — see
+ * {@link emitDirectCallEdgesForCall}. `line` is the source line of the call that
+ * produced the row, used to detect out-of-source-order collection artifacts
+ * (bare decorators processed after call-expression matches in the query path).
+ */
+interface DynZeroEdgeEntry {
+  idx: number;
+  line: number;
+}
+
 interface NodeIdStmt {
   get(name: string, kind: string, file: string, line: number): { id: number } | undefined;
 }
@@ -1395,8 +1407,12 @@ function resolveFallbackTargets(
  *   - If a pts edge already exists for this pair, upgrades it in-place to
  *     direct-call confidence and promotes to seenCallEdges.
  *   - If a dyn=0 edge already exists and the incoming call has an explicit
- *     dynamicKind (e.g. 'reflection' for bare decorators), upgrades the
- *     existing row to dyn=1 in-place so the semantic classification wins.
+ *     dynamicKind AND textually precedes the recorded dyn=0 call (e.g. a bare
+ *     decorator `@Log` reordered after `@Log()` by the query path's
+ *     query-then-walk collection — see buildFileCallEdges), upgrades the
+ *     existing row to dyn=1 in-place so the earlier-in-source classification
+ *     wins, matching what native's single-pass source-order walk produces
+ *     natively.
  *   - Otherwise records a new `calls` edge with `ts-native` technique.
  */
 function emitDirectCallEdgesForCall(
@@ -1405,11 +1421,12 @@ function emitDirectCallEdgesForCall(
   importedFrom: string | null | undefined,
   isDynamic: number,
   hasDynamicKind: boolean,
+  callLine: number,
   relPath: string,
   seenCallEdges: Set<string>,
   ptsEdgeRows: Map<string, number>,
   allEdgeRows: EdgeRowTuple[],
-  dynZeroEdgeRows?: Map<string, number>,
+  dynZeroEdgeRows?: Map<string, DynZeroEdgeEntry>,
 ): void {
   // Sort targets by confidence descending before emitting edges.
   // For multi-target calls with duplicate (source_id, target_id) pairs the
@@ -1432,14 +1449,30 @@ function emitDirectCallEdgesForCall(
     if (seenCallEdges.has(edgeKey)) {
       // Edge already emitted. If the incoming call carries an explicit semantic
       // dynamic classification (dynamicKind set — e.g. 'reflection' for bare
-      // decorators) and the existing edge was recorded with dyn=0, upgrade it
-      // in-place so the more specific classification wins.
-      // Generic dynamic=true without dynamicKind (alias/callback calls) does
-      // NOT override dyn=0 to avoid false positives on f.call/f.bind patterns.
+      // decorators or .call/.apply/.bind) and the existing edge was recorded
+      // with dyn=0, only upgrade it in-place when the incoming call's source
+      // line is EARLIER than the recorded dyn=0 call's line.
+      //
+      // Why line order, not just "hasDynamicKind": the query path collects
+      // calls in two phases — tree-sitter query matches (callfn_node/callmem_node,
+      // true source order) first, then a supplementary walk pass for constructs
+      // the query grammar can't capture (bare decorators, object-literal
+      // value-refs) appended AFTERWARD regardless of true position (#1683).
+      // A bare `@Log` at an earlier line can therefore reach this branch AFTER
+      // `@Log()` at a later line already recorded dyn=0 — upgrading is correct
+      // there because native's single-pass source-order walk would have seen
+      // `@Log` first and kept dyn=1.
+      //
+      // But `.call/.apply/.bind` calls (e.g. `f(); f.call({})`, #1687/#1778) are
+      // ordinary call_expressions collected in the SAME query phase as the
+      // direct call, so true source order is already preserved: when the
+      // dynamic-flavored call's line is LATER than the recorded dyn=0 call, it
+      // is genuinely a second, later reference to the same target — native's
+      // dedup (first-recorded-wins, no upgrade) drops it, so WASM must too.
       if (isDynamic === 1 && hasDynamicKind && dynZeroEdgeRows) {
-        const dynZeroIdx = dynZeroEdgeRows.get(edgeKey);
-        if (dynZeroIdx !== undefined) {
-          const row = allEdgeRows[dynZeroIdx];
+        const dynZeroEntry = dynZeroEdgeRows.get(edgeKey);
+        if (dynZeroEntry !== undefined && callLine < dynZeroEntry.line) {
+          const row = allEdgeRows[dynZeroEntry.idx];
           if (row) row[4] = 1;
           dynZeroEdgeRows.delete(edgeKey);
         }
@@ -1463,10 +1496,12 @@ function emitDirectCallEdgesForCall(
       seenCallEdges.add(edgeKey);
       const newIdx = allEdgeRows.length;
       allEdgeRows.push([caller.id, t.id, 'calls', confidence, isDynamic, 'ts-native', null]);
-      // Track dyn=0 edges so a later dyn=1+dynamicKind call for the same pair
-      // can upgrade them (e.g. bare decorator after call-expression decorator).
+      // Track dyn=0 edges (with their source line) so a later dyn=1+dynamicKind
+      // call for the same pair can decide whether to upgrade them — see the
+      // line-order comparison above (e.g. bare decorator reordered ahead of a
+      // call-expression decorator by the query path, #1683).
       if (isDynamic === 0 && dynZeroEdgeRows) {
-        dynZeroEdgeRows.set(edgeKey, newIdx);
+        dynZeroEdgeRows.set(edgeKey, { idx: newIdx, line: callLine });
       }
     }
   }
@@ -1736,11 +1771,13 @@ function buildFileCallEdges(
   // no longer tracked here.
   const ptsEdgeRows = new Map<string, number>();
 
-  // Tracks direct-call edges emitted with dyn=0 (edgeKey → allEdgeRows index).
-  // When a later call to the same target has dyn=1 (e.g. a bare decorator `@Log`
-  // processed after the call-expression `@Log()` in the query path), the existing
-  // dyn=0 row is upgraded in-place so the more specific dynamic classification wins.
-  const dynZeroEdgeRows = new Map<string, number>();
+  // Tracks direct-call edges emitted with dyn=0 (edgeKey → { row index, source line }).
+  // When a later call to the same target has dyn=1 and textually precedes the recorded
+  // call (e.g. a bare decorator `@Log` reordered after the call-expression `@Log()` by
+  // the query path, #1683), the existing dyn=0 row is upgraded in-place. See the line-order
+  // comparison in emitDirectCallEdgesForCall for why line order (not mere dynamicKind
+  // presence) gates the upgrade — this is also what keeps #1687/#1778 from regressing.
+  const dynZeroEdgeRows = new Map<string, DynZeroEdgeEntry>();
 
   // Pre-compute the set of names that appear as lhs in fnRefBindings so that
   // case (c) of the pts gate below only fires for names that are genuine
@@ -1773,6 +1810,7 @@ function buildFileCallEdges(
       importedFrom,
       isDynamic,
       !!call.dynamicKind,
+      call.line,
       relPath,
       seenCallEdges,
       ptsEdgeRows,

src/extractors/javascript.ts

@@ -353,9 +353,11 @@ function dispatchQueryMatch(
     if (callfnInfo) calls.push(callfnInfo);
     calls.push(...extractCallbackReferenceCalls(c.callfn_node));
   } else if (c.callmem_node) {
-    // extractCallInfo → extractMemberExprCallInfo applies the plain-identifier guard for
-    // .call/.apply/.bind: when the object is a bare identifier (e.g. `fn.call(ctx)`),
-    // the call is emitted as static (no dynamic flag), matching the walk path and native engine.
+    // extractCallInfo → extractMemberExprCallInfo tags .call/.apply/.bind (e.g. `fn.call(ctx)`)
+    // as dynamic/reflection regardless of receiver shape, matching the walk path and native
+    // engine (#1778). The #1687 dedup-collision case — the same target already reached by a
+    // direct call from the same caller in the same scope — is resolved downstream in
+    // build-edges.ts's emitDirectCallEdgesForCall, not here.
     const callInfo = extractCallInfo(c.callmem_fn!, c.callmem_node);
     if (callInfo) calls.push(callInfo);
     const cbDef = extractCallbackDefinition(c.callmem_node, c.callmem_fn);
@@ -3357,16 +3359,18 @@ function extractMemberExprCallInfo(fn: TreeSitterNode, callNode: TreeSitterNode)
     };
   }
 
-  // .call()/.apply()/.bind() — this-rebinding; the wrapped function is the real callee.
-  // When the object is a plain identifier (e.g. `f.call({})`), the target is statically
-  // known so we emit a static call (no dynamic flag).  This keeps parity with the native
-  // Rust engine, which also resolves these as dyn=0, and prevents the dynZeroEdgeRows
-  // upgrade path in emitDirectCallEdgesForCall from wrongly converting a dyn=0 edge
-  // (emitted by a prior direct `f()` call) to dyn=1.
-  // When the object is a member_expression (e.g. `obj.method.call({})`), we still mark
-  // it dynamic/reflection because the inner callee requires a second resolution hop.
+  // .call()/.apply()/.bind() — this-rebinding; the wrapped function is the real callee, but
+  // invoking it through .call/.apply/.bind is a genuinely reflective mechanism (a distinct
+  // invocation path from a plain `f()` call), so both identifier and member-expression
+  // receivers are tagged dynamic/reflection — matching the native Rust engine and preserving
+  // the informational value of the `reflection` DynamicKind (queryable via
+  // `codegraph roles --dynamic`; see ADR-002). This does NOT reintroduce #1687: that bug was
+  // a dedup-collision in build-edges.ts (a direct `f()` edge getting wrongly flipped to dyn=1
+  // by a later `f.call()` to the same target in the same scope), fixed narrowly at the
+  // edge-emission layer in emitDirectCallEdgesForCall rather than by suppressing the tag here.
   if (propText === 'call' || propText === 'apply' || propText === 'bind') {
-    if (obj && obj.type === 'identifier') return { name: obj.text, line: callLine };
+    if (obj && obj.type === 'identifier')
+      return { name: obj.text, line: callLine, dynamic: true, dynamicKind: 'reflection' };
     if (obj && obj.type === 'member_expression') {
       const innerProp = obj.childForFieldName('property');
       if (innerProp)

tests/engines/dynamic-call-ffi.test.ts

@@ -65,28 +65,31 @@ describe('dynamic call classification — dynamicKind and keyExpr fields', () =>
     expect(c?.dynamic).toBe(true);
   });
 
-  it('resolves fn.call(ctx) as a static call — no dynamic flag (#1687)', () => {
-    // `greet.call(ctx, 'world')` — plain-identifier receiver; target is statically known.
-    // We emit a static call (no dynamic, no dynamicKind) to match native Rust parity and
-    // prevent the dynZeroEdgeRows upgrade from promoting a prior dyn=0 edge to dyn=1.
+  it('tags fn.call(ctx) as reflection kind (#1778)', () => {
+    // `greet.call(ctx, 'world')` — plain-identifier receiver. The wrapped function
+    // is the real callee, but invoking it via .call is a genuinely reflective
+    // mechanism, so it's tagged dynamic/reflection — matching native Rust parity.
+    // (Option A of #1778: the dedup-collision bug this used to work around
+    // — #1687 — is now fixed narrowly at the build-edges.ts edge-emission layer
+    // instead of by suppressing this tag for every identifier receiver.)
     const out = parseJS(`
       function test(ctx) { greet.call(ctx, 'world'); }
     `);
     const c = out.calls.find((c) => c.name === 'greet');
     expect(c).toBeDefined();
-    expect(c?.dynamic).toBeFalsy();
-    expect(c?.dynamicKind).toBeUndefined();
+    expect(c?.dynamicKind).toBe('reflection');
+    expect(c?.dynamic).toBe(true);
   });
 
-  it('resolves fn.apply(ctx, args) as a static call — no dynamic flag (#1687)', () => {
-    // Same as .call(): plain-identifier receiver → static call.
+  it('tags fn.apply(ctx, args) as reflection kind (#1778)', () => {
+    // Same as .call(): plain-identifier receiver → dynamic/reflection.
     const out = parseJS(`
       function test(ctx) { greet.apply(ctx, ['world']); }
     `);
     const c = out.calls.find((c) => c.name === 'greet');
     expect(c).toBeDefined();
-    expect(c?.dynamic).toBeFalsy();
-    expect(c?.dynamicKind).toBeUndefined();
+    expect(c?.dynamicKind).toBe('reflection');
+    expect(c?.dynamic).toBe(true);
   });
 
   it('tags obj[a + b]() as unresolved-dynamic kind', () => {