Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
47 changes: 39 additions & 8 deletions packages/pyright-internal/src/analyzer/dataClasses.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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.
Expand Down
84 changes: 84 additions & 0 deletions packages/pyright-internal/src/tests/samples/dataclassTransform5.py
Original file line number Diff line number Diff line change
@@ -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
6 changes: 6 additions & 0 deletions packages/pyright-internal/src/tests/typeEvaluator5.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -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']);

Expand Down