use overload information from class definition to resolve type parameters in cases of Protocols

[KotlinIsland]

from typing import Protocol, overload

class A:
    @overload
    def f(self, x: int) -> int: ...
    @overload
    def f(self, x: str) -> str: ...

    def f(self, x: int | str) -> int | str: ...

class CanF[X, R](Protocol):
    def f(self, x: X) -> R: ...

def f[X, R](s: CanF[X, R], x: X) -> R:
    return s.f(x)

a = A()
reveal_type(a.f(1))  # int
reveal_type(a.f(""))  # str
reveal_type(f(a, 1))  # int
reveal_type(f(a, ""))  # int - Argument of type "Literal['']" cannot be assigned to parameter "x" of type "X@f" in function "f"

here, f(a, "") should resolve to Callable[[A, str], str] / X = str, R= str because it can retrieve information from the definition of A to find a valid solution

a more complicated scenario involving intersections would look like:

from typing import Never, Protocol, overload

class A:
    @overload
    def f(self, x: int) -> int: ...

    @overload
    def f(self, x: str) -> str: ...

    def f(self, x: int | str) -> int | str: ...

class CanF[R](Protocol):
    def f(self, x: Never) -> R: ...

def f[X, R](s: CanF[R]) -> CanF[R]: ...

a = A()
reveal_type(a.f)  # Overload[(x: int) -> int, (x: str) -> str]
reveal_type(f(a))  # CanF[int], ideally CanF[int] & CanF[str]

credit to @jorenham for the discovery of this defect

• rejected upstream: Protocol method only considers the first overload of the matched method, ignoring all others microsoft/pyright#9663