fix

Author: hauntsaninja

mypy/checker.py

@@ -8314,19 +8314,28 @@ def conditional_types(
     proper_type = get_proper_type(current_type)
     # factorize over union types: isinstance(A|B, C) -> yes = A_yes | B_yes
     if isinstance(proper_type, UnionType):
-        result: list[tuple[Type | None, Type | None]] = [
-            conditional_types(
+        yes_items: list[Type] | None = []
+        no_items: list[Type] | None = []
+        for union_item in proper_type.items:
+            yes_type, no_type = conditional_types(
                 union_item,
                 proposed_type_ranges,
                 default=union_item,
                 consider_runtime_isinstance=consider_runtime_isinstance,
                 consider_promotion_overlap=consider_promotion_overlap,
             )
-            for union_item in get_proper_types(proper_type.items)
-        ]
-        # separate list of tuples into two lists
-        yes_types, no_types = zip(*result)
-        proposed_type = make_simplified_union([t for t in yes_types if t is not None])
+            if yes_type is None:
+                yes_items = None
+            elif yes_items is not None:
+                yes_items.append(yes_type)
+            if no_type is None:
+                no_items = None
+            elif no_items is not None:
+                no_items.append(no_type)
+
+        proposed_type = make_simplified_union(yes_items) if yes_items is not None else None
+        remaining_type = make_simplified_union(no_items) if no_items is not None else None
+        return proposed_type, remaining_type
     else:
         proposed_items = [type_range.item for type_range in proposed_type_ranges]
         proposed_type = make_simplified_union(proposed_items)

test-data/unit/check-isinstance.test

@@ -1407,20 +1407,30 @@ def f(x: Union[A, B]) -> None:
 # flags: --warn-unreachable
 from typing import Union
 
-class FloatLike: pass
-class IntLike(FloatLike): pass
-
 def f1(x: Union[float, int]) -> None:
     # We ignore promotions in isinstance checks
     if isinstance(x, float):
         reveal_type(x)  # N: Revealed type is "builtins.float"
     else:
         reveal_type(x)  # N: Revealed type is "builtins.int"
 
+class FloatLike: pass
+class IntLike(FloatLike): pass
+
 def f2(x: Union[FloatLike, IntLike]) -> None:
-    # ...but not regular subtyping relationships
     if isinstance(x, FloatLike):
-        reveal_type(x)  # N: Revealed type is "__main__.FloatLike | __main__.IntLike"
+        reveal_type(x)  # N: Revealed type is "__main__.FloatLike"
+    else:
+        reveal_type(x)  # E: Statement is unreachable
+
+class FloatLike2: pass
+class IntLike2: pass
+
+def f3(x: Union[FloatLike2, IntLike2]) -> None:
+    if isinstance(x, FloatLike2):
+        reveal_type(x)  # N: Revealed type is "__main__.FloatLike2"
+    else:
+        reveal_type(x)  # N: Revealed type is "__main__.IntLike2"
 [builtins fixtures/isinstance.pyi]
 
 [case testIsinstanceOfSuperclass]

test-data/unit/check-narrowing.test

@@ -3523,6 +3523,14 @@ def f3(number: float | int, five: Literal[5]):
         reveal_type(number)  # N: Revealed type is "builtins.float | Literal[5]"
         reveal_type(five)  # N: Revealed type is "Literal[5]"
 
+def f8(number: float | Literal[5], five: Literal[5]):
+    if number == five:
+        reveal_type(number)  # N: Revealed type is "builtins.float | Literal[5]"
+        reveal_type(five)  # N: Revealed type is "Literal[5]"
+    else:
+        reveal_type(number)  # N: Revealed type is "builtins.float"
+        reveal_type(five)  # N: Revealed type is "Literal[5]"
+
 def f4(number: float | None, i: int):
     if number == i:
         reveal_type(number)  # N: Revealed type is "builtins.float"