fix: correct self-contradictory value-ref filter docs (docs check acknowledged)

The filter is keyed on dynamicKind, not on which extraction site fired,
so adding class for instanceof also extends the #1771 object-literal and
#1776 Lua sites to accept class-kind targets. The prior wording claimed
those two sites stayed function/method-only, which the code contradicts.

Impact: 1 functions changed, 3 affected

Author: carlos-alm

crates/codegraph-core/src/domain/graph/builder/stages/build_edges.rs

@@ -791,13 +791,14 @@ fn process_file<'a>(
         // of these positions is as likely to be a plain data reference
         // (`{ name: SOME_CONSTANT }`) as a real function/class, so drop any
         // other-kind match rather than fabricating a "calls" edge to a
-        // constant. `class` is included alongside function/method because
-        // `instanceof`'s right operand is always a class/constructor
-        // (#1784) — unlike the original #1771 object-literal case, which is
-        // function/method only. Applied once here (after all
-        // resolve_call_targets tiers), mirroring the
-        // `dynamicKind === 'value-ref'` filter in resolveFallbackTargets
-        // (stages/build-edges.ts).
+        // constant. `class` was added because `instanceof`'s right operand
+        // is always a class/constructor (#1784). The filter is keyed on
+        // `dynamic_kind`, not on which site produced the call, so the #1771
+        // object-literal and #1776 Lua sites also gain class-kind
+        // resolution as a side effect — not because either idiom commonly
+        // names a class. Applied once here (after all resolve_call_targets
+        // tiers), mirroring the `dynamicKind === 'value-ref'` filter in
+        // resolveFallbackTargets (stages/build-edges.ts).
         if call.dynamic_kind.as_deref() == Some("value-ref") {
             targets.retain(|t| t.kind == "function" || t.kind == "method" || t.kind == "class");
         }

docs/architecture/decisions/002-dynamic-call-resolution.md

@@ -83,8 +83,10 @@ export type DynamicKind =
                           // global/builtin identifier (e.g. `require = tracedRequire`,
                           // #1776), or the right operand of an `instanceof` check
                           // (e.g. `err instanceof CodegraphError`, #1784) —
-                          // resolvable against function/method-kind targets, plus
-                          // class-kind for the instanceof site
+                          // resolvable against function/method/class-kind targets;
+                          // class was added for instanceof, but the filter is
+                          // per-kind rather than per-site, so all three sites
+                          // share the same allow-list
 ```
 
 `dynamic?: boolean` is kept to avoid churning every `call.dynamic ? 1 : 0` site.
@@ -106,11 +108,13 @@ is the correct substitute for real alias tracking), and the right operand of
 an `instanceof` check (#1784, `err instanceof CodegraphError` — `instanceof`
 evaluates its right operand as a value, never calls it) are three independent
 extraction sites feeding the same resolution/filtering logic downstream. The
-`instanceof` site is the first to resolve against `class`-kind targets (the
-other two are function/method only, since `instanceof`'s operand is always a
-class/constructor) — the resolver-side filter is keyed on `dynamicKind`, not
-on which site produced the call, so this is a per-kind allowed-target-kind
-set rather than a per-site one. New languages/positions can add a fourth
+`instanceof` site is the motivation for adding `class` to the allowed
+target kinds, since its operand is always a class/constructor — but the
+resolver-side filter is keyed on `dynamicKind`, not on which site produced
+the call, so this is a per-kind allowed-target-kind set rather than a
+per-site one: object-literal and Lua value-ref sites also gain class-kind
+resolution as a side effect of this change, not because either idiom
+commonly names a class. New languages/positions can add a fourth
 without touching `build-edges.ts` / `incremental.ts` / `build_edges.rs`
 again, beyond widening the allowed-target-kind set if the new site's operand
 isn't a function/method/class.

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

@@ -1378,11 +1378,12 @@ function resolveFallbackTargets(
   // these positions is as likely to be a plain data reference
   // (`{ name: SOME_CONSTANT }`) as a real function/class, so drop any
   // other-kind match rather than fabricating a "calls" edge to a constant.
-  // `class` is included alongside function/method because `instanceof`'s
-  // right operand is always a class/constructor (#1784) — unlike the
-  // original #1771 object-literal case, which is function/method only.
-  // Applied once here, after every fallback tier above, so it covers
-  // whichever tier produced the match.
+  // `class` was added because `instanceof`'s right operand is always a
+  // class/constructor (#1784). The filter is keyed on `dynamicKind`, not on
+  // which site produced the call, so the #1771 object-literal and #1776 Lua
+  // sites also gain class-kind resolution as a side effect — not because
+  // either idiom commonly names a class. Applied once here, after every
+  // fallback tier above, so it covers whichever tier produced the match.
   if (call.dynamicKind === 'value-ref') {
     // `targets` is typed without `kind` when it flows straight through from
     // resolveCallTargets (call-resolver.ts's declared return type omits it),

src/types.ts

@@ -488,7 +488,7 @@ export type DynamicKind =
   | 'reflection' // .call/.apply/.bind / Reflect.* / callable-ref — resolved when target is in codebase; sink edge emitted if unresolved
   | 'eval' // eval() / new Function() — undecidable; always flagged
   | 'unresolved-dynamic' // any other detected dynamic pattern; flagged
-  | 'value-ref'; // bare identifier used as a value reference rather than a call site — object-literal property value (dispatch-table pattern, e.g. `{ resolve: someFn }`, #1771), assignment to a Lua global/builtin identifier (e.g. `require = tracedRequire`, #1776), or the right operand of an `instanceof` check (e.g. `err instanceof CodegraphError`, #1784) — resolved only against function/method/class-kind targets (class only relevant for the instanceof site); unresolved (e.g. plain data references) are dropped silently, NOT flagged
+  | 'value-ref'; // bare identifier used as a value reference rather than a call site — object-literal property value (dispatch-table pattern, e.g. `{ resolve: someFn }`, #1771), assignment to a Lua global/builtin identifier (e.g. `require = tracedRequire`, #1776), or the right operand of an `instanceof` check (e.g. `err instanceof CodegraphError`, #1784) — resolved against function/method/class-kind targets; class was added for instanceof, but the filter is per-kind rather than per-site, so all three sites share the same allow-list; unresolved (e.g. plain data references) are dropped silently, NOT flagged
 
 /** A function/method call detected by an extractor. */
 export interface Call {