Fix method plugin hooks to use defining class fullname

method_fullname() now resolves the class where a method was defined via get_containing_type_info(), matching the documented plugin hook semantics (Base.method rather than Derived.method for inherited calls).

Fixes #19181

Author: itxsamad1

mypy/checkexpr.py

@@ -679,8 +679,8 @@ def check_str_format_call(self, e: CallExpr) -> None:
             self.strfrm_checker.check_str_format_call(e, format_value)
 
     def method_fullname(self, object_type: Type, method_name: str) -> str | None:
-        """Convert a method name to a fully qualified name, based on the type of the object that
-        it is invoked on. Return `None` if the name of `object_type` cannot be determined.
+        """Convert a method name to a fully qualified name, based on the class where the
+        method was defined. Return `None` if the name of `object_type` cannot be determined.
         """
         object_type = get_proper_type(object_type)
 
@@ -694,12 +694,15 @@ def method_fullname(self, object_type: Type, method_name: str) -> str | None:
 
         type_name = None
         if isinstance(object_type, Instance):
-            type_name = object_type.type.fullname
+            info = object_type.type.get_containing_type_info(method_name)
+            type_name = info.fullname if info is not None else object_type.type.fullname
         elif isinstance(object_type, (TypedDictType, LiteralType)):
             info = object_type.fallback.type.get_containing_type_info(method_name)
             type_name = info.fullname if info is not None else None
         elif isinstance(object_type, TupleType):
-            type_name = tuple_fallback(object_type).type.fullname
+            fallback = tuple_fallback(object_type)
+            info = fallback.type.get_containing_type_info(method_name)
+            type_name = info.fullname if info is not None else fallback.type.fullname
 
         if type_name:
             return f"{type_name}.{method_name}"

mypy/plugin.py

@@ -647,7 +647,7 @@ def get_method_signature_hook(
         may infer a better type for the method. The hook is also called for special
         Python dunder methods except __init__ and __new__ (use get_function_hook to customize
         class instantiation). This function is called with the method full name using
-        the class of the object on which the method is called. For example, in this code:
+        the class where it was _defined_. For example, in this code:
 
             from lib import Special
 
@@ -663,7 +663,7 @@ class Derived(Base):
             x: Special
             y = x[0]
 
-        this method is called with '__main__.Derived.method', and then with
+        this method is called with '__main__.Base.method', and then with
         'lib.Special.__getitem__'.
         """
         return None
@@ -672,7 +672,7 @@ def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | No
         """Adjust return type of a method call.
 
         This is the same as get_function_hook(), but is called with the
-        method full name (using the class of the object on which the method is called).
+        method full name (again, using the class where the method is defined).
         """
         return None
 

test-data/unit/check-custom-plugin.test

@@ -602,6 +602,22 @@ plugins=<ROOT>/test-data/unit/plugins/fully_qualified_test_hook.py
 [builtins fixtures/classmethod.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
+[case testMethodSignatureHookUsesDefiningClass]
+# flags: --config-file tmp/mypy.ini
+from typing import Any
+
+class Base:
+    def method(self, arg: Any) -> Any: ...
+
+class Derived(Base): ...
+
+var: Derived
+reveal_type(var.method(42))  # N: Revealed type is "builtins.int"
+
+[file mypy.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/method_hook_defining_class.py
+
 [case testDynamicClassPlugin]
 # flags: --config-file tmp/mypy.ini
 from mod import declarative_base, Column, Instr

test-data/unit/plugins/arg_names.py

@@ -26,8 +26,8 @@ def get_method_hook(self, fullname: str) -> Callable[[MethodContext], Type] | No
             "mod.Class.mystaticmethod",
             "mod.ClassUnfilled.method",
             "mod.ClassStarExpr.method",
-            "mod.ClassChild.method",
-            "mod.ClassChild.myclassmethod",
+            "mod.Base.method",
+            "mod.Base.myclassmethod",
         }:
             return extract_classname_and_set_as_return_type_method
         return None

test-data/unit/plugins/method_hook_defining_class.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from mypy.plugin import MethodSigContext, Plugin
+from mypy.types import CallableType
+
+
+class DefiningClassPlugin(Plugin):
+    def get_method_signature_hook(
+        self, fullname: str
+    ) -> Callable[[MethodSigContext], CallableType] | None:
+        if fullname == "__main__.Base.method":
+            return defining_class_hook
+        return None
+
+
+def defining_class_hook(ctx: MethodSigContext) -> CallableType:
+    return ctx.default_signature.copy_modified(
+        ret_type=ctx.api.named_generic_type("builtins.int", [])
+    )
+
+
+def plugin(version: str) -> type[DefiningClassPlugin]:
+    return DefiningClassPlugin