Assignability to a Protocol Using Self Must Respect Variance #2051
Description
I just stumbled across this paragraph:
Lines 2540 to 2544 in 2d88da2
If I understand it correctly, then the following code is fine, i.e., Foo is assignable to Proto according to the explanation:
from __future__ import annotations
from typing import Protocol, Self
class Proto(Protocol):
def f(self, x: Self) -> None: ...
class Foo:
def f(self, x: Sub) -> None:
pass
class Sub(Foo):
pass
x: Proto = Foo()However, type checkers like mypy and pyright reject this code. This aligns with my expectation: If I have an instance x: Proto, then I should be able to call x.f(x). But for y: Foo, I cannot call y.f(y).
The paragraph in question should distinguish between covariant, contravariant, and invariant occurences of Self:
from __future__ import annotations
from typing import Protocol, Self
class Proto(Protocol):
def f(self, x: Self) -> None: ... # contravariant
def g(self, x: Self) -> Self: ... # x: contravariant, return type: covariant
def h(self, x: list[Self]) -> None: ... # invariant
class Sup:
pass
class Foo(Sup):
def f(self, x: Sup) -> None: # x can be of type Foo or any superclass
pass
def g(self, x: Sup) -> Sub: # return type can be Foo or any subclass
raise RuntimeError()
def h(self, x: list[Foo]) -> None: # no sub-/superclass allowed as argument to list
pass
class Sub(Foo):
pass
x: Proto = Foo() # OK, also according to mypy and pyrightI assume that all the uses of Self are valid in this example, at least mypy and pyright do not complain and I couldn’t find any statement that would restrict Self in protocols to covariant positions or even return types only. Maybe it also makes sense to adjust the example after the paragraph in question. Currently, it only uses Self in a return type.