Fix __init__ in Dataclasses inheriting from Any

[joey-laminar]

Description

Fixes #11921

Dataclasses that inherit from Any (actually another type that we don't
know) should allow any constructor.

The way this bug was noticed was while importing a class that mypy didn't know
about with the --ignore-missing-imports flag:

import dataclasses
from mypackage import MyClass

# @dataclasses.dataclass
# class MyClass:
#     bar: str

@dataclasses.dataclass
class Inherits(MyClass):
    foo: str

i = Inherits(foo="hi", bar="bye")

Test Plan

Added appropriate test case

[joey-laminar]

I didn't really want to give the variables names (args, kwargs) but I couldn't find a better way to do it without writing a lot of code to duplicate add_method

[JelleZijlstra]

What happens if the child dataclass has a field named args or kwargs?

[joey-laminar]

Still works fine because we completely overwrite the args to init with these args. The original fields won't appear

[joey-laminar]

Found a workaround without using variable names. Using an empty var for both arguments won't work unless it is the same empty var, that way mypy won't throw an error.

The main difference is in the result of reveal_type(A) where A is a dataclass inheriting from any. When using args and kwargs it appeared as:

a.py:9: note: Revealed type is "def (*args: Any, **kwargs: Any) -> a.A"

and now it appears as

a.py:9: note: Revealed type is "def (*Any, **Any) -> a.A"

[hauntsaninja]

Thanks for catching this! We should still complain about A(a="asdf", b=2) and A(b=2) (if a doesn't have a default). This could be done by forcing argument kinds to be ARG_NAMED_OPT or ARG_NAMED.

[joey-laminar]

Thanks for catching this! We should still complain about A(a="asdf", b=2) and A(b=2) (if a doesn't have a default). This could be done by forcing argument kinds to be ARG_NAMED_OPT or ARG_NAMED.

Hmm, but we also want to accept A(2). And it is hard to type check at all because if we call A("A", False, 3) the 3 is presumably the int argument.

I think the best we can do it to force the arguments to be ARG_OPT, so that we will at least catch a wrong type when called with keywords but will miss the case where the argument is not present at all. I think this is a reasonable fallback since we're pretty much falling back to Any since we're missing the base class

[joey-laminar]

Updated type of positional arguments to be ARG_OPT. Now the function signature (is illegal in python but) does what we want:

Revealed type is "def (*Any, a: builtins.int =, **Any) -> a.A"

Meaning if there is an a sent it has to be an int, otherwise types can be whatever.

The only thing this doesn't catch is not sending any arguments, but I don't think that we can handle that while not knowing previous arguments. What we really want would be something like def (*Any, a: builtins.int, **Any) -> a.A meaning any number of positional arguments followed by an int, but python does not let us do that.

[hauntsaninja]

Thanks for thinking this through! Looks good to me, but I'll leave open for a couple days in case others see something I don't :-)

[JukkaL]

Looks good to me!