Fix two type inference bugs related to enum value attributes

mypy/erasetype.py

@@ -161,3 +161,12 @@ def visit_type_alias_type(self, t: TypeAliasType) -> Type:
         # Type aliases can't contain literal values, because they are
         # always constructed as explicit types.
         return t
+
+    def visit_union_type(self, t: UnionType) -> Type:
+        new = super().visit_union_type(t)
+        new = get_proper_type(new)
+        if isinstance(new, UnionType):
+            from mypy.typeops import make_simplified_union
+            # Erasure can result in many duplicate items; remove them.
+            new = make_simplified_union(new.items)
+        return new

mypy/join.py

@@ -175,15 +175,15 @@ def join_types(s: Type, t: Type, instance_joiner: Optional[InstanceJoiner] = Non
         s = mypy.typeops.true_or_false(s)
         t = mypy.typeops.true_or_false(t)
 
+    if isinstance(s, UnionType) and not isinstance(t, UnionType):
+        s, t = t, s
+
     if isinstance(s, AnyType):
         return s
 
     if isinstance(s, ErasedType):
         return t
 
-    if isinstance(s, UnionType) and not isinstance(t, UnionType):
-        s, t = t, s
-
     if isinstance(s, NoneType) and not isinstance(t, NoneType):
         s, t = t, s
 

test-data/unit/check-enum.test

@@ -1868,3 +1868,21 @@ class WithOverload(enum.IntEnum):
 class SubWithOverload(WithOverload):  # Should pass
     pass
 [builtins fixtures/tuple.pyi]
+
+[case testEnumtValueUnionSimplification]
+from enum import IntEnum
+from typing import Any
+
+class C(IntEnum):
+    X = 0
+    Y = 1
+    Z = 2
+
+def f1(c: C) -> None:
+    x = {'x': c.value}
+    reveal_type(x)  # N: Revealed type is "builtins.dict[builtins.str*, builtins.int]"
+
+def f2(c: C, a: Any) -> None:
+    x = {'x': c.value, 'y': a}
+    reveal_type(x)  # N: Revealed type is "builtins.dict[builtins.str*, Any]"
+[builtins fixtures/dict.pyi]