much softer approach

Author: tyralla

mypy/binder.py

@@ -10,7 +10,6 @@
 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,
@@ -238,22 +237,8 @@ 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
-
-                    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])
-
+                    type = join_simple(self.declarations[key], 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:

mypy/join.py

@@ -17,6 +17,7 @@
     is_protocol_implementation,
     is_subtype,
 )
+from mypy.typeops import make_simplified_union
 from mypy.types import (
     AnyType,
     CallableType,
@@ -54,7 +55,8 @@
 
 
 class InstanceJoiner:
-    def __init__(self) -> None:
+    def __init__(self, prefer_union_over_supertype: bool = False) -> None:
+        self.prefer_union_over_supertype: bool = prefer_union_over_supertype
         self.seen_instances: list[tuple[Instance, Instance]] = []
 
     def join_instances(self, t: Instance, s: Instance) -> ProperType:
@@ -164,6 +166,9 @@ def join_instances_via_supertype(self, t: Instance, s: Instance) -> ProperType:
             if is_subtype(p, t):
                 return join_types(t, p, self)
 
+        if self.prefer_union_over_supertype:
+            return make_simplified_union([t, s])
+
         # Compute the "best" supertype of t when joined with s.
         # The definition of "best" may evolve; for now it is the one with
         # the longest MRO.  Ties are broken by using the earlier base.
@@ -224,7 +229,9 @@ def join_simple(declaration: Type | None, s: Type, t: Type) -> ProperType:
     if isinstance(s, UnionType) and not isinstance(t, UnionType):
         s, t = t, s
 
-    value = t.accept(TypeJoinVisitor(s))
+    value = t.accept(
+        TypeJoinVisitor(s, instance_joiner=InstanceJoiner(prefer_union_over_supertype=True))
+    )
     if declaration is None or is_subtype(value, declaration):
         return value
 

test-data/unit/check-narrowing.test

@@ -2353,8 +2353,7 @@ def fn_while(arg: T) -> None:
     return None
 [builtins fixtures/primitives.pyi]
 
-
-[case testNarrowingIsinstanceCreatesUnion]
+[case testNarrowingInstancesCreatesUnion]
 
 class A: ...
 class B(A): y: int