fix(resolver): scope this.prop typeMap key to enclosing class to prevent false edges in multi-class files (#1382)

* fix(resolver): scope this.prop typeMap key to class to prevent false edges in multi-class files

When a file defines two or more classes that both assign `this.service = new X()` in
their constructors, `handlePropWriteTypeMap` previously stored all entries under the
unqualified key `this.service`. `setTypeMapEntry` discards equal-confidence duplicates,
so only one class's entry survived, causing the other class's `this.service.method()`
calls to resolve against the wrong type and producing spurious call-graph edges.

Fix: extractTypeMapWalk now threads a `currentClass: string | null` parameter through
its inner walk. When a `class_declaration` node is encountered, the class name is
extracted and passed down to all children. `handlePropWriteTypeMap` uses this to key
`this.prop = new Ctor()` writes as `ClassName.prop` (e.g. `ClassA.service`) instead
of `this.prop`, so two classes with the same property name no longer collide in the
typeMap.

The call resolver gains a symmetric fallback: when a `this.X` receiver isn't found via
`effectiveReceiver` / `this.X` lookups, it also tries `CallerClass.X` where the caller
class is extracted from `callerName` (e.g. `ClassA.runA` → `ClassA`). This correctly
resolves the class-scoped key while leaving all other resolution paths untouched.

Also adds: `multi-class.js` fixture, four expected edges, driver exercise, and three
unit tests covering the new scoping, fallback when there is no enclosing class, and the
absence of false entries.

Closes #1323

* fix(extractor): use this.prop fallback for named class expressions in typeMap

Named class expressions (`const Foo = class Bar { ... }`) store the key as
`Bar.x` using the expression-internal name, but the resolver derives callerClass
from the binding name `Foo`, so it looks up `Foo.x` and misses `Bar.x`.

Walk class expression children with null so the pre-fix `this.prop` fallback
is preserved and the second lookup in resolveByMethodOrGlobal still finds the
entry. Only class_declaration and abstract_class_declaration receive the
class-scoped key treatment.

Add a unit test asserting `this.x` is stored (not `Bar.x`) for named class
expressions.

Fixes a silent regression identified by Greptile in PR #1382 review.

Author: carlos-alm

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

@@ -72,10 +72,22 @@ export function resolveByMethodOrGlobal(
     const effectiveReceiver = call.receiver.startsWith('this.')
       ? call.receiver.slice('this.'.length)
       : call.receiver;
-    const typeEntry =
+    // For this.prop receivers, also try the class-scoped key (ClassName.prop) seeded by
+    // handlePropWriteTypeMap — prevents false edges when multiple classes define the same
+    // property name (issue #1323).
+    let typeEntry =
       typeMap.get(effectiveReceiver) ??
       typeMap.get(call.receiver) ??
+      // Phase 8.3f: callee-scoped rest-param key (`callee::restName`) to avoid
+      // same-name rest-binding collision across functions in the same file (#1358).
       (callerName ? typeMap.get(`${callerName}::${effectiveReceiver}`) : undefined);
+    if (!typeEntry && call.receiver.startsWith('this.') && callerName) {
+      const dotIdx = callerName.lastIndexOf('.');
+      if (dotIdx > -1) {
+        const callerClass = callerName.slice(0, dotIdx);
+        typeEntry = typeMap.get(`${callerClass}.${effectiveReceiver}`);
+      }
+    }
     let typeName = typeEntry
       ? typeof typeEntry === 'string'
         ? typeEntry

src/extractors/javascript.ts

@@ -1741,23 +1741,41 @@ function extractTypeMapWalk(
   callAssignments?: CallAssignment[],
   fnRefBindings?: FnRefBinding[],
 ): void {
-  function walk(node: TreeSitterNode, depth: number): void {
+  function walk(node: TreeSitterNode, depth: number, currentClass: string | null): void {
     if (depth >= MAX_WALK_DEPTH) return;
     const t = node.type;
+    if (t === 'class_declaration' || t === 'abstract_class_declaration') {
+      const nameNode = node.childForFieldName('name');
+      const className = nameNode?.text ?? null;
+      for (let i = 0; i < node.childCount; i++) {
+        walk(node.child(i)!, depth + 1, className);
+      }
+      return;
+    }
+    // Class expressions (e.g. `const Foo = class Bar { ... }`): the expression-internal
+    // name (`Bar`) is never visible to the resolver, which derives callerClass from the
+    // binding name (`Foo`). Walking with null preserves the pre-fix `this.prop` fallback
+    // so the second lookup in resolveByMethodOrGlobal still finds the entry.
+    if (t === 'class') {
+      for (let i = 0; i < node.childCount; i++) {
+        walk(node.child(i)!, depth + 1, null);
+      }
+      return;
+    }
     if (t === 'variable_declarator') {
       handleVarDeclaratorTypeMap(node, typeMap, returnTypeMap, callAssignments, fnRefBindings);
     } else if (t === 'required_parameter' || t === 'optional_parameter') {
       handleParamTypeMap(node, typeMap);
     } else if (t === 'assignment_expression') {
-      handlePropWriteTypeMap(node, typeMap);
+      handlePropWriteTypeMap(node, typeMap, currentClass);
     } else if (t === 'call_expression') {
       handleDefinePropertyTypeMap(node, typeMap);
     }
     for (let i = 0; i < node.childCount; i++) {
-      walk(node.child(i)!, depth + 1);
+      walk(node.child(i)!, depth + 1, currentClass);
     }
   }
-  walk(rootNode, 0);
+  walk(rootNode, 0, null);
 }
 
 /** Extract type info from a variable_declarator: type annotation, constructor, or factory. */
@@ -1957,12 +1975,17 @@ function handleParamTypeMap(node: TreeSitterNode, typeMap: Map<string, TypeMapEn
  * Phase 8.3d: seed the pts map from object property writes.
  *
  * `handlers.auth = authMiddleware` → typeMap.set('handlers.auth', { type: 'authMiddleware', confidence: 0.85 })
- * `this.logger = new Logger(...)` → typeMap.set('this.logger', { type: 'Logger', confidence: 1.0 })
+ * `this.logger = new Logger(...)` → typeMap.set('UserService.logger', { type: 'Logger', confidence: 1.0 })
+ *   (keyed as ClassName.prop when currentClass is known, to avoid collisions across classes)
  *
  * Only simple `obj.prop = identifier` and `this.prop = new Ctor()` writes are tracked
  * (not chained `a.b.c = x`). BUILTIN_GLOBALS are skipped (e.g. `console.log = fn`).
  */
-function handlePropWriteTypeMap(node: TreeSitterNode, typeMap: Map<string, TypeMapEntry>): void {
+function handlePropWriteTypeMap(
+  node: TreeSitterNode,
+  typeMap: Map<string, TypeMapEntry>,
+  currentClass: string | null,
+): void {
   const lhsN = node.childForFieldName('left');
   const rhsN = node.childForFieldName('right');
   if (!lhsN || !rhsN) return;
@@ -1975,10 +1998,15 @@ function handlePropWriteTypeMap(node: TreeSitterNode, typeMap: Map<string, TypeM
   // computed subscript expressions — consistent with the adjacent fnRefBindings block.
   if (prop.type !== 'property_identifier' && prop.type !== 'identifier') return;
 
-  // this.prop = new ClassName(...) — constructor-assigned property type
+  // this.prop = new ClassName(...) — constructor-assigned property type.
+  // Key as ClassName.prop (class-scoped) so two classes with identically-named
+  // properties don't overwrite each other's typeMap entry.
   if (obj.type === 'this' && rhsN.type === 'new_expression') {
     const ctorType = extractNewExprTypeName(rhsN);
-    if (ctorType) setTypeMapEntry(typeMap, `this.${prop.text}`, ctorType, 1.0);
+    if (ctorType) {
+      const key = currentClass ? `${currentClass}.${prop.text}` : `this.${prop.text}`;
+      setTypeMapEntry(typeMap, key, ctorType, 1.0);
+    }
     return;
   }
 

tests/benchmarks/resolution/fixtures/javascript/driver.mjs

@@ -12,6 +12,7 @@
 
 import { directInstantiation, main } from './index.js';
 import { Logger } from './logger.js';
+import { ClassA, ClassB } from './multi-class.js';
 import { buildService } from './service.js';
 import { normalize, validate } from './validators.js';
 
@@ -39,6 +40,10 @@ try {
   svc.createUser({ name: 'Direct' });
   svc.deleteUser(99);
 
+  // Multi-class fixture — exercises class-scoped this.prop typeMap (issue #1323)
+  new ClassA().runA();
+  new ClassB().runB();
+
   globalThis.__tracer.popCall();
 } catch {
   // Swallow errors — we only care about call edges

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

@@ -247,6 +247,34 @@
       "kind": "calls",
       "mode": "defineProperty-accessor",
       "notes": "this.accessMethod() inside accessorGetter — this === accessorTarget (get accessor via Object.defineProperty); accessorTarget.accessMethod is the qualified node name for the arrow function property of accessorTarget"
+    },
+    {
+      "source": { "name": "ClassA.constructor", "file": "multi-class.js" },
+      "target": { "name": "ServiceA", "file": "multi-class.js" },
+      "kind": "calls",
+      "mode": "constructor",
+      "notes": "new ServiceA() — constructor call in ClassA.constructor"
+    },
+    {
+      "source": { "name": "ClassB.constructor", "file": "multi-class.js" },
+      "target": { "name": "ServiceB", "file": "multi-class.js" },
+      "kind": "calls",
+      "mode": "constructor",
+      "notes": "new ServiceB() — constructor call in ClassB.constructor"
+    },
+    {
+      "source": { "name": "ClassA.runA", "file": "multi-class.js" },
+      "target": { "name": "ServiceA.doA", "file": "multi-class.js" },
+      "kind": "calls",
+      "mode": "receiver-typed",
+      "notes": "this.service.doA() — receiver-typed via ClassA.service = new ServiceA() (class-scoped typeMap key prevents collision with ClassB.service)"
+    },
+    {
+      "source": { "name": "ClassB.runB", "file": "multi-class.js" },
+      "target": { "name": "ServiceB.doB", "file": "multi-class.js" },
+      "kind": "calls",
+      "mode": "receiver-typed",
+      "notes": "this.service.doB() — receiver-typed via ClassB.service = new ServiceB() (class-scoped typeMap key prevents collision with ClassA.service)"
     }
   ]
 }

tests/benchmarks/resolution/fixtures/javascript/multi-class.js

@@ -0,0 +1,34 @@
+/**
+ * Fixture: two classes in the same file that both use `this.service`,
+ * but assign different types.  Before the fix, the second class's
+ * typeMap entry overwrote the first, causing one class to resolve
+ * `this.service.method()` against the wrong type (false edge).
+ */
+
+export class ServiceA {
+  doA() {}
+}
+
+export class ServiceB {
+  doB() {}
+}
+
+export class ClassA {
+  constructor() {
+    this.service = new ServiceA();
+  }
+
+  runA() {
+    this.service.doA();
+  }
+}
+
+export class ClassB {
+  constructor() {
+    this.service = new ServiceB();
+  }
+
+  runB() {
+    this.service.doB();
+  }
+}

tests/parsers/javascript.test.ts

@@ -360,24 +360,65 @@ describe('JavaScript parser', () => {
       expect(symbols.typeMap.has('b.c')).toBe(false);
     });
 
-    it('seeds typeMap for this.prop = new ClassName() with confidence 1.0', () => {
+    it('seeds typeMap for this.prop = new ClassName() using class-scoped key', () => {
       const symbols = parseJS(`
         class UserService {
           constructor() {
             this.logger = new Logger('UserService');
           }
         }
       `);
+      expect(symbols.typeMap.get('UserService.logger')).toEqual({
+        type: 'Logger',
+        confidence: 1.0,
+      });
+      expect(symbols.typeMap.has('this.logger')).toBe(false);
+    });
+
+    it('uses this.prop key when no enclosing class is present', () => {
+      const symbols = parseJS(`
+        function setup() {
+          this.logger = new Logger();
+        }
+      `);
       expect(symbols.typeMap.get('this.logger')).toEqual({ type: 'Logger', confidence: 1.0 });
     });
 
+    it('scopes this.prop typeMap key to enclosing class — no collision across classes', () => {
+      const symbols = parseJS(`
+        class ClassA {
+          constructor() { this.service = new ServiceA(); }
+        }
+        class ClassB {
+          constructor() { this.service = new ServiceB(); }
+        }
+      `);
+      expect(symbols.typeMap.get('ClassA.service')).toEqual({ type: 'ServiceA', confidence: 1.0 });
+      expect(symbols.typeMap.get('ClassB.service')).toEqual({ type: 'ServiceB', confidence: 1.0 });
+      expect(symbols.typeMap.has('this.service')).toBe(false);
+    });
+
+    it('uses this.prop fallback for named class expressions (expression name not resolver-visible)', () => {
+      // `const Foo = class Bar { ... }` — the resolver derives callerClass from the
+      // binding name `Foo`, never from the expression name `Bar`. Storing as `Bar.x`
+      // would produce an unreachable key, so we fall back to `this.x` instead.
+      const symbols = parseJS(`
+        const Foo = class Bar {
+          constructor() { this.x = new X(); }
+        };
+      `);
+      expect(symbols.typeMap.get('this.x')).toEqual({ type: 'X', confidence: 1.0 });
+      expect(symbols.typeMap.has('Bar.x')).toBe(false);
+    });
+
     it('does not seed typeMap for this.prop = identifier (only new expressions)', () => {
       const symbols = parseJS(`
         class Foo {
           init(logger) { this.logger = logger; }
         }
       `);
       expect(symbols.typeMap.has('this.logger')).toBe(false);
+      expect(symbols.typeMap.has('Foo.logger')).toBe(false);
     });
 
     it('ignores non-identifier RHS (a.prop = obj.method)', () => {