Should pyright complain reportInvalidTypeVarUse on custom covariant Self?

[Congee]

Because the new typing.Self introduced by PEP673 is an invariant, I have to write my own covariant Self.

from typing import TypeVar

Self = TypeVar('Self', bound='Klass', covariant=True)

class Klass:
    def method(self) -> Self:
        ...         # ^ [pyright: reportInvalidTypeVarUse] TypeVar "Self" appears only once in generic function signature

And I'm confused by this comment

Yes, this is intended behavior. If the TypeVar is explicitly bound or constrained, it is allowed to be used only once in a signature.

Originally posted by @erictraut in #2111 (reply in thread)

Actually, the type inference of pyright works perfectly and I can just ignore this type error. But, I'm just really curious if the error report is correct. If so, what alternative should I take?

[erictraut]

I'm not sure what you're trying to do with the Self TypeVar. It doesn't appear to have any valid use here. There's no way to "solve" for its type value because it's used only once. Is your intent for the self parameter to also have the Self type? If so, then it should not be covariant.

So yes, I think pyright is correct to complain here because I don't see any valid use of the Self TypeVar in this example.

[Congee]

Sorry to have you confused it with Self. It should be stated as a covariant named something else like T. But, the question remains - is there any way to make method return a covariant of Klass without making pyright report an error?

[erictraut]

In your example above, there's no good reason to use a TypeVar. You are declaring a TypeVar Self bound to the scope of the method method. There's no way for a type checker to determine the type of the TypeVar Self in this case because it's used in isolation. A TypeVar that is scoped to a method should appear more than once in the signature for that method.

Depending on what you're trying to do, the sample should be changed to one of the following:

from typing import TypeVar

Self = TypeVar('Self', bound='Klass') # Note: Invariant

class Klass:
    def method(self: Self) -> Self:
        ...

or

class Klass:
    def method(self) -> 'Klass':
        ...

So yes, pyright is correct to emit an error for the example because it's an incorrect usage of a method-scoped TypeVar.

[Congee]

Ha, the invariant is exactly what I've been trying to avoid. I was here to post this question because, actually, the type inference of pyright "works" if I type-annotate where the method is called. Per my understanding, pyright should complain about both the wrong type definition and its usage.

from typing import TypeVar

T = TypeVar('T', bound='Klass', covariant=True)

class Klass:
    def method(self) -> T: ...

class Derived(Klass): ...

foo          = Derived().method()  # foo -> Derived
foo: Klass   = Derived().method()  # foo -> Klass
bar: Derived = Derived().method()  # foo -> Derived

Anyway, thanks for your detailed explanation <3