60% of tests

Author: A5rocks

test-data/unit/check-typeis.test

@@ -819,6 +819,7 @@ accept_typeguard(typeguard)
 [builtins fixtures/tuple.pyi]
 
 [case testTypeIsInOverloads]
+# flags: --warn-unreachable
 from typing import Any, overload, Union
 from typing_extensions import TypeIs
 
@@ -843,13 +844,15 @@ def func3(val: Union[int, str]):
     if func1(val):
         reveal_type(val)  # N: Revealed type is "Union[builtins.int, builtins.str]"
     else:
-        reveal_type(val)
+        reveal_type(val)  # E: Statement is unreachable \
+                          # N: Revealed type is "Union[builtins.int, builtins.str]"
 
 def func4(val: int):
     if func1(val):
         reveal_type(val)  # N: Revealed type is "builtins.int"
     else:
-        reveal_type(val)
+        reveal_type(val)  # E: Statement is unreachable \
+                          # N: Revealed type is "builtins.int"
 [builtins fixtures/tuple.pyi]
 
 [case testTypeIsInOverloadsSameReturn]

test-data/unit/check-typevar-tuple.test

@@ -1273,15 +1273,17 @@ def test(d: A[int, str]) -> None:
     if isinstance(d, A):
         reveal_type(d)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.A[builtins.int, builtins.str]]"
     else:
-        reveal_type(d)  # E: Statement is unreachable
+        reveal_type(d)  # E: Statement is unreachable \
+                        # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.A[builtins.int, builtins.str]]"
 
 class B(Generic[Unpack[TP]]): ...
 
 def test2(d: B[int, str]) -> None:
     if isinstance(d, B):
         reveal_type(d)  # N: Revealed type is "__main__.B[builtins.int, builtins.str]"
     else:
-        reveal_type(d)  # E: Statement is unreachable
+        reveal_type(d)  # E: Statement is unreachable \
+                        # N: Revealed type is "__main__.B[builtins.int, builtins.str]"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testVariadicTupleSubtyping]

test-data/unit/check-typevar-values.test

@@ -112,35 +112,33 @@ from typing import TypeVar
 T = TypeVar('T', int, str)
 def f(x: T) -> T:
     if isinstance(x, int):
-        return 2
+        return 2  # E: Incompatible return value type (got "int", expected "str")
     return x
 def g(x: T) -> T:
     if isinstance(x, str):
-        return ''
+        return ''  # E: Incompatible return value type (got "str", expected "int")
     return x
 def h(x: T) -> T:
     if isinstance(x, int):
         return '' # E: Incompatible return value type (got "str", expected "int")
     return x
 [builtins fixtures/isinstance.pyi]
-[out]
 
 [case testIsinstanceAndTypeVarValues2]
 from typing import TypeVar
 T = TypeVar('T', int, str)
 def f(x: T) -> T:
     if isinstance(x, int):
-        return 2
+        return 2  # E: Incompatible return value type (got "int", expected "str")
     else:
-        return ''
+        return ''  # E: Incompatible return value type (got "str", expected "int")
 def g(x: T) -> T:
     if isinstance(x, int):
         return '' # E: Incompatible return value type (got "str", expected "int")
     else:
         return 2  # E: Incompatible return value type (got "int", expected "str")
     return x
 [builtins fixtures/isinstance.pyi]
-[out]
 
 [case testIsinstanceAndTypeVarValues3]
 from typing import TypeVar
@@ -149,8 +147,8 @@ def f(x: T) -> T:
     if isinstance(x, int):
         y = 1
     else:
-        y = ''
-    return y
+        y = ''  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+    return y  # E: Incompatible return value type (got "int", expected "str")
 [builtins fixtures/isinstance.pyi]
 
 [case testIsinstanceAndTypeVarValues4]
@@ -160,10 +158,9 @@ def f(x: T) -> T:
     if isinstance(x, int):
         y = 1
     else:
-        y = object()
-    return y # E: Incompatible return value type (got "object", expected "str")
+        y = object()  # E: Incompatible types in assignment (expression has type "object", variable has type "int")
+    return y # E: Incompatible return value type (got "int", expected "str")
 [builtins fixtures/isinstance.pyi]
-[out]
 
 [case testIsinstanceAndTypeVarValues5]
 from typing import TypeVar
@@ -189,9 +186,10 @@ def f1(x: T1) -> None:
         x = y
         x = A() # E: Incompatible types in assignment (expression has type "A", variable has type "B")
     else:
-        x = B()
+        x = B()  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
         x = y
-        x.foo() # E: "B" has no attribute "foo"
+        x.foo() # E: "A" has no attribute "foo" \
+                # E: "B" has no attribute "foo"
 
 class C:
     field: int
@@ -203,19 +201,19 @@ def f2(x: T2) -> None:
     if isinstance(x, C):
         # C and D are non-overlapping, so this branch is never checked
         x = y
-        x = C()
+        x = C()  # E: Incompatible types in assignment (expression has type "C", variable has type "D")
     else:
-        x = D()
+        x = D()  # E: Incompatible types in assignment (expression has type "D", variable has type "C")
         x = y
-        x.foo() # E: "D" has no attribute "foo"
+        x.foo() # E: "C" has no attribute "foo" \
+                # E: "D" has no attribute "foo"
 
 S = TypeVar('S', int, str)
 def g(x: S) -> None:
     y = x
     if isinstance(x, int):
         x = y
 [builtins fixtures/isinstance.pyi]
-[out]
 
 [case testIsinstanceWithUserDefinedTypeAndTypeVarValues2]
 from typing import TypeVar
@@ -226,14 +224,13 @@ def f(x: T) -> None:
     if isinstance(x, S):
         # This is checked only when type of x is str.
         x = y
-        x = S()
+        x = S()  # E: Incompatible types in assignment (expression has type "S", variable has type "int")
         x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "S")
     else:
         x = y
-        x = 1
+        x = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "S")
         x = S() # E: Incompatible types in assignment (expression has type "S", variable has type "int")
 [builtins fixtures/isinstance.pyi]
-[out]
 
 [case testTypeVarValuesAndNestedCalls]
 from typing import TypeVar
@@ -740,8 +737,10 @@ W = TypeVar("W", int, str)
 
 def fn(w: W) -> W:
     if type(w) is str:
-        reveal_type(w)  # N: Revealed type is "builtins.str"
+        reveal_type(w)  # N: Revealed type is "builtins.int" \
+                        # N: Revealed type is "builtins.str"
     elif type(w) is int:
-        reveal_type(w)  # N: Revealed type is "builtins.int"
+        reveal_type(w)  # N: Revealed type is "builtins.int" \
+                        # N: Revealed type is "builtins.str"
     return w
 [builtins fixtures/isinstance.pyi]