Move the join-based narrowing logic towards a union-based narrowing logic.

More concretely: use `make_simplified_union` instead of `join_simple` in `ConditionalTypeBinder.update_from_options`

Author: tyralla

mypy/binder.py

@@ -10,6 +10,7 @@
 from mypy.literals import Key, literal, literal_hash, subkeys
 from mypy.nodes import Expression, IndexExpr, MemberExpr, NameExpr, RefExpr, TypeInfo, Var
 from mypy.subtypes import is_same_type, is_subtype
+from mypy.typeops import make_simplified_union
 from mypy.types import (
     AnyType,
     Instance,
@@ -237,8 +238,22 @@ def update_from_options(self, frames: list[Frame]) -> bool:
                     type = AnyType(TypeOfAny.from_another_any, source_any=declaration_type)
             else:
                 for other in resulting_values[1:]:
+
                     assert other is not None
-                    type = join_simple(self.declarations[key], type, other.type)
+
+                    if (
+                        isinstance(t1 := get_proper_type(type), TupleType)
+                        and isinstance(t2 := get_proper_type(other.type), TupleType)
+                        and (len(l1 := t1.items) == len(l2 := t2.items))
+                        and (find_unpack_in_list(l1) is None)
+                        and (find_unpack_in_list(l2) is None)
+                    ):
+                        type = t1.copy_modified(
+                            items=[make_simplified_union([i1, i2]) for i1, i2 in zip(l1, l2)]
+                        )
+                    else:
+                        type = make_simplified_union([type, other.type])
+
                     # Try simplifying resulting type for unions involving variadic tuples.
                     # Technically, everything is still valid without this step, but if we do
                     # not do this, this may create long unions after exiting an if check like:

test-data/unit/check-narrowing.test

@@ -2352,3 +2352,24 @@ def fn_while(arg: T) -> None:
         return None
     return None
 [builtins fixtures/primitives.pyi]
+
+
+[case testNarrowingIsinstanceCreatesUnion]
+
+class A: ...
+class B(A): y: int
+class C(A): y: int
+class D(C): ...
+class E(C): ...
+class F(C): ...
+
+def f(x: A):
+    if isinstance(x, B): ...
+    elif isinstance(x, D): ...
+    elif isinstance(x, E): ...
+    elif isinstance(x, F): ...
+    else: return
+    reveal_type(x)  # N: Revealed type is "Union[__main__.B, __main__.D, __main__.E, __main__.F]"
+    reveal_type(x.y)  # N: Revealed type is "builtins.int"
+
+[builtins fixtures/isinstance.pyi]

test-data/unit/check-redefine.test

@@ -321,7 +321,7 @@ def f() -> None:
     x = 1
     if int():
         x = ''
-    reveal_type(x) # N: Revealed type is "builtins.object"
+    reveal_type(x) # N: Revealed type is "Union[builtins.str, builtins.int]"
     x = ''
     reveal_type(x) # N: Revealed type is "builtins.str"
     if int():