Is not reporting on covariant TypeVars in Protocols when using it for a private variable intentional?

[Daraan]

The situation is like this:

T = TypeVar("T", covariant=True)

# Type variable "T" used in generic protocol "P1" should be invariant
class P1(Protocol[T]):
    value: T

# OK
class P2(Protocol[T]):
    _value: T

Is it intentional that for P2 no errors are reported; mypy reports both? If yes, could you give me some insights into the idea behind the decision?

Related discussion: #3090

[erictraut]

I added an exemption for variables with protected or private names based on this discussion. This also affects auto-invariance calculations for TypeVars that use the new (PEP 695) syntax.

In hindsight, I wonder if this was the right decision — at least for protected variables. I think it's justified for private variables because they cannot be modified outside of the class and cannot be overridden by subclasses (because of name mangling), but I'm not as sure about variables with protected names.

The Python typing spec is silent on this topic. Because this is a gray area, I'm reluctant to change pyright's behavior unless/until there is consensus in the community about the "correct" behavior. If you feel strongly about it, you're welcome to start a discussion in the Python typing forum.

[Daraan]

@erictraut Thank you for the reply.

I now ran into this again from the other side: I want an invariant protected field but pyright suggest I should use a covariant on it.
First I would assume this is okay, secondly from the linked discussion #5568 I would assume that they are excluded from the checking.
Now I am confused why does pyright suggest it to be the opposite way for a protected type variable?

Code sample in pyright playground

from typing import TypeVar, Protocol

T = TypeVar("T")
_T_private = TypeVar("_T_private")
_T_private_co = TypeVar("_T_private_co", covariant=True)
T_co = TypeVar("T_co", covariant=True)

# Type variable "_T_private" used in generic Protocol "Foo" should be covariant
# Type variable "T_co" used in generic Protocol "Foo" should be invariant
class Foo(Protocol[T, _T_private, _T_private_co, T_co]):
    _private_inv: _T_private   # <-- should be covariant; expected OK
    public_inv: T      # OK

    _private_co: _T_private_co  # OK; exempt
    public_co: T_co   # should be invariant; as expected

[Daraan]

small ping :)

Could you help me with the confusing part in my last comment