ignore promotions

Author: hauntsaninja

mypy/checker.py

@@ -6719,13 +6719,15 @@ 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])
+                        operands[i],
+                        *conditional_types(expanded_expr_type, [target], ignore_promotions=False),
                     )
                     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])
+                        operands[i],
+                        *conditional_types(expr_type, [target], ignore_promotions=False),
                     )
                     # 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
@@ -6756,7 +6758,8 @@ def narrow_type_by_identity_equality(
                     target = TypeRange(target_type, is_upper_bound=False)
                     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])
+                            operands[i],
+                            *conditional_types(expr_type, [target], ignore_promotions=False),
                         )
                         if else_map:
                             all_else_maps.append(else_map)
@@ -6786,7 +6789,10 @@ def narrow_type_by_identity_equality(
                         expr_type = coerce_to_literal(expr_type)
                         expr_type = try_expanding_sum_type_to_union(expr_type, None)
                     if_map, else_map = conditional_types_to_typemaps(
-                        operands[i], *conditional_types(expr_type, [target], default=expr_type)
+                        operands[i],
+                        *conditional_types(
+                            expr_type, [target], default=expr_type, ignore_promotions=False
+                        ),
                     )
                     or_if_maps.append(if_map)
                     if is_value_target:
@@ -8244,6 +8250,7 @@ def conditional_types(
     default: None = None,
     *,
     consider_runtime_isinstance: bool = True,
+    ignore_promotions: bool = True,
 ) -> tuple[Type | None, Type | None]: ...
 
 
@@ -8254,6 +8261,7 @@ def conditional_types(
     default: Type,
     *,
     consider_runtime_isinstance: bool = True,
+    ignore_promotions: bool = True,
 ) -> tuple[Type, Type]: ...
 
 
@@ -8263,6 +8271,7 @@ def conditional_types(
     default: Type | None = None,
     *,
     consider_runtime_isinstance: bool = True,
+    ignore_promotions: bool = True,
 ) -> tuple[Type | None, Type | None]:
     """Takes in the current type and a proposed type of an expression.
 
@@ -8321,14 +8330,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=True):
+        if is_proper_subtype(current_type, proposed_type, ignore_promotions=ignore_promotions):
             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=True):
+        ) and is_subtype(current_type, proposed_type, ignore_promotions=ignore_promotions):
             # 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(
@@ -8337,7 +8346,7 @@ def conditional_types(
                 consider_runtime_isinstance=consider_runtime_isinstance,
             )
             return default, remainder
-    if not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
+    if not is_overlapping_types(current_type, proposed_type, ignore_promotions=ignore_promotions):
         # Expression is never of any type in proposed_type_ranges
         return UninhabitedType(), default
     # we can only restrict when the type is precise, not bounded

test-data/unit/check-narrowing.test

@@ -3264,18 +3264,40 @@ def bar(y: Any):
 
 
 [case testNarrowingConstrainedTypeVarType]
-from __future__ import annotations
+# flags: --strict-equality --warn-unreachable
 from typing import TypeVar, Any, Type
 
 TargetType = TypeVar("TargetType", int, float, str)
 
 def convert_type(target_type: Type[TargetType]) -> TargetType:
     if target_type == str:
         return str()
-    if target_type == int:
+    if target_type == int:s
         return int()
     if target_type == float:
         return float()
     raise
+[builtins fixtures/primitives.pyi]
+
+
+[case testNarrowingEqualityWithPromotions]
+# flags: --strict-equality --warn-unreachable
+from __future__ import annotations
+from typing import Literal
+
+def f1(number: float, i: int):
+    if number == i:
+        reveal_type(number)  # 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]"
+
+class Custom:
+    def __eq__(self, other: object) -> bool: return True
 
+def f3(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"
 [builtins fixtures/primitives.pyi]