fix(js): bind this calls to the caller's own class

this.save() in one JS/TS class was resolved through the file-wide name
map, which keeps only the last definition of each name, so a class that
calls this.save() was wired to the save() of whichever class the file
declared last, as EXTRACTED. In zod's v3 types.ts every ZodString,
ZodNumber and ZodBigInt check method landed on ZodDate._addCheck.

Route this.m() and super.m() through the self-call lookup the Python
fix added, renamed _self_call_target. It binds to the caller's own
class when that class defines m(). JS/TS extends edges are only emitted
by the later symbol pass, so the base chain is unknown at this point;
anything the own class does not define keeps the plain lookup, which
leaves inherited this.m() edges exactly as they were.

Author: Cintu07

graphify/extractors/engine.py

@@ -1356,7 +1356,12 @@ def _python_collect_assignment_targets(node, source: bytes, out: set[str]) -> No
         for c in node.children:
             _python_collect_assignment_targets(c, source, out)
 
-def _python_self_call_target(
+# Languages whose `self`/`this` member calls bind through _self_call_target.
+_SELF_CALL_LANGUAGES = frozenset({
+    "tree_sitter_python", "tree_sitter_javascript", "tree_sitter_typescript",
+})
+
+def _self_call_target(
     caller_nid: str,
     callee: str,
     receiver: str,
@@ -1365,8 +1370,14 @@ def _python_self_call_target(
     method_owner: dict[str, str],
     methods_by_owner: dict[tuple[str, str], str],
     class_bases: dict[str, list[str]],
+    walk_bases: bool = True,
 ) -> str | None:
-    """In-file target of `self.m()`, `cls.m()` or `super().m()`, else None.
+    """In-file target of `self.m()` / `cls.m()` / `super().m()` in Python and
+    `this.m()` / `super.m()` in JS/TS, else None.
+
+    ``walk_bases=False`` stops after the caller's own class and otherwise keeps
+    the plain lookup: JS/TS `extends` edges come from the later symbol pass, so
+    the chain is unknown here and an inherited `this.m()` must not be refused.
 
     The receiver is the caller's own instance, so the lookup starts at the
     enclosing class (skipped for `super`) and walks its in-file bases one level
@@ -1393,6 +1404,8 @@ class to whichever class declared save() last. A file-wide hit that is not
             hits = {methods_by_owner[(c, callee)] for c in level if (c, callee) in methods_by_owner}
             if hits:
                 return hits.pop() if len(hits) == 1 else None
+        if not walk_bases:
+            return fallback
         skip_own = False
         level = list(dict.fromkeys(
             base for c in level for base in class_bases.get(c, ()) if base not in seen
@@ -6215,10 +6228,11 @@ def scala_base_name(type_node) -> str | None:
         if _e.get("relation") == "inherits":
             _local_bases.setdefault(_e["source"], []).append(_e["target"])
 
-    # Class membership for Python self-calls (see _python_self_call_target).
+    # Class membership for self-calls (see _self_call_target): Python
+    # self/cls/super and JS/TS this/super.
     method_owner: dict[str, str] = {}
     methods_by_owner: dict[tuple[str, str], str] = {}
-    if config.ts_module == "tree_sitter_python":
+    if config.ts_module in _SELF_CALL_LANGUAGES:
         label_by_nid = {n["id"]: n["label"] for n in nodes}
         for e in edges:
             if e["relation"] == "method":
@@ -6507,6 +6521,9 @@ def walk_calls(
             callee_name: str | None = None
             is_member_call: bool = False
             is_this_field_call: bool = False
+            # JS/TS `this.m()` / `super.m()`: kept apart from member_receiver,
+            # which feeds the receiver-typed resolvers and raw_calls.
+            self_receiver: str | None = None
             swift_receiver: str | None = None
             member_receiver: str | None = None
             kotlin_qualified_prefix: str | None = None
@@ -6892,6 +6909,12 @@ def walk_calls(
                             obj = func_node.child_by_field_name(config.call_accessor_object_field)
                             if obj is not None and obj.type == "identifier":
                                 member_receiver = _read_text(obj, source)
+                            elif (
+                                obj is not None
+                                and obj.type in ("this", "super")
+                                and config.ts_module in _SELF_CALL_LANGUAGES
+                            ):
+                                self_receiver = obj.type
                             elif (
                                 config.ts_module == "tree_sitter_python"
                                 and obj is not None
@@ -7017,14 +7040,14 @@ def walk_calls(
                             curr_scope = scope_parents.get(curr_scope)
                         if not tgt_nid:
                             tgt_nid = label_to_nid.get(callee_name)
-                    elif (
+                    elif is_member_call and (self_receiver or (
                         config.ts_module == "tree_sitter_python"
-                        and is_member_call
                         and member_receiver in ("self", "cls", "super")
-                    ):
-                        tgt_nid = _python_self_call_target(
-                            caller_nid, callee_name, member_receiver, label_to_nid,
-                            scope_parents, method_owner, methods_by_owner, _local_bases,
+                    )):
+                        tgt_nid = _self_call_target(
+                            caller_nid, callee_name, self_receiver or member_receiver or "",
+                            label_to_nid, scope_parents, method_owner, methods_by_owner,
+                            _local_bases, walk_bases=self_receiver is None,
                         )
                     else:
                         tgt_nid = label_to_nid.get(callee_name)

tests/test_extract.py

@@ -2234,6 +2234,50 @@ def test_python_self_call_to_stored_module_function_still_binds(tmp_path):
     assert ("svc_job_run", "svc_handler") in calls
 
 
+def _js_call_pairs(tmp_path, source, ext):
+    """Extract one JS/TS file and return {(caller_id, callee_id)} for calls edges."""
+    f = tmp_path / f"svc.{ext}"
+    f.write_text(source, encoding="utf-8")
+    result = extract([f], cache_root=tmp_path)
+    return {(e["source"], e["target"]) for e in result["edges"] if e["relation"] == "calls"}
+
+
+@pytest.mark.parametrize("ext", ["ts", "js"])
+def test_js_this_call_binds_to_own_class_not_last_declared(tmp_path, ext):
+    """`this.save()` in Server must reach Server.save, not the save() of a class
+    declared later in the file. An arrow function keeps the method's `this`."""
+    calls = _js_call_pairs(tmp_path, (
+        "class Server {\n"
+        "  save() { return 1; }\n"
+        "  flush() { return this.save(); }\n"
+        "  later() { return [1].map(() => this.save()); }\n"
+        "}\n"
+        "class Cache {\n"
+        "  save() { return 2; }\n"
+        "  flush() { return this.save(); }\n"
+        "}\n"
+    ), ext)
+    assert ("svc_server_flush", "svc_server_save") in calls
+    assert ("svc_server_flush", "svc_cache_save") not in calls
+    assert ("svc_server_later", "svc_server_save") in calls
+    assert ("svc_cache_flush", "svc_cache_save") in calls
+
+
+@pytest.mark.parametrize("ext", ["ts", "js"])
+def test_js_this_call_to_inherited_method_keeps_its_edge(tmp_path, ext):
+    """`extends` is only known after the symbol pass, so a method the class does
+    not define itself keeps the plain lookup instead of being refused."""
+    calls = _js_call_pairs(tmp_path, (
+        "class Base {\n"
+        "  ping() { return 0; }\n"
+        "}\n"
+        "class Server extends Base {\n"
+        "  run() { return this.ping(); }\n"
+        "}\n"
+    ), ext)
+    assert ("svc_server_run", "svc_base_ping") in calls
+
+
 def test_python_qualified_call_ambiguous_class_bails(tmp_path):
     """When the class name is defined in 2+ files, the qualified call must not
     resolve — single-definition god-node guard (#1446)."""