diff --git a/packages/pyright-internal/src/analyzer/dataClasses.ts b/packages/pyright-internal/src/analyzer/dataClasses.ts index a361d53669d7..26f26ee93fc0 100644 --- a/packages/pyright-internal/src/analyzer/dataClasses.ts +++ b/packages/pyright-internal/src/analyzer/dataClasses.ts @@ -116,6 +116,15 @@ function isDataClassKeywordOnlySeparator( return isClassInstance(annotatedType) && ClassType.isBuiltIn(annotatedType, 'KW_ONLY'); } +function isDataClassTransformClass(classType: ClassType) { + return ( + classType.shared.classDataClassTransform !== undefined || + (classType.shared.declaredMetaclass !== undefined && + isInstantiableClass(classType.shared.declaredMetaclass) && + classType.shared.declaredMetaclass.shared.classDataClassTransform !== undefined) + ); +} + // Calculate generated slots without forcing deferred dataclass method synthesis. export function synthesizeDataClassSlots(evaluator: TypeEvaluator, classType: ClassType) { delete classType.shared.synthesizeDataClassSlotsDeferred; @@ -1609,18 +1618,40 @@ function applyDataClassBehaviorOverrideValue( behaviors.frozen = argValue; } + // A class that directly provides dataclass transform behaviors is + // neither frozen nor non-frozen, so it isn't subject to the normal + // dataclass inheritance compatibility checks. + if (isDataClassTransformClass(classType)) { + break; + } + classType.shared.baseClasses.forEach((baseClass) => { if (isInstantiableClass(baseClass) && ClassType.isDataClass(baseClass)) { + // A class decorated with dataclass_transform is neither frozen + // nor non-frozen. It can be used as a base for either kind of + // generated dataclass without triggering an inheritance error. + if (isDataClassTransformClass(baseClass)) { + // The provider itself is neutral, but concrete dataclass + // ancestors still constrain generated subclasses. + baseClass.shared.mro.slice(1).forEach((mroClass) => { + if ( + isInstantiableClass(mroClass) && + ClassType.isDataClass(mroClass) && + !isDataClassTransformClass(mroClass) + ) { + if (ClassType.isDataClassFrozen(mroClass)) { + hasFrozenBaseClass = true; + } else { + hasUnfrozenBaseClass = true; + } + } + }); + return; + } + if (ClassType.isDataClassFrozen(baseClass)) { hasFrozenBaseClass = true; - } else if ( - !baseClass.shared.classDataClassTransform && - !( - baseClass.shared.declaredMetaclass && - isInstantiableClass(baseClass.shared.declaredMetaclass) && - !!baseClass.shared.declaredMetaclass.shared.classDataClassTransform - ) - ) { + } else { // If this base class is unfrozen and isn't the class that directly // references the metaclass that provides dataclass-like behaviors, // we'll assume we're deriving from an unfrozen dataclass. diff --git a/packages/pyright-internal/src/tests/samples/dataclassTransform5.py b/packages/pyright-internal/src/tests/samples/dataclassTransform5.py new file mode 100644 index 000000000000..ebe6c237369a --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/dataclassTransform5.py @@ -0,0 +1,84 @@ +# This sample tests that classes decorated with dataclass_transform are neither +# frozen nor non-frozen when used as base classes. + +from abc import ABC +from dataclasses import dataclass +from typing import cast +from typing_extensions import dataclass_transform # pyright: ignore[reportMissingModuleSource] + + +@dataclass_transform(frozen_default=True) +class DataClass(ABC): + def __init_subclass__(cls, frozen: bool = True): + pass + + +@dataclass_transform(frozen_default=True) +class ExtendedDataClass(DataClass, ABC): + pass + + +class Config(ExtendedDataClass, frozen=False): + name: str + + +class FrozenConfig(ExtendedDataClass, frozen=True): + name: str + + +@dataclass_transform(frozen_default=True) +class Meta(type): + def __new__(cls, name, bases, namespace, *, frozen=True, provider=False): + result = super().__new__(cls, name, bases, namespace) + if not provider: + dataclass(cast(type, result), frozen=frozen) + return result + + +@dataclass(frozen=True) +class ConcreteFrozen: + value: int = 0 + + +class NeutralFrozen(ConcreteFrozen, metaclass=Meta, provider=True): + pass + + +# This should generate an error because a non-frozen dataclass cannot +# derive from the concrete frozen dataclass through the neutral provider. +class MutableFromFrozen(NeutralFrozen, frozen=False): + pass + + +class FrozenFromFrozen(NeutralFrozen, frozen=True): + pass + + +@dataclass +class ConcreteMutable: + value: int = 0 + + +class NeutralMutable(ConcreteMutable, metaclass=Meta, provider=True): + pass + + +# This should generate an error because a frozen dataclass cannot derive +# from the concrete non-frozen dataclass through the neutral provider. +class FrozenFromMutable(NeutralMutable, frozen=True): + pass + + +class MutableFromMutable(NeutralMutable, frozen=False): + pass + + +@dataclass_transform() +class MutableMeta(type): + pass + + +# A class that directly specifies a transform-decorated metaclass is neutral, +# so its default frozen behavior should not conflict with its concrete base. +class NeutralProvider(ConcreteFrozen, metaclass=MutableMeta): + pass diff --git a/packages/pyright-internal/src/tests/typeEvaluator5.test.ts b/packages/pyright-internal/src/tests/typeEvaluator5.test.ts index dba285a01535..d5def3dc5413 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator5.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator5.test.ts @@ -476,6 +476,12 @@ test('DataclassTransform4', () => { TestUtils.validateResults(analysisResults, 2); }); +test('DataclassTransform5', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['dataclassTransform5.py']); + + TestUtils.validateResults(analysisResults, 2); +}); + test('Async1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['async1.py']);