refactored conditional_types and restrict_subtype_away

Author: randolf-scholz

mypy/checker.py

@@ -8001,7 +8001,10 @@ def conditional_types(
             None means no new information can be inferred.
         If default is set it is returned instead.
     """
-    if proposed_type_ranges and len(proposed_type_ranges) == 1:
+    if not proposed_type_ranges:
+        return UninhabitedType(), default
+
+    if len(proposed_type_ranges) == 1:
         # expand e.g. bool -> Literal[True] | Literal[False]
         target = proposed_type_ranges[0].item
         target = get_proper_type(target)
@@ -8012,7 +8015,11 @@ def conditional_types(
             current_type = try_expanding_sum_type_to_union(current_type, enum_name)
 
     current_type = get_proper_type(current_type)
-    if isinstance(current_type, UnionType) and (default == current_type):
+    if (
+        isinstance(current_type, UnionType)
+        and not any(tr.is_upper_bound for tr in proposed_type_ranges)
+        and (default in (current_type, None))
+    ):
         # factorize over union types
         # if we try to narrow A|B to C, we instead narrow A to C and B to C, and
         # return the union of the results
@@ -8027,47 +8034,39 @@ def conditional_types(
         ]
         # separate list of tuples into two lists
         yes_types, no_types = zip(*result)
-        yes_type = make_simplified_union([t for t in yes_types if t is not None])
-        no_type = restrict_subtype_away(
-            current_type, yes_type, consider_runtime_isinstance=consider_runtime_isinstance
-        )
-
-        return yes_type, no_type
-
-    if proposed_type_ranges:
+        proposed_type = make_simplified_union([t for t in yes_types if t is not None])
+    else:
         proposed_items = [type_range.item for type_range in proposed_type_ranges]
         proposed_type = make_simplified_union(proposed_items)
-        if isinstance(proposed_type, AnyType):
-            # We don't really know much about the proposed type, so we shouldn't
-            # attempt to narrow anything. Instead, we broaden the expr to Any to
-            # avoid false positives
-            return proposed_type, default
-        elif not any(
-            type_range.is_upper_bound for type_range in proposed_type_ranges
-        ) and is_proper_subtype(current_type, proposed_type, ignore_promotions=True):
-            # Expression is always of one of the types in proposed_type_ranges
-            return default, UninhabitedType()
-        elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
-            # Expression is never of any type in proposed_type_ranges
-            return UninhabitedType(), default
-        else:
-            # we can only restrict when the type is precise, not bounded
-            proposed_precise_type = UnionType.make_union(
-                [
-                    type_range.item
-                    for type_range in proposed_type_ranges
-                    if not type_range.is_upper_bound
-                ]
-            )
-            remaining_type = restrict_subtype_away(
-                current_type,
-                proposed_precise_type,
-                consider_runtime_isinstance=consider_runtime_isinstance,
-            )
-            return proposed_type, remaining_type
+
+    if isinstance(proposed_type, AnyType):
+        # We don't really know much about the proposed type, so we shouldn't
+        # attempt to narrow anything. Instead, we broaden the expr to Any to
+        # avoid false positives
+        return proposed_type, default
+    elif not any(
+        type_range.is_upper_bound for type_range in proposed_type_ranges
+    ) and is_proper_subtype(current_type, proposed_type, ignore_promotions=True):
+        # Expression is always of one of the types in proposed_type_ranges
+        return default, UninhabitedType()
+    elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
+        # Expression is never of any type in proposed_type_ranges
+        return UninhabitedType(), default
     else:
-        # An isinstance check, but we don't understand the type
-        return current_type, default
+        # we can only restrict when the type is precise, not bounded
+        proposed_precise_type = UnionType.make_union(
+            [
+                type_range.item
+                for type_range in proposed_type_ranges
+                if not type_range.is_upper_bound
+            ]
+        )
+        remaining_type = restrict_subtype_away(
+            current_type,
+            proposed_precise_type,
+            consider_runtime_isinstance=consider_runtime_isinstance,
+        )
+        return proposed_type, remaining_type
 
 
 def conditional_types_to_typemaps(

mypy/subtypes.py

@@ -2094,6 +2094,8 @@ def restrict_subtype_away(t: Type, s: Type, *, consider_runtime_isinstance: bool
     isinstance(). Currently, this just removes elements of a union type.
     """
     p_t = get_proper_type(t)
+    s_t = get_proper_type(s)
+
     if isinstance(p_t, UnionType):
         new_items = try_restrict_literal_union(p_t, s)
         if new_items is None:
@@ -2107,7 +2109,15 @@ def restrict_subtype_away(t: Type, s: Type, *, consider_runtime_isinstance: bool
             [item for item in new_items if not isinstance(get_proper_type(item), UninhabitedType)]
         )
     elif isinstance(p_t, TypeVarType):
-        return p_t.copy_modified(upper_bound=restrict_subtype_away(p_t.upper_bound, s))
+        if isinstance(s_t, TypeVarType):
+            upper_bound = restrict_subtype_away(p_t.upper_bound, s_t.upper_bound)
+            upper_bound = get_proper_type(upper_bound)
+            return (
+                upper_bound
+                if isinstance(upper_bound, UninhabitedType)
+                else p_t.copy_modified(upper_bound=upper_bound)
+            )
+        return p_t.copy_modified(upper_bound=restrict_subtype_away(p_t.upper_bound, s_t))
 
     if consider_runtime_isinstance:
         if covers_at_runtime(t, s):

test-data/unit/check-isinstance.test

@@ -1483,11 +1483,12 @@ def f(x: Union[int, A], a: Type[A]) -> None:
 [builtins fixtures/isinstancelist.pyi]
 
 [case testIsInstanceWithEmtpy2ndArg]
+# flags: --warn-unreachable
 from typing import Union
 
 def f(x: Union[int, str]) -> None:
     if isinstance(x, ()):
-        reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str]"
+        reveal_type(x)  # E: Statement is unreachable
     else:
         reveal_type(x)  # N: Revealed type is "Union[builtins.int, builtins.str]"
 [builtins fixtures/isinstancelist.pyi]

test-data/unit/check-narrowing.test

@@ -2639,7 +2639,7 @@ def baz(item: Base) -> None:
 
     reveal_type(item)  # N: Revealed type is "Union[__main__.<subclass of "__main__.Base" and "__main__.FooMixin">, __main__.<subclass of "__main__.Base" and "__main__.BarMixin">]"
     if isinstance(item, FooMixin):
-        reveal_type(item)  # N: Revealed type is "__main__.FooMixin"
+        reveal_type(item)  # N: Revealed type is "__main__.<subclass of "__main__.Base" and "__main__.FooMixin">"
         item.foo()
     else:
         reveal_type(item)  # N: Revealed type is "__main__.<subclass of "__main__.Base" and "__main__.BarMixin">"