mypy infer incorrect types in frozen dataclass with descriptors as attributes.

I am having issues with frozen dataclass that inherits from a frozen dataclass with descriptors as attributes. mypy infer incorrect datatypes of the attributes from the base class. If the dataclasses are not frozen, then mypy infer correct datatypes in inherited class.

Below is the minimal code to reproduce the issue.
python=3.11
mypy=1.14.0

mypy-play.net

To Reproduce

from abc import ABCMeta, abstractmethod
from dataclasses import dataclass
from typing import Self, SupportsFloat, TypeVar, overload, Type, Optional, Generic, Any

T = TypeVar("T")
V = TypeVar("V")


class Base(Generic[T, V], metaclass=ABCMeta):
    def __set_name__(self, owner: type, name: str) -> None:
        self.public_name = name
        self.private_name = "_" + name

    @overload
    def __get__(self, instance: None, owner: Optional[Type[Any]] = None) -> Self:...

    @overload
    def __get__(self, instance: Any, owner: Optional[Type[Any]] = None) -> V | None:...

    def __get__(self, instance: Any, owner: Optional[Type[Any]] = None) ->  Self | V | None:
        if instance is None:
            return self
        return getattr(instance, self.private_name, None)

    def __set__(self, instance: Any, value: Optional[T]) -> None:
        if value is self or value is None:
            return
        converted = self._converter(value)
        object.__setattr__(instance, self.private_name, converted)

    @abstractmethod
    def _converter(self, value: T) -> V:
        """
        Hook to implement conversion logic
        """

class FloatParameter(Base[SupportsFloat, float]):
    def _converter(self, value: SupportsFloat) -> float:
        """Can have more logic here to check if value can be converted to float"""
        return float(value)
        

@dataclass(frozen=True, kw_only=True)
class BaseDataClass:
    float_param: FloatParameter = FloatParameter()


@dataclass(frozen=True, kw_only=True)
class DerivedDataClass(BaseDataClass):
    boolean: bool = True


reveal_type(BaseDataClass.float_param) # correct FloatParameter
reveal_type(DerivedDataClass.float_param) # Incorrect Union[typing.SupportsFloat, None]

reveal_type(BaseDataClass().float_param) # Correct "Union[builtins.float, None]"
reveal_type(DerivedDataClass().float_param) # Incorrect Union[typing.SupportsFloat, None]

NOTE: Pylance on the other hand on VSCode shows correct datatypes.

Inizia con la riproduzione minima in Python 3.11 usando mypy 1.14.0 e confronta i risultati di reveal_type per BaseDataClass e DerivedDataClass. Analizza l’ereditarietà di dataclass congelate con attributi descriptor; il lavoro è completo quando la classe derivata segnala FloatParameter sulla classe e float | None sulle istanze, in corrispondenza della classe base.