Move this check to special case in check_op

Author: sterliakov

mypy/checkexpr.py

@@ -4038,7 +4038,21 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
         # We store the determined order inside the 'variants_raw' variable,
         # which records tuples containing the method, base type, and the argument.
 
-        if op_name in operators.op_methods_that_shortcut and is_same_type(left_type, right_type):
+        if (
+            op_name in operators.op_methods_that_shortcut
+            and is_same_type(left_type, right_type)
+            and not (
+                # We consider typevars with equal IDs "same types" even if some narrowing
+                # has been applied. However, different bounds here might come from union
+                # expansion applied earlier, so we are not supposed to check them as
+                # being same types here. For plain union items `is_same_type` will
+                # return false, but not for typevars having these items as bounds.
+                # See testReversibleOpOnTypeVarProtocol.
+                isinstance(left_type, TypeVarType)
+                and isinstance(right_type, TypeVarType)
+                and not is_same_type(left_type.upper_bound, right_type.upper_bound)
+            )
+        ):
             # When we do "A() + A()", for example, Python will only call the __add__ method,
             # never the __radd__ method.
             #

mypy/subtypes.py

@@ -273,6 +273,10 @@ def is_same_type(
     ):
         return all(is_same_type(x, y) for x, y in zip(a.args, b.args))
     elif isinstance(a, TypeVarType) and isinstance(b, TypeVarType) and a.id == b.id:
+        # This is not only a performance optimization. Deeper check will compare upper
+        # bounds, but we want to consider copies of the same type variable "same type".
+        # This makes sense semantically: even we have narrowed the upper bound somehow,
+        # it's still the same object it used to be before.
         return True
 
     # Note that using ignore_promotions=True (default) makes types like int and int64

test-data/unit/check-expressions.test

@@ -734,17 +734,56 @@ def check(x: _T, y: _T) -> bool:
 [case testReversibleOpOnTypeVarProtocol]
 # https://github.com/python/mypy/issues/18203
 from typing import Protocol, TypeVar, Union
-from typing_extensions import Self
+from typing_extensions import Self, runtime_checkable
 
 class A(Protocol):
     def __add__(self, other: Union[int, Self]) -> Self: ...
     def __radd__(self, other: Union[int, Self]) -> Self: ...
 
 AT = TypeVar("AT", bound=Union[int, A])
 
-def f(a: AT, _b: AT) -> None:
-    a + a
-[builtins fixtures/ops.pyi]
+def f(a: AT, b: AT) -> None:
+    reveal_type(a + a)  # N: Revealed type is "Union[builtins.int, AT`-1]"
+    reveal_type(a + b)  # N: Revealed type is "Union[builtins.int, AT`-1]"
+    if isinstance(a, int):
+        reveal_type(a)  # N: Revealed type is "AT`-1"
+        reveal_type(a + a)  # N: Revealed type is "builtins.int"
+        reveal_type(a + b)  # N: Revealed type is "Union[builtins.int, AT`-1]"
+        reveal_type(b + a)  # N: Revealed type is "Union[builtins.int, AT`-1]"
+
+@runtime_checkable
+class B(Protocol):
+    def __radd__(self, other: Union[int, Self]) -> Self: ...
+
+BT = TypeVar("BT", bound=Union[int, B])
+
+def g(a: BT, b: BT) -> None:
+    reveal_type(a + a)  # E: Unsupported left operand type for + ("BT") \
+                        # N: Both left and right operands are unions \
+                        # N: Revealed type is "Union[builtins.int, BT`-1, Any]"
+    reveal_type(a + b)  # E: Unsupported left operand type for + ("BT") \
+                        # N: Both left and right operands are unions \
+                        # N: Revealed type is "Union[builtins.int, BT`-1, Any]"
+    if isinstance(a, int):
+        reveal_type(a)  # N: Revealed type is "BT`-1"
+        reveal_type(0 + a)  # N: Revealed type is "builtins.int"
+        reveal_type(a + 0)  # N: Revealed type is "builtins.int"
+        reveal_type(a + a)  # N: Revealed type is "builtins.int"
+        reveal_type(a + b)  # N: Revealed type is "Union[builtins.int, BT`-1]"
+        reveal_type(b + a)  # E: Unsupported left operand type for + ("BT") \
+                            # N: Left operand is of type "BT" \
+                            # N: Revealed type is "Union[builtins.int, Any]"
+    if isinstance(a, B):
+        reveal_type(a)  # N: Revealed type is "BT`-1"
+        reveal_type(0 + a)  # N: Revealed type is "BT`-1"
+        reveal_type(a + 0)  # E: Unsupported left operand type for + ("BT") \
+                            # N: Revealed type is "Any"
+        reveal_type(a + a)  # E: Unsupported left operand type for + ("BT") \
+                            # N: Revealed type is "Any"
+        reveal_type(a + b)  # E: Unsupported left operand type for + ("BT") \
+                            # N: Right operand is of type "BT" \
+                            # N: Revealed type is "Any"
+[builtins fixtures/isinstance.pyi]
 
 
 [case testErrorContextAndBinaryOperators]