[ty] Use partially qualified names when reporting diagnostics regarding bad calls to methods (#24560)

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/annotations/self.md

@@ -181,7 +181,7 @@ Calling an instance method explicitly verifies the first argument:
 ```py
 A.implicit_self(a)
 
-# error: [invalid-argument-type] "Argument to function `implicit_self` is incorrect: Argument type `Literal[1]` does not satisfy upper bound `A` of type variable `Self`"
+# error: [invalid-argument-type] "Argument to function `A.implicit_self` is incorrect: Argument type `Literal[1]` does not satisfy upper bound `A` of type variable `Self`"
 A.implicit_self(1)
 ```
 
@@ -193,7 +193,7 @@ from typing import Never, Callable
 class Strange:
     def can_not_be_called(self: Never) -> None: ...
 
-# error: [invalid-argument-type] "Argument to bound method `can_not_be_called` is incorrect: Expected `Never`, found `Strange`"
+# error: [invalid-argument-type] "Argument to bound method `Strange.can_not_be_called` is incorrect: Expected `Never`, found `Strange`"
 Strange().can_not_be_called()
 ```
 
@@ -1065,7 +1065,7 @@ class Explicit:
     def forward(self: Explicit) -> None:
         reveal_type(self)  # revealed: Explicit
 
-# error: [invalid-argument-type] "Argument to bound method `bad` is incorrect: Expected `Disjoint`, found `Explicit`"
+# error: [invalid-argument-type] "Argument to bound method `Explicit.bad` is incorrect: Expected `Disjoint`, found `Explicit`"
 Explicit().bad()
 
 Explicit().forward()

crates/ty_python_semantic/resources/mdtest/bidirectional.md

@@ -443,7 +443,7 @@ class A:
 
 A(f(1))
 
-# error: [invalid-argument-type] "Argument to function `__new__` is incorrect: Expected `list[int | str]`, found `list[list[Unknown]]`"
+# error: [invalid-argument-type] "Argument to constructor `A.__new__` is incorrect: Expected `list[int | str]`, found `list[list[Unknown]]`"
 A(f([]))
 ```
 

crates/ty_python_semantic/resources/mdtest/call/callable_instance.md

@@ -85,7 +85,7 @@ class C:
 
 c = C()
 
-# error: 15 [invalid-argument-type] "Argument to bound method `__call__` is incorrect: Expected `int`, found `Literal["foo"]`"
+# error: 15 [invalid-argument-type] "Argument to bound method `C.__call__` is incorrect: Expected `int`, found `Literal["foo"]`"
 reveal_type(c("foo"))  # revealed: int
 ```
 
@@ -99,7 +99,7 @@ class C:
 
 c = C()
 
-# error: 13 [invalid-argument-type] "Argument to bound method `__call__` is incorrect: Expected `int`, found `C`"
+# error: 13 [invalid-argument-type] "Argument to bound method `C.__call__` is incorrect: Expected `int`, found `C`"
 reveal_type(c())  # revealed: int
 ```
 

crates/ty_python_semantic/resources/mdtest/call/constructor.md

@@ -42,7 +42,7 @@ class Foo: ...
 
 reveal_type(Foo())  # revealed: Foo
 
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
+# error: [too-many-positional-arguments] "Too many positional arguments to `object.__init__`: expected 1, got 2"
 reveal_type(Foo(1))  # revealed: Foo
 ```
 
@@ -55,11 +55,11 @@ class Foo:
 
 reveal_type(Foo(1))  # revealed: Foo
 
-# error: [invalid-argument-type] "Argument to function `__new__` is incorrect: Expected `int`, found `Literal["x"]`"
+# error: [invalid-argument-type] "Argument to constructor `Foo.__new__` is incorrect: Expected `int`, found `Literal["x"]`"
 reveal_type(Foo("x"))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of constructor `Foo.__new__`"
 reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 2, got 3"
+# error: [too-many-positional-arguments] "Too many positional arguments to constructor `Foo.__new__`: expected 2, got 3"
 reveal_type(Foo(1, 2))  # revealed: Foo
 ```
 
@@ -79,9 +79,9 @@ class Foo(Base): ...
 
 reveal_type(Foo(1))  # revealed: Foo
 
-# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of constructor `Base.__new__`"
 reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 2, got 3"
+# error: [too-many-positional-arguments] "Too many positional arguments to constructor `Base.__new__`: expected 2, got 3"
 reveal_type(Foo(1, 2))  # revealed: Foo
 ```
 
@@ -98,7 +98,7 @@ class Foo:
 reveal_type(Foo(1))  # revealed: Foo
 
 Foo(1)
-# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 2, got 3"
+# error: [too-many-positional-arguments] "Too many positional arguments to constructor `Foo.__new__`: expected 2, got 3"
 Foo(1, 2)
 ```
 
@@ -114,13 +114,13 @@ def _(flag: bool) -> None:
             def __new__(cls, x: int, y: int = 1): ...
 
     reveal_type(Foo(1))  # revealed: Foo
-    # error: [invalid-argument-type] "Argument to function `__new__` is incorrect: Expected `int`, found `Literal["1"]`"
-    # error: [invalid-argument-type] "Argument to function `__new__` is incorrect: Expected `int`, found `Literal["1"]`"
+    # error: [invalid-argument-type] "Argument to constructor `Foo.__new__` is incorrect: Expected `int`, found `Literal["1"]`"
+    # error: [invalid-argument-type] "Argument to constructor `Foo.__new__` is incorrect: Expected `int`, found `Literal["1"]`"
     reveal_type(Foo("1"))  # revealed: Foo
-    # error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
-    # error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
+    # error: [missing-argument] "No argument provided for required parameter `x` of constructor `Foo.__new__`"
+    # error: [missing-argument] "No argument provided for required parameter `x` of constructor `Foo.__new__`"
     reveal_type(Foo())  # revealed: Foo
-    # error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 2, got 3"
+    # error: [too-many-positional-arguments] "Too many positional arguments to constructor `Foo.__new__`: expected 2, got 3"
     reveal_type(Foo(1, 2))  # revealed: Foo
 ```
 
@@ -141,7 +141,7 @@ class Foo:
     __new__: Descriptor = Descriptor()
 
 reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of bound method `SomeCallable.__call__`"
 reveal_type(Foo())  # revealed: Foo
 ```
 
@@ -166,8 +166,8 @@ class Foo:
     def __new__(cls, x: int):
         return object.__new__(cls)
 
-# error: [invalid-argument-type] "Argument to bound method `__new__` is incorrect: Expected `int`, found `<class 'Foo'>`"
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__new__`: expected 1, got 2"
+# error: [invalid-argument-type] "Argument to bound method `Foo.__new__` is incorrect: Expected `int`, found `<class 'Foo'>`"
+# error: [too-many-positional-arguments] "Too many positional arguments to bound method `Foo.__new__`: expected 1, got 2"
 Foo(1)
 ```
 
@@ -184,7 +184,7 @@ class Foo:
     __new__ = Callable()
 
 reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of bound method `Callable.__call__`"
 reveal_type(Foo())  # revealed: Foo
 ```
 
@@ -237,9 +237,9 @@ class Foo:
 
 reveal_type(Foo(1))  # revealed: Foo
 
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of `Foo.__init__`"
 reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 2, got 3"
+# error: [too-many-positional-arguments] "Too many positional arguments to `Foo.__init__`: expected 2, got 3"
 reveal_type(Foo(1, 2))  # revealed: Foo
 ```
 
@@ -1163,9 +1163,9 @@ class C:
 T = TypeVar("T", bound=C)
 
 def f(cls: type[T]):
-    # error: [missing-argument] "No argument provided for required parameter `y` of function `__new__`"
+    # error: [missing-argument] "No argument provided for required parameter `y` of constructor `C.__new__`"
     cls(1)
-    # error: [invalid-argument-type] "Argument to function `__new__` is incorrect: Expected `str`, found `Literal[2]`"
+    # error: [invalid-argument-type] "Argument to constructor `C.__new__` is incorrect: Expected `str`, found `Literal[2]`"
     cls(1, 2)
     reveal_type(cls(1, "foo"))  # revealed: T@f
 ```
@@ -1199,9 +1199,9 @@ class Foo(Base): ...
 
 reveal_type(Foo(1))  # revealed: Foo
 
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of `Base.__init__`"
 reveal_type(Foo())  # revealed: Foo
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 2, got 3"
+# error: [too-many-positional-arguments] "Too many positional arguments to `Base.__init__`: expected 2, got 3"
 reveal_type(Foo(1, 2))  # revealed: Foo
 ```
 
@@ -1217,13 +1217,13 @@ def _(flag: bool) -> None:
             def __init__(self, x: int, y: int = 1): ...
 
     reveal_type(Foo(1))  # revealed: Foo
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `int`, found `Literal["1"]`"
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `int`, found `Literal["1"]`"
+    # error: [invalid-argument-type] "Argument to `Foo.__init__` is incorrect: Expected `int`, found `Literal["1"]`"
+    # error: [invalid-argument-type] "Argument to `Foo.__init__` is incorrect: Expected `int`, found `Literal["1"]`"
     reveal_type(Foo("1"))  # revealed: Foo
-    # error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
-    # error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+    # error: [missing-argument] "No argument provided for required parameter `x` of `Foo.__init__`"
+    # error: [missing-argument] "No argument provided for required parameter `x` of `Foo.__init__`"
     reveal_type(Foo())  # revealed: Foo
-    # error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 2, got 3"
+    # error: [too-many-positional-arguments] "Too many positional arguments to `Foo.__init__`: expected 2, got 3"
     reveal_type(Foo(1, 2))  # revealed: Foo
 ```
 
@@ -1246,7 +1246,7 @@ class Foo:
     __init__: Descriptor = Descriptor()
 
 reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of bound method `SomeCallable.__call__`"
 reveal_type(Foo())  # revealed: Foo
 ```
 
@@ -1263,7 +1263,7 @@ class Foo:
     __init__ = Callable()
 
 reveal_type(Foo(1))  # revealed: Foo
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__call__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of bound method `Callable.__call__`"
 reveal_type(Foo())  # revealed: Foo
 ```
 
@@ -1302,11 +1302,11 @@ class Foo:
     def __init__(self, x: int) -> None:
         self.x = x
 
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of `Foo.__init__`"
 reveal_type(Foo())  # revealed: Foo
 reveal_type(Foo(1))  # revealed: Foo
 
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 2, got 3"
+# error: [too-many-positional-arguments] "Too many positional arguments to `Foo.__init__`: expected 2, got 3"
 reveal_type(Foo(1, 2))  # revealed: Foo
 ```
 
@@ -1320,10 +1320,10 @@ class Foo:
     def __init__(self, x: str) -> None:
         self.x = x
 
-# error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `str`, found `Literal[1]`"
+# error: [invalid-argument-type] "Argument to `Foo.__init__` is incorrect: Expected `str`, found `Literal[1]`"
 Foo(1)
 
-# error: [invalid-argument-type] "Argument to function `__new__` is incorrect: Expected `int`, found `Literal["x"]`"
+# error: [invalid-argument-type] "Argument to constructor `Foo.__new__` is incorrect: Expected `int`, found `Literal["x"]`"
 Foo("x")
 ```
 
@@ -1339,10 +1339,10 @@ class Foo:
     def __init__(self, x):
         self.x = 42
 
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of `Foo.__init__`"
 reveal_type(Foo())  # revealed: Foo
 
-# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 1, got 2"
+# error: [too-many-positional-arguments] "Too many positional arguments to constructor `Foo.__new__`: expected 1, got 2"
 reveal_type(Foo(42))  # revealed: Foo
 
 class Foo2:
@@ -1352,10 +1352,10 @@ class Foo2:
     def __init__(self):
         pass
 
-# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of constructor `Foo2.__new__`"
 reveal_type(Foo2())  # revealed: Foo2
 
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
+# error: [too-many-positional-arguments] "Too many positional arguments to `Foo2.__init__`: expected 1, got 2"
 reveal_type(Foo2(42))  # revealed: Foo2
 
 class Foo3(metaclass=abc.ABCMeta):
@@ -1365,10 +1365,10 @@ class Foo3(metaclass=abc.ABCMeta):
     def __init__(self, x):
         self.x = 42
 
-# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of `Foo3.__init__`"
 reveal_type(Foo3())  # revealed: Foo3
 
-# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 1, got 2"
+# error: [too-many-positional-arguments] "Too many positional arguments to constructor `Foo3.__new__`: expected 1, got 2"
 reveal_type(Foo3(42))  # revealed: Foo3
 
 class Foo4(metaclass=abc.ABCMeta):
@@ -1378,10 +1378,10 @@ class Foo4(metaclass=abc.ABCMeta):
     def __init__(self):
         pass
 
-# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
+# error: [missing-argument] "No argument provided for required parameter `x` of constructor `Foo4.__new__`"
 reveal_type(Foo4())  # revealed: Foo4
 
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
+# error: [too-many-positional-arguments] "Too many positional arguments to `Foo4.__init__`: expected 1, got 2"
 reveal_type(Foo4(42))  # revealed: Foo4
 ```
 

crates/ty_python_semantic/resources/mdtest/call/methods.md

@@ -70,7 +70,7 @@ reveal_type(bound_method(1))  # revealed: str
 When we call the function object itself, we need to pass the `instance` explicitly:
 
 ```py
-# error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `C`, found `Literal[1]`"
+# error: [invalid-argument-type] "Argument to function `C.f` is incorrect: Expected `C`, found `Literal[1]`"
 # error: [missing-argument]
 C.f(1)
 
@@ -399,7 +399,7 @@ class D:
         # This function is wrongly annotated, it should be `type[D]` instead of `D`
         pass
 
-# error: [invalid-argument-type] "Argument to bound method `f` is incorrect: Expected `D`, found `<class 'D'>`"
+# error: [invalid-argument-type] "Argument to bound method `D.f` is incorrect: Expected `D`, found `<class 'D'>`"
 D.f()
 ```
 

crates/ty_python_semantic/resources/mdtest/call/subclass_of.md

@@ -20,11 +20,11 @@ class C:
 def _(subclass_of_c: type[C]):
     reveal_type(subclass_of_c(1))  # revealed: C
 
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `int`, found `Literal["a"]`"
+    # error: [invalid-argument-type] "Argument to `C.__init__` is incorrect: Expected `int`, found `Literal["a"]`"
     reveal_type(subclass_of_c("a"))  # revealed: C
-    # error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+    # error: [missing-argument] "No argument provided for required parameter `x` of `C.__init__`"
     reveal_type(subclass_of_c())  # revealed: C
-    # error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 2, got 3"
+    # error: [too-many-positional-arguments] "Too many positional arguments to `C.__init__`: expected 2, got 3"
     reveal_type(subclass_of_c(1, 2))  # revealed: C
 ```
 

crates/ty_python_semantic/resources/mdtest/call/union.md

@@ -113,7 +113,7 @@ class B:
 
 def _(flag: bool):
     cls = A if flag else B
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `str`, found `Literal[1]`"
+    # error: [invalid-argument-type] "Argument to `B.__init__` is incorrect: Expected `str`, found `Literal[1]`"
     reveal_type(cls(1))  # revealed: A | B
 ```
 
@@ -129,8 +129,8 @@ class B:
     def __init__(self, x: int) -> None: ...
 
 def _(factory: type[A] | type[B]):
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `int`, found `Literal["hello"]`"
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `int`, found `Literal["hello"]`"
+    # error: [invalid-argument-type] "Argument to `A.__init__` is incorrect: Expected `int`, found `Literal["hello"]`"
+    # error: [invalid-argument-type] "Argument to `B.__init__` is incorrect: Expected `int`, found `Literal["hello"]`"
     factory("hello")
 ```
 
@@ -155,8 +155,8 @@ class IntDiag(DeferredDiagBase[int]): ...
 class StrDiag(DeferredDiagBase[str]): ...
 
 def _(factory: type[IntDiag] | type[StrDiag]):
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `int`, found `float`"
-    # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `str`, found `float`"
+    # error: [invalid-argument-type] "Argument to `DeferredDiagBase.__init__` is incorrect: Expected `int`, found `float`"
+    # error: [invalid-argument-type] "Argument to `DeferredDiagBase.__init__` is incorrect: Expected `str`, found `float`"
     factory(1.2)
 ```
 

crates/ty_python_semantic/resources/mdtest/class/super.md

@@ -783,7 +783,7 @@ class Parent:
 
 class Child(Parent):
     def __init__(self, children: Mapping[str, Child] | None = None) -> None:
-        # error: [invalid-argument-type] "Argument to bound method `__init__` is incorrect: Expected `Mapping[str, Self@__init__] | None`, found `Mapping[str, Child] | None`"
+        # error: [invalid-argument-type] "Argument to `Parent.__init__` is incorrect: Expected `Mapping[str, Self@__init__] | None`, found `Mapping[str, Child] | None`"
         super().__init__(children)
 
 # The fix is to use `Self` consistently in the subclass:

crates/ty_python_semantic/resources/mdtest/decorators.md

@@ -273,7 +273,7 @@ emit an error:
 ```py
 class NoInit: ...
 
-# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
+# error: [too-many-positional-arguments] "Too many positional arguments to `object.__init__`: expected 1, got 2"
 @NoInit
 def foo(): ...
 
@@ -342,7 +342,7 @@ Using `type[SomeClass]` as a decorator validates against the class's constructor
 class Base: ...
 
 def apply_decorator(cls: type[Base]) -> None:
-    # error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
+    # error: [too-many-positional-arguments] "Too many positional arguments to `object.__init__`: expected 1, got 2"
     @cls
     def inner() -> None: ...
 ```