Prevent narrowing by equality to overlapping literals (discarding enum info).

Author: sterliakov

mypy/checker.py

@@ -6866,8 +6866,28 @@ def should_coerce_inner(typ: Type) -> bool:
             # We intentionally use 'conditional_types' directly here instead of
             # 'self.conditional_types_with_intersection': we only compute ad-hoc
             # intersections when working with pure instances.
-            types = conditional_types(expr_type, target_type)
-            partial_type_maps.append(conditional_types_to_typemaps(expr, *types))
+            yes, no = conditional_types(expr_type, target_type)
+            # If we encounter `enum_value == 1` checks (enum vs literal), we do not want
+            # to narrow the former to literal and should preserve the enum identity.
+            # TODO: maybe we should infer literals here?
+            if (
+                isinstance(get_proper_type(yes), LiteralType)
+                and isinstance(proper_expr := get_proper_type(expr_type), Instance)
+                and proper_expr.type.is_enum
+            ):
+                yes_items = []
+                for name in proper_expr.type.enum_members:
+                    e = proper_expr.type.get(name)
+                    if (
+                        e is not None
+                        and isinstance(proper_e := get_proper_type(e.type), Instance)
+                        and proper_e.last_known_value == yes
+                    ):
+                        name_val = LiteralType(name, fallback=proper_expr)
+                        yes_items.append(proper_expr.copy_modified(last_known_value=name_val))
+                if yes_items:
+                    yes = UnionType.make_union(yes_items)
+            partial_type_maps.append(conditional_types_to_typemaps(expr, yes, no))
 
         return reduce_conditional_maps(partial_type_maps)
 

test-data/unit/check-narrowing.test

@@ -2203,6 +2203,11 @@ def f3(x: IE | IE2) -> None:
      else:
          reveal_type(x)  # N: Revealed type is "Union[__main__.IE, __main__.IE2]"
 
+     if x == 1:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, __main__.IE2]"
+     else:
+         reveal_type(x)  # N: Revealed type is "Union[__main__.IE, __main__.IE2]"
+
 def f4(x: IE | E) -> None:
      if x == IE.X:
          reveal_type(x)  # N: Revealed type is "Literal[__main__.IE.X]"