Call to super() is flagged with an error in function but not in classmethod

[danpascu]

I have a class that is like a dataclass. It can either be initialized by calling the class with the name=value keyword arguments with all the defined fields, or it has an alternate constructor that receives some bytes data, parses it and initializes the object's field from the parsed data.

The code sample to showcase the issue is below:

from contextvars import copy_context
from typing import Self


class Structure:
    def __init__(self, **kw: object) -> None:
        # init instance from kw

    @classmethod
    def alt_create_1(cls, data: bytes) -> Self:
        instance = super(Structure, cls).__new__(cls)  # this call to super is not flagged
        # alternative instance initialisation from data
        return instance

    @classmethod
    def alt_create_2(cls, data: bytes) -> Self:
        context = copy_context()
        return context.run(_alt_create_2, cls, data)


def _alt_create_2[T: Structure](cls: type[T], data: bytes) -> T:
    instance = super(Structure, cls).__new__(cls)  # this is flagged with a error (see below)
    # init instance from data
    return instance


# typing-12.py
#   typing-12.py:23:46 - error: Argument of type "type[T@_alt_create_2]" cannot be assigned to parameter "cls" of type "type[Self@Structure*]" in function "__new__"
#   Type "type[T@_alt_create_2]" is incompatible with type "type[Self@Structure*]" (reportArgumentType)

Calling super(Structure, cls).__new__(cls) works fine in the alt_create_1 classmethod. But I need to run this in a contextvars context so I split the body of the method into a function and I call that with context.run() as seen in the alt_create_2 classmethod.

However in the function, the same call to super(Structure, cls).__new__(cls) gets flagged with an error. At runtime this works just fine and in both cases super(Structure, cls).__new__ points to object.__new__ as expected.

I can fix this and get rid of the error if in the function I use object.__new__(cls), but I would rather not hard code the parent class like that, in case inheritance changes later.

The question I have is why do I get that call to super flagged in the function but not in the classmethod. Am I doing something wrong or did I ran into some bug here?

[erictraut]

In a class method, if you don't specify a type annotation for the cls parameter, it implicitly has the type type[Self]. This is analogous to the self parameter in an instance method, which implicitly has the type Self.

In your function _alt_creat_2, the type of cls is annotated to be type[T] where T is bound to Structure. This is not the same as type[Self@Structure]. That explains why you're seeing a difference in behavior.

I'll need to think more about whether it's safe from a type perspective to support what you're doing here. At first glance, it seems like it should be. The question is then whether it's worth attempting to enhance the handling of super in pyright to support this. The logic for super is already very complex.

[erictraut]

I've dug deeper into the issue, and I agree that it's a bug in pyright. It will be addressed in the next release.

[danpascu]

Is there anything that can be done right now other than adding a pyright: ignore[reportArgumentType] comment?

Also in light of your explanation, it looks to me that the error message is just wrong. When cls is a subclass of Structure, like it is the case here, super(Structure, cls).__new__(cls) looks up the first parent class in cls.__mro__ starting after Structure that has a __new__ method (which in this case will be object) and calls it with cls as an argument which results in an instance of cls. Seems perfectly fine both from the perspective of the types involved as well as the runtime behavior.

[danpascu]

To answer my own question, one way to address it without the planned fix is to create the instance in the class method and only split the initialization part to the external function which will receive the instance