feat(resolver): resolve prototype-based method calls, spread/iteration callbacks, func-prop this-dispatch, and object-rest param dispatch (JS)

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

@@ -81,6 +81,33 @@ export function resolveByMethodOrGlobal(
     if (typeName) {
       const typed = lookup.byName(`${typeName}.${call.name}`).filter((n) => n.kind === 'method');
       if (typed.length > 0) return typed;
+      // Prototype alias: `Foo.prototype.bar = fn` seeds typeMap['Foo.bar'] = { type: 'fn' }
+      const protoAlias = (typeMap.get(`${typeName}.${call.name}`) as { type?: string } | undefined)
+        ?.type;
+      if (protoAlias) {
+        const resolved = lookup
+          .byName(protoAlias)
+          .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+        if (resolved.length > 0) return resolved;
+      }
+    }
+    // Inline new-expression receiver: `(new Foo).bar()` — extract class name for type lookup
+    if (!typeName && call.receiver) {
+      const m = /^\(?\s*new\s+([A-Z_$][A-Za-z0-9_$]*)/.exec(call.receiver);
+      if (m?.[1]) {
+        const inlineType = m[1];
+        const typed = lookup.byName(`${inlineType}.${call.name}`).filter((n) => n.kind === 'method');
+        if (typed.length > 0) return typed;
+        const protoAlias = (
+          typeMap.get(`${inlineType}.${call.name}`) as { type?: string } | undefined
+        )?.type;
+        if (protoAlias) {
+          const resolved = lookup
+            .byName(protoAlias)
+            .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
+          if (resolved.length > 0) return resolved;
+        }
+      }
     }
     // Phase 8.3d: composite pts key — `obj.prop = fn` seeds typeMap['obj.prop'] = { type: 'fn' }.
     // When a call site references `obj.prop` as a callback, resolve directly to the target fn.

src/extractors/javascript.ts

@@ -351,6 +351,9 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
   // Extract definitions from destructured bindings (query patterns don't match object_pattern)
   extractDestructuredBindingsWalk(tree.rootNode, definitions);
 
+  // Pre-ES6 prototype methods: `Foo.prototype.bar = fn` and `Foo.prototype = { bar: fn }`
+  extractPrototypeMethodsWalk(tree.rootNode, definitions, typeMap);
+
   // Phase 8.5: collect all `new X()` constructor names for RTA instantiation tracking
   const newExpressions: string[] = [];
   extractNewExpressionsWalk(tree.rootNode, newExpressions);
@@ -614,6 +617,8 @@ function extractSymbolsWalk(tree: TreeSitterTree): ExtractorOutput {
   );
   // Phase 8.3c: Extract call-site argument bindings for parameter-flow pts analysis
   extractParamBindingsWalk(tree.rootNode, ctx.paramBindings!);
+  // Pre-ES6 prototype methods: `Foo.prototype.bar = fn` and `Foo.prototype = { bar: fn }`
+  extractPrototypeMethodsWalk(tree.rootNode, ctx.definitions, ctx.typeMap!);
   // Phase 8.5: collect all `new X()` constructor names for RTA instantiation tracking
   const newExpressions: string[] = [];
   extractNewExpressionsWalk(tree.rootNode, newExpressions);
@@ -1397,6 +1402,124 @@ function extractNewExpressionsWalk(rootNode: TreeSitterNode, newExpressions: str
   walk(rootNode, 0);
 }
 
+/** AST node types that represent a function body (used by prototype extraction). */
+const PROTO_FN_TYPES = new Set([
+  'function_expression',
+  'arrow_function',
+  'generator_function',
+]);
+
+/**
+ * Walk the AST collecting pre-ES6 prototype assignments:
+ *   Foo.prototype.bar = function() {}   → definition Foo.bar (kind: method)
+ *   Foo.prototype.bar = f               → typeMap['Foo.bar'] = { type: 'f', confidence: 0.9 }
+ *   Foo.prototype = { bar: fn, baz: f } → same rules per property
+ */
+function extractPrototypeMethodsWalk(
+  rootNode: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  function walk(node: TreeSitterNode, depth: number): void {
+    if (depth >= MAX_WALK_DEPTH) return;
+    if (node.type === 'expression_statement') {
+      const expr = node.child(0);
+      if (expr?.type === 'assignment_expression') handlePrototypeAssignment(expr, definitions, typeMap);
+      // Don't recurse inside expression_statement — no nested prototype assignments expected
+      return;
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      walk(node.child(i)!, depth + 1);
+    }
+  }
+  walk(rootNode, 0);
+}
+
+function handlePrototypeAssignment(
+  assignNode: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  const lhs = assignNode.childForFieldName('left');
+  const rhs = assignNode.childForFieldName('right');
+  if (!lhs || !rhs || lhs.type !== 'member_expression') return;
+
+  const lhsProp = lhs.childForFieldName('property');
+  const lhsObj = lhs.childForFieldName('object');
+  if (!lhsProp || !lhsObj) return;
+
+  // Pattern 1: Foo.prototype.bar = rhs
+  if (lhsObj.type === 'member_expression') {
+    const innerProp = lhsObj.childForFieldName('property');
+    const innerObj = lhsObj.childForFieldName('object');
+    if (
+      innerProp?.text === 'prototype' &&
+      innerObj?.type === 'identifier' &&
+      !BUILTIN_GLOBALS.has(innerObj.text)
+    ) {
+      emitPrototypeMethod(innerObj.text, lhsProp.text, rhs, definitions, typeMap);
+    }
+    return;
+  }
+
+  // Pattern 2: Foo.prototype = { ... }
+  if (
+    lhsProp.text === 'prototype' &&
+    lhsObj.type === 'identifier' &&
+    !BUILTIN_GLOBALS.has(lhsObj.text) &&
+    (rhs.type === 'object' || rhs.type === 'object_expression')
+  ) {
+    extractPrototypeObjectLiteral(lhsObj.text, rhs, definitions, typeMap);
+  }
+}
+
+function emitPrototypeMethod(
+  className: string,
+  methodName: string,
+  rhs: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  const qualifiedName = `${className}.${methodName}`;
+  if (PROTO_FN_TYPES.has(rhs.type)) {
+    definitions.push({
+      name: qualifiedName,
+      kind: 'method',
+      line: nodeStartLine(rhs),
+      endLine: nodeEndLine(rhs),
+    });
+  } else if (rhs.type === 'identifier' && !BUILTIN_GLOBALS.has(rhs.text)) {
+    setTypeMapEntry(typeMap, qualifiedName, rhs.text, 0.9);
+  }
+}
+
+function extractPrototypeObjectLiteral(
+  className: string,
+  objNode: TreeSitterNode,
+  definitions: Definition[],
+  typeMap: Map<string, TypeMapEntry>,
+): void {
+  for (let i = 0; i < objNode.childCount; i++) {
+    const child = objNode.child(i);
+    if (!child) continue;
+    if (child.type === 'pair') {
+      const key = child.childForFieldName('key');
+      const value = child.childForFieldName('value');
+      if (key && value) emitPrototypeMethod(className, key.text, value, definitions, typeMap);
+    } else if (child.type === 'method_definition') {
+      const nameNode = child.childForFieldName('name');
+      if (nameNode) {
+        definitions.push({
+          name: `${className}.${nameNode.text}`,
+          kind: 'method',
+          line: nodeStartLine(child),
+          endLine: nodeEndLine(child),
+        });
+      }
+    }
+  }
+}
+
 /**
  * Extract variable-to-type assignments into a per-file type map.
  *

tests/parsers/javascript.test.ts

@@ -734,4 +734,72 @@ describe('JavaScript parser', () => {
       expect(def.endLine).toBe(4);
     });
   });
+
+  describe('prototype method extraction', () => {
+    it('extracts Foo.prototype.bar = function() {} as a method definition', () => {
+      const symbols = parseJS(`
+        function C() {}
+        C.prototype.foo = function() {}
+      `);
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: 'C.foo', kind: 'method' }),
+      );
+    });
+
+    it('extracts Foo.prototype.bar = arrow as a method definition', () => {
+      const symbols = parseJS(`
+        function C() {}
+        C.prototype.greet = () => 'hello';
+      `);
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: 'C.greet', kind: 'method' }),
+      );
+    });
+
+    it('seeds typeMap for Foo.prototype.bar = identifier with confidence 0.9', () => {
+      const symbols = parseJS(`
+        const f = () => {};
+        class A {}
+        A.prototype.t = f;
+      `);
+      expect(symbols.typeMap.get('A.t')).toEqual({ type: 'f', confidence: 0.9 });
+    });
+
+    it('extracts methods from Foo.prototype = { bar: fn } object literal', () => {
+      const symbols = parseJS(`
+        function C() {}
+        C.prototype = {
+          foo: function() {},
+          baz: function() {},
+        };
+      `);
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: 'C.foo', kind: 'method' }),
+      );
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: 'C.baz', kind: 'method' }),
+      );
+    });
+
+    it('seeds typeMap for identifier values in object literal prototype assignment', () => {
+      const symbols = parseJS(`
+        function helper() {}
+        function C() {}
+        C.prototype = { run: helper };
+      `);
+      expect(symbols.typeMap.get('C.run')).toEqual({ type: 'helper', confidence: 0.9 });
+    });
+
+    it('does not extract prototype assignments on built-in globals', () => {
+      const symbols = parseJS(`Array.prototype.last = function() { return this[this.length - 1]; };`);
+      expect(symbols.definitions).not.toContainEqual(
+        expect.objectContaining({ name: 'Array.last' }),
+      );
+    });
+
+    it('does not seed typeMap for prototype identifier assignment from built-in globals', () => {
+      const symbols = parseJS(`Object.prototype.clone = myClone;`);
+      expect(symbols.typeMap.has('Object.clone')).toBe(false);
+    });
+  });
 });