fix: merge origin/main into feat/super-dispatch-1377

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
@@ -186,7 +198,11 @@ export function resolveByMethodOrGlobal(
     if (call.receiver && callerName) {
       const dotIdx = callerName.lastIndexOf('.');
       if (dotIdx > -1) {
-        const callerClass = callerName.slice(0, dotIdx);
+        // Extract only the segment immediately before the method name so that
+        // 'Namespace.ClassName.method' yields 'ClassName', not 'Namespace.ClassName'.
+        // Symbols are stored under their bare class name, not their qualified path.
+        const prevDot = callerName.lastIndexOf('.', dotIdx - 1);
+        const callerClass = callerName.slice(prevDot + 1, dotIdx);
         const qualifiedName = `${callerClass}.${call.name}`;
         const sameClass = lookup
           .byName(qualifiedName)

src/domain/graph/builder/incremental.ts

@@ -516,6 +516,7 @@ function buildCallEdges(
       relPath,
       importedNames,
       typeMap,
+      caller.callerName,
     );
 
     for (const t of targets) {

src/domain/graph/builder/stages/native-orchestrator.ts

@@ -669,6 +669,51 @@ async function runPostNativePrototypeMethods(
 
   db.transaction(() => batchInsertNodes(db, newNodeRows))();
 
+  // ── Caller-only second pass (#1371) ──────────────────────────────────────
+  // `wasmResults` only covers `protoFiles` (definition files). A file that
+  // only *calls* a newly-inserted method (e.g. `f.method()`) was excluded from
+  // the pre-filter, so its call edges to the new nodes are silently dropped.
+  // After node insertion we know the method name suffixes; text-search the
+  // remaining JS/TS files and WASM-parse any that contain a matching call.
+  const newMethodSuffixes = new Set(
+    newDefs.map((d) => {
+      const dotIdx = d.name.indexOf('.');
+      return dotIdx !== -1 ? d.name.slice(dotIdx + 1) : d.name;
+    }),
+  );
+
+  let mergedWasmResults = wasmResults;
+  if (newMethodSuffixes.size > 0) {
+    // Pre-compile patterns once — avoids re-compiling up to newMethodSuffixes.size
+    // regexes on every file in the scan loop.
+    const suffixPatterns = [...newMethodSuffixes].map((m) => {
+      const escaped = m.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      return new RegExp(`\\.${escaped}\\s*\\(`);
+    });
+    const protoFileSet = new Set(protoFiles);
+    const callerCandidateAbs: string[] = [];
+    for (const relPath of jsFiles) {
+      if (protoFileSet.has(relPath)) continue; // already parsed in first pass
+      try {
+        const content = readFileSafe(path.join(rootDir, relPath));
+        const matchesAny = suffixPatterns.some((re) => re.test(content));
+        if (matchesAny) callerCandidateAbs.push(path.join(rootDir, relPath));
+      } catch {
+        /* skip unreadable files */
+      }
+    }
+    if (callerCandidateAbs.length > 0) {
+      try {
+        const callerWasmResults = await parseFilesWasmForBackfill(callerCandidateAbs, rootDir);
+        if (callerWasmResults.size > 0) {
+          mergedWasmResults = new Map([...wasmResults, ...callerWasmResults]);
+        }
+      } catch (e) {
+        debug(`runPostNativePrototypeMethods: caller-only WASM parse failed: ${toErrorMessage(e)}`);
+      }
+    }
+  }
+
   // Build a name → node lookup from all DB nodes (including newly inserted ones).
   type NodeEntry = { id: number; file: string; kind: string };
   const byNameMap = new Map<string, NodeEntry[]>();
@@ -716,14 +761,13 @@ async function runPostNativePrototypeMethods(
   // zero benefit and could OOM on large repositories.
   const seenByPair = new Set<string>();
 
-  // Resolve call edges in every file — not just those that define new func-prop
-  // methods. A caller in app.js calling a method defined in lib.js
-  // would be silently missed if we only scanned definition files.
-  // The newNodeIds guard inside the loop already prevents duplicate edges.
+  // Resolve call edges across all parsed files (definition files + caller-only
+  // files discovered in the second WASM pass above). The newNodeIds guard inside
+  // the loop prevents emitting duplicate edges for nodes the Rust engine already built.
   const newEdgeRows: unknown[][] = [];
   const fileNodeStmt = db.prepare(`SELECT id FROM nodes WHERE kind = 'file' AND file = ?`);
 
-  for (const [relPath, symbols] of wasmResults) {
+  for (const [relPath, symbols] of mergedWasmResults) {
     const fileNodeRow = fileNodeStmt.get(relPath) as { id: number } | undefined;
     if (!fileNodeRow) continue;
 
@@ -734,14 +778,32 @@ async function runPostNativePrototypeMethods(
 
       const caller = findCaller(lookup, call, symbols.definitions ?? [], relPath, fileNodeRow);
 
-      const targets = resolveByMethodOrGlobal(
+      let targets = resolveByMethodOrGlobal(
         lookup,
         call,
         relPath,
         typeMap as Map<string, unknown>,
         caller.callerName,
       );
 
+      // Direct receiver.method fallback: caller-only files often lack typeMap entries
+      // for the receiver (e.g. `f.process()` where `f` isn't declared in the file).
+      // Try qualified-name lookup scoped to newly-inserted nodes to avoid false positives.
+      // Note: `call.receiver` is always truthy here — the `if (!call.receiver) continue`
+      // guard above ensures we never reach this point with a falsy receiver.
+      if (
+        targets.length === 0 &&
+        call.receiver !== 'this' &&
+        call.receiver !== 'super' &&
+        call.receiver !== 'self'
+      ) {
+        const qualifiedName = `${call.receiver}.${call.name}`;
+        const direct = lookup
+          .byName(qualifiedName)
+          .filter((n) => n.kind === 'method' && newNodeIds.has(n.id));
+        if (direct.length > 0) targets = direct;
+      }
+
       for (const t of targets) {
         // Only emit edges to newly-inserted func-prop nodes to avoid
         // duplicating edges the Rust engine already built.

src/domain/graph/resolver/points-to.ts

@@ -185,11 +185,29 @@ export function buildPointsToMap(
   // `function f({ ...rest }) {}` + `f(obj)` + `const obj = { prop: fn }` →
   // seed pts["rest.prop"] = {"fn"} so that `rest.prop()` resolves to `fn`.
   if (objectRestParamBindings && objectPropBindings && paramBindings) {
+    // Index paramBindings: "callee::argIndex" → argName[] (O(|paramBindings|) build,
+    // O(1) lookup — avoids scanning paramBindings for each rest binding).
+    const paramByCalleeIdx = new Map<string, string[]>();
+    for (const { callee, argIndex, argName } of paramBindings) {
+      const k = `${callee}::${argIndex}`;
+      const list = paramByCalleeIdx.get(k);
+      if (list) list.push(argName);
+      else paramByCalleeIdx.set(k, [argName]);
+    }
+
+    // Index objectPropBindings: objectName → {propName, valueName}[]
+    const propsByObject = new Map<string, Array<{ propName: string; valueName: string }>>();
+    for (const { objectName, propName, valueName } of objectPropBindings) {
+      const list = propsByObject.get(objectName);
+      if (list) list.push({ propName, valueName });
+      else propsByObject.set(objectName, [{ propName, valueName }]);
+    }
+
     for (const { callee, restName, argIndex } of objectRestParamBindings) {
-      for (const { callee: pbCallee, argIndex: pbArgIdx, argName } of paramBindings) {
-        if (pbCallee !== callee || pbArgIdx !== argIndex) continue;
-        for (const { objectName, propName, valueName } of objectPropBindings) {
-          if (objectName !== argName) continue;
+      const argNames = paramByCalleeIdx.get(`${callee}::${argIndex}`) ?? [];
+      for (const argName of argNames) {
+        const props = propsByObject.get(argName) ?? [];
+        for (const { propName, valueName } of props) {
           if (!definitionNames.has(valueName) && !importedNames.has(valueName)) continue;
           const key = `${restName}.${propName}`;
           if (!pts.has(key)) pts.set(key, new Set());

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;
   }
 
@@ -2255,6 +2283,29 @@ function extractSpreadForOfWalk(
         funcStack.push(nameNode.text);
         pushedFunc = true;
       }
+    } else if (node.type === 'assignment_expression') {
+      // `obj.method = function() { ... }` — func-prop assignment.
+      // Mirror handleFuncPropAssignment's logic so for-of loops inside the
+      // body get the correct enclosingFunc (e.g. 'obj.method') instead of
+      // '<module>' or the wrong outer function name.
+      const lhs = node.childForFieldName('left');
+      const rhs = node.childForFieldName('right');
+      if (
+        lhs?.type === 'member_expression' &&
+        (rhs?.type === 'function_expression' || rhs?.type === 'arrow_function')
+      ) {
+        const obj = lhs.childForFieldName('object');
+        const prop = lhs.childForFieldName('property');
+        if (
+          obj?.type === 'identifier' &&
+          (prop?.type === 'property_identifier' || prop?.type === 'identifier') &&
+          !BUILTIN_GLOBALS.has(obj.text) &&
+          prop.text !== 'prototype'
+        ) {
+          funcStack.push(`${obj.text}.${prop.text}`);
+          pushedFunc = true;
+        }
+      }
     }
 
     if (node.type === 'call_expression') {

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();
+  }
+}