More testing related improvements and updates (#20709)

Less trivial follow up to #20707

Several of the skipped match tests now pass or have better behaviour, so
unskipping them

The two new tests I added both do not have great behaviour, mostly
predating my rewrite. I improve these in
#20660 but that PR is a little tricky
to land, so I'm separating it out. This way it is easier for reviewers
to evaluate what the changes are.

Author: hauntsaninja

test-data/unit/check-narrowing.test

@@ -3246,14 +3246,15 @@ class B: ...
 
 T = TypeVar("T")
 
-def forgets_about_subclasses1(self, obj: T) -> T:
+def forgets_about_subclasses(self, obj: T) -> T:
     if isinstance(obj, A):
         return A()  # E: Incompatible return value type (got "A", expected "T")
     elif isinstance(obj, B):
         return B()  # E: Incompatible return value type (got "B", expected "T")
     raise
 
 def correct1(self, obj: T) -> T:
+    # TODO: mypy should not error in this case
     if type(obj) == A:
         return A()  # E: Incompatible return value type (got "A", expected "T")
     elif type(obj) == B:
@@ -3262,7 +3263,10 @@ def correct1(self, obj: T) -> T:
 
 T_value = TypeVar("T_value", A, B)
 
-def forgets_about_subclasses2(self, obj: T_value) -> T_value:
+def forgets_about_multiple_inheritance(self, obj: T_value) -> T_value:
+    # Note that it is a little confusing that mypy only errors in the first branch here, but this
+    # is a branch that would be taken by a subclass of both A and B.
+    # See also https://github.com/python/mypy/issues/10302#issuecomment-3832182574
     if isinstance(obj, A):
         return A()  # E: Incompatible return value type (got "A", expected "B")
     elif isinstance(obj, B):
@@ -3479,6 +3483,71 @@ def bar(X: type[T]) -> T:
     raise
 [builtins fixtures/type.pyi]
 
+[case testNarrowingConstrainedTypeVarType]
+# flags: --strict-equality --warn-unreachable
+from typing import TypeVar, Any, Type
+
+TargetType = TypeVar("TargetType", int, float, str)
+
+# TODO: this behaviour is incorrect, it will be fixed by improving reachability
+def convert_type(target_type: Type[TargetType]) -> TargetType:
+    if target_type == str:
+        return str()  # E: Incompatible return value type (got "str", expected "int") \
+                      # E: Incompatible return value type (got "str", expected "float")
+    if target_type == int:
+        return int()  # E: Incompatible return value type (got "int", expected "str")
+    if target_type == float:
+        return float()  # E: Incompatible return value type (got "float", expected "int") \
+                        # E: Incompatible return value type (got "float", expected "str")
+    raise
+[builtins fixtures/primitives.pyi]
+
+
+[case testNarrowingEqualityWithPromotions]
+# flags: --strict-equality --warn-unreachable
+from __future__ import annotations
+from typing import Literal
+
+# TODO: the behaviour on some of these test cases is incorrect
+def f1(number: float, i: int):
+    if number == i:
+        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)  # E: Statement is unreachable
+        reveal_type(five)
+
+def f3(number: float | int, five: Literal[5]):
+    if number == five:
+        reveal_type(number)  # N: Revealed type is "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.float | None"
+        reveal_type(i)  # N: Revealed type is "builtins.int"
+
+def f5(number: float | int, i: int):
+    if number == i:
+        reveal_type(number)  # N: Revealed type is "builtins.int"
+        reveal_type(i)  # N: Revealed type is "builtins.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 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 fixtures/primitives.pyi]
+
 [case testNarrowingAnyNegativeIntersection-xfail]
 # flags: --strict-equality --warn-unreachable
 # https://github.com/python/mypy/issues/20597

test-data/unit/check-python310.test

@@ -36,12 +36,17 @@ match m:
     case other:
         reveal_type(other)  # N: Revealed type is "Any"
 
-[case testMatchLiteralPatternAlreadyNarrower-skip]
-m: bool
+[case testMatchLiteralPatternBoolIntAlreadyNarrower]
+# flags: --strict-equality --warn-unreachable
 
-match m:
-    case 1:
-        reveal_type(m)  # This should probably be unreachable, but isn't detected as such.
+def foo(m: bool, x: int):
+    match m:
+        case 1:
+            reveal_type(m)  # N: Revealed type is "Literal[1]"
+
+    match m:
+        case x:
+            reveal_type(m)  # N: Revealed type is "builtins.bool"
 [builtins fixtures/primitives.pyi]
 
 [case testMatchLiteralPatternUnreachable]
@@ -402,7 +407,7 @@ match d.tag:
         reveal_type(d)  # N: Revealed type is "__main__.B"
         reveal_type(d.num)  # N: Revealed type is "builtins.int"
 
-[case testMatchSequenceUnion-skip]
+[case testMatchSequenceUnion]
 from typing import List, Union
 m: Union[List[List[str]], str]
 
@@ -1878,7 +1883,8 @@ match m:
         assert_never(unreachable)
 [builtins fixtures/enum.pyi]
 
-[case testMatchLiteralPatternEnumCustomEquals-skip]
+[case testMatchLiteralPatternEnumCustomEquals]
+# flags: --strict-equality --warn-unreachable
 from enum import Enum
 class Medal(Enum):
     gold = 1
@@ -1891,9 +1897,9 @@ m: Medal
 
 match m:
     case Medal.gold:
-        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
-    case _:
         reveal_type(m)  # N: Revealed type is "__main__.Medal"
+    case _:
+        reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.silver] | Literal[__main__.Medal.bronze]"
 [builtins fixtures/enum.pyi]
 
 [case testMatchNarrowUsingPatternGuardSpecialCase]
@@ -2035,7 +2041,8 @@ match c:
         assert_never(c) # E: Argument 1 to "assert_never" has incompatible type "Literal['red']"; expected "Never"
 [typing fixtures/typing-typeddict.pyi]
 
-[case testMatchAsPatternIntersection-skip]
+[case testMatchAsPatternIntersection]
+# flags: --strict-equality --warn-unreachable
 class A: pass
 class B: pass
 class C: pass
@@ -2046,7 +2053,7 @@ def f(x: A) -> None:
             reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B">"
         case C() as y:
             reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.C">"
-    reveal_type(y)  # N: Revealed type is "Union[__main__.<subclass of "__main__.A" and "__main__.B">, __main__.<subclass of "__main__.A" and "__main__.C">]"
+    reveal_type(y)  # N: Revealed type is "__main__.<subclass of "__main__.A" and "__main__.B"> | __main__.<subclass of "__main__.A" and "__main__.C">"
 
 [case testMatchWithBreakAndContinue]
 def f(x: int | str | None) -> None:

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)  # N: Revealed type is "tuple[__main__.B]"
+    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]