stage unit test changes

Author: MechanicalConstruct

test-data/unit/check-functools.test

@@ -332,7 +332,7 @@ p = functools.partial(foo, kwarg="asdf")
 def bar(a: int, b: str, c: float) -> None: ...
 p(bar, 1, "a", 3.0)  # OK
 p(bar, 1, "a", 3.0, kwarg="asdf")  # OK
-p(bar, 1, "a", "b")  # E: Argument 1 to "foo" has incompatible type "Callable[[int, str, float], None]"; expected "Callable[[int, str, str], None]"
+p(bar, 1, "a", "b")  # E: Argument 1 to "foo" has incompatible type "(int, str, float) -> None"; expected "(int, str, str) -> None"
 [builtins fixtures/dict.pyi]
 
 [case testFunctoolsPartialUnion]
@@ -353,7 +353,7 @@ reveal_type(functools.partial(fn2, 2)())  # N: Revealed type is "Union[builtins.
 fn3: Union[Callable[[int], int], str]
 reveal_type(functools.partial(fn3, 2)())  # E: "str" not callable \
                                           # N: Revealed type is "builtins.int" \
-                                          # E: Argument 1 to "partial" has incompatible type "Union[Callable[[int], int], str]"; expected "Callable[..., int]"
+                                          # E: Argument 1 to "partial" has incompatible type "Union[Callable[[int], int], str]"; expected "(..., int)"
 [builtins fixtures/tuple.pyi]
 
 [case testFunctoolsPartialUnionOfTypeAndCallable]
@@ -385,8 +385,8 @@ p: partial[str] = partial(generic, resulting_type=str)
 q: partial[bool] = partial(generic, resulting_type=str)  # E: Argument "resulting_type" to "generic" has incompatible type "Type[str]"; expected "Type[bool]"
 
 pc: Callable[..., str] = partial(generic, resulting_type=str)
-qc: Callable[..., bool] = partial(generic, resulting_type=str)  # E: Incompatible types in assignment (expression has type "partial[str]", variable has type "Callable[..., bool]") \
-                                                                # N: "partial[str].__call__" has type "Callable[[VarArg(Any), KwArg(Any)], str]"
+qc: Callable[..., bool] = partial(generic, resulting_type=str)  # E: Incompatible types in assignment (expression has type "partial[str]", variable has type "(..., bool)") \
+                                                                # N: "partial[str].__call__" has type "(Any, Any) -> str"
 [builtins fixtures/tuple.pyi]
 
 [case testFunctoolsPartialNestedPartial]

test-data/unit/check-inference.test

@@ -400,7 +400,7 @@ main:6: error: Need more than 3 values to unpack (4 expected)
 [case testInvalidRvalueTypeInInferredMultipleLvarDefinition]
 import typing
 def f() -> None:
-    a, b = f   # E: "Callable[[], None]" object is not iterable
+    a, b = f   # E: "() -> None" object is not iterable
     c, d = A() # E: "A" object is not iterable
 class A: pass
 [builtins fixtures/for.pyi]
@@ -409,7 +409,7 @@ class A: pass
 [case testInvalidRvalueTypeInInferredNestedTupleAssignment]
 import typing
 def f() -> None:
-    a1, (a2, b) = A(), f   # E: "Callable[[], None]" object is not iterable
+    a1, (a2, b) = A(), f   # E: "() -> None" object is not iterable
     a3, (c, d) = A(), A() # E: "A" object is not iterable
 class A: pass
 [builtins fixtures/for.pyi]
@@ -988,7 +988,7 @@ a = k2
 if int():
     a = k2
 if int():
-    a = k1 # E: Incompatible types in assignment (expression has type "Callable[[int, List[T@k1]], List[Union[T@k1, int]]]", variable has type "Callable[[S, List[T@k2]], List[Union[T@k2, int]]]")
+    a = k1 # E: Incompatible types in assignment (expression has type "(int, List[T@k1]) -> List[Union[T@k1, int]]", variable has type "(S, List[T@k2]) -> List[Union[T@k2, int]]")
 b = k1
 if int():
     b = k1
@@ -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 "(x: int) -> int"; expected "(y: int) -> int"
 list_2 = [f, h]
 [builtins fixtures/list.pyi]
 
@@ -1390,14 +1390,14 @@ from typing import List, Callable
 li = [1]
 l = lambda: li
 f1 = l # type: Callable[[], List[int]]
-f2 = l # type: Callable[[], List[str]] # E: Incompatible types in assignment (expression has type "Callable[[], List[int]]", variable has type "Callable[[], List[str]]")
+f2 = l # type: Callable[[], List[str]] # E: Incompatible types in assignment (expression has type "() -> List[int]", variable has type "() -> List[str]")
 [builtins fixtures/list.pyi]
 
 [case testInferLambdaType2]
 from typing import List, Callable
 l = lambda: [B()]
 f1 = l # type: Callable[[], List[B]]
-f2 = l # type: Callable[[], List[A]] # E: Incompatible types in assignment (expression has type "Callable[[], List[B]]", variable has type "Callable[[], List[A]]")
+f2 = l # type: Callable[[], List[A]] # E: Incompatible types in assignment (expression has type "() -> List[B]", variable has type "() -> List[A]")
 
 class A: pass
 class B: pass
@@ -1435,7 +1435,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 "(Any, Any) -> int", argument has type "(..., None)")
     pass
 [builtins fixtures/dict.pyi]
 

test-data/unit/check-namedtuple.test

@@ -549,7 +549,7 @@ b = B._make([''])  # type: B
 [case testNamedTupleIncompatibleRedefinition]
 from typing import NamedTuple
 class Crash(NamedTuple):
-    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[int, ...], object], int]")
+    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "(Tuple[int, ...], object) -> int")
 [builtins fixtures/tuple.pyi]
 
 [case testNamedTupleInClassNamespace]

test-data/unit/check-recursive-types.test

@@ -1012,5 +1012,5 @@ p = ta
 from typing import Callable
 from bogus import Foo  # type: ignore
 
-A = Callable[[Foo, "B"], Foo]  # E: Type alias target becomes "Callable[[Any, B], Any]" due to an unfollowed import
-B = Callable[[Foo, A], Foo]  # E: Type alias target becomes "Callable[[Any, A], Any]" due to an unfollowed import
+A = Callable[[Foo, "B"], Foo]  # E: Type alias target becomes "(Any, B) -> Any" due to an unfollowed import
+B = Callable[[Foo, A], Foo]  # E: Type alias target becomes "(Any, A) -> Any" due to an unfollowed import

test-data/unit/daemon.test

@@ -456,7 +456,7 @@ $ dmypy inspect foo.py:3:10:3:17 -vv
 $ dmypy inspect foo.py:9:9:9:11
 "int"
 $ dmypy inspect foo.py:11:1:11:3
-"Callable[[Optional[int]], None]"
+"(Optional[int]) -> None"
 $ dmypy inspect foo.py:11:1:13:1
 "None"
 $ dmypy inspect foo.py:1:2:3:4
@@ -517,7 +517,7 @@ $ dmypy inspect foo.py:7:5 -vv
 $ dmypy inspect foo.py:7:5 -vv --limit=1
 "builtins.int"
 $ dmypy inspect foo.py:7:3
-"Callable[[int], None]"
+"(int) -> None"
 "None"
 $ dmypy inspect foo.py:1:2
 Can't find any expressions at position 1:2

test-data/unit/fine-grained.test

@@ -1340,7 +1340,7 @@ class A:
 [out]
 ==
 -- This is a bad error message
-main:7: error: Argument 1 to "use" has incompatible type "Type[A]"; expected "Callable[[], A]"
+main:7: error: Argument 1 to "use" has incompatible type "Type[A]"; expected "() -> A"
 
 [case testConstructorSignatureChanged3]
 from a import C
@@ -2227,7 +2227,7 @@ class B:
     x: int
 [out]
 ==
-a.py:3: error: Argument 1 to "deca" has incompatible type "Callable[[B], B]"; expected "Callable[[str], str]"
+a.py:3: error: Argument 1 to "deca" has incompatible type "(B) -> B"; expected "(str) -> str"
 ==
 a.py:6: error: "B" has no attribute "x"
 ==
@@ -2295,7 +2295,7 @@ class B:
     x: int
 [out]
 ==
-a.py:4: error: Argument 1 to "deca" has incompatible type "Callable[[B], B]"; expected "Callable[[str], str]"
+a.py:4: error: Argument 1 to "deca" has incompatible type "(B) -> B"; expected "(str) -> str"
 ==
 a.py:7: error: "B" has no attribute "x"
 ==
@@ -2363,7 +2363,7 @@ class B:
     x: int
 [out]
 ==
-a.py:4: error: Argument 1 to "deca" has incompatible type "Callable[[D, B], B]"; expected "Callable[..., str]"
+a.py:4: error: Argument 1 to "deca" has incompatible type "(D, B) -> B"; expected "(..., str)"
 ==
 a.py:7: error: "B" has no attribute "x"
 ==
@@ -2389,7 +2389,7 @@ def dec(func: Callable[[str], str]) -> Callable[[str], str]:
     pass
 [out]
 ==
-a.py:5: error: Argument 1 to "dec" has incompatible type "Callable[[int], int]"; expected "Callable[[str], str]"
+a.py:5: error: Argument 1 to "dec" has incompatible type "(int) -> int"; expected "(str) -> str"
 
 [case testDecoratorUpdateNestedClass]
 import a
@@ -2414,7 +2414,7 @@ class C:
         pass
 [out]
 ==
-a.py:6: error: Argument 1 to "dec" of "C" has incompatible type "Callable[[Inner, int], int]"; expected "Callable[..., str]"
+a.py:6: error: Argument 1 to "dec" of "C" has incompatible type "(Inner, int) -> int"; expected "(..., str)"
 
 [case testDecoratorUpdateClassInFunction]
 import a
@@ -2450,7 +2450,7 @@ class B:
     x: str
 [out]
 ==
-a.py:6: error: Argument 1 to "dec" of "C" has incompatible type "Callable[[Inner, B], int]"; expected "Callable[..., str]"
+a.py:6: error: Argument 1 to "dec" of "C" has incompatible type "(Inner, B) -> int"; expected "(..., str)"
 ==
 a.py:8: error: Incompatible return value type (got "str", expected "int")
 
@@ -2480,7 +2480,7 @@ def dec(f: Callable[[C], int]) -> Callable[[int], int]:
     pass
 [out]
 ==
-a.py:3: error: Argument 1 to "dec" has incompatible type "Callable[[B], int]"; expected "Callable[[C], int]"
+a.py:3: error: Argument 1 to "dec" has incompatible type "(B) -> int"; expected "(C) -> int"
 
 [case testOverloadRefresh]
 from typing import overload
@@ -4514,9 +4514,9 @@ x = 0
 x = ''
 [builtins fixtures/tuple.pyi]
 [out]
-b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[int, ...], object], int]")
+b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "(Tuple[int, ...], object) -> int")
 ==
-b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[int, ...], object], int]")
+b.py:5: error: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "(Tuple[int, ...], object) -> int")
 
 [case testReprocessEllipses1]
 import a
@@ -6161,7 +6161,7 @@ class C:
         pass
 [out]
 ==
-a.py:6: error: Argument 1 to "func" has incompatible type "Type[C]"; expected "Callable[[int], Any]"
+a.py:6: error: Argument 1 to "func" has incompatible type "Type[C]"; expected "(int) -> Any"
 
 [case testDunderNewDefine]
 import a
@@ -8094,7 +8094,7 @@ def A(x: str) -> str: pass
 [builtins fixtures/list.pyi]
 [out]
 ==
-a.py:4: error: Incompatible import of "A" (imported name has type "Callable[[str], str]", local name has type "Type[List[Any]]")
+a.py:4: error: Incompatible import of "A" (imported name has type "(str) -> str", local name has type "Type[List[Any]]")
 
 [case testFakeOverloadCrash]
 import b

test-data/unit/pythoneval-asyncio.test

@@ -364,7 +364,7 @@ try:
 finally:
     loop.close()
 [out]
-_program.py:17: error: Argument 1 to "add_done_callback" of "Future" has incompatible type "Callable[[Future[int]], None]"; expected "Callable[[Future[str]], object]"
+_program.py:17: error: Argument 1 to "add_done_callback" of "Future" has incompatible type "(Future[int]) -> None"; expected "(Future[str]) -> object"
 
 [case testErrorOneMoreFutureInReturnType]
 import typing

test-data/unit/pythoneval.test

@@ -616,7 +616,7 @@ def f(*args: str) -> str: return args[0]
 map(f, ['x'])
 map(f, [1])
 [out]
-_program.py:4: error: Argument 1 to "map" has incompatible type "Callable[[VarArg(str)], str]"; expected "Callable[[int], str]"
+_program.py:4: error: Argument 1 to "map" has incompatible type "(str) -> str"; expected "(int) -> str"
 
 [case testMapStr]
 import typing
@@ -823,7 +823,7 @@ class MyDDict(t.DefaultDict[int,T], t.Generic[T]):
 MyDDict(dict)['0']
 MyDDict(dict)[0]
 [out]
-_program.py:7: error: Argument 1 to "defaultdict" has incompatible type "Type[List[Any]]"; expected "Optional[Callable[[], str]]"
+_program.py:7: error: Argument 1 to "defaultdict" has incompatible type "Type[List[Any]]"; expected "Optional[() -> str]"
 _program.py:10: error: Invalid index type "str" for "defaultdict[int, str]"; expected type "int"
 _program.py:10: error: Incompatible types in assignment (expression has type "int", target has type "str")
 _program.py:20: error: Argument 1 to "tst" has incompatible type "defaultdict[str, List[Never]]"; expected "defaultdict[int, List[Never]]"