fix check-assert-type-fail.test, check-callable.test, check-functools.test, check-inference.test, check-python311.test, check-statements.test, check-varargs.test

Author: theodoreando

test-data/unit/check-assert-type-fail.test

@@ -30,7 +30,7 @@ def f(si: arr.array[int]):
 [case testAssertTypeFailCallableArgKind]
 from typing import assert_type, Callable
 def myfunc(arg: int) -> None: pass
-assert_type(myfunc, Callable[[int], None])  # E: Expression is of type "Callable[[Arg(int, 'arg')], None]", not "Callable[[int], None]"
+assert_type(myfunc, Callable[[int], None])  # E: Expression is of type "def myfunc(arg: int) -> None", not "Callable[[int], None]"
 
 [case testAssertTypeOverload]
 from typing import assert_type, overload

test-data/unit/check-callable.test

@@ -654,13 +654,13 @@ class Call(Protocol):
 
 def f1() -> None: ...
 a1: Call = f1  # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "Call") \
-               # N: "Call.__call__" has type "Callable[[Arg(int, 'x'), VarArg(Any), KwArg(Any)], None]"
+               # N: "Call.__call__" has type "def __call__(self, x: int, *args: Any, **kwargs: Any) -> None"
 def f2(x: str) -> None: ...
 a2: Call = f2  # E: Incompatible types in assignment (expression has type "Callable[[str], None]", variable has type "Call") \
-               # N: "Call.__call__" has type "Callable[[Arg(int, 'x'), VarArg(Any), KwArg(Any)], None]"
+               # N: "Call.__call__" has type "def __call__(self, x: int, *args: Any, **kwargs: Any) -> None"
 def f3(y: int) -> None: ...
 a3: Call = f3  # E: Incompatible types in assignment (expression has type "Callable[[int], None]", variable has type "Call") \
-               # N: "Call.__call__" has type "Callable[[Arg(int, 'x'), VarArg(Any), KwArg(Any)], None]"
+               # N: "Call.__call__" has type "def __call__(self, x: int, *args: Any, **kwargs: Any) -> None"
 def f4(x: int) -> None: ...
 a4: Call = f4
 

test-data/unit/check-functools.test

@@ -698,10 +698,10 @@ use_func_callable(partial(func_b, b=""))
 use_int_callable(partial(func_c, b=""))
 use_func_callable(partial(func_c, b=""))
 use_int_callable(partial(func_fn, b=""))  # E: Argument 1 to "use_int_callable" has incompatible type "partial[def (*Any, **Any) -> Any]"; expected "Callable[[int], int]" \
-                                          # N: "partial[Callable[[VarArg(Any), KwArg(Any)], Any]].__call__" has type "def __call__(__self, *args: Any, **kwargs: Any) -> def (*Any, **Any) -> Any"
+                                          # N: "partial[def (*Any, **Any) -> Any].__call__" has type "def __call__(__self, *args: Any, **kwargs: Any) -> def (*Any, **Any) -> Any"
 use_func_callable(partial(func_fn, b=""))
 use_int_callable(partial(func_fn_unpack, b=""))  # E: Argument 1 to "use_int_callable" has incompatible type "partial[def (*Any) -> Any]"; expected "Callable[[int], int]" \
-                                                 # N: "partial[Callable[[VarArg(Any)], Any]].__call__" has type "def __call__(__self, *args: Any, **kwargs: Any) -> def (*Any) -> Any"
+                                                 # N: "partial[def (*Any) -> Any].__call__" has type "def __call__(__self, *args: Any, **kwargs: Any) -> def (*Any) -> Any"
 use_func_callable(partial(func_fn_unpack, b=""))
 
 # But we should not erase typevars that aren't bound by function

test-data/unit/check-inference.test

@@ -1109,7 +1109,7 @@ def f(*, x: int) -> int: ...
 def g(*, y: int) -> int: ...
 def h(*, x: int) -> int: ...
 
-list_1 = [f, g]  # E: List item 0 has incompatible type "Callable[[NamedArg(int, 'x')], int]"; expected "Callable[[NamedArg(int, 'y')], int]"
+list_1 = [f, g]  # E: List item 0 has incompatible type "def f(*, x: int) -> int"; expected "def g(*, y: int) -> int"
 list_2 = [f, h]
 [builtins fixtures/list.pyi]
 
@@ -1434,7 +1434,7 @@ from typing import Callable
 def f(a: Callable[..., None] = lambda *a, **k: None):
     pass
 
-def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible default for argument "a" (default has type "Callable[[VarArg(Any), KwArg(Any)], int]", argument has type "Callable[..., None]")
+def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible default for argument "a" (default has type "def (*a: Any, **k: Any) -> int", argument has type "Callable[..., None]")
     pass
 [builtins fixtures/dict.pyi]
 
@@ -3704,7 +3704,7 @@ def f(x: Call[T]) -> Tuple[T, T]: ...
 def g(__x: str) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "tuple[Never, Never]" \
                    # E: Argument 1 to "f" has incompatible type "Callable[[str], None]"; expected "Call[Never]" \
-                   # N: "Call[Never].__call__" has type "Callable[[NamedArg(Never, 'x')], None]"
+                   # N: "Call[Never].__call__" has type "def __call__(self, *, x: Never) -> None"
 [builtins fixtures/list.pyi]
 
 [case testCallableInferenceAgainstCallableNamedVsPosOnly]
@@ -3720,7 +3720,7 @@ def f(x: Call[T]) -> Tuple[T, T]: ...
 
 def g(*, x: str) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "tuple[Never, Never]" \
-                   # E: Argument 1 to "f" has incompatible type "Callable[[NamedArg(str, 'x')], None]"; expected "Call[Never]" \
+                   # E: Argument 1 to "f" has incompatible type "def g(*, x: str) -> None"; expected "Call[Never]" \
                    # N: "Call[Never].__call__" has type "Callable[[Never], None]"
 [builtins fixtures/list.pyi]
 
@@ -3737,7 +3737,7 @@ def f(x: Call[T]) -> Tuple[T, T]: ...
 
 def g(**x: str) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "tuple[Never, Never]" \
-                   # E: Argument 1 to "f" has incompatible type "Callable[[KwArg(str)], None]"; expected "Call[Never]" \
+                   # E: Argument 1 to "f" has incompatible type "def g(**x: str) -> None"; expected "Call[Never]" \
                    # N: "Call[Never].__call__" has type "Callable[[Never], None]"
 [builtins fixtures/list.pyi]
 
@@ -3754,8 +3754,8 @@ def f(x: Call[T]) -> Tuple[T, T]: ...
 
 def g(*args: str) -> None: pass
 reveal_type(f(g))  # N: Revealed type is "tuple[Never, Never]" \
-                   # E: Argument 1 to "f" has incompatible type "Callable[[VarArg(str)], None]"; expected "Call[Never]" \
-                   # N: "Call[Never].__call__" has type "Callable[[NamedArg(Never, 'x')], None]"
+                   # E: Argument 1 to "f" has incompatible type "def g(*args: str) -> None"; expected "Call[Never]" \
+                   # N: "Call[Never].__call__" has type "def __call__(self, *, x: Never) -> None"
 [builtins fixtures/list.pyi]
 
 [case testInferenceAgainstTypeVarActualBound]

test-data/unit/check-python311.test

@@ -157,7 +157,7 @@ Alias1 = Callable[[*Ts], int]  # E: Variable "__main__.Ts" is not valid as a typ
 x1: Alias1[int]  # E: Bad number of arguments for type alias, expected 0, given 1
 reveal_type(x1)  # N: Revealed type is "def (*Any) -> builtins.int"
 x1 = good
-x1 = bad  # E: Incompatible types in assignment (expression has type "Callable[[VarArg(int), NamedArg(int, 'y')], int]", variable has type "Callable[[VarArg(Any)], int]")
+x1 = bad  # E: Incompatible types in assignment (expression has type "def bad(*x: int, y: int) -> int", variable has type "def (*Any) -> int")
 
 Alias2 = Callable[[*T], int]  # E: "T" cannot be unpacked (must be tuple or TypeVarTuple)
 x2: Alias2[int]

test-data/unit/check-statements.test

@@ -2358,6 +2358,6 @@ describe(CAny())
 describe(C())
 describe(CNone())
 describe(CWrong())  # E: Argument 1 to "describe" has incompatible type "CWrong"; expected "Callable[[], None]" \
-                    # N: "CWrong.__call__" has type "Callable[[Arg(int, 'x')], None]"
+                    # N: "CWrong.__call__" has type "def __call__(self, x: int) -> None"
 describe(f)
 [builtins fixtures/isinstancelist.pyi]

test-data/unit/check-varargs.test

@@ -660,7 +660,7 @@ x: Callable[[int], None]
 def f(*x: int) -> None: pass
 def g(*x: str) -> None: pass
 x = f
-x = g # E: Incompatible types in assignment (expression has type "Callable[[VarArg(str)], None]", variable has type "Callable[[int], None]")
+x = g # E: Incompatible types in assignment (expression has type "def g(*x: str) -> None", variable has type "Callable[[int], None]")
 [builtins fixtures/list.pyi]
 [out]