Incorrect type inferencing when parameterizing with Self-like type variable involving `__ge__`

Bắt đầu bằng cách chạy reproducer được cung cấp với phiên bản mypy hiện tại và lần theo quá trình suy luận cho foo, đặc biệt là tham số SupportsComparison tương tự Self và các phương thức ge. Tìm các bài kiểm thử suy luận kiểu liên quan hoặc thêm một bài kiểm thử hồi quy cho ví dụ; công việc được xem là hoàn tất khi reveal_type báo cáo tuple[float, float] thay vì tuple[Fraction, float].

Found a very strange bug involving self-like type variables while using __ge__ and similar methods. The following example defines:

• a parameterized protocol SupportsComparison which takes Self as its first parameter and the type being compared to with its other parameter,
• a protocol SupportsRadd which allows type-hinting type(t + supports_radd) == type(t),
• a function foo should then accept foo(x, y, z) where x supports comparison with y and z supports radd with x and returns (x, y).

In the example, foo(float, float, Fraction) -> tuple[float, float] is the expected result, since:

• float supports comparison with float and self should be float, meaning x: SupportsComparison[float, float],
• Fraction supports radd with float, meaning z: SupportsRadd[float].

However, the result given by reveal_type(...) gives tuple[Fraction, float]. How is this the case?

from typing import Any, Protocol, TypeVar

T = TypeVar("T")
T_con = TypeVar("T_con", contravariant=True)

Self = TypeVar("Self", bound="SupportsComparison[Any, Any]", covariant=True)


class SupportsComparison(Protocol[Self, T_con]):

    def __ge__(self: Self, other: T_con) -> bool: ...
    def __gt__(self: Self, other: T_con) -> bool: ...
    def __le__(self: Self, other: T_con) -> bool: ...
    def __lt__(self: Self, other: T_con) -> bool: ...


class SupportsRadd(Protocol[T]):

    def __radd__(self, other: T) -> T: ...


X = TypeVar("X", bound=SupportsComparison[Any, Any])
Y = TypeVar("Y")
Z = TypeVar("Z", bound=SupportsRadd[Any])

def foo(
    x: SupportsComparison[X, Y],
    y: Y,
    z: SupportsRadd[X],
) -> tuple[X, Y]:
    return (x, y)

from fractions import Fraction

reveal_type(foo(float(), float(), Fraction()))  # Revealed type is "Tuple[fractions.Fraction*, builtins.float*]"

• Mypy version: 0.942.
• Python version used: 3.10.0.