correct tests

Author: hauntsaninja

test-data/unit/check-enum.test

@@ -1032,7 +1032,7 @@ else:
     reveal_type(z)  # No output: this branch is unreachable
 [builtins fixtures/bool.pyi]
 
-[case testEnumReachabilityNoNarrowingForUnionMessiness]
+[case testEnumReachabilityNarrowingForUnionMessiness]
 from enum import Enum
 from typing import Literal
 
@@ -1045,17 +1045,16 @@ x: Foo
 y: Literal[Foo.A, Foo.B]
 z: Literal[Foo.B, Foo.C]
 
-# For the sake of simplicity, no narrowing is done when the narrower type is a Union.
 if x is y:
-    reveal_type(x)  # N: Revealed type is "__main__.Foo"
+    reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
 else:
     reveal_type(x)  # N: Revealed type is "__main__.Foo"
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
 
 if y is z:
-    reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
-    reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"
+    reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.B]"
+    reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.B]"
 else:
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B]"
     reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"

test-data/unit/check-flags.test

@@ -2377,7 +2377,7 @@ x: int = ""  # E: Incompatible types in assignment (expression has type "str", v
 x: int = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 [case testDisableBytearrayPromotion]
-# flags: --disable-bytearray-promotion --strict-equality
+# flags: --disable-bytearray-promotion --strict-equality --warn-unreachable
 def f(x: bytes) -> None: ...
 f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
 f(memoryview(b"asdf"))

test-data/unit/check-isinstance.test

@@ -2760,13 +2760,14 @@ else:
     reveal_type(x)  # N: Revealed type is "builtins.int | builtins.str"
 
 [case testTypeEqualsMultipleTypesShouldntNarrow]
+# flags: --warn-unreachable
 # make sure we don't do any narrowing if there are multiple types being compared
 
 from typing import Union
 
 x: Union[int, str]
 if type(x) == int == str:
-    reveal_type(x)  # N: Revealed type is "builtins.int | builtins.str"
+    reveal_type(x)  # E: Statement is unreachable
 else:
     reveal_type(x)  # N: Revealed type is "builtins.int | builtins.str"
 

test-data/unit/check-narrowing.test

@@ -1364,13 +1364,13 @@ class A: ...
 val: Optional[A]
 
 if val == None:
-    reveal_type(val)  # N: Revealed type is "__main__.A | None"
+    reveal_type(val)  # N: Revealed type is "None"
 else:
     reveal_type(val)  # N: Revealed type is "__main__.A"
 if val != None:
     reveal_type(val)  # N: Revealed type is "__main__.A"
 else:
-    reveal_type(val)  # N: Revealed type is "__main__.A | None"
+    reveal_type(val)  # N: Revealed type is "None"
 
 if val in (None,):
     reveal_type(val)  # N: Revealed type is "__main__.A | None"
@@ -1380,6 +1380,19 @@ if val not in (None,):
     reveal_type(val)  # N: Revealed type is "__main__.A | None"
 else:
     reveal_type(val)  # N: Revealed type is "__main__.A | None"
+
+class Hmm:
+    def __eq__(self, other) -> bool: ...
+
+hmm: Optional[Hmm]
+if hmm == None:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm | None"
+else:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm"
+if hmm != None:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm"
+else:
+    reveal_type(hmm)  # N: Revealed type is "__main__.Hmm | None"
 [builtins fixtures/primitives.pyi]
 
 [case testNarrowingWithTupleOfTypes]
@@ -2277,7 +2290,7 @@ def f4(x: SE) -> None:
 # https://github.com/python/mypy/issues/17864
 def f(x: str | int) -> None:
     if x == "x":
-        reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int"
+        reveal_type(x)  # N: Revealed type is "builtins.str"
         y = x
 
     if x in ["x"]:

test-data/unit/check-optional.test

@@ -445,28 +445,29 @@ foo([f])  # E: List item 0 has incompatible type "Callable[[], int]"; expected "
 
 [case testInferEqualsNotOptional]
 from typing import Optional
-x = ''  # type: Optional[str]
-if x == '<string>':
-    reveal_type(x)  # N: Revealed type is "builtins.str"
-else:
-    reveal_type(x)  # N: Revealed type is "builtins.str | None"
-if x is '<string>':
-    reveal_type(x)  # N: Revealed type is "builtins.str"
-else:
-    reveal_type(x)  # N: Revealed type is "builtins.str | None"
+
+def main(x: Optional[str]):
+    if x == '<string>':
+        reveal_type(x)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.str | None"
+    if x is '<string>':
+        reveal_type(x)  # N: Revealed type is "Literal['<string>']"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.str | None"
 [builtins fixtures/ops.pyi]
 
 [case testInferEqualsNotOptionalWithUnion]
 from typing import Union
-x = ''  # type: Union[str, int, None]
-if x == '<string>':
-    reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int"
-else:
-    reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
-if x is '<string>':
-    reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int"
-else:
-    reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
+def main(x: Union[str, int, None]):
+    if x == '<string>':
+        reveal_type(x)  # N: Revealed type is "builtins.str"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
+    if x is '<string>':
+        reveal_type(x)  # N: Revealed type is "Literal['<string>']"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
 [builtins fixtures/ops.pyi]
 
 [case testInferEqualsNotOptionalWithOverlap]
@@ -483,28 +484,30 @@ else:
 [builtins fixtures/ops.pyi]
 
 [case testInferEqualsStillOptionalWithNoOverlap]
+# flags: --warn-unreachable
 from typing import Optional
-x = ''  # type: Optional[str]
-if x == 0:
-    reveal_type(x)  # N: Revealed type is "builtins.str | None"
-else:
-    reveal_type(x)  # N: Revealed type is "builtins.str | None"
-if x is 0:
-    reveal_type(x)  # N: Revealed type is "builtins.str | None"
-else:
-    reveal_type(x)  # N: Revealed type is "builtins.str | None"
+
+def main(x: Optional[str]):
+    if x == 0:
+        reveal_type(x)  # E: Statement is unreachable
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.str | None"
+    if x is 0:
+        reveal_type(x)  # N: Revealed type is "builtins.str | None"
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.str | None"
 [builtins fixtures/ops.pyi]
 
 [case testInferEqualsStillOptionalWithBothOptional]
 from typing import Union
 x = ''  # type: Union[str, int, None]
 y = ''  # type: Union[str, None]
 if x == y:
-    reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
+    reveal_type(x)  # N: Revealed type is "builtins.str | None"
 else:
     reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
 if x is y:
-    reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
+    reveal_type(x)  # N: Revealed type is "builtins.str | None"
 else:
     reveal_type(x)  # N: Revealed type is "builtins.str | builtins.int | None"
 [builtins fixtures/ops.pyi]

test-data/unit/check-python310.test

@@ -61,7 +61,7 @@ m: object
 
 match m:
     case b.b:
-        reveal_type(m)  # N: Revealed type is "builtins.object"
+        reveal_type(m)  # N: Revealed type is "builtins.int"
 [file b.py]
 b: int
 

test-data/unit/fixtures/primitives.pyi

@@ -39,16 +39,19 @@ class bytes(Sequence[int]):
     def __iter__(self) -> Iterator[int]: pass
     def __contains__(self, other: object) -> bool: pass
     def __getitem__(self, item: int) -> int: pass
+    def __eq__(self, other: object) -> bool: pass
 class bytearray(Sequence[int]):
     def __init__(self, x: bytes) -> None: pass
     def __iter__(self) -> Iterator[int]: pass
     def __contains__(self, other: object) -> bool: pass
     def __getitem__(self, item: int) -> int: pass
+    def __eq__(self, other: object) -> bool: pass
 class memoryview(Sequence[int]):
     def __init__(self, x: bytes) -> None: pass
     def __iter__(self) -> Iterator[int]: pass
     def __contains__(self, other: object) -> bool: pass
     def __getitem__(self, item: int) -> int: pass
+    def __eq__(self, other: object) -> bool: pass
 class tuple(Generic[T]):
     def __contains__(self, other: object) -> bool: pass
 class list(Sequence[T]):