[red-knot] Dataclasses: support order=True

Author: sharkdp

crates/red_knot_python_semantic/resources/mdtest/dataclasses.md

@@ -91,6 +91,98 @@ repr(C())
 C() == C()
 ```
 
+## Other dataclass parameters
+
+### `repr`
+
+A custom `__repr__` method is generated by default. It can be disabled by passing `repr=False`, but
+in that case `__repr__` is still available via `object.__repr__`:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(repr=False)
+class WithoutRepr:
+    x: int
+
+reveal_type(WithoutRepr(1).__repr__)  # revealed: bound method WithoutRepr.__repr__() -> str
+```
+
+### `eq`
+
+The same is true for `__eq__`. Setting `eq=False` disables the generated `__eq__` method, but
+`__eq__` is still available via `object.__eq__`:
+
+```py
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class WithoutEq:
+    x: int
+
+reveal_type(WithoutEq(1) == WithoutEq(2))  # revealed: bool
+```
+
+### `order`
+
+`order` is set to `False` by default. If `order=True`, `__lt__`, `__le__`, `__gt__`, and `__ge__`
+methods will be generated:
+
+```py
+from dataclasses import dataclass
+
+@dataclass
+class WithoutOrder:
+    x: int
+
+WithoutOrder(1) < WithoutOrder(2)  # error: [unsupported-operator]
+WithoutOrder(1) <= WithoutOrder(2)  # error: [unsupported-operator]
+WithoutOrder(1) > WithoutOrder(2)  # error: [unsupported-operator]
+WithoutOrder(1) >= WithoutOrder(2)  # error: [unsupported-operator]
+
+@dataclass(order=True)
+class WithOrder:
+    x: int
+
+WithOrder(1) < WithOrder(2)
+WithOrder(1) <= WithOrder(2)
+WithOrder(1) > WithOrder(2)
+WithOrder(1) >= WithOrder(2)
+```
+
+Comparisons are only allowed for `WithOrder` instances:
+
+```py
+WithOrder(1) < 2  # error: [unsupported-operator]
+WithOrder(1) <= 2  # error: [unsupported-operator]
+WithOrder(1) > 2  # error: [unsupported-operator]
+WithOrder(1) >= 2  # error: [unsupported-operator]
+```
+
+### `unsafe_hash`
+
+To do
+
+### `frozen`
+
+To do
+
+### `match_args`
+
+To do
+
+### `kw_only`
+
+To do
+
+### `slots`
+
+To do
+
+### `weakref_slot`
+
+To do
+
 ## Inheritance
 
 ### Normal class inheriting from a dataclass
@@ -174,7 +266,28 @@ To do
 
 ## Descriptor-typed fields
 
-To do
+```py
+from dataclasses import dataclass
+
+class Descriptor:
+    _value: int = 0
+
+    def __get__(self, instance, owner) -> str:
+        return str(self._value)
+
+    def __set__(self, instance, value: int) -> None:
+        self._value = value
+
+@dataclass
+class C:
+    d: Descriptor = Descriptor()
+
+c = C(1)
+reveal_type(c.d)  # revealed: str
+
+# TODO: should be an error
+C("a")
+```
 
 ## `dataclasses.field`
 
@@ -197,13 +310,37 @@ class C:
 reveal_type(C.__init__)  # revealed: (*args: Any, **kwargs: Any) -> None
 ```
 
-### Dataclass with `init=False`
+### Dataclass with custom `__init__` method
 
-To do
+If a class already defines `__init__`, it is not replaced by the `dataclass` decorator.
 
-### Dataclass with custom `__init__` method
+```py
+from dataclasses import dataclass
 
-To do
+@dataclass(init=True)
+class C:
+    x: str
+
+    def __init__(self, x: int) -> None:
+        self.x = str(x)
+
+C(1)  # OK
+
+# TODO: should be an error
+C("a")
+```
+
+Similarly, if we set `init=False`, we still recognize the custom `__init__` method:
+
+```py
+@dataclass(init=False)
+class D:
+    def __init__(self, x: int) -> None:
+        self.x = str(x)
+
+D(1)  # OK
+D()  # error: [missing-argument]
+```
 
 ### Dataclass with `ClassVar`s
 

crates/red_knot_python_semantic/src/types/class.rs

@@ -792,21 +792,29 @@ impl<'db> ClassLiteralType<'db> {
     /// 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)),
+            if name == "__init__" && 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();
+            } else if matches!(name, "__lt__" | "__le__" | "__gt__" | "__ge__") {
+                if metadata.contains(DataclassMetadata::ORDER) {
+                    let signature = Signature::new(
+                        Parameters::new([Parameter::positional_or_keyword(Name::new_static(
+                            "other",
+                        ))
+                        .with_annotated_type(Type::instance(self.default_specialization(db)))]),
+                        Some(KnownClass::Bool.to_instance(db)),
                     );
-
-                    return Symbol::bound(Type::Callable(CallableType::new(db, init_signature)))
-                        .into();
+                    return Symbol::bound(Type::Callable(CallableType::new(db, signature))).into();
                 }
             }
         }