Having __slots__ in a class causes invariance

[CrowdingFaun624]

When defining a class, its type variables become invariant whenever attributes involving it are in __slots__. This is demonstrated by my examples:

class A[T](): # `T` says it is covariant

    def __init__(self, arg: T) -> None:
        self.arg: Final[T] = arg

class B[T](): # `T` says it is invariant

    __slots__ = ("arg",)

    def __init__(self, arg: T) -> None:
        self.arg: Final[T] = arg

I can't think of a reason for why this would be. arg is immutable whether it is in __slots__ or not, so it should always be covariant. This is pretty annoying for my code, since I like using __slots__.

[Joren Hammudoglu (jorenham)]

This looks like a bug to me.

[Aymen Hmaidi (aymenhmaidiwastaken)]

It's explicable rather than a bug, and there's a fix that keeps __slots__.

Listing a name in __slots__ makes it a class-level slot descriptor, and a slot descriptor is settable. Pyright models the attribute as mutable on that basis, and a mutable attribute of type T forces T invariant. The Final in self.arg: Final[T] = arg doesn't change that — it annotates the assignment inside __init__, not the descriptor __slots__ created.

Which is why the variance tracks the slot, not __slots__ being present:

class A[T]:                       # covariant
    def __init__(self, arg: T) -> None:
        self.arg: Final[T] = arg

class B[T]:                       # invariant  <- reported
    __slots__ = ("arg",)
    def __init__(self, arg: T) -> None:
        self.arg: Final[T] = arg

class C[T]:                       # covariant  - empty __slots__
    __slots__ = ()
    def __init__(self, arg: T) -> None:
        self.arg: Final[T] = arg

class D[T]:                       # covariant  - "arg" not slotted
    __slots__ = ("other",)
    def __init__(self, arg: T) -> None:
        self.arg: Final[T] = arg
        self.other: int = 0

A, C and D all accept X[Animal] = X[Dog](Dog()). Only B rejects it. Having __slots__ isn't what does it — having this attribute in it is.

The fix is to declare the attribute at class level, where Final attaches to the symbol the slot creates:

class Fixed[T]:
    __slots__ = ("arg",)
    arg: Final[T]

    def __init__(self, arg: T) -> None:
        self.arg = arg

ok: Fixed[Animal] = Fixed[Dog](Dog())   # accepted

Checked on pyright 1.1.411 — no errors, no suppressions needed, and __slots__ still does its job at runtime:

('arg',)
slot enforced: 'Fixed' object has no attribute 'other'

So you keep the memory behaviour you wanted and get covariance back.

Note the class-level arg: Final[T] is a bare annotation with no assignment, so it doesn't create a class attribute and doesn't collide with the slot — which is the reason this works rather than raising ValueError: 'arg' in __slots__ conflicts with class variable the way an assignment would.

Where I'd leave the door open: whether pyright should infer the same thing from self.arg: Final[T] = arg when the name is slotted is a reasonable question, since the two forms describe the same intent. That part is worth Eric Traut (@erictraut)'s view — but it's a design call rather than the bug it looks like from the outside, and you don't need it resolved to unblock your code.