Fix narrowing for unions (#20728)

Previously we considered the else branch unreachable in the
`testNarrowingAnyUnion` test case. It's also nice that the new code is
more obviously correct

Fixes #20330

This will help with landing #20727 as well

Author: hauntsaninja

mypy/checker.py

@@ -8305,24 +8305,29 @@ def conditional_types(
             enum_name = target.fallback.type.fullname
             current_type = try_expanding_sum_type_to_union(current_type, enum_name)
 
+    proposed_type: Type
+    remaining_type: Type
+
     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] = []
+        no_items: list[Type] = []
+        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,
             )
-            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])
-    else:
-        proposed_items = [type_range.item for type_range in proposed_type_ranges]
-        proposed_type = make_simplified_union(proposed_items)
+            yes_items.append(yes_type)
+            no_items.append(no_type)
+
+        proposed_type = make_simplified_union(yes_items)
+        remaining_type = make_simplified_union(no_items)
+        return proposed_type, remaining_type
+
+    proposed_type = make_simplified_union([type_range.item for type_range in proposed_type_ranges])
 
     if isinstance(proper_type, AnyType):
         return proposed_type, current_type

test-data/unit/check-isinstance.test

@@ -1407,20 +1407,21 @@ 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
 [builtins fixtures/isinstance.pyi]
 
 [case testIsinstanceOfSuperclass]

test-data/unit/check-narrowing.test

@@ -1652,6 +1652,21 @@ else:
 reveal_type(t)  # N: Revealed type is "Any"
 [builtins fixtures/isinstancelist.pyi]
 
+[case testNarrowingAnyUnion]
+# flags: --strict-equality --warn-unreachable
+from __future__ import annotations
+from unknown import A, AA  # E: Cannot find implementation or library stub for module named "unknown" \
+                           # N: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
+
+class B: ...
+
+def f(x: A | B) -> None:
+    if isinstance(x, (AA, B)):
+        reveal_type(x)  # N: Revealed type is "Any | __main__.B"
+    else:
+        reveal_type(x)  # N: Revealed type is "Any"
+[builtins fixtures/isinstancelist.pyi]
+
 [case testNarrowingLenItemAndLenCompare]
 # flags: --strict-equality --warn-unreachable
 from typing import Any

test-data/unit/check-typeis.test

@@ -950,3 +950,51 @@ def main(x: Union[A, B]) -> None:
     else:
         reveal_type(x)  # N: Revealed type is "__main__.B"
 [builtins fixtures/tuple.pyi]
+
+
+[case testTypeIsGeneric]
+from __future__ import annotations
+from typing import Any, Callable, TypeVar
+from typing_extensions import TypeIs
+
+T = TypeVar('T')
+
+def positive(x: T | int, checker: Callable[[Any], TypeIs[T]], default: int) -> int:
+    if checker(x):
+        reveal_type(x)  # N: Revealed type is "T`-1"
+        return default
+    else:
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+        return x
+
+def negative(x: T | int, checker: Callable[[Any], TypeIs[int]], default: T) -> T:
+    if checker(x):
+        reveal_type(x)  # N: Revealed type is "builtins.int"
+        return default
+    else:
+        reveal_type(x)  # N: Revealed type is "T`-1"
+        return x
+[builtins fixtures/tuple.pyi]
+
+
+[case testTypeIsAwaitable]
+from __future__ import annotations
+from typing import Any, Awaitable, Callable, TypeVar, overload
+from typing_extensions import TypeIs
+
+T = TypeVar("T")
+AwaitableCallable = Callable[..., Awaitable[T]]
+
+@overload
+def is_async_callable(obj: AwaitableCallable[T]) -> TypeIs[AwaitableCallable[T]]: ...
+@overload
+def is_async_callable(obj: Any) -> TypeIs[AwaitableCallable[Any]]: ...
+def is_async_callable(obj): ...
+
+def main(f: Callable[[], int | Awaitable[int]] | Callable[[], Awaitable[int]]) -> None:
+    if is_async_callable(f):
+        reveal_type(f)  # N: Revealed type is "(def (*Any, **Any) -> typing.Awaitable[Any]) | (def () -> typing.Awaitable[builtins.int])"
+    else:
+        reveal_type(f)  # N: Revealed type is "def () -> builtins.int | typing.Awaitable[builtins.int]"
+
+[builtins fixtures/tuple.pyi]