another approach

hauntsaninja · hauntsaninja · commit 54512be4fae1 · 2026-01-27T23:35:26.000-08:00
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -6720,14 +6720,14 @@ def narrow_type_by_identity_equality(
                 if is_target_for_value_narrowing(get_proper_type(target_type)):
                     if_map, else_map = conditional_types_to_typemaps(
                         operands[i],
-                        *conditional_types(expanded_expr_type, [target], ignore_promotions=False),
+                        *conditional_types(expanded_expr_type, [target], consider_promotion_overlap=True),
                     )
                     all_if_maps.append(if_map)
                     all_else_maps.append(else_map)
                 else:
                     if_map, else_map = conditional_types_to_typemaps(
                         operands[i],
-                        *conditional_types(expr_type, [target], ignore_promotions=False),
+                        *conditional_types(expr_type, [target], consider_promotion_overlap=True),
                     )
                     # For value targets, it is safe to narrow in the negative case.
                     # e.g. if (x: Literal[5] | None) != (y: Literal[5]), we can narrow x to None
@@ -6759,7 +6759,7 @@ def narrow_type_by_identity_equality(
                     if is_target_for_value_narrowing(get_proper_type(target_type)):
                         if_map, else_map = conditional_types_to_typemaps(
                             operands[i],
-                            *conditional_types(expr_type, [target], ignore_promotions=False),
+                            *conditional_types(expr_type, [target], consider_promotion_overlap=True),
                         )
                         if else_map:
                             all_else_maps.append(else_map)
@@ -6791,7 +6791,7 @@ def narrow_type_by_identity_equality(
                     if_map, else_map = conditional_types_to_typemaps(
                         operands[i],
                         *conditional_types(
-                            expr_type, [target], default=expr_type, ignore_promotions=False
+                            expr_type, [target], default=expr_type, consider_promotion_overlap=True
                         ),
                     )
                     or_if_maps.append(if_map)
@@ -8250,7 +8250,7 @@ def conditional_types(
     default: None = None,
     *,
     consider_runtime_isinstance: bool = True,
-    ignore_promotions: bool = True,
+    consider_promotion_overlap: bool = False,
 ) -> tuple[Type | None, Type | None]: ...
 
 
@@ -8261,7 +8261,7 @@ def conditional_types(
     default: Type,
     *,
     consider_runtime_isinstance: bool = True,
-    ignore_promotions: bool = True,
+    consider_promotion_overlap: bool = False,
 ) -> tuple[Type, Type]: ...
 
 
@@ -8271,7 +8271,7 @@ def conditional_types(
     default: Type | None = None,
     *,
     consider_runtime_isinstance: bool = True,
-    ignore_promotions: bool = True,
+    consider_promotion_overlap: bool = False,
 ) -> tuple[Type | None, Type | None]:
     """Takes in the current type and a proposed type of an expression.
 
@@ -8311,7 +8311,7 @@ def conditional_types(
                 proposed_type_ranges,
                 default=union_item,
                 consider_runtime_isinstance=consider_runtime_isinstance,
-                ignore_promotions=ignore_promotions,
+                consider_promotion_overlap=consider_promotion_overlap,
             )
             for union_item in get_proper_types(proper_type.items)
         ]
@@ -8331,14 +8331,14 @@ def conditional_types(
         return proposed_type, default
     if not any(type_range.is_upper_bound for type_range in proposed_type_ranges):
         # concrete subtype
-        if is_proper_subtype(current_type, proposed_type, ignore_promotions=ignore_promotions):
+        if is_proper_subtype(current_type, proposed_type, ignore_promotions=True):
             return default, UninhabitedType()
 
         # structural subtypes
         if (
             isinstance(proposed_type, CallableType)
             or (isinstance(proposed_type, Instance) and proposed_type.type.is_protocol)
-        ) and is_subtype(current_type, proposed_type, ignore_promotions=ignore_promotions):
+        ) and is_subtype(current_type, proposed_type, ignore_promotions=True):
             # Note: It's possible that current_type=`Any | Proto` while proposed_type=`Proto`
             #  so we cannot return `Never` for the else branch
             remainder = restrict_subtype_away(
@@ -8347,9 +8347,11 @@ def conditional_types(
                 consider_runtime_isinstance=consider_runtime_isinstance,
             )
             return default, remainder
-    if not is_overlapping_types(current_type, proposed_type, ignore_promotions=ignore_promotions):
+    if not is_overlapping_types(current_type, proposed_type, ignore_promotions=not consider_promotion_overlap):
         # Expression is never of any type in proposed_type_ranges
         return UninhabitedType(), default
+    if consider_promotion_overlap and not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
+        return default, default
     # we can only restrict when the type is precise, not bounded
     proposed_precise_type = UnionType.make_union(
         [type_range.item for type_range in proposed_type_ranges if not type_range.is_upper_bound]
diff --git a/test-data/unit/check-narrowing.test b/test-data/unit/check-narrowing.test
@@ -3287,28 +3287,38 @@ from typing import Literal
 
 def f1(number: float, i: int):
     if number == i:
-        reveal_type(number)  # N: Revealed type is "builtins.int"
+        reveal_type(number)  # N: Revealed type is "builtins.float"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
 
 def f2(number: float, five: Literal[5]):
     if number == five:
-        reveal_type(number)  # N: Revealed type is "Literal[5]"
+        reveal_type(number)  # N: Revealed type is "builtins.float"
+        reveal_type(five)  # N: Revealed type is "Literal[5]"
 
-def f3(number: float | None, i: int):
+def f3(number: float | int, five: Literal[5]):
+    if number == five:
+        reveal_type(number)  # N: Revealed type is "builtins.float | Literal[5]"
+        reveal_type(five)  # N: Revealed type is "Literal[5]"
+
+def f4(number: float | None, i: int):
     if number == i:
-        reveal_type(number)  # N: Revealed type is "builtins.int"
+        reveal_type(number)  # N: Revealed type is "builtins.float"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
 
-def f4(number: float | int, i: int):
+def f5(number: float | int, i: int):
     if number == i:
         reveal_type(number)  # N: Revealed type is "builtins.float | builtins.int"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
 
-def f5(number: float | complex, i: int):
+def f6(number: float | complex, i: int):
     if number == i:
         reveal_type(number)  # N: Revealed type is "builtins.float | builtins.complex"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
 
 class Custom:
     def __eq__(self, other: object) -> bool: return True
 
-def f6(number: float, x: Custom | int):
+def f7(number: float, x: Custom | int):
     if number == x:
         reveal_type(number)  # N: Revealed type is "builtins.float"
         reveal_type(x)  # N: Revealed type is "__main__.Custom | builtins.int"
