Use union types instead of join in binder

Author: ilevkivskyi

mypy/binder.py

@@ -7,10 +7,10 @@
 from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.erasetype import remove_instance_last_known_values
-from mypy.join import join_simple
 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,27 +237,25 @@ 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)
-                    # 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:
-                    #     x: tuple[int, ...]
-                    #     if len(x) < 10:
-                    #         ...
-                    # We want the type of x to be tuple[int, ...] after this block (if it is
-                    # still equivalent to such type).
-                    if isinstance(type, UnionType):
-                        type = collapse_variadic_union(type)
-                    if isinstance(type, ProperType) and isinstance(type, UnionType):
-                        # Simplify away any extra Any's that were added to the declared
-                        # type when popping a frame.
-                        simplified = UnionType.make_union(
-                            [t for t in type.items if not isinstance(get_proper_type(t), AnyType)]
-                        )
-                        if simplified == self.declarations[key]:
-                            type = simplified
+                type = make_simplified_union([t.type for t in resulting_values])
+                # 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:
+                #     x: tuple[int, ...]
+                #     if len(x) < 10:
+                #         ...
+                # We want the type of x to be tuple[int, ...] after this block (if it is
+                # still equivalent to such type).
+                if isinstance(type, UnionType):
+                    type = collapse_variadic_union(type)
+                if isinstance(type, ProperType) and isinstance(type, UnionType):
+                    # Simplify away any extra Any's that were added to the declared
+                    # type when popping a frame.
+                    simplified = UnionType.make_union(
+                        [t for t in type.items if not isinstance(get_proper_type(t), AnyType)]
+                    )
+                    if simplified == self.declarations[key]:
+                        type = simplified
             if current_value is None or not is_same_type(type, current_value[0]):
                 self._put(key, type, from_assignment=True)
                 changed = True

mypy/join.py

@@ -183,55 +183,6 @@ def join_instances_via_supertype(self, t: Instance, s: Instance) -> ProperType:
         return best
 
 
-def join_simple(declaration: Type | None, s: Type, t: Type) -> ProperType:
-    """Return a simple least upper bound given the declared type.
-
-    This function should be only used by binder, and should not recurse.
-    For all other uses, use `join_types()`.
-    """
-    declaration = get_proper_type(declaration)
-    s = get_proper_type(s)
-    t = get_proper_type(t)
-
-    if (s.can_be_true, s.can_be_false) != (t.can_be_true, t.can_be_false):
-        # if types are restricted in different ways, use the more general versions
-        s = mypy.typeops.true_or_false(s)
-        t = mypy.typeops.true_or_false(t)
-
-    if isinstance(s, AnyType):
-        return s
-
-    if isinstance(s, ErasedType):
-        return t
-
-    if is_proper_subtype(s, t, ignore_promotions=True):
-        return t
-
-    if is_proper_subtype(t, s, ignore_promotions=True):
-        return s
-
-    if isinstance(declaration, UnionType):
-        return mypy.typeops.make_simplified_union([s, t])
-
-    if isinstance(s, NoneType) and not isinstance(t, NoneType):
-        s, t = t, s
-
-    if isinstance(s, UninhabitedType) and not isinstance(t, UninhabitedType):
-        s, t = t, s
-
-    # Meets/joins require callable type normalization.
-    s, t = normalize_callables(s, t)
-
-    if isinstance(s, UnionType) and not isinstance(t, UnionType):
-        s, t = t, s
-
-    value = t.accept(TypeJoinVisitor(s))
-    if declaration is None or is_subtype(value, declaration):
-        return value
-
-    return declaration
-
-
 def trivial_join(s: Type, t: Type) -> Type:
     """Return one of types (expanded) if it is a supertype of other, otherwise top type."""
     if is_subtype(s, t):

mypy/test/testtypes.py

@@ -7,7 +7,7 @@
 
 from mypy.erasetype import erase_type, remove_instance_last_known_values
 from mypy.indirection import TypeIndirectionVisitor
-from mypy.join import join_simple, join_types
+from mypy.join import join_types
 from mypy.meet import meet_types, narrow_declared_type
 from mypy.nodes import (
     ARG_NAMED,
@@ -817,12 +817,12 @@ def test_any_type(self) -> None:
             self.assert_join(t, self.fx.anyt, self.fx.anyt)
 
     def test_mixed_truth_restricted_type_simple(self) -> None:
-        # join_simple against differently restricted truthiness types drops restrictions.
+        # make_simplified_union against differently restricted truthiness types drops restrictions.
         true_a = true_only(self.fx.a)
         false_o = false_only(self.fx.o)
-        j = join_simple(self.fx.o, true_a, false_o)
-        assert j.can_be_true
-        assert j.can_be_false
+        u = make_simplified_union([true_a, false_o])
+        assert u.can_be_true
+        assert u.can_be_false
 
     def test_mixed_truth_restricted_type(self) -> None:
         # join_types against differently restricted truthiness types drops restrictions.

test-data/unit/check-python310.test

@@ -1487,11 +1487,13 @@ match m5:
     case _:
         reveal_type(m5)  # N: Revealed type is "Tuple[Literal[2], Union[Literal['a'], Literal['b']]]"
 
-match m5:
+m6: Tuple[Literal[1, 2], Literal["a", "b"]]
+
+match m6:
     case (1, "a"):
-        reveal_type(m5)  # N: Revealed type is "Tuple[Literal[1], Literal['a']]"
+        reveal_type(m6)  # N: Revealed type is "Tuple[Literal[1], Literal['a']]"
     case _:
-        reveal_type(m5)  # N: Revealed type is "Tuple[Union[Literal[1], Literal[2]], Union[Literal['a'], Literal['b']]]"
+        reveal_type(m6)  # N: Revealed type is "Tuple[Union[Literal[1], Literal[2]], Union[Literal['a'], Literal['b']]]"
 
 [builtins fixtures/tuple.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():