From 5059243710e3e94c784f6c6339be036e1537c82a Mon Sep 17 00:00:00 2001 From: 2301_80183707 <2100820071@qq.com> Date: Mon, 9 Nov 2026 11:11:03 +0800 Subject: [PATCH 1/3] Fix dataclass_transform base frozen inheritance --- .../src/analyzer/dataClasses.ts | 22 ++++++++++------- .../src/tests/samples/dataclassTransform5.py | 24 +++++++++++++++++++ .../src/tests/typeEvaluator5.test.ts | 6 +++++ 3 files changed, 44 insertions(+), 8 deletions(-) create mode 100644 packages/pyright-internal/src/tests/samples/dataclassTransform5.py diff --git a/packages/pyright-internal/src/analyzer/dataClasses.ts b/packages/pyright-internal/src/analyzer/dataClasses.ts index a361d53669d7..3909a35a8a55 100644 --- a/packages/pyright-internal/src/analyzer/dataClasses.ts +++ b/packages/pyright-internal/src/analyzer/dataClasses.ts @@ -1611,16 +1611,22 @@ function applyDataClassBehaviorOverrideValue( 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. + const isDataClassTransformClass = + baseClass.shared.classDataClassTransform !== undefined || + (baseClass.shared.declaredMetaclass && + isInstantiableClass(baseClass.shared.declaredMetaclass) && + baseClass.shared.declaredMetaclass.shared.classDataClassTransform !== undefined); + + if (isDataClassTransformClass) { + 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..f600bd3ea2d6 --- /dev/null +++ b/packages/pyright-internal/src/tests/samples/dataclassTransform5.py @@ -0,0 +1,24 @@ +# 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 typing_extensions import dataclass_transform + + +@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 diff --git a/packages/pyright-internal/src/tests/typeEvaluator5.test.ts b/packages/pyright-internal/src/tests/typeEvaluator5.test.ts index e3c32819dbab..8345ec4b1980 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator5.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator5.test.ts @@ -468,6 +468,12 @@ test('DataclassTransform4', () => { TestUtils.validateResults(analysisResults, 2); }); +test('DataclassTransform5', () => { + const analysisResults = TestUtils.typeAnalyzeSampleFiles(['dataclassTransform5.py']); + + TestUtils.validateResults(analysisResults, 0); +}); + test('Async1', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['async1.py']); From d9c672cf25f93b4212524dbeffc63a8e4439e1f5 Mon Sep 17 00:00:00 2001 From: Bill Schnurr Date: Tue, 17 Nov 2026 10:13:22 -0700 Subject: [PATCH 2/3] Suppress missing typing_extensions source warning in dataclassTransform5 sample Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../pyright-internal/src/tests/samples/dataclassTransform5.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/pyright-internal/src/tests/samples/dataclassTransform5.py b/packages/pyright-internal/src/tests/samples/dataclassTransform5.py index f600bd3ea2d6..47bf85a73f27 100644 --- a/packages/pyright-internal/src/tests/samples/dataclassTransform5.py +++ b/packages/pyright-internal/src/tests/samples/dataclassTransform5.py @@ -2,7 +2,7 @@ # frozen nor non-frozen when used as base classes. from abc import ABC -from typing_extensions import dataclass_transform +from typing_extensions import dataclass_transform # pyright: ignore[reportMissingModuleSource] @dataclass_transform(frozen_default=True) From 1df9af89100832340d0fc4431a32ff49fa48e23e Mon Sep 17 00:00:00 2001 From: 2301_80183707 <2100820071@qq.com> Date: Sat, 21 Nov 2026 10:43:43 +0800 Subject: [PATCH 3/3] Fix concrete dataclass checks through transform providers --- .../src/analyzer/dataClasses.ts | 39 +++++++++--- .../src/tests/samples/dataclassTransform5.py | 60 +++++++++++++++++++ .../src/tests/typeEvaluator5.test.ts | 2 +- 3 files changed, 93 insertions(+), 8 deletions(-) diff --git a/packages/pyright-internal/src/analyzer/dataClasses.ts b/packages/pyright-internal/src/analyzer/dataClasses.ts index 3909a35a8a55..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,34 @@ 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. - const isDataClassTransformClass = - baseClass.shared.classDataClassTransform !== undefined || - (baseClass.shared.declaredMetaclass && - isInstantiableClass(baseClass.shared.declaredMetaclass) && - baseClass.shared.declaredMetaclass.shared.classDataClassTransform !== undefined); - - if (isDataClassTransformClass) { + 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; } diff --git a/packages/pyright-internal/src/tests/samples/dataclassTransform5.py b/packages/pyright-internal/src/tests/samples/dataclassTransform5.py index 47bf85a73f27..ebe6c237369a 100644 --- a/packages/pyright-internal/src/tests/samples/dataclassTransform5.py +++ b/packages/pyright-internal/src/tests/samples/dataclassTransform5.py @@ -2,6 +2,8 @@ # 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] @@ -22,3 +24,61 @@ class Config(ExtendedDataClass, frozen=False): 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 086f80328303..d5def3dc5413 100644 --- a/packages/pyright-internal/src/tests/typeEvaluator5.test.ts +++ b/packages/pyright-internal/src/tests/typeEvaluator5.test.ts @@ -479,7 +479,7 @@ test('DataclassTransform4', () => { test('DataclassTransform5', () => { const analysisResults = TestUtils.typeAnalyzeSampleFiles(['dataclassTransform5.py']); - TestUtils.validateResults(analysisResults, 0); + TestUtils.validateResults(analysisResults, 2); }); test('Async1', () => {