Support finding metaclasses from intersection-typed bases

[jvdillon]

When a metaclass __get__ returns Intersection[_T, type[SomeGeneric[TypeVar]]], dataclass_transform field inheritance breaks for child classes.

from __future__ import annotations
from typing import TYPE_CHECKING, Any, ClassVar, Generic, dataclass_transform
from typing_extensions import TypeVar
import dataclasses

if TYPE_CHECKING:
    from ty_extensions import Intersection

_T = TypeVar("_T")
_P = TypeVar("_P", default=Any)
_O = TypeVar("_O")

class Makeable(Generic[_P]):
    def make(self) -> _P: ...

class MyMeta(type):
    if TYPE_CHECKING:
        def __get__(cls: _T, obj: object, owner: type[_O]) -> Intersection[_T, type[Makeable[_O]]]:
            return cls

@dataclass_transform(kw_only_default=True)
class FigMeta(MyMeta):
    def __new__(mcls, name, bases, attrs, **kw):
        cls = super().__new__(mcls, name, bases, attrs)
        if "__slots__" not in cls.__dict__:
            cls = dataclasses.dataclass(cls, kw_only=True, slots=True)
        return cls

class Fig(Makeable[_P], metaclass=FigMeta):
    __slots__: ClassVar[tuple[str, ...]] = ()

class Parent:
    class Config(Fig):
        x: int = 0

class Child(Parent):
    class Config(Parent.Config):
        y: int = 1

Child.Config(x=1, y=2)  # warning: y is unknown-argument

Parent's field x is recognized. Child's own field y is not.

The trigger is specifically a TypeVar inside a parameterized generic inside type[] inside the Intersection. Replacing Makeable[_O] with any of these makes the warning disappear:

• Makeable[Any]
• Makeable (bare)
• object

Expected behavior: Child class fields should be recognized regardless of what Intersection contains.

Workaround: moving @dataclass_transform from the metaclass to the base class avoids the issue:

# Instead of:
@dataclass_transform(kw_only_default=True)
class FigMeta(MyMeta): ...

class Fig(Makeable[_P], metaclass=FigMeta): ...

# Do:
class FigMeta(MyMeta): ...

@dataclass_transform(kw_only_default=True)
class Fig(Makeable[_P], metaclass=FigMeta): ...

Both placements are valid per PEP 681, but only the base class placement works when the metaclass has __get__ returning Intersection[_T, type[Generic[TypeVar]]].

ty version: 0.0.30

[carljm]

Fun one, thanks for reporting!

The root cause here is that Type::to_class_type supports only Type::ClassLiteral and Type::GenericAlias (notably, not intersections), and StaticClassLiteral::fully_static_explicit_bases filters using Type::to_class_type, and try_metaclass uses fully_static_explicit_bases to choose/inherit the metaclass.

But (somewhat inconsistently), ClassBase::try_from_type does support inheriting from an intersection.

The result is that when a base class expression is typed as an intersection, we do support (in general) picking a workable base class type out of the positive elements of that intersection, but we don't support finding an inherited metaclass from that base!

So in class Config(Parent.Config), since Parent.Config (via the descriptor resolution) is typed as an intersection, we fail to resolve the metaclass for the child Config class, and thus we fail to find the metaclass-based dataclass-transform.

Switching to a base-class-based dataclass-transform fixes it because we are no longer relying on finding the right metaclass.

The variants Makeable[Any], bare Makeable (which is really the same as Makeable[Any]), and object also fix it because they cause the intersection to immediately simplify to just class Config, so we no longer have the "base class expression has intersection type" situation at all.

The fix should be to teach try_metaclass to support intersections, possibly by consolidating it into using ClassBase?

I haven't bothered to create it yet, but I expect this can be reproduced without the descriptor and even without an explicitly-annotated Intersection type, by using narrowing to turn a base class into an intersection type instead.

[carljm]

Here's a repro that strips out dataclass-transform, descriptors, and generics, to demonstrate clearly that the root problem is just finding metaclasses on inherited intersections:

from typing import Any

class Meta(type):
    meta_attr: int = 1

class Model(metaclass=Meta):
    pass

Base = Model

class DirectChild(Base):  # does not inherit an intersection
    pass

reveal_type(DirectChild.meta_attr)  # reveals `int`; inherited metaclass is found

def f(other: Any):
    if Base is other:
        reveal_type(Base)  # reveals `<class 'Model'> & Any`

        class Child(Base):  # inherits an intersection
            pass

        reveal_type(Child.meta_attr)  # attribute not found; inherited metaclass not found

[AlexWaygood]

yet more minimal:

from typing import Any

class Meta(type):
    meta_attr: int = 1

class Base(metaclass=Meta): ...
class DirectChild(Base): ...  # does not inherit an intersection

reveal_type(DirectChild.__class__)  # <class 'Meta'>
reveal_type(DirectChild.meta_attr)  # reveals `int`; inherited metaclass is found

def f(other: Any):
    if Base is other:
        reveal_type(Base)  # reveals `<class 'Model'> & Any`

        class Child(Base): ...  # inherits an intersection

        reveal_type(Child.__class__)  # <class 'type'>
        reveal_type(Child.meta_attr)  # false-positive error