fix(receiver): same-file function constructors win over cross-file class nodes

When multiple files define a symbol with the same name, the receiver-type edge
for a `new C()` call in a file that defines `function C() {}` (pre-ES6
constructor) was pointing to a `class C` in a different file instead of the
local constructor.

Root cause: `RECEIVER_KINDS` / `receiver_kinds` did not include `function`, so
the same-file `C` (kind=function) was filtered out, the same-file set became
empty, and the global fallback found the wrong `class C` in another file.

Fix: introduce `RECEIVER_KINDS_SAME_FILE` (TS) and `receiver_kinds_same_file`
(Rust) that extend the base set with `function`.  Same-file candidate lookup
uses the wider set; the global cross-file fallback keeps the narrower set to
avoid false positives from unrelated same-named functions in other files.

Applied in both engines (call-resolver.ts + build_edges.rs) to maintain parity.

Closes #1513

Author: carlos-alm

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

@@ -140,6 +140,11 @@ struct EdgeContext<'a> {
     nodes_by_file: HashMap<&'a str, Vec<&'a NodeInfo>>,
     builtin_set: HashSet<&'a str>,
     receiver_kinds: HashSet<&'a str>,
+    /// Same-file receiver lookup also accepts `function` to handle pre-ES6
+    /// function constructors (e.g. `function C() {}` with `C.prototype = { … }`).
+    /// Global fallback keeps the narrower set to avoid false positives from
+    /// unrelated same-named functions in other files.
+    receiver_kinds_same_file: HashSet<&'a str>,
 }
 
 impl<'a> EdgeContext<'a> {
@@ -158,7 +163,17 @@ impl<'a> EdgeContext<'a> {
         let builtin_set: HashSet<&str> = builtin_receivers.iter().map(|s| s.as_str()).collect();
         let receiver_kinds: HashSet<&str> = ["class", "struct", "interface", "type", "module"]
             .iter().copied().collect();
-        Self { nodes_by_name, nodes_by_name_and_file, nodes_by_file, builtin_set, receiver_kinds }
+        let receiver_kinds_same_file: HashSet<&str> =
+            ["class", "struct", "interface", "type", "module", "function"]
+                .iter().copied().collect();
+        Self {
+            nodes_by_name,
+            nodes_by_name_and_file,
+            nodes_by_file,
+            builtin_set,
+            receiver_kinds,
+            receiver_kinds_same_file,
+        }
     }
 }
 
@@ -1035,16 +1050,15 @@ fn emit_receiver_edge(
     let type_entry = type_map.get(receiver.as_str());
     let effective_receiver = type_entry.map(|&(t, _)| t).unwrap_or(receiver.as_str());
 
-    // Filter-before: apply receiver_kinds to same-file candidates first, then
-    // fall back to global candidates (also filtered) only when same-file yields
-    // nothing.  This prevents an imported name emitted as kind='function' in the
-    // importing file from blocking the fallback to the actual class/struct/etc.
-    // node in the defining file.
+    // Same-file candidates use receiver_kinds_same_file (includes "function") so
+    // that pre-ES6 function constructors (e.g. `function C() {}`) in the same
+    // file are matched.  Global fallback uses the narrower receiver_kinds to
+    // avoid false positives from unrelated same-named functions in other files.
     let samefile_candidates: Vec<&NodeInfo> = ctx.nodes_by_name_and_file
         .get(&(effective_receiver, rel_path))
         .cloned().unwrap_or_default()
         .into_iter()
-        .filter(|n| ctx.receiver_kinds.contains(n.kind.as_str()))
+        .filter(|n| ctx.receiver_kinds_same_file.contains(n.kind.as_str()))
         .collect();
     let receiver_nodes: Vec<&NodeInfo> = if !samefile_candidates.is_empty() {
         samefile_candidates

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

@@ -23,6 +23,18 @@ export interface CallNodeLookup {
 
 export const RECEIVER_KINDS = new Set(['class', 'struct', 'interface', 'type', 'module']);
 
+/**
+ * Kinds accepted as receiver-type candidates when looking in the *same file*
+ * as the call site.  Same-file scope makes the match unambiguous, so we also
+ * accept `function` to handle pre-ES6 function constructors (e.g.
+ * `function C() {}` with `C.prototype = { … }`) that are extracted as
+ * `kind='function'` rather than `kind='class'`.
+ *
+ * Global (cross-file) lookups deliberately exclude `function` to avoid false
+ * positives from unrelated same-named functions in other files.
+ */
+export const RECEIVER_KINDS_SAME_FILE = new Set([...RECEIVER_KINDS, 'function']);
+
 /**
  * Languages where bare `foo()` calls inside a class method are lexically scoped
  * to the module, not the class — there is no implicit this/class binding.
@@ -355,13 +367,15 @@ export function resolveCallTargets(
  * Returns the edge tuple to insert, or null if nothing matched or the edge
  * was already seen.  Callers are responsible for the actual DB/array insert.
  *
- * Receiver resolution collects all same-file candidates first (no kind
- * filter), falls back to global candidates only when the same-file set is
- * entirely empty, then filters the chosen set by RECEIVER_KINDS.  This
- * matches the native Rust build path: if a file imports a name that happens
- * to be emitted as `kind='function'` in the importer, the same-file set is
- * non-empty and blocks the global fallback, so no receiver edge is emitted.
- * Keeping this behaviour identical to the Rust path maintains engine parity.
+ * Same-file candidates are filtered by RECEIVER_KINDS_SAME_FILE (which
+ * includes `function` to handle pre-ES6 function constructors).  If no
+ * same-file candidate matches, the lookup falls back to global candidates
+ * filtered by the narrower RECEIVER_KINDS (no `function`) to avoid false
+ * positives from unrelated same-named functions in other files.
+ *
+ * This means a local `function C() {}` in the same file always wins over a
+ * `class C` defined in a different file — fixing cross-file receiver
+ * non-determinism when multiple files define the same constructor name.
  */
 export function resolveReceiverEdge(
   lookup: CallNodeLookup,
@@ -382,14 +396,13 @@ export function resolveReceiverEdge(
       ? ((typeEntry as { confidence?: number }).confidence ?? null)
       : null;
   const effectiveReceiver = typeName || call.receiver;
-  // Filter-before: apply RECEIVER_KINDS to same-file candidates first, then
-  // fall back to global candidates (also filtered) only when same-file yields
-  // nothing.  This prevents an imported name emitted as kind='function' in the
-  // importing file from blocking the fallback to the actual class/struct/etc.
-  // node in the defining file.
+  // Same-file candidates use RECEIVER_KINDS_SAME_FILE (includes 'function') so
+  // that pre-ES6 function constructors (e.g. `function C() {}`) in the same
+  // file are matched.  Global fallback uses the narrower RECEIVER_KINDS to
+  // avoid false positives from unrelated same-named functions in other files.
   const sameFileCandidates = lookup
     .byNameAndFile(effectiveReceiver, relPath)
-    .filter((n) => RECEIVER_KINDS.has(n.kind ?? ''));
+    .filter((n) => RECEIVER_KINDS_SAME_FILE.has(n.kind ?? ''));
   const candidates =
     sameFileCandidates.length > 0
       ? sameFileCandidates

tests/integration/issue-1513-receiver-same-file-priority.test.ts

@@ -0,0 +1,104 @@
+/**
+ * Regression test for #1513: receiver edge for a function constructor must
+ * point to the same-file definition when multiple files define the same name.
+ *
+ * Setup: two files both define a symbol named `C`.
+ *   - a.js: `function C() {}` with `C.prototype = { foo: function(){} }`
+ *             and a caller `run()` that does `new C(); v.foo()`
+ *   - b.js: `class C { bar() {} }` — same name, different file
+ *
+ * Expected receiver edge: `a.js::run → C` where C is the one in a.js (kind=function),
+ * NOT the class C in b.js.
+ */
+
+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 FILE_A = `
+function C() {}
+C.prototype = {
+  foo: function() {},
+};
+export function run() {
+  var v = new C();
+  v.foo();
+}
+`;
+
+// Same name C in a different file — must not steal the receiver edge from a.js
+const FILE_B = `
+export class C {
+  bar() {}
+}
+`;
+
+let tmpWasm: string;
+let tmpNative: string;
+
+beforeAll(async () => {
+  tmpWasm = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-1513-wasm-'));
+  fs.writeFileSync(path.join(tmpWasm, 'a.js'), FILE_A);
+  fs.writeFileSync(path.join(tmpWasm, 'b.js'), FILE_B);
+
+  tmpNative = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-1513-native-'));
+  fs.writeFileSync(path.join(tmpNative, 'a.js'), FILE_A);
+  fs.writeFileSync(path.join(tmpNative, 'b.js'), FILE_B);
+
+  await Promise.all([
+    buildGraph(tmpWasm, { incremental: false, skipRegistry: true, engine: 'wasm' }),
+    buildGraph(tmpNative, { incremental: false, skipRegistry: true, engine: 'native' }),
+  ]);
+});
+
+afterAll(() => {
+  fs.rmSync(tmpWasm, { recursive: true, force: true });
+  fs.rmSync(tmpNative, { recursive: true, force: true });
+});
+
+function getReceiverEdges(dbPath: string) {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    return db
+      .prepare(
+        `SELECT n1.name AS src, n2.name AS tgt, n2.file AS tgt_file
+         FROM edges e
+         JOIN nodes n1 ON e.source_id = n1.id
+         JOIN nodes n2 ON e.target_id = n2.id
+         WHERE e.kind = 'receiver'
+         ORDER BY n1.name, n2.name`,
+      )
+      .all() as Array<{ src: string; tgt: string; tgt_file: string }>;
+  } finally {
+    db.close();
+  }
+}
+
+describe('receiver same-file priority over cross-file (#1513)', () => {
+  it('WASM: run() receiver edge targets C in a.js, not b.js', () => {
+    const edges = getReceiverEdges(path.join(tmpWasm, '.codegraph', 'graph.db'));
+    const edge = edges.find((e) => e.src === 'run');
+    expect(edge).toBeDefined();
+    expect(edge?.tgt).toBe('C');
+    expect(edge?.tgt_file).toBe('a.js');
+  });
+
+  it('Native: run() receiver edge targets C in a.js, not b.js', () => {
+    const edges = getReceiverEdges(path.join(tmpNative, '.codegraph', 'graph.db'));
+    const edge = edges.find((e) => e.src === 'run');
+    expect(edge).toBeDefined();
+    expect(edge?.tgt).toBe('C');
+    expect(edge?.tgt_file).toBe('a.js');
+  });
+
+  it('WASM and native produce the same receiver edges', () => {
+    const wasmEdges = getReceiverEdges(path.join(tmpWasm, '.codegraph', 'graph.db'));
+    const nativeEdges = getReceiverEdges(path.join(tmpNative, '.codegraph', 'graph.db'));
+    const wasmSet = new Set(wasmEdges.map((e) => `${e.src}→${e.tgt}@${e.tgt_file}`));
+    const nativeSet = new Set(nativeEdges.map((e) => `${e.src}→${e.tgt}@${e.tgt_file}`));
+    expect(wasmSet).toEqual(nativeSet);
+  });
+});