revert union behavior

Author: randolf-scholz

mypy/join.py

@@ -274,10 +274,6 @@ def visit_unbound_type(self, t: UnboundType) -> ProperType:
     def visit_union_type(self, t: UnionType) -> ProperType:
         if is_proper_subtype(self.s, t):
             return t
-        elif isinstance(self.s, LiteralType):
-            # E.g.  join("x", "y" | "z") -> "x" | "y" | "z"
-            #   and join(1, "y" | "z") -> object
-            return mypy.typeops.make_simplified_union([join_types(self.s, x) for x in t.items])
         else:
             return mypy.typeops.make_simplified_union([self.s, t])
 
@@ -636,9 +632,7 @@ def visit_literal_type(self, t: LiteralType) -> ProperType:
             if t == self.s:
                 # E.g. Literal["x"], Literal["x"] -> Literal["x"]
                 return t
-            if (self.s.fallback.type == t.fallback.type) or (
-                self.s.fallback.type.is_enum and t.fallback.type.is_enum
-            ):
+            if self.s.fallback.type.is_enum and t.fallback.type.is_enum:
                 return mypy.typeops.make_simplified_union([self.s, t])
             return join_types(self.s.fallback, t.fallback)
         elif isinstance(self.s, Instance) and self.s.last_known_value == t:

mypy/test/testtypes.py

@@ -1015,8 +1015,7 @@ def test_literal_type(self) -> None:
         self.assert_join(lit1, lit1, lit1)
         self.assert_join(lit1, a, a)
         self.assert_join(lit1, d, self.fx.o)
-        self.assert_simple_join(lit1, lit2, UnionType([lit1, lit2]))
-        self.assert_simple_join(lit2, lit1, UnionType([lit2, lit1]))
+        self.assert_join(lit1, lit2, a)
         self.assert_join(lit1, lit3, self.fx.o)
         self.assert_join(lit1, self.fx.anyt, self.fx.anyt)
         self.assert_join(UnionType([lit1, lit2]), lit2, UnionType([lit1, lit2]))
@@ -1064,12 +1063,11 @@ def test_mixed_literal_types(self) -> None:
         self.assert_join(str1_inst, str1_inst, str1_inst)
 
         # other operand is a different literal
-        # "x" , "y"  -> "x" | "y" (treat real literals like enum)
+        # "x" , "y"  -> str (TODO: consider using "x" | "y" (treat real literals like enum))
         # "x" , "y"? -> str
         # "x"?, "y"  -> str
         # "x"?, "y"? -> str
-        self.assert_simple_join(str1, str2, UnionType([str1, str2]))
-        self.assert_simple_join(str2, str1, UnionType([str2, str1]))
+        self.assert_join(str1, str2, str_type)
         self.assert_join(str1, str2_inst, str_type)
         self.assert_join(str1_inst, str2_inst, str_type)
 

test-data/unit/check-literal.test

@@ -1169,7 +1169,7 @@ arr4 = [lit1, lit2, lit3]
 arr5 = [object(), lit1]
 
 reveal_type(arr1)  # N: Revealed type is "builtins.list[Literal[1]]"
-reveal_type(arr2)  # N: Revealed type is "builtins.list[Union[Literal[1], Literal[2]]]"
+reveal_type(arr2)  # N: Revealed type is "builtins.list[builtins.int]"
 reveal_type(arr3)  # N: Revealed type is "builtins.list[builtins.int]"
 reveal_type(arr4)  # N: Revealed type is "builtins.list[builtins.object]"
 reveal_type(arr5)  # N: Revealed type is "builtins.list[builtins.object]"