Assignability to a Protocol Using `Self` Must Respect Variance

[nhusung]

I just stumbled across this paragraph:

typing/docs/spec/generics.rst

Lines 2540 to 2544 in 2d88da2

	Checking a class for assignability to a protocol: If a protocol uses ``Self``
	in methods or attribute annotations, then a class ``Foo`` is :term:`assignable`
	to the protocol if its corresponding methods and attribute annotations use
	either ``Self`` or ``Foo`` or any of ``Foo``’s subclasses. See the examples
	below:

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 pyright

I 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.

[JelleZijlstra]

Thanks, I agree the current text is incorrect here.

Even your suggested change has some problems, though. For example, in your second example, calling Sub().h() with an argument to type list[Sub] would be rejected (because of invariance). This means that while Foo implements the protocol Proto, its subclass Sub does not, which breaks transitivity of subclassing. There's a similar issue in covariant positions: if there is another subclass Sub2(Foo), then Sub2().g() returns an instance of Sub1, so Sub2 also does not implement Foo.

A sound solution might be to say that if a Protocol uses Self in an invariant or covariant position, only @final classes can implement it.

[JelleZijlstra]

One for the collection: JelleZijlstra/unsoundness#27