Python/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff synced 2026-01-23 22:40:48 -05:00
Code Issues Packages Projects Releases Wiki Activity

[red-knot] Initial support for dataclasses (#17353)

Browse Source 
## Summary

Add very early support for dataclasses. This is mostly to make sure that
we do not emit false positives on dataclass construction, but it also
lies some foundations for future extensions.

This seems like a good initial step to merge to me, as it basically
removes all false positives on dataclass constructor calls. This allows
us to use the ecosystem checks for making sure we don't introduce new
false positives as we continue to work on dataclasses.

## Ecosystem analysis

I re-ran the mypy_primer evaluation of [the `__init__`
PR](https://github.com/astral-sh/ruff/pull/16512) locally with our
current mypy_primer version and project selection. It introduced 1597
new diagnostics. Filtering those by searching for `__init__` and
rejecting those that contain `invalid-argument-type` (those could not
possibly be solved by this PR) leaves 1281 diagnostics. The current
version of this PR removes 1171 diagnostics, which leaves 110
unaccounted for. I extracted the lint + file path for all of these
diagnostics and generated a diff (of diffs), to see which
`__init__`-diagnostics remain. I looked at a subset of these: There are
a lot of `SomeClass(*args)` calls where we don't understand the
unpacking yet (this is not even related to `__init__`). Some others are
related to `NamedTuple`, which we also don't support yet. And then there
are some errors related to `@attrs.define`-decorated classes, which
would probably require support for `dataclass_transform`, which I made
no attempt to include in this PR.

## Test Plan

New Markdown tests.
This commit is contained in:
David Peter
2025-04-15 10:39:21 +02:00
committed by GitHub
parent 4894f52bae
commit 03adae80dc
9 changed files with 505 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/red_knot_python_semantic/src/module_resolver/module.rs
View File

@@ -116,6 +116,7 @@ pub enum KnownModule {
Sys,
#[allow(dead_code)]
Abc, // currently only used in tests
Dataclasses,
Collections,
Inspect,
KnotExtensions,
@@ -132,6 +133,7 @@ impl KnownModule {
Self::TypingExtensions => "typing_extensions",
Self::Sys => "sys",
Self::Abc => "abc",
Self::Dataclasses => "dataclasses",
Self::Collections => "collections",
Self::Inspect => "inspect",
Self::KnotExtensions => "knot_extensions",

147
crates/red_knot_python_semantic/src/types.rs
View File

@@ -311,6 +311,32 @@ impl<'db> PropertyInstanceType<'db> {
}
}
bitflags! {
/// Used as the return type of `dataclass(…)` calls. Keeps track of the arguments
/// that were passed in. For the precise meaning of the fields, see [1].
///
/// [1]: https://docs.python.org/3/library/dataclasses.html
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct DataclassMetadata: u16 {
const INIT = 0b0000_0000_0001;
const REPR = 0b0000_0000_0010;
const EQ = 0b0000_0000_0100;
const ORDER = 0b0000_0000_1000;
const UNSAFE_HASH = 0b0000_0001_0000;
const FROZEN = 0b0000_0010_0000;
const MATCH_ARGS = 0b0000_0100_0000;
const KW_ONLY = 0b0000_1000_0000;
const SLOTS = 0b0001_0000_0000;
const WEAKREF_SLOT = 0b0010_0000_0000;
}
}
impl Default for DataclassMetadata {
fn default() -> Self {
Self::INIT | Self::REPR | Self::EQ | Self::MATCH_ARGS
}
}
/// Representation of a type: a set of possible values at runtime.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, salsa::Update)]
pub enum Type<'db> {
@@ -348,6 +374,10 @@ pub enum Type<'db> {
/// type. We currently add this as a separate variant because `FunctionType.__get__`
/// is an overloaded method and we do not support `@overload` yet.
WrapperDescriptor(WrapperDescriptorKind),
/// A special callable that is returned by a `dataclass(…)` call. It is usually
/// used as a decorator. Note that this is only used as a return type for actual
/// `dataclass` calls, not for the argumentless `@dataclass` decorator.
DataclassDecorator(DataclassMetadata),
/// The type of an arbitrary callable object with a certain specified signature.
Callable(CallableType<'db>),
/// A specific module object
@@ -458,7 +488,8 @@ impl<'db> Type<'db> {
| Self::Dynamic(DynamicType::Unknown | DynamicType::Any)
| Self::BoundMethod(_)
| Self::WrapperDescriptor(_)
| Self::MethodWrapper(_) => false,
| Self::MethodWrapper(_)
| Self::DataclassDecorator(_) => false,
Self::GenericAlias(generic) => generic
.specialization(db)
@@ -747,6 +778,7 @@ impl<'db> Type<'db> {
| Type::MethodWrapper(_)
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Self::DataclassDecorator(_)
| Type::ModuleLiteral(_)
| Type::ClassLiteral(_)
| Type::KnownInstance(_)
@@ -979,6 +1011,11 @@ impl<'db> Type<'db> {
.signature(db)
.is_subtype_of(db, other_callable.signature(db)),
(Type::DataclassDecorator(_), _) => {
// TODO: Implement subtyping using an equivalent `Callable` type.
false
}
(Type::Callable(_), _) => {
// TODO: Implement subtyping between callable types and other types like
// function literals, bound methods, class literals, `type[]`, etc.)
@@ -1507,6 +1544,7 @@ impl<'db> Type<'db> {
| Type::BoundMethod(..)
| Type::MethodWrapper(..)
| Type::WrapperDescriptor(..)
| Type::DataclassDecorator(..)
| Type::IntLiteral(..)
| Type::SliceLiteral(..)
| Type::StringLiteral(..)
@@ -1522,6 +1560,7 @@ impl<'db> Type<'db> {
| Type::BoundMethod(..)
| Type::MethodWrapper(..)
| Type::WrapperDescriptor(..)
| Type::DataclassDecorator(..)
| Type::IntLiteral(..)
| Type::SliceLiteral(..)
| Type::StringLiteral(..)
@@ -1716,7 +1755,8 @@ impl<'db> Type<'db> {
true
}
(Type::Callable(_), _) | (_, Type::Callable(_)) => {
(Type::Callable(_) | Type::DataclassDecorator(_), _)
| (_, Type::Callable(_) | Type::DataclassDecorator(_)) => {
// TODO: Implement disjointness for general callable type with other types
false
}
@@ -1773,6 +1813,7 @@ impl<'db> Type<'db> {
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(_)
| Type::DataclassDecorator(_)
| Type::ModuleLiteral(..)
| Type::IntLiteral(_)
| Type::BooleanLiteral(_)
@@ -1891,6 +1932,7 @@ impl<'db> Type<'db> {
// (this variant represents `f.__get__`, where `f` is any function)
false
}
Type::DataclassDecorator(_) => false,
Type::Instance(InstanceType { class }) => {
class.known(db).is_some_and(KnownClass::is_singleton)
}
@@ -1977,7 +2019,8 @@ impl<'db> Type<'db> {
| Type::AlwaysTruthy
| Type::AlwaysFalsy
| Type::Callable(_)
| Type::PropertyInstance(_) => false,
| Type::PropertyInstance(_)
| Type::DataclassDecorator(_) => false,
}
}
@@ -2106,6 +2149,7 @@ impl<'db> Type<'db> {
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(_)
| Type::DataclassDecorator(_)
| Type::ModuleLiteral(_)
| Type::KnownInstance(_)
| Type::AlwaysTruthy
@@ -2198,6 +2242,9 @@ impl<'db> Type<'db> {
Type::WrapperDescriptor(_) => KnownClass::WrapperDescriptorType
.to_instance(db)
.instance_member(db, name),
Type::DataclassDecorator(_) => KnownClass::FunctionType
.to_instance(db)
.instance_member(db, name),
Type::Callable(_) => KnownClass::Object.to_instance(db).instance_member(db, name),
Type::TypeVar(typevar) => match typevar.bound_or_constraints(db) {
@@ -2604,6 +2651,9 @@ impl<'db> Type<'db> {
Type::WrapperDescriptor(_) => KnownClass::WrapperDescriptorType
.to_instance(db)
.member(db, &name),
Type::DataclassDecorator(_) => {
KnownClass::FunctionType.to_instance(db).member(db, &name)
}
Type::Callable(_) => KnownClass::Object.to_instance(db).member(db, &name),
Type::Instance(InstanceType { class })
@@ -2898,6 +2948,7 @@ impl<'db> Type<'db> {
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(_)
| Type::DataclassDecorator(_)
| Type::ModuleLiteral(_)
| Type::SliceLiteral(_)
| Type::AlwaysTruthy => Truthiness::AlwaysTrue,
@@ -3289,6 +3340,83 @@ impl<'db> Type<'db> {
Signatures::single(signature)
}
Some(KnownFunction::Dataclass) => {
let signature = CallableSignature::from_overloads(
self,
[
// def dataclass(cls: None, /) -> Callable[[type[_T]], type[_T]]: ...
Signature::new(
Parameters::new([Parameter::positional_only(Some(
Name::new_static("cls"),
))
.with_annotated_type(Type::none(db))]),
None,
),
// def dataclass(cls: type[_T], /) -> type[_T]: ...
Signature::new(
Parameters::new([Parameter::positional_only(Some(
Name::new_static("cls"),
))
// TODO: type[_T]
.with_annotated_type(Type::any())]),
None,
),
// TODO: make this overload Python-version-dependent
// def dataclass(
// *,
// init: bool = True,
// repr: bool = True,
// eq: bool = True,
// order: bool = False,
// unsafe_hash: bool = False,
// frozen: bool = False,
// match_args: bool = True,
// kw_only: bool = False,
// slots: bool = False,
// weakref_slot: bool = False,
// ) -> Callable[[type[_T]], type[_T]]: ...
Signature::new(
Parameters::new([
Parameter::keyword_only(Name::new_static("init"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(true)),
Parameter::keyword_only(Name::new_static("repr"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(true)),
Parameter::keyword_only(Name::new_static("eq"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(true)),
Parameter::keyword_only(Name::new_static("order"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(false)),
Parameter::keyword_only(Name::new_static("unsafe_hash"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(false)),
Parameter::keyword_only(Name::new_static("frozen"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(false)),
Parameter::keyword_only(Name::new_static("match_args"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(true)),
Parameter::keyword_only(Name::new_static("kw_only"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(false)),
Parameter::keyword_only(Name::new_static("slots"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(false)),
Parameter::keyword_only(Name::new_static("weakref_slot"))
.with_annotated_type(KnownClass::Bool.to_instance(db))
.with_default_type(Type::BooleanLiteral(false)),
]),
None,
),
],
);
Signatures::single(signature)
}
_ => Signatures::single(CallableSignature::single(
self,
function_type.signature(db).clone(),
@@ -3911,6 +4039,7 @@ impl<'db> Type<'db> {
| Type::MethodWrapper(_)
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Type::DataclassDecorator(_)
| Type::Instance(_)
| Type::KnownInstance(_)
| Type::PropertyInstance(_)
@@ -3979,6 +4108,7 @@ impl<'db> Type<'db> {
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(_)
| Type::DataclassDecorator(_)
| Type::Never
| Type::FunctionLiteral(_)
| Type::PropertyInstance(_) => Err(InvalidTypeExpressionError {
@@ -4188,6 +4318,7 @@ impl<'db> Type<'db> {
Type::BoundMethod(_) => KnownClass::MethodType.to_class_literal(db),
Type::MethodWrapper(_) => KnownClass::MethodWrapperType.to_class_literal(db),
Type::WrapperDescriptor(_) => KnownClass::WrapperDescriptorType.to_class_literal(db),
Type::DataclassDecorator(_) => KnownClass::FunctionType.to_class_literal(db),
Type::Callable(_) => KnownClass::Type.to_instance(db),
Type::ModuleLiteral(_) => KnownClass::ModuleType.to_class_literal(db),
Type::Tuple(_) => KnownClass::Tuple.to_class_literal(db),
@@ -4326,6 +4457,7 @@ impl<'db> Type<'db> {
| Type::AlwaysFalsy
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(MethodWrapperKind::StrStartswith(_))
| Type::DataclassDecorator(_)
| Type::ModuleLiteral(_)
// A non-generic class never needs to be specialized. A generic class is specialized
// explicitly (via a subscript expression) or implicitly (via a call), and not because
@@ -4430,6 +4562,7 @@ impl<'db> Type<'db> {
| Self::SliceLiteral(_)
| Self::MethodWrapper(_)
| Self::WrapperDescriptor(_)
| Self::DataclassDecorator(_)
| Self::PropertyInstance(_)
| Self::Tuple(_) => self.to_meta_type(db).definition(db),
@@ -5581,6 +5714,9 @@ pub enum KnownFunction {
#[strum(serialize = "abstractmethod")]
AbstractMethod,
/// `dataclasses.dataclass`
Dataclass,
/// `inspect.getattr_static`
GetattrStatic,
@@ -5640,6 +5776,9 @@ impl KnownFunction {
Self::AbstractMethod => {
matches!(module, KnownModule::Abc)
}
Self::Dataclass => {
matches!(module, KnownModule::Dataclasses)
}
Self::GetattrStatic => module.is_inspect(),
Self::IsAssignableTo
| Self::IsDisjointFrom
@@ -6578,6 +6717,8 @@ pub(crate) mod tests {
KnownFunction::AbstractMethod => KnownModule::Abc,
KnownFunction::Dataclass => KnownModule::Dataclasses,
KnownFunction::GetattrStatic => KnownModule::Inspect,
KnownFunction::Cast

54
crates/red_knot_python_semantic/src/types/call/bind.rs
View File

@@ -18,8 +18,8 @@ use crate::types::diagnostic::{
};
use crate::types::signatures::{Parameter, ParameterForm};
use crate::types::{
todo_type, BoundMethodType, FunctionDecorators, KnownClass, KnownFunction, KnownInstanceType,
MethodWrapperKind, PropertyInstanceType, UnionType, WrapperDescriptorKind,
todo_type, BoundMethodType, DataclassMetadata, FunctionDecorators, KnownClass, KnownFunction,
KnownInstanceType, MethodWrapperKind, PropertyInstanceType, UnionType, WrapperDescriptorKind,
};
use ruff_db::diagnostic::{Annotation, Severity, Span, SubDiagnostic};
use ruff_python_ast as ast;
@@ -573,6 +573,56 @@ impl<'db> Bindings<'db> {
);
}
Some(KnownFunction::Dataclass) => {
if let [init, repr, eq, order, unsafe_hash, frozen, match_args, kw_only, slots, weakref_slot] =
overload.parameter_types()
{
let to_bool = |ty: &Option<Type<'_>>, default: bool| -> bool {
if let Some(Type::BooleanLiteral(value)) = ty {
*value
} else {
// TODO: emit a diagnostic if we receive `bool`
default
}
};
let mut metadata = DataclassMetadata::empty();
if to_bool(init, true) {
metadata |= DataclassMetadata::INIT;
}
if to_bool(repr, true) {
metadata |= DataclassMetadata::REPR;
}
if to_bool(eq, true) {
metadata |= DataclassMetadata::EQ;
}
if to_bool(order, false) {
metadata |= DataclassMetadata::ORDER;
}
if to_bool(unsafe_hash, false) {
metadata |= DataclassMetadata::UNSAFE_HASH;
}
if to_bool(frozen, false) {
metadata |= DataclassMetadata::FROZEN;
}
if to_bool(match_args, true) {
metadata |= DataclassMetadata::MATCH_ARGS;
}
if to_bool(kw_only, false) {
metadata |= DataclassMetadata::KW_ONLY;
}
if to_bool(slots, false) {
metadata |= DataclassMetadata::SLOTS;
}
if to_bool(weakref_slot, false) {
metadata |= DataclassMetadata::WEAKREF_SLOT;
}
overload.set_return_type(Type::DataclassDecorator(metadata));
}
}
_ => {}
},

29
crates/red_knot_python_semantic/src/types/class.rs
View File

@@ -7,6 +7,8 @@ use super::{
};
use crate::semantic_index::definition::Definition;
use crate::types::generics::{GenericContext, Specialization};
use crate::types::signatures::{Parameter, Parameters};
use crate::types::{CallableType, DataclassMetadata, Signature};
use crate::{
module_resolver::file_to_module,
semantic_index::{
@@ -30,6 +32,7 @@ use crate::{
use indexmap::IndexSet;
use itertools::Itertools as _;
use ruff_db::files::File;
use ruff_python_ast::name::Name;
use ruff_python_ast::{self as ast, PythonVersion};
use rustc_hash::FxHashSet;
@@ -98,6 +101,8 @@ pub struct Class<'db> {
pub(crate) body_scope: ScopeId<'db>,
pub(crate) known: Option<KnownClass>,
pub(crate) dataclass_metadata: Option<DataclassMetadata>,
}
impl<'db> Class<'db> {
@@ -364,6 +369,10 @@ impl<'db> ClassLiteralType<'db> {
self.class(db).known
}
pub(crate) fn dataclass_metadata(self, db: &'db dyn Db) -> Option<DataclassMetadata> {
self.class(db).dataclass_metadata
}
/// Return `true` if this class represents `known_class`
pub(crate) fn is_known(self, db: &'db dyn Db, known_class: KnownClass) -> bool {
self.class(db).known == Some(known_class)
@@ -782,6 +791,26 @@ impl<'db> ClassLiteralType<'db> {
/// directly. Use [`ClassLiteralType::class_member`] if you require a method that will
/// traverse through the MRO until it finds the member.
pub(super) fn own_class_member(self, db: &'db dyn Db, name: &str) -> SymbolAndQualifiers<'db> {
if let Some(metadata) = self.dataclass_metadata(db) {
if name == "__init__" {
if metadata.contains(DataclassMetadata::INIT) {
// TODO: Generate the signature from the attributes on the class
let init_signature = Signature::new(
Parameters::new([
Parameter::variadic(Name::new_static("args"))
.with_annotated_type(Type::any()),
Parameter::keyword_variadic(Name::new_static("kwargs"))
.with_annotated_type(Type::any()),
]),
Some(Type::none(db)),
);
return Symbol::bound(Type::Callable(CallableType::new(db, init_signature)))
.into();
}
}
}
let body_scope = self.body_scope(db);
class_symbol(db, body_scope, name)
}

1
crates/red_knot_python_semantic/src/types/class_base.rs
View File

@@ -86,6 +86,7 @@ impl<'db> ClassBase<'db> {
| Type::BoundMethod(_)
| Type::MethodWrapper(_)
| Type::WrapperDescriptor(_)
| Type::DataclassDecorator(_)
| Type::BytesLiteral(_)
| Type::IntLiteral(_)
| Type::StringLiteral(_)

3
crates/red_knot_python_semantic/src/types/display.rs
View File

@@ -165,6 +165,9 @@ impl Display for DisplayRepresentation<'_> {
};
write!(f, "<wrapper-descriptor `{method}` of `{object}` objects>")
}
Type::DataclassDecorator(_) => {
f.write_str("<decorator produced by dataclasses.dataclass>")
}
Type::Union(union) => union.display(self.db).fmt(f),
Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
Type::IntLiteral(n) => n.fmt(f),

33
crates/red_knot_python_semantic/src/types/infer.rs
View File

@@ -82,12 +82,13 @@ use crate::types::mro::MroErrorKind;
use crate::types::unpacker::{UnpackResult, Unpacker};
use crate::types::{
todo_type, CallDunderError, CallableSignature, CallableType, Class, ClassLiteralType,
DynamicType, FunctionDecorators, FunctionType, GenericAlias, GenericClass, IntersectionBuilder,
IntersectionType, KnownClass, KnownFunction, KnownInstanceType, MemberLookupPolicy,
MetaclassCandidate, NonGenericClass, Parameter, ParameterForm, Parameters, Signature,
Signatures, SliceLiteralType, StringLiteralType, SubclassOfType, Symbol, SymbolAndQualifiers,
Truthiness, TupleType, Type, TypeAliasType, TypeAndQualifiers, TypeArrayDisplay,
TypeQualifiers, TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder, UnionType,
DataclassMetadata, DynamicType, FunctionDecorators, FunctionType, GenericAlias, GenericClass,
IntersectionBuilder, IntersectionType, KnownClass, KnownFunction, KnownInstanceType,
MemberLookupPolicy, MetaclassCandidate, NonGenericClass, Parameter, ParameterForm, Parameters,
Signature, Signatures, SliceLiteralType, StringLiteralType, SubclassOfType, Symbol,
SymbolAndQualifiers, Truthiness, TupleType, Type, TypeAliasType, TypeAndQualifiers,
TypeArrayDisplay, TypeQualifiers, TypeVarBoundOrConstraints, TypeVarInstance, UnionBuilder,
UnionType,
};
use crate::unpack::{Unpack, UnpackPosition};
use crate::util::subscript::{PyIndex, PySlice};
@@ -1725,8 +1726,21 @@ impl<'db> TypeInferenceBuilder<'db> {
body: _,
} = class_node;
let mut dataclass_metadata = None;
for decorator in decorator_list {
self.infer_decorator(decorator);
let decorator_ty = self.infer_decorator(decorator);
if decorator_ty
.into_function_literal()
.is_some_and(|function| function.is_known(self.db(), KnownFunction::Dataclass))
{
dataclass_metadata = Some(DataclassMetadata::default());
continue;
}
if let Type::DataclassDecorator(metadata) = decorator_ty {
dataclass_metadata = Some(metadata);
continue;
}
}
let generic_context = type_params.as_ref().map(|type_params| {
@@ -1744,6 +1758,7 @@ impl<'db> TypeInferenceBuilder<'db> {
name: name.id.clone(),
body_scope,
known: maybe_known_class,
dataclass_metadata,
};
let class_literal = match generic_context {
Some(generic_context) => {
@@ -2432,6 +2447,7 @@ impl<'db> TypeInferenceBuilder<'db> {
| Type::BoundMethod(_)
| Type::MethodWrapper(_)
| Type::WrapperDescriptor(_)
| Type::DataclassDecorator(_)
| Type::TypeVar(..)
| Type::AlwaysTruthy
| Type::AlwaysFalsy => {
@@ -4677,6 +4693,7 @@ impl<'db> TypeInferenceBuilder<'db> {
| Type::Callable(..)
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(_)
| Type::DataclassDecorator(_)
| Type::BoundMethod(_)
| Type::ModuleLiteral(_)
| Type::ClassLiteral(_)
@@ -4955,6 +4972,7 @@ impl<'db> TypeInferenceBuilder<'db> {
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(_)
| Type::DataclassDecorator(_)
| Type::ModuleLiteral(_)
| Type::ClassLiteral(_)
| Type::GenericAlias(_)
@@ -4977,6 +4995,7 @@ impl<'db> TypeInferenceBuilder<'db> {
| Type::BoundMethod(_)
| Type::WrapperDescriptor(_)
| Type::MethodWrapper(_)
| Type::DataclassDecorator(_)
| Type::ModuleLiteral(_)
| Type::ClassLiteral(_)
| Type::GenericAlias(_)

6
crates/red_knot_python_semantic/src/types/type_ordering.rs
View File

@@ -70,6 +70,12 @@ pub(super) fn union_or_intersection_elements_ordering<'db>(
(Type::WrapperDescriptor(_), _) => Ordering::Less,
(_, Type::WrapperDescriptor(_)) => Ordering::Greater,
(Type::DataclassDecorator(left), Type::DataclassDecorator(right)) => {
left.bits().cmp(&right.bits())
}
(Type::DataclassDecorator(_), _) => Ordering::Less,
(_, Type::DataclassDecorator(_)) => Ordering::Greater,
(Type::Callable(left), Type::Callable(right)) => {
debug_assert_eq!(*left, left.normalized(db));
debug_assert_eq!(*right, right.normalized(db));