Improve narrowing via more coercion

Author: hauntsaninja

mypy/checker.py

@@ -6655,10 +6655,9 @@ def narrow_type_by_identity_equality(
                 continue  # Handled later
 
             expr_type = operand_types[i]
-            expanded_expr_type = try_expanding_sum_type_to_union(coerce_to_literal(expr_type), None)
-
             expr_enum_keys = ambiguous_enum_equality_keys(expr_type)
 
+            expr_type = try_expanding_sum_type_to_union(coerce_to_literal(expr_type), None)
             for j in expr_indices:
                 if i == j:
                     continue
@@ -6684,21 +6683,15 @@ def narrow_type_by_identity_equality(
                     continue
 
                 target = TypeRange(target_type, is_upper_bound=False)
-                is_value_target = 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])
+                )
 
-                if is_value_target:
-                    if_map, else_map = conditional_types_to_typemaps(
-                        operands[i], *conditional_types(expanded_expr_type, [target])
-                    )
-                    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])
-                    )
+                all_if_maps.append(if_map)
+                if is_target_for_value_narrowing(get_proper_type(target_type)):
                     # For type_targets, we cannot narrow in the negative case, so ignore else_map
                     # e.g. if (x: str | None) != (y: str), we cannot narrow x to None
-                    all_if_maps.append(if_map)
+                    all_else_maps.append(else_map)
 
         # Handle narrowing for operands with custom __eq__ methods specially
         # In most cases, we won't be able to do any narrowing
@@ -6718,9 +6711,7 @@ def narrow_type_by_identity_equality(
                     if should_coerce_literals:
                         target_type = coerce_to_literal(target_type)
                     target = TypeRange(target_type, is_upper_bound=False)
-                    is_value_target = is_target_for_value_narrowing(get_proper_type(target_type))
-
-                    if is_value_target:
+                    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])
                         )
@@ -6737,23 +6728,19 @@ def narrow_type_by_identity_equality(
                 if has_custom_eq_checks(expr_type):
                     or_if_maps.append({operands[i]: expr_type})
 
+                expr_type = coerce_to_literal(try_expanding_sum_type_to_union(expr_type, None))
                 for j in expr_indices:
                     if j in custom_eq_indices:
                         continue
                     target_type = operand_types[j]
                     if should_coerce_literals:
                         target_type = coerce_to_literal(target_type)
                     target = TypeRange(target_type, is_upper_bound=False)
-                    is_value_target = is_target_for_value_narrowing(get_proper_type(target_type))
-
-                    if is_value_target:
-                        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)
                     )
                     or_if_maps.append(if_map)
-                    if is_value_target:
+                    if is_target_for_value_narrowing(get_proper_type(target_type)):
                         or_else_maps.append(else_map)
 
             all_if_maps.append(reduce_or_conditional_type_maps(or_if_maps))

test-data/unit/check-optional.test

@@ -493,11 +493,11 @@ from typing import Optional
 
 def main(x: Optional[str]):
     if x == 0:
-        reveal_type(x)  # N: Revealed type is "builtins.str | None"
+        reveal_type(x)  # E: Statement is unreachable
     else:
         reveal_type(x)  # N: Revealed type is "builtins.str | None"
     if x is 0:
-        reveal_type(x)  # N: Revealed type is "builtins.str | None"
+        reveal_type(x)  # E: Statement is unreachable
     else:
         reveal_type(x)  # N: Revealed type is "builtins.str | None"
 [builtins fixtures/ops.pyi]

test-data/unit/check-python310.test

@@ -56,6 +56,7 @@ match m:
 -- Value Pattern --
 
 [case testMatchValuePatternNarrows]
+# flags: --warn-unreachable
 import b
 m: object
 
@@ -66,6 +67,7 @@ match m:
 b: int
 
 [case testMatchValuePatternAlreadyNarrower]
+# flags: --warn-unreachable
 import b
 m: bool
 
@@ -76,27 +78,28 @@ match m:
 b: int
 
 [case testMatchValuePatternIntersect]
+# flags: --warn-unreachable
 import b
 
 class A: ...
 m: A
 
 match m:
     case b.b:
-        reveal_type(m)  # N: Revealed type is "__main__.A"
+        reveal_type(m)  # E: Statement is unreachable
 [file b.py]
 class B: ...
 b: B
 
 [case testMatchValuePatternUnreachable]
-# primitives are needed because otherwise mypy doesn't see that int and str are incompatible
+# flags: --warn-unreachable
 import b
 
 m: int
 
 match m:
     case b.b:
-        reveal_type(m)  # N: Revealed type is "builtins.int"
+        reveal_type(m)  # E: Statement is unreachable
 [file b.py]
 b: str
 [builtins fixtures/primitives.pyi]
@@ -2766,7 +2769,7 @@ def x() -> tuple[Literal["test"]]: ...
 
 match x():
     case (x,) if x == "test":  # E: Incompatible types in capture pattern (pattern captures type "Literal['test']", variable has type "Callable[[], tuple[Literal['test']]]")
-        reveal_type(x)  # N: Revealed type is "def () -> tuple[Literal['test']]"
+        reveal_type(x)  # E: Statement is unreachable
     case foo:
         foo
 

test-data/unit/check-tuples.test

@@ -1533,17 +1533,24 @@ reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.int]"
 [builtins fixtures/tuple.pyi]
 
 [case testTupleOverlapDifferentTuples]
+# flags: --warn-unreachable
 from typing import Optional, Tuple
 class A: pass
 class B: pass
 
-possibles: Tuple[int, Tuple[A]]
-x: Optional[Tuple[B]]
+def f1(possibles: Tuple[int, Tuple[A]], x: Optional[Tuple[B]]):
+    if x in possibles:
+        reveal_type(x)  # E: Statement is unreachable
+    else:
+        reveal_type(x) # N: Revealed type is "tuple[__main__.B] | None"
+
+class AA(A): pass
 
-if x in possibles:
-    reveal_type(x) # N: Revealed type is "tuple[__main__.B]"
-else:
-    reveal_type(x) # N: Revealed type is "tuple[__main__.B] | None"
+def f2(possibles: Tuple[int, Tuple[A]], x: Optional[Tuple[AA]]):
+    if x in possibles:
+        reveal_type(x)  # N: Revealed type is "tuple[__main__.AA]"
+    else:
+        reveal_type(x) # N: Revealed type is "tuple[__main__.AA] | None"
 
 [builtins fixtures/tuple.pyi]