Narrow things based on key types even if the type is Never

Author: A5rocks

mypy/checker.py

@@ -6093,7 +6093,7 @@ def find_isinstance_check(
         for example, some errors are suppressed.
 
         May return {}, {}.
-        Can return None, None in situations involving NoReturn.
+        Can return None, None in situations involving Never.
         """
         if_map, else_map = self.find_isinstance_check_helper(
             node, in_boolean_context=in_boolean_context
@@ -6628,21 +6628,22 @@ def replay_lookup(new_parent_type: ProperType) -> Type | None:
             # Take each element in the parent union and replay the original lookup procedure
             # to figure out which parents are compatible.
             new_parent_types = []
+            expr_type_p = get_proper_type(expr_type)
             for item in flatten_nested_unions(parent_type.items):
                 member_type = replay_lookup(get_proper_type(item))
                 if member_type is None:
                     # We were unable to obtain the member type. So, we give up on refining this
                     # parent type entirely and abort.
                     return output
 
-                if is_overlapping_types(member_type, expr_type):
-                    new_parent_types.append(item)
+                # note: this is not unconditionally setting `UninhabitedType`
+                #       as there might be X.a which is a Never
+                if isinstance(expr_type_p, UninhabitedType):
+                    if isinstance(get_proper_type(member_type), UninhabitedType):
+                        new_parent_types.append(item)
 
-            # If none of the parent types overlap (if we derived an empty union), something
-            # went wrong. We should never hit this case, but deriving the uninhabited type or
-            # reporting an error both seem unhelpful. So we abort.
-            if not new_parent_types:
-                return output
+                elif is_overlapping_types(member_type, expr_type):
+                    new_parent_types.append(item)
 
             expr = parent_expr
             expr_type = output[parent_expr] = make_simplified_union(new_parent_types)

test-data/unit/check-narrowing.test

@@ -264,8 +264,8 @@ else:
 
 if x.key is Key.D:
     # TODO: this should narrow to Never
-    reveal_type(x)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Union[__main__.Object1, __main__.Object2]"
+    reveal_type(x)  # E: Statement is unreachable \
+                    # N: Revealed type is "Never"
 else:
     reveal_type(x)  # N: Revealed type is "Union[__main__.Object1, __main__.Object2]"
 [builtins fixtures/tuple.pyi]
@@ -291,8 +291,8 @@ else:
     reveal_type(x)  # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key': Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key': Union[Literal['B'], Literal['C']]})]"
 
 if x['key'] == 'D':
-    reveal_type(x)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key': Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key': Union[Literal['B'], Literal['C']]})]"
+    reveal_type(x)  # E: Statement is unreachable \
+                    # N: Revealed type is "Never"
 else:
     reveal_type(x)  # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key': Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key': Union[Literal['B'], Literal['C']]})]"
 [builtins fixtures/primitives.pyi]
@@ -319,8 +319,8 @@ else:
     reveal_type(x)  # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key'?: Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key'?: Union[Literal['B'], Literal['C']]})]"
 
 if x['key'] == 'D':
-    reveal_type(x)  # E: Statement is unreachable  \
-                    # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key'?: Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key'?: Union[Literal['B'], Literal['C']]})]"
+    reveal_type(x)  # E: Statement is unreachable \
+                    # N: Revealed type is "Never"
 else:
     reveal_type(x)  # N: Revealed type is "Union[TypedDict('__main__.TypedDict1', {'key'?: Union[Literal['A'], Literal['C']]}), TypedDict('__main__.TypedDict2', {'key'?: Union[Literal['B'], Literal['C']]})]"
 [builtins fixtures/primitives.pyi]
@@ -611,8 +611,8 @@ else:
 y: Union[Parent1, Parent2]
 if y["model"]["key"] is Key.C:
     reveal_type(y)              # E: Statement is unreachable \
-                                # N: Revealed type is "Union[TypedDict('__main__.Parent1', {'model': TypedDict('__main__.Model1', {'key': Literal[__main__.Key.A]}), 'foo': builtins.int}), TypedDict('__main__.Parent2', {'model': TypedDict('__main__.Model2', {'key': Literal[__main__.Key.B]}), 'bar': builtins.str})]"
-    reveal_type(y["model"])  # N: Revealed type is "Union[TypedDict('__main__.Model1', {'key': Literal[__main__.Key.A]}), TypedDict('__main__.Model2', {'key': Literal[__main__.Key.B]})]"
+                                # N: Revealed type is "Never"
+    reveal_type(y["model"])  # N: Revealed type is "Never"
 else:
     reveal_type(y)              # N: Revealed type is "Union[TypedDict('__main__.Parent1', {'model': TypedDict('__main__.Model1', {'key': Literal[__main__.Key.A]}), 'foo': builtins.int}), TypedDict('__main__.Parent2', {'model': TypedDict('__main__.Model2', {'key': Literal[__main__.Key.B]}), 'bar': builtins.str})]"
     reveal_type(y["model"])     # N: Revealed type is "Union[TypedDict('__main__.Model1', {'key': Literal[__main__.Key.A]}), TypedDict('__main__.Model2', {'key': Literal[__main__.Key.B]})]"
@@ -648,8 +648,8 @@ else:
 y: Union[Parent1, Parent2]
 if y["model"]["key"] == 'C':
     reveal_type(y)              # E: Statement is unreachable \
-                                # N: Revealed type is "Union[TypedDict('__main__.Parent1', {'model': TypedDict('__main__.Model1', {'key': Literal['A']}), 'foo': builtins.int}), TypedDict('__main__.Parent2', {'model': TypedDict('__main__.Model2', {'key': Literal['B']}), 'bar': builtins.str})]"
-    reveal_type(y["model"])  # N: Revealed type is "Union[TypedDict('__main__.Model1', {'key': Literal['A']}), TypedDict('__main__.Model2', {'key': Literal['B']})]"
+                                # N: Revealed type is "Never"
+    reveal_type(y["model"])  # N: Revealed type is "Never"
 else:
     reveal_type(y)              # N: Revealed type is "Union[TypedDict('__main__.Parent1', {'model': TypedDict('__main__.Model1', {'key': Literal['A']}), 'foo': builtins.int}), TypedDict('__main__.Parent2', {'model': TypedDict('__main__.Model2', {'key': Literal['B']}), 'bar': builtins.str})]"
     reveal_type(y["model"])     # N: Revealed type is "Union[TypedDict('__main__.Model1', {'key': Literal['A']}), TypedDict('__main__.Model2', {'key': Literal['B']})]"
@@ -2445,3 +2445,16 @@ def foo(x: T) -> T:
     reveal_type(x)  # N: Revealed type is "T`-1"
     return x
 [builtins fixtures/isinstance.pyi]
+
+[case testNarrowingToClassWithNeverProperty]
+# flags: --warn-unreachable
+from typing import Never
+
+class X:
+    a: Never
+
+x: X
+if x.a is 5:
+    reveal_type(x)  # N: Revealed type is "__main__.X"
+else:
+    reveal_type(x)  # N: Revealed type is "__main__.X"