Narrow isinstance checks to Never

Author: A5rocks

mypy/checker.py

@@ -8000,9 +8000,7 @@ def conditional_types_to_typemaps(
     maps: list[TypeMap] = []
     for typ in (yes_type, no_type):
         proper_type = get_proper_type(typ)
-        if isinstance(proper_type, UninhabitedType):
-            maps.append(None)
-        elif proper_type is None:
+        if proper_type is None:
             maps.append({})
         else:
             assert typ is not None

mypy/checkexpr.py

@@ -3548,9 +3548,7 @@ def visit_op_expr(self, e: OpExpr) -> Type:
                     allow_reverse=False,
                 )
             else:
-                # TODO: fix this bug with enum narrowing
-                # somehow the `use_reverse is UseReverse.ALWAYS` doesn't narrow.
-                assert_never(use_reverse)  # type: ignore[arg-type]
+                assert_never(use_reverse)
             e.method_type = method_type
             return result
         else:

test-data/unit/check-enum.test

@@ -888,9 +888,8 @@ elif x is Foo.B:
 elif x is Foo.C:
     reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.C]"
 else:
-    # TODO: this should narrow to Never
-    reveal_type(x)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Literal[__main__.Foo.C]"
+    reveal_type(x)  # N: Revealed type is "Never"
+    _ = "unreachable"  # E: Statement is unreachable
 reveal_type(x) # N: Revealed type is "Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B], Literal[__main__.Foo.C]]"
 
 if Foo.A is x:
@@ -900,8 +899,8 @@ elif Foo.B is x:
 elif Foo.C is x:
     reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.C]"
 else:
-    reveal_type(x)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Literal[__main__.Foo.C]"
+    reveal_type(x)  # N: Revealed type is "Never"
+    _ = "unreachable"  # E: Statement is unreachable
 reveal_type(x) # N: Revealed type is "Union[Literal[__main__.Foo.A], Literal[__main__.Foo.B], Literal[__main__.Foo.C]]"
 
 y: Foo
@@ -912,8 +911,7 @@ elif y is Foo.B:
 elif y is Foo.C:
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.C]"
 else:
-    reveal_type(y)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Literal[__main__.Foo.C]"
+    reveal_type(y)  # N: Revealed type is "Never"
 reveal_type(y) # N: Revealed type is "__main__.Foo"
 
 if Foo.A is y:
@@ -923,8 +921,8 @@ elif Foo.B is y:
 elif Foo.C is y:
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.C]"
 else:
-    reveal_type(y)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Literal[__main__.Foo.C]"
+    reveal_type(y)  # N: Revealed type is "Never"
+    _ = "unreachable"  # E: Statement is unreachable
 reveal_type(y) # N: Revealed type is "__main__.Foo"
 [builtins fixtures/bool.pyi]
 
@@ -946,8 +944,7 @@ if x is Foo.A:
 elif x is Foo.B:
     reveal_type(x)  # N: Revealed type is "Literal[__main__.Foo.B]"
 else:
-    reveal_type(x)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Literal[__main__.Foo.B]"
+    reveal_type(x)  # N: Revealed type is "Never"
 
 class Bar(Enum):
     __order__ = "A B"
@@ -962,26 +959,23 @@ if y is Bar.A:
 elif y is Bar.B:
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Bar.B]"
 else:
-    reveal_type(y)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Literal[__main__.Bar.B]"
+    reveal_type(y)  # N: Revealed type is "Never"
 
 x2: Foo
 if x2 is Foo.A:
     reveal_type(x2)  # N: Revealed type is "Literal[__main__.Foo.A]"
 elif x2 is Foo.B:
     reveal_type(x2)  # N: Revealed type is "Literal[__main__.Foo.B]"
 else:
-    reveal_type(x2)  # E: Statement is unreachable  \
-                     # N: Revealed type is "Literal[__main__.Foo.B]"
+    reveal_type(x2)  # N: Revealed type is "Never"
 
 y2: Bar
 if y2 is Bar.A:
     reveal_type(y2)  # N: Revealed type is "Literal[__main__.Bar.A]"
 elif y2 is Bar.B:
     reveal_type(y2)  # N: Revealed type is "Literal[__main__.Bar.B]"
 else:
-    reveal_type(y2)  # E: Statement is unreachable  \
-                     # N: Revealed type is "Literal[__main__.Bar.B]"
+    reveal_type(y2)  # N: Revealed type is "Never"
 [builtins fixtures/tuple.pyi]
 
 [case testEnumReachabilityChecksIndirect]
@@ -1039,17 +1033,17 @@ if y is z:
     reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.A]?"
     accepts_foo_a(z)
 else:
-    reveal_type(y)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Literal[__main__.Foo.A]"
-    reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.A]?"
+    reveal_type(y)  # N: Revealed type is "Never"
+    reveal_type(z)  # E: Statement is unreachable \
+                    # N: Revealed type is "Literal[__main__.Foo.A]?"
 if z is y:
     reveal_type(y)  # N: Revealed type is "Literal[__main__.Foo.A]"
     reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.A]?"
     accepts_foo_a(z)
 else:
-    reveal_type(y)  # E: Statement is unreachable  \
+    reveal_type(y)  # E: Statement is unreachable \
                     # N: Revealed type is "Literal[__main__.Foo.A]"
-    reveal_type(z)  # N: Revealed type is "Literal[__main__.Foo.A]?"
+    reveal_type(z)  # N: Revealed type is "Never"
 [builtins fixtures/bool.pyi]
 
 [case testEnumReachabilityNoNarrowingForUnionMessiness]
@@ -2305,8 +2299,7 @@ if e == MyEnum.A:
 elif e == MyEnum.B:
     reveal_type(e)  # N: Revealed type is "Literal[__main__.MyEnum.B]"
 else:
-    reveal_type(e)  # E: Statement is unreachable \
-                    # N: Revealed type is "Literal[__main__.MyEnum.B]"
+    reveal_type(e)  # N: Revealed type is "Never"
 [builtins fixtures/dict.pyi]
 
 

test-data/unit/check-errorcodes.test

@@ -805,7 +805,7 @@ g = 3 if True else 4                     # E: If condition is always true  [redu
 h = 3 if False else 4                    # E: If condition is always false  [redundant-expr]
 i = [x for x in lst if True]             # E: If condition in comprehension is always true  [redundant-expr]
 j = [x for x in lst if False]            # E: If condition in comprehension is always false  [redundant-expr]
-k = [x for x in lst if isinstance(x, int) or foo()]  # E: If condition in comprehension is always true  [redundant-expr]
+k = [x for x in lst if isinstance(x, int) or foo()]
 [builtins fixtures/isinstancelist.pyi]
 
 [case testRedundantExprTruthiness]

test-data/unit/check-expressions.test

@@ -1506,7 +1506,7 @@ z = x.append(y) if bool() else x.append(y) # E: "append" of "list" does not retu
 from typing import TypeVar
 T = TypeVar("T", int, str)
 def foo(x: T) -> T:
-    return x + 1 if isinstance(x, int) else x + "a"
+    return x + 1 if isinstance(x, int) else x + "a"  # E: Unsupported left operand type for + ("Never")
 [builtins fixtures/isinstancelist.pyi]
 
 -- Special cases

test-data/unit/check-incremental.test

@@ -5415,7 +5415,9 @@ reveal_type(z)
 [out]
 tmp/c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 [out2]
-tmp/c.py:2: note: Revealed type is "a.A"
+tmp/a.py:7: error: Need type annotation for "y"
+tmp/b.py:2: error: Need type annotation for "z"
+tmp/c.py:2: note: Revealed type is "Never"
 
 [case testIsInstanceAdHocIntersectionIncrementalUnreachableToIntersection]
 import c
@@ -5446,7 +5448,9 @@ from b import z
 reveal_type(z)
 [builtins fixtures/isinstance.pyi]
 [out]
-tmp/c.py:2: note: Revealed type is "a.A"
+tmp/a.py:7: error: Need type annotation for "y"
+tmp/b.py:2: error: Need type annotation for "z"
+tmp/c.py:2: note: Revealed type is "Never"
 [out2]
 tmp/c.py:2: note: Revealed type is "a.<subclass of "a.A" and "a.B">"
 

test-data/unit/check-isinstance.test

@@ -734,11 +734,9 @@ while bool():
         x + 1
         break
     # TODO: only report unreachability once
-    # TODO: narrow x to Never
-    elif isinstance(x, str):  # E: Statement is unreachable  \
-                              # E: Subclass of "int" and "str" cannot exist: would have incompatible method signatures
+    elif isinstance(x, str):  # E: Statement is unreachable
         _ = "unreachable"  # E: Statement is unreachable
-        x + 'a'  # E: Unsupported operand types for + ("int" and "str")
+        x + 'a'  # E: Unsupported left operand type for + ("Never")
         break
     _ = "unreachable"  # E: Statement is unreachable
 x + [1]               # E: Unsupported operand types for + ("int" and "List[int]") \
@@ -1275,7 +1273,8 @@ if isinstance(y, int) and isinstance(x, B):  # E: Subclass of "A" and "int" cann
                                              # E: Right operand of "and" is never evaluated
     _ = "unreachable"  # E: Statement is unreachable
 if isinstance(y, int) and y > 42:  # E: Subclass of "A" and "int" cannot exist: would have incompatible method signatures \
-                                   # E: Right operand of "and" is never evaluated
+                                   # E: Right operand of "and" is never evaluated \
+                                   # E: Unsupported left operand type for > ("Never")
     _ = "unreachable"  # E: Statement is unreachable
 [builtins fixtures/isinstancelist.pyi]
 
@@ -1370,9 +1369,9 @@ x = B()
 if isinstance(x, A):
     reveal_type(x)  # N: Revealed type is "__main__.B"
 if not isinstance(x, A):
-    reveal_type(x)  # E: Statement is unreachable \
-                    # N: Revealed type is "__main__.B"
-    x = A()  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
+    reveal_type(x)  # N: Revealed type is "Never"
+    x = A()  # E: Statement is unreachable \
+             # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 reveal_type(x)  # N: Revealed type is "__main__.B"
 [builtins fixtures/isinstance.pyi]
 
@@ -1537,8 +1536,7 @@ from typing import Type, Sequence, Union
 
 x: Type[str]
 if issubclass(x, int):  # E: Subclass of "str" and "int" cannot exist: would have incompatible method signatures
-    reveal_type(x)  # E: Statement is unreachable \
-                    # N: Revealed type is "Type[builtins.str]"
+    reveal_type(x)  # N: Revealed type is "Type[builtins.str]"
 
 class X: pass
 class Y(X): pass
@@ -1548,8 +1546,7 @@ a: Union[Type[Y], Type[Z]]
 if issubclass(a, X):
     reveal_type(a)  # N: Revealed type is "Union[Type[__main__.Y], Type[__main__.Z]]"
 else:
-    reveal_type(a)  # E: Statement is unreachable \
-                    # N: Revealed type is "Union[Type[__main__.Y], Type[__main__.Z]]"
+    reveal_type(a)  # N: Revealed type is "Union[Type[__main__.Y], Type[__main__.Z]]"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testIssubclasDestructuringUnions1]
@@ -1891,8 +1888,7 @@ def f(x: Type[int]) -> None:
     if isinstance(x, type):
         reveal_type(x) # N: Revealed type is "Type[builtins.int]"
     else:
-        reveal_type(x)  # E: Statement is unreachable \
-                        # N: Revealed type is "Type[builtins.int]"
+        reveal_type(x)  # N: Revealed type is "Never"
     reveal_type(x) # N: Revealed type is "Type[builtins.int]"
 [builtins fixtures/isinstance.pyi]
 
@@ -2392,17 +2388,15 @@ class C:
 class Example(A, B): pass  # E: Definition of "f" in base class "A" is incompatible with definition in base class "B"
 x: A
 if isinstance(x, B):  # E: Subclass of "A" and "B" cannot exist: would have incompatible method signatures
-    reveal_type(x)    # E: Statement is unreachable \
-                      # N: Revealed type is "__main__.A"
+    reveal_type(x)    # N: Revealed type is "Never"
 else:
     reveal_type(x)    # N: Revealed type is "__main__.A"
 
 y: C
 if isinstance(y, B):
     reveal_type(y)        # N: Revealed type is "__main__.<subclass of "__main__.C" and "__main__.B">"
     if isinstance(y, A):  # E: Subclass of "C", "B", and "A" cannot exist: would have incompatible method signatures
-        reveal_type(y)    # E: Statement is unreachable \
-                          # N: Revealed type is "__main__.<subclass of "__main__.C" and "__main__.B">"
+        reveal_type(y)    # N: Revealed type is "Never"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsInstanceAdHocIntersectionReversed]
@@ -2431,7 +2425,7 @@ class B:
     def t0(self) -> None:
         if isinstance(self, A0):        # E: Subclass of "B" and "A0" cannot exist: would have incompatible method signatures
             x0: Literal[0] = self.f()   # E: Statement is unreachable \
-                                        # E: Incompatible types in assignment (expression has type "Literal[1, 2]", variable has type "Literal[0]")
+                                        # E: "Never" has no attribute "f"
 
     def t1(self) -> None:
         if isinstance(self, A1):
@@ -2468,8 +2462,7 @@ class B:
 
 x: A[int]
 if isinstance(x, B):    # E: Subclass of "A[int]" and "B" cannot exist: would have incompatible method signatures
-    reveal_type(x)      # E: Statement is unreachable \
-                        # N: Revealed type is "__main__.A[builtins.int]"
+    reveal_type(x)      # N: Revealed type is "Never"
 else:
     reveal_type(x)      # N: Revealed type is "__main__.A[builtins.int]"
 
@@ -2509,29 +2502,28 @@ def f1(x: T1) -> T1:
                             # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
         else:
             reveal_type(x)  # N: Revealed type is "__main__.A" \
-                            # N: Revealed type is "__main__.<subclass of "__main__.B" and "__main__.A">"
+                            # N: Revealed type is "Never"
     else:
-        reveal_type(x)      # N: Revealed type is "__main__.A" \
+        reveal_type(x)      # N: Revealed type is "Never" \
                             # N: Revealed type is "__main__.B"
     return x
 
 T2 = TypeVar('T2', B, C)
 def f2(x: T2) -> T2:
     if isinstance(x, B):
         reveal_type(x)      # N: Revealed type is "__main__.B" \
-                            # N: Revealed type is "__main__.C"
+                            # N: Revealed type is "Never"
         # Note: even though --warn-unreachable is set, we don't report
         # errors for the below: we don't yet have a way of filtering out
         # reachability errors that occur for only one variation of the
         # TypeVar yet.
         if isinstance(x, C):
-            reveal_type(x)  # N: Revealed type is "__main__.B" \
-                            # N: Revealed type is "__main__.C"
+            reveal_type(x)  # N: Revealed type is "Never"
         else:
             reveal_type(x)  # N: Revealed type is "__main__.B" \
-                            # N: Revealed type is "__main__.C"
+                            # N: Revealed type is "Never"
     else:
-        reveal_type(x)      # N: Revealed type is "__main__.B" \
+        reveal_type(x)      # N: Revealed type is "Never" \
                             # N: Revealed type is "__main__.C"
     return x
 
@@ -2648,8 +2640,7 @@ class B(Y, X): pass
 
 foo: A
 if isinstance(foo, B):  # E: Subclass of "A" and "B" cannot exist: would have inconsistent method resolution order
-    reveal_type(foo)    # E: Statement is unreachable \
-                        # N: Revealed type is "__main__.A"
+    reveal_type(foo)    # N: Revealed type is "Never"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsInstanceAdHocIntersectionAmbiguousClass]
@@ -2683,8 +2674,7 @@ x: Type[A]
 if issubclass(x, B):
     reveal_type(x)        # N: Revealed type is "Type[__main__.<subclass of "__main__.A" and "__main__.B">]"
     if issubclass(x, C):  # E: Subclass of "A", "B", and "C" cannot exist: would have incompatible method signatures
-        reveal_type(x)    # E: Statement is unreachable \
-                          # N: Revealed type is "Type[__main__.<subclass of "__main__.A" and "__main__.B">]"
+        reveal_type(x)    # N: Revealed type is "Type[__main__.<subclass of "__main__.A" and "__main__.B">]"
     else:
         reveal_type(x)    # N: Revealed type is "Type[__main__.<subclass of "__main__.A" and "__main__.B">]"
 else: