[ty] diagnostic for dataclass field order

Author: PrettyWood

crates/ty_python_semantic/resources/mdtest/dataclasses/dataclasses.md

@@ -116,7 +116,7 @@ If attributes without default values are declared after attributes with default
 @dataclass
 class D:
     x: int = 1
-    # TODO: this should be an error: field without default defined after field with default
+    # error: [dataclass-field-order] "Required field `y` cannot be defined after fields with default values"
     y: str
 ```
 

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -38,6 +38,7 @@ pub(crate) fn register_lints(registry: &mut LintRegistryBuilder) {
     registry.register_lint(&DIVISION_BY_ZERO);
     registry.register_lint(&DUPLICATE_BASE);
     registry.register_lint(&DUPLICATE_KW_ONLY);
+    registry.register_lint(&DATACLASS_FIELD_ORDER);
     registry.register_lint(&INSTANCE_LAYOUT_CONFLICT);
     registry.register_lint(&INCONSISTENT_MRO);
     registry.register_lint(&INDEX_OUT_OF_BOUNDS);
@@ -337,6 +338,32 @@ declare_lint! {
     }
 }
 
+declare_lint! {
+    /// ## What it does
+    /// Checks for dataclass definitions where required fields are defined after
+    /// fields with default values.
+    ///
+    /// ## Why is this bad?
+    /// In dataclasses, all required fields (fields without default values) must be
+    /// defined before fields with default values. This is a Python requirement that
+    /// will raise a `TypeError` at runtime if violated.
+    ///
+    /// ## Example
+    /// ```python
+    /// from dataclasses import dataclass
+    ///
+    /// @dataclass
+    /// class Example:
+    ///     x: int = 1    # Field with default value
+    ///     y: str        # Error: Required field after field with default
+    /// ```
+    pub(crate) static DATACLASS_FIELD_ORDER = {
+        summary: "detects dataclass definitions with required fields after fields with default values",
+        status: LintStatus::preview("1.0.0"),
+        default_level: Level::Error,
+    }
+}
+
 declare_lint! {
     /// ## What it does
     /// Checks for classes definitions which will fail at runtime due to

crates/ty_python_semantic/src/types/infer.rs

@@ -93,18 +93,19 @@ use crate::types::call::{Binding, Bindings, CallArguments, CallError, CallErrorK
 use crate::types::class::{CodeGeneratorKind, Field, MetaclassErrorKind, SliceLiteral};
 use crate::types::diagnostic::{
     self, CALL_NON_CALLABLE, CONFLICTING_DECLARATIONS, CONFLICTING_METACLASS,
-    CYCLIC_CLASS_DEFINITION, DIVISION_BY_ZERO, DUPLICATE_KW_ONLY, INCONSISTENT_MRO,
-    INVALID_ARGUMENT_TYPE, INVALID_ASSIGNMENT, INVALID_ATTRIBUTE_ACCESS, INVALID_BASE,
-    INVALID_DECLARATION, INVALID_GENERIC_CLASS, INVALID_KEY, INVALID_PARAMETER_DEFAULT,
-    INVALID_TYPE_FORM, INVALID_TYPE_GUARD_CALL, INVALID_TYPE_VARIABLE_CONSTRAINTS,
-    IncompatibleBases, POSSIBLY_UNBOUND_IMPLICIT_CALL, POSSIBLY_UNBOUND_IMPORT,
-    TypeCheckDiagnostics, UNDEFINED_REVEAL, UNRESOLVED_ATTRIBUTE, UNRESOLVED_GLOBAL,
-    UNRESOLVED_IMPORT, UNRESOLVED_REFERENCE, UNSUPPORTED_OPERATOR, report_implicit_return_type,
-    report_instance_layout_conflict, report_invalid_argument_number_to_special_form,
-    report_invalid_arguments_to_annotated, report_invalid_arguments_to_callable,
-    report_invalid_assignment, report_invalid_attribute_assignment,
-    report_invalid_generator_function_return_type, report_invalid_key_on_typed_dict,
-    report_invalid_return_type, report_possibly_unbound_attribute,
+    CYCLIC_CLASS_DEFINITION, DATACLASS_FIELD_ORDER, DIVISION_BY_ZERO, DUPLICATE_KW_ONLY,
+    INCONSISTENT_MRO, INVALID_ARGUMENT_TYPE, INVALID_ASSIGNMENT, INVALID_ATTRIBUTE_ACCESS,
+    INVALID_BASE, INVALID_DECLARATION, INVALID_GENERIC_CLASS, INVALID_KEY,
+    INVALID_PARAMETER_DEFAULT, INVALID_TYPE_FORM, INVALID_TYPE_GUARD_CALL,
+    INVALID_TYPE_VARIABLE_CONSTRAINTS, IncompatibleBases, POSSIBLY_UNBOUND_IMPLICIT_CALL,
+    POSSIBLY_UNBOUND_IMPORT, TypeCheckDiagnostics, UNDEFINED_REVEAL, UNRESOLVED_ATTRIBUTE,
+    UNRESOLVED_GLOBAL, UNRESOLVED_IMPORT, UNRESOLVED_REFERENCE, UNSUPPORTED_OPERATOR,
+    report_implicit_return_type, report_instance_layout_conflict,
+    report_invalid_argument_number_to_special_form, report_invalid_arguments_to_annotated,
+    report_invalid_arguments_to_callable, report_invalid_assignment,
+    report_invalid_attribute_assignment, report_invalid_generator_function_return_type,
+    report_invalid_key_on_typed_dict, report_invalid_return_type,
+    report_possibly_unbound_attribute,
 };
 use crate::types::enums::is_enum_class;
 use crate::types::function::{
@@ -1356,30 +1357,38 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 }
             }
 
-            // (5) Check that a dataclass does not have more than one `KW_ONLY`.
+            // (5) Check that a dataclass does not have more than one `KW_ONLY`
+            // and that required fields are defined before default fields.
             if let Some(field_policy @ CodeGeneratorKind::DataclassLike) =
                 CodeGeneratorKind::from_class(self.db(), class)
             {
                 let specialization = None;
                 let mut kw_only_field_names = vec![];
+                let mut required_after_default_field_names = vec![];
+                let mut has_seen_default_field = false;
 
                 for (
                     name,
                     Field {
                         declared_ty: field_ty,
+                        default_ty,
                         ..
                     },
                 ) in class.fields(self.db(), specialization, field_policy)
                 {
-                    let Some(instance) = field_ty.into_nominal_instance() else {
-                        continue;
-                    };
-
-                    if !instance.class.is_known(self.db(), KnownClass::KwOnly) {
-                        continue;
+                    // Check for KW_ONLY
+                    if let Some(instance) = field_ty.into_nominal_instance() {
+                        if instance.class.is_known(self.db(), KnownClass::KwOnly) {
+                            kw_only_field_names.push(name.clone());
+                        }
                     }
 
-                    kw_only_field_names.push(name);
+                    // Check field ordering
+                    if default_ty.is_some() {
+                        has_seen_default_field = true;
+                    } else if has_seen_default_field {
+                        required_after_default_field_names.push(name);
+                    }
                 }
 
                 if kw_only_field_names.len() > 1 {
@@ -1401,6 +1410,31 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                         ));
                     }
                 }
+
+                // Report field ordering violations
+                for name in required_after_default_field_names {
+                    // Find the AST node for this field
+                    if let Some(field_node) = class_node.body.iter().find_map(|stmt| {
+                        if let ast::Stmt::AnnAssign(ann_assign) = stmt {
+                            if let ast::Expr::Name(name_expr) = ann_assign.target.as_ref() {
+                                if name_expr.id == *name {
+                                    return Some(ann_assign.target.as_ref());
+                                }
+                            }
+                        }
+                        None
+                    }) {
+                        // Report the lint error
+                        if let Some(builder) =
+                            self.context.report_lint(&DATACLASS_FIELD_ORDER, field_node)
+                        {
+                            builder.into_diagnostic(format_args!(
+                                "Required field `{}` cannot be defined after fields with default values",
+                                name
+                            ));
+                        }
+                    }
+                }
             }
         }
     }