fix: resolve merge conflicts with feat/prototype-resolver-1317

carlos-alm · carlos-alm · commit df3c25139f6f · 2026-06-06T03:40:02.000-06:00
diff --git a/biome.json b/biome.json
@@ -25,5 +25,13 @@
       "semicolons": "always",
       "trailingCommas": "all"
     }
-  }
+  },
+  "overrides": [
+    {
+      "includes": ["tests/benchmarks/resolution/fixtures/**"],
+      "linter": {
+        "enabled": false
+      }
+    }
+  ]
 }
diff --git a/crates/codegraph-core/src/edge_builder.rs b/crates/codegraph-core/src/edge_builder.rs
@@ -483,15 +483,27 @@ fn resolve_call_targets<'a>(
                 if !class_scoped.is_empty() { return class_scoped; }
             }
 
-            // Broader fallback: same-file suffix scan to pick up CHA-expanded targets
-            // (subclasses that override the method).
+            // Broader fallback: same-file suffix scan.  Always restrict to the caller's
+            // own class prefix — regardless of how many matches are found — to avoid
+            // false-positive edges to unrelated classes in the same file.
+            // (e.g. this.area() inside Shape.describe must never yield Calculator.area,
+            // even when Calculator.area is the only method with that name in the file.)
             let suffix = format!(".{}", call.name);
             if let Some(file_nodes) = ctx.nodes_by_file.get(rel_path) {
                 let same_file_methods: Vec<&NodeInfo> = file_nodes.iter()
                     .filter(|n| n.kind == "method" && n.name.ends_with(&suffix))
                     .copied()
                     .collect();
-                if !same_file_methods.is_empty() { return same_file_methods; }
+                if !same_file_methods.is_empty() {
+                    if let Some(dot_pos) = caller_name.find('.') {
+                        let caller_prefix = format!("{}.", &caller_name[..dot_pos]);
+                        let caller_scoped: Vec<&NodeInfo> = same_file_methods.iter()
+                            .filter(|n| n.name.starts_with(&caller_prefix))
+                            .copied()
+                            .collect();
+                        if !caller_scoped.is_empty() { return caller_scoped; }
+                    }
+                }
             }
         }
         return exact; // empty
diff --git a/src/domain/graph/builder/stages/build-edges.ts b/src/domain/graph/builder/stages/build-edges.ts
@@ -1079,21 +1079,33 @@ function buildFileCallEdges(
     // direct call to the same target in the same function body can upgrade confidence
     // rather than being silently dropped by the dedup guard.
     const scopedPtsKey = caller.callerName != null ? `${caller.callerName}::${call.name}` : null;
+    // Module-level calls (callerName === null) use the '<module>' sentinel emitted by
+    // extractSpreadForOfWalk for top-level for-of loops. Look it up as a fallback so
+    // that `for (const f of arr) { f(); }` at module scope resolves correctly.
+    const modulePtsKey =
+      caller.callerName === null && ptsMap?.has(`<module>::${call.name}`)
+        ? `<module>::${call.name}`
+        : null;
     const flatPtsKey =
       !call.dynamic && fnRefBindingLhs.has(call.name) && ptsMap?.has(call.name) ? call.name : null;
     if (
       targets.length === 0 &&
       !call.receiver &&
       ptsMap &&
-      (call.dynamic || (scopedPtsKey != null && ptsMap.has(scopedPtsKey)) || flatPtsKey != null)
+      (call.dynamic ||
+        (scopedPtsKey != null && ptsMap.has(scopedPtsKey)) ||
+        modulePtsKey != null ||
+        flatPtsKey != null)
     ) {
       const ptsLookupName = call.dynamic
         ? call.name
         : scopedPtsKey != null && ptsMap.has(scopedPtsKey)
           ? scopedPtsKey
-          : // flatPtsKey != null is guaranteed by the outer if condition: if neither
-            // call.dynamic nor scopedPtsKey matched, flatPtsKey != null must be true.
-            flatPtsKey!;
+          : modulePtsKey != null
+            ? modulePtsKey
+            : // flatPtsKey != null is guaranteed by the outer if condition: if neither
+              // call.dynamic nor scopedPtsKey nor modulePtsKey matched, flatPtsKey must be non-null.
+              flatPtsKey!;
       for (const alias of resolveViaPointsTo(ptsLookupName, ptsMap)) {
         // Resolve the concrete alias target. Only `name` is needed here — receiver
         // and line are not relevant for alias resolution (we are looking up the
diff --git a/src/domain/wasm-worker-entry.ts b/src/domain/wasm-worker-entry.ts
@@ -819,6 +819,11 @@ function serializeExtractorOutput(
       ? { objectPropBindings: symbols.objectPropBindings }
       : {}),
     ...(symbols.newExpressions?.length ? { newExpressions: symbols.newExpressions } : {}),
+    ...(symbols.returnTypeMap?.size
+      ? { returnTypeMap: Array.from(symbols.returnTypeMap.entries()) }
+      : {}),
+    ...(symbols.callAssignments?.length ? { callAssignments: symbols.callAssignments } : {}),
+    ...(symbols.paramBindings?.length ? { paramBindings: symbols.paramBindings } : {}),
   };
 }
 
diff --git a/src/domain/wasm-worker-pool.ts b/src/domain/wasm-worker-pool.ts
@@ -116,6 +116,13 @@ function deserializeResult(ser: SerializedExtractorOutput | null): ExtractorOutp
     out.objectRestParamBindings = ser.objectRestParamBindings;
   if (ser.objectPropBindings?.length) out.objectPropBindings = ser.objectPropBindings;
   if (ser.newExpressions?.length) out.newExpressions = ser.newExpressions;
+  if (ser.returnTypeMap?.length) {
+    const returnTypeMap = new Map<string, TypeMapEntry>();
+    for (const [k, v] of ser.returnTypeMap) returnTypeMap.set(k, v);
+    out.returnTypeMap = returnTypeMap;
+  }
+  if (ser.callAssignments?.length) out.callAssignments = ser.callAssignments;
+  if (ser.paramBindings?.length) out.paramBindings = ser.paramBindings;
   return out;
 }
 
diff --git a/src/domain/wasm-worker-protocol.ts b/src/domain/wasm-worker-protocol.ts
@@ -12,12 +12,14 @@
 
 import type {
   Call,
+  CallAssignment,
   ClassRelation,
   DataflowResult,
   Definition,
   Export,
   Import,
   LanguageId,
+  ParamBinding,
   TypeMapEntry,
 } from '../types.js';
 
@@ -71,6 +73,9 @@ export interface SerializedExtractorOutput {
   objectRestParamBindings?: import('../types.js').ObjectRestParamBinding[];
   objectPropBindings?: import('../types.js').ObjectPropBinding[];
   newExpressions?: readonly string[];
+  returnTypeMap?: Array<[string, TypeMapEntry]>;
+  callAssignments?: CallAssignment[];
+  paramBindings?: ParamBinding[];
 }
 
 export interface WorkerParseResponseOk {
diff --git a/src/extractors/javascript.ts b/src/extractors/javascript.ts
@@ -1871,12 +1871,30 @@ function extractSpreadForOfWalk(
   fnRefBindings: FnRefBinding[],
 ): void {
   const funcStack: string[] = [];
+  // Tracks the enclosing class name so that method_definition nodes push a
+  // qualified name (e.g. 'Foo.bar') matching what findCaller returns from the
+  // definitions array (where class methods are stored as 'Foo.bar').
+  const classStack: string[] = [];
 
   function walk(node: TreeSitterNode, depth: number): void {
     if (depth >= MAX_WALK_DEPTH) return;
 
     let pushedFunc = false;
-    if (node.type === 'function_declaration' || node.type === 'generator_function_declaration') {
+    let pushedClass = false;
+    if (
+      node.type === 'class_declaration' ||
+      node.type === 'abstract_class_declaration' ||
+      node.type === 'class'
+    ) {
+      const nameNode = node.childForFieldName('name');
+      if (nameNode?.type === 'identifier') {
+        classStack.push(nameNode.text);
+        pushedClass = true;
+      }
+    } else if (
+      node.type === 'function_declaration' ||
+      node.type === 'generator_function_declaration'
+    ) {
       const nameNode = node.childForFieldName('name');
       if (nameNode?.type === 'identifier') {
         funcStack.push(nameNode.text);
@@ -1885,7 +1903,11 @@ function extractSpreadForOfWalk(
     } else if (node.type === 'method_definition') {
       const nameNode = node.childForFieldName('name');
       if (nameNode) {
-        funcStack.push(nameNode.text);
+        // Qualify with the enclosing class name so the PTS key matches
+        // callerName from findCaller (which uses def.name = 'ClassName.method').
+        const enclosingClass = classStack.length > 0 ? classStack[classStack.length - 1] : null;
+        const qualifiedName = enclosingClass ? `${enclosingClass}.${nameNode.text}` : nameNode.text;
+        funcStack.push(qualifiedName);
         pushedFunc = true;
       }
     } else if (node.type === 'variable_declarator') {
@@ -2027,6 +2049,7 @@ function extractSpreadForOfWalk(
     }
 
     if (pushedFunc) funcStack.pop();
+    if (pushedClass) classStack.pop();
   }
 
   walk(rootNode, 0);
diff --git a/tests/benchmarks/resolution/fixtures/javascript/expected-edges.json b/tests/benchmarks/resolution/fixtures/javascript/expected-edges.json
@@ -130,35 +130,35 @@
       "notes": "new UserService() — class instantiation tracked as consumption"
     },
     {
-      "source": { "name": "defProp", "file": "define-property.js" },
+      "source": { "name": "_defProp", "file": "define-property.js" },
       "target": { "name": "f1", "file": "define-property.js" },
       "kind": "calls",
       "mode": "pts-define-property",
       "notes": "obj.f() — resolved via Object.defineProperty(obj, \"f\", { value: f1 })"
     },
     {
-      "source": { "name": "defProps", "file": "define-property.js" },
+      "source": { "name": "_defProps", "file": "define-property.js" },
       "target": { "name": "f1", "file": "define-property.js" },
       "kind": "calls",
       "mode": "pts-define-property",
       "notes": "obj.f1() — resolved via Object.defineProperties(obj, { \"f1\": { value: f1 } })"
     },
     {
-      "source": { "name": "defProps", "file": "define-property.js" },
+      "source": { "name": "_defProps", "file": "define-property.js" },
       "target": { "name": "f2", "file": "define-property.js" },
       "kind": "calls",
       "mode": "pts-define-property",
       "notes": "obj.f2() — resolved via Object.defineProperties(obj, { \"f2\": { value: f2 } })"
     },
     {
-      "source": { "name": "create", "file": "define-property.js" },
+      "source": { "name": "_create", "file": "define-property.js" },
       "target": { "name": "f1", "file": "define-property.js" },
       "kind": "calls",
       "mode": "pts-create-prototype",
       "notes": "obj.f1() — resolved via Object.create({ f1, f2 })"
     },
     {
-      "source": { "name": "create", "file": "define-property.js" },
+      "source": { "name": "_create", "file": "define-property.js" },
       "target": { "name": "f2", "file": "define-property.js" },
       "kind": "calls",
       "mode": "pts-create-prototype",
diff --git a/tests/benchmarks/resolution/fixtures/javascript/inheritance.js b/tests/benchmarks/resolution/fixtures/javascript/inheritance.js
@@ -29,6 +29,6 @@ export class Counter {
 
 export class DoubleCounter extends Counter {
   static count() {
-    return Counter.count() * 2; // static super.method() → Counter.count
+    return super.count() * 2; // static super.count() → Counter.count via CHA parents map
   }
 }
diff --git a/tests/fixtures/this-dispatch-scope/shapes.ts b/tests/fixtures/this-dispatch-scope/shapes.ts
@@ -0,0 +1,24 @@
+// Three unrelated classes in one file, each with an area() method.
+// this.area() inside Shape.describe must resolve only to Shape.area,
+// not to Calculator.area or Formatter.area.
+
+export class Shape {
+  describe(): string {
+    return `area=${this.area()}`;
+  }
+  area(): number {
+    return 0;
+  }
+}
+
+export class Calculator {
+  area(): number {
+    return 100;
+  }
+}
+
+export class Formatter {
+  area(): string {
+    return 'n/a';
+  }
+}
diff --git a/tests/fixtures/this-dispatch-scope/single-sibling.ts b/tests/fixtures/this-dispatch-scope/single-sibling.ts
@@ -0,0 +1,16 @@
+// Two classes in one file; only one defines area().
+// this.area() inside Caller.run must NOT resolve to Sibling.area
+// even when Sibling.area is the only method with that suffix in the file.
+// The caller's own class (Caller) has no area() → the edge must be omitted.
+
+export class Caller {
+  run(): string {
+    return `result=${this.area()}`;
+  }
+}
+
+export class Sibling {
+  area(): number {
+    return 42;
+  }
+}
diff --git a/tests/integration/this-dispatch-scope.test.ts b/tests/integration/this-dispatch-scope.test.ts
@@ -0,0 +1,118 @@
+/**
+ * this-dispatch scope: same-file fallback must not emit false-positive edges
+ * to methods in unrelated classes.
+ *
+ * Fixtures:
+ *  - shapes.ts — three unrelated classes (Shape, Calculator, Formatter) all
+ *    defining area().  this.area() inside Shape.describe must resolve only to
+ *    Shape.area (multi-match disambiguation path).
+ *  - single-sibling.ts — two classes: Caller (no area()) and Sibling (area()).
+ *    this.area() inside Caller.run must NOT resolve to Sibling.area even though
+ *    it is the only method with that suffix in the file (single-match path).
+ *
+ * Covers the Rust edge_builder fix in issue #1324.
+ */
+
+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';
+import type { EngineMode } from '../../src/types.js';
+
+const FIXTURE_DIR = path.join(import.meta.dirname, '..', 'fixtures', 'this-dispatch-scope');
+
+interface CallEdgeRow {
+  caller_name: string;
+  callee_name: string;
+}
+
+function readCallEdges(dbPath: string): CallEdgeRow[] {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    return db
+      .prepare(
+        `SELECT n1.name AS caller_name, n2.name AS callee_name
+         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'`,
+      )
+      .all() as CallEdgeRow[];
+  } finally {
+    db.close();
+  }
+}
+
+const ENGINES: EngineMode[] = ['wasm', 'native'];
+
+describe.each(ENGINES)('this-dispatch scope (%s)', (engine) => {
+  let tmpDir: string;
+  let callEdges: CallEdgeRow[] = [];
+
+  beforeAll(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `codegraph-this-scope-${engine}-`));
+    fs.cpSync(FIXTURE_DIR, tmpDir, { recursive: true });
+    await buildGraph(tmpDir, { incremental: false, skipRegistry: true, engine });
+    callEdges = readCallEdges(path.join(tmpDir, '.codegraph', 'graph.db'));
+  }, 60_000);
+
+  afterAll(() => {
+    if (tmpDir) fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('emits Shape.describe → Shape.area (correct this-dispatch)', () => {
+    const edge = callEdges.find(
+      (e) => e.caller_name === 'Shape.describe' && e.callee_name === 'Shape.area',
+    );
+    expect(
+      edge,
+      `Expected Shape.describe → Shape.area edge.\nActual edges:\n${JSON.stringify(callEdges, null, 2)}`,
+    ).toBeDefined();
+  });
+
+  // Native binary v3.11.2 does not include the edge_builder.rs fix for issue #1324 yet.
+  // These assertions are active for WASM and will be re-enabled for native once a new
+  // binary is published that includes the Rust fix.
+  if (engine === 'native') {
+    it.todo('does NOT emit Shape.describe → Calculator.area (native binary gap #1324)');
+    it.todo('does NOT emit Shape.describe → Formatter.area (native binary gap #1324)');
+    it.todo(
+      'does NOT emit Caller.run → Sibling.area (single-match false-positive, native binary gap #1324)',
+    );
+  } else {
+    it('does NOT emit Shape.describe → Calculator.area (unrelated class, same method name)', () => {
+      const edge = callEdges.find(
+        (e) => e.caller_name === 'Shape.describe' && e.callee_name === 'Calculator.area',
+      );
+      expect(
+        edge,
+        `Expected NO Shape.describe → Calculator.area edge (false-positive from same-file scan).\nActual edges:\n${JSON.stringify(callEdges, null, 2)}`,
+      ).toBeUndefined();
+    });
+
+    it('does NOT emit Shape.describe → Formatter.area (unrelated class, same method name)', () => {
+      const edge = callEdges.find(
+        (e) => e.caller_name === 'Shape.describe' && e.callee_name === 'Formatter.area',
+      );
+      expect(
+        edge,
+        `Expected NO Shape.describe → Formatter.area edge (false-positive from same-file scan).\nActual edges:\n${JSON.stringify(callEdges, null, 2)}`,
+      ).toBeUndefined();
+    });
+
+    // single-sibling.ts: only one class (Sibling) has area(); Caller does not.
+    // The single-match arm must still check the caller's own class — Caller.run
+    // must not gain a false edge to Sibling.area.
+    it('does NOT emit Caller.run → Sibling.area (single-match false-positive, same-file scan)', () => {
+      const edge = callEdges.find(
+        (e) => e.caller_name === 'Caller.run' && e.callee_name === 'Sibling.area',
+      );
+      expect(
+        edge,
+        `Expected NO Caller.run → Sibling.area edge (false-positive from single-match suffix scan).\nActual edges:\n${JSON.stringify(callEdges, null, 2)}`,
+      ).toBeUndefined();
+    });
+  }
+});

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,6 @@ export class Counter {`
`29`	`29`
`30`	`30`	`export class DoubleCounter extends Counter {`
`31`	`31`	`static count() {`
`32`		`- return Counter.count() * 2; // static super.method() → Counter.count`
	`32`	`+ return super.count() * 2; // static super.count() → Counter.count via CHA parents map`
`33`	`33`	`}`
`34`	`34`	`}`