dataclass collection inference problem

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.*)

Commencez par le reproducer autonome dans l’issue et l’exemple mypy-play lié, puis suivez l’inférence de types de mypy pour les littéraux de liste contenant des classes dataclass. La tâche est terminée lorsque [C1, C2] est inféré comme une liste de types de classes plutôt que comme des callables, et que tous les appels présentés à f passent la vérification de types sans l’erreur de type-variable.