dataclass collection inference problem

[abergeron]

Bug Report

It seems that when typing a collection of dataclasses, if they all happen to have the same fields, then the inferred type will be a Callable instead of type.

The example below is self-contained and demonstrates the problem very clearly.

To Reproduce

https://mypy-play.net/?mypy=latest&python=3.14&gist=5dfadfda23e846913cbee4d56568b69e

from dataclasses import Field, dataclass
from typing import ClassVar, Protocol, TypeVar


@dataclass
class C1:
    foo: int = 0


@dataclass
class C2:
    foo: int = 1


@dataclass
class C3:
    foo: int = 2
    bar: str = ""


class Dataclass(Protocol):
    __dataclass_fields__: ClassVar[dict[str, Field]]


DataclassT = TypeVar("DataclassT", bound=Dataclass)


def f(a1: list[type[DataclassT]]): ...

reveal_type([C1, C2])
reveal_type([C1, C3])

f([C1, C2])  # this gives an error, but the others work
f([C1, C3])
f([C2, C3])
f([C1, C2, C3])

Expected Behavior

I would expect dataclasses to always be typed as classes instead of becoming callables because they happen share fields.

Actual Behavior

t.py:31: note: Revealed type is "builtins.list[def (foo: builtins.int =) -> builtins.object]"
t.py:32: note: Revealed type is "builtins.list[builtins.type]"
t.py:34: error: Value of type variable "DataclassT" of "f" cannot be "object" [type-var]
Found 1 error in 1 file (checked 1 source file)

Your Environment

• Mypy version used: 1.18.2 (but I tested 1.18.1, 1.17.1, 1.17.0 and they all have the same problem)
• Mypy command-line flags: None
• Mypy configuration options from mypy.ini (and other config files): follow_untyped_imports = true
• Python version used: 3.14.0 (also fails with 3.13.*)

[A5rocks]

The callable-ness is not IMO the problem, I think we keep track that a callable == that class (for __init__ reasons, etc.). I guess we forgot to propagate that information for a join?

[sterliakov]

Note that this passes:

def f(a1: list[type]): ...

f([C1, C2])

so we haven't lost the type fallback completely (join(type, type) remains type as expected, even though it shows up as a Callable - constructor callables and classes are almost interchangeable), but only its __dataclass_fields__.

[sterliakov]

And the problem is that two Instances C1 and C2 have no common ancestor (neither nominal nor explicit structural), thus join(C1(), C2()) is object, and join(C1, C2) of constructor callables is def (foo: int = ...) -> object with type fallback.

join(C1, C3), on the other hand, does not contain any "similar" callables, so the join falls back to plain type which is equivalent to type[Any], and type[Any] matches the protocol despite not having explicit __dataclass_fields__ (because, well, Any).

This could be solved by injecting implicit DataclassProtocol base into all dataclasses via plugin, but there's nothing with join logic itself - we certainly do not want to compute a structural join ("all common attributes and methods as a Protocol") every time.