RUF008/9 for non-dataclasses as well

crates/ruff/resources/test/fixtures/ruff/RUF010.py

@@ -0,0 +1,20 @@
+import typing
+from typing import Sequence
+
+KNOWINGLY_MUTABLE_DEFAULT = []
+
+
+class A:
+    mutable_default: list[int] = []
+    immutable_annotation: typing.Sequence[int] = []
+    without_annotation = []
+    ignored_via_comment: list[int] = []  # noqa: RUF010
+    correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
+
+
+class B:
+    mutable_default: list[int] = []
+    immutable_annotation: Sequence[int] = []
+    without_annotation = []
+    ignored_via_comment: list[int] = []  # noqa: RUF010
+    correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT

crates/ruff/resources/test/fixtures/ruff/RUF011.py

@@ -0,0 +1,30 @@
+import datetime
+import typing
+from typing import NamedTuple
+from dataclasses import field
+
+def default_function() -> list[int]:
+    return []
+
+
+class ImmutableType(NamedTuple):
+    something: int = 8
+
+
+class A:
+    hidden_mutable_default: list[int] = default_function()
+    class_variable: typing.ClassVar[list[int]] = default_function()
+    fine_date: datetime.date = datetime.date(2042, 1, 1)
+
+
+DEFAULT_IMMUTABLETYPE_FOR_ALL_DATACLASSES = ImmutableType(40)
+DEFAULT_A_FOR_ALL_DATACLASSES = A([1, 2, 3])
+
+
+class B:
+    hidden_mutable_default: list[int] = default_function()
+    another_class: A = A()
+    not_optimal: ImmutableType = ImmutableType(20)
+    good_variant: ImmutableType = DEFAULT_IMMUTABLETYPE_FOR_ALL_DATACLASSES
+    okay_variant: A = DEFAULT_A_FOR_ALL_DATACLASSES
+    not_fine_field: list[int] = field(default_vactory=list)

crates/ruff/src/checkers/ast/mod.rs

@@ -843,19 +843,45 @@ where
 
                 if self.settings.rules.any_enabled(&[
                     Rule::MutableDataclassDefault,
+                    Rule::MutableClassDefault,
                     Rule::FunctionCallInDataclassDefaultArgument,
-                ]) && ruff::rules::is_dataclass(self, decorator_list)
-                {
-                    if self.settings.rules.enabled(Rule::MutableDataclassDefault) {
-                        ruff::rules::mutable_dataclass_default(self, body);
+                    Rule::FunctionCallInClassDefaultArgument,
+                ]) {
+                    let is_dataclass = ruff::rules::is_dataclass(self, decorator_list);
+
+                    if is_dataclass {
+                        if self.settings.rules.enabled(Rule::MutableDataclassDefault) {
+                            ruff::rules::mutable_class_default(self, true, body);
+                        }
+
+                        if self
+                            .settings
+                            .rules
+                            .enabled(Rule::FunctionCallInDataclassDefaultArgument)
+                        {
+                            ruff::rules::function_call_in_class_defaults(
+                                self,
+                                body,
+                                is_dataclass,
+                                true,
+                            );
+                        }
+                    }
+                    if self.settings.rules.enabled(Rule::MutableClassDefault) {
+                        ruff::rules::mutable_class_default(self, false, body);
                     }
 
                     if self
                         .settings
                         .rules
-                        .enabled(Rule::FunctionCallInDataclassDefaultArgument)
+                        .enabled(Rule::FunctionCallInClassDefaultArgument)
                     {
-                        ruff::rules::function_call_in_dataclass_defaults(self, body);
+                        ruff::rules::function_call_in_class_defaults(
+                            self,
+                            body,
+                            is_dataclass,
+                            false,
+                        );
                     }
                 }
 

crates/ruff/src/codes.rs

@@ -720,6 +720,8 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Ruff, "007") => Rule::PairwiseOverZipped,
         (Ruff, "008") => Rule::MutableDataclassDefault,
         (Ruff, "009") => Rule::FunctionCallInDataclassDefaultArgument,
+        (Ruff, "010") => Rule::MutableClassDefault,
+        (Ruff, "011") => Rule::FunctionCallInClassDefaultArgument,
         (Ruff, "100") => Rule::UnusedNOQA,
 
         // flake8-django

crates/ruff/src/registry.rs

@@ -657,6 +657,8 @@ ruff_macros::register_rules!(
     rules::ruff::rules::PairwiseOverZipped,
     rules::ruff::rules::MutableDataclassDefault,
     rules::ruff::rules::FunctionCallInDataclassDefaultArgument,
+    rules::ruff::rules::MutableClassDefault,
+    rules::ruff::rules::FunctionCallInClassDefaultArgument,
     // flake8-django
     rules::flake8_django::rules::DjangoNullableModelStringField,
     rules::flake8_django::rules::DjangoLocalsInRenderFunction,

crates/ruff/src/registry/rule_set.rs

@@ -7,10 +7,10 @@ use std::iter::FusedIterator;
 ///
 /// Uses a bitset where a bit of one signals that the Rule with that [u16] is in this set.
 #[derive(Clone, Default, CacheKey, PartialEq, Eq)]
-pub struct RuleSet([u64; 9]);
+pub struct RuleSet([u64; 10]);
 
 impl RuleSet {
-    const EMPTY: [u64; 9] = [0; 9];
+    const EMPTY: [u64; 10] = [0; 10];
 
     // 64 fits into a u16 without truncation
     #[allow(clippy::cast_possible_truncation)]

crates/ruff/src/rules/ruff/mod.rs

@@ -155,7 +155,19 @@ mod tests {
 
     #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008.py"); "RUF008")]
     #[test_case(Rule::FunctionCallInDataclassDefaultArgument, Path::new("RUF009.py"); "RUF009")]
-    fn mutable_defaults(rule_code: Rule, path: &Path) -> Result<()> {
+    fn mutable_dataclass_defaults(rule_code: Rule, path: &Path) -> Result<()> {
+        let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("ruff").join(path).as_path(),
+            &settings::Settings::for_rule(rule_code),
+        )?;
+        assert_messages!(snapshot, diagnostics);
+        Ok(())
+    }
+
+    #[test_case(Rule::MutableClassDefault, Path::new("RUF010.py"); "RUF010")]
+    #[test_case(Rule::FunctionCallInClassDefaultArgument, Path::new("RUF011.py"); "RUF011")]
+    fn mutable_class_defaults(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
         let diagnostics = test_path(
             Path::new("ruff").join(path).as_path(),

crates/ruff/src/rules/ruff/rules/mod.rs

@@ -1,7 +1,7 @@
 mod ambiguous_unicode_character;
 mod asyncio_dangling_task;
 mod collection_literal_concatenation;
-mod mutable_defaults_in_dataclass_fields;
+mod mutable_defaults_in_class_fields;
 mod pairwise_over_zipped;
 mod unused_noqa;
 
@@ -13,9 +13,10 @@ pub use asyncio_dangling_task::{asyncio_dangling_task, AsyncioDanglingTask};
 pub use collection_literal_concatenation::{
     collection_literal_concatenation, CollectionLiteralConcatenation,
 };
-pub use mutable_defaults_in_dataclass_fields::{
-    function_call_in_dataclass_defaults, is_dataclass, mutable_dataclass_default,
-    FunctionCallInDataclassDefaultArgument, MutableDataclassDefault,
+pub use mutable_defaults_in_class_fields::{
+    function_call_in_class_defaults, is_dataclass, mutable_class_default,
+    FunctionCallInClassDefaultArgument, FunctionCallInDataclassDefaultArgument,
+    MutableClassDefault, MutableDataclassDefault,
 };
 pub use pairwise_over_zipped::{pairwise_over_zipped, PairwiseOverZipped};
 pub use unused_noqa::{UnusedCodes, UnusedNOQA};

crates/ruff/src/rules/ruff/rules/mutable_defaults_in_dataclass_fields.rs → crates/ruff/src/rules/ruff/rules/mutable_defaults_in_class_fields.rs

@@ -60,6 +60,17 @@ impl Violation for MutableDataclassDefault {
     }
 }
 
+/// This rule is same as MutableDataclassDefault, but for any class. The same arguments apply.
+#[violation]
+pub struct MutableClassDefault;
+
+impl Violation for MutableClassDefault {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!("Do not use mutable default values for class attributes")
+    }
+}
+
 /// ## What it does
 /// Checks for function calls in dataclass defaults.
 ///
@@ -135,6 +146,25 @@ impl Violation for FunctionCallInDataclassDefaultArgument {
     }
 }
 
+/// Same as FunctionCallInDataclassDefaultArgument, but for any class.
+/// Importantly, this error will be issued on calls to dataclasses.field
+#[violation]
+pub struct FunctionCallInClassDefaultArgument {
+    pub name: Option<String>,
+}
+
+impl Violation for FunctionCallInClassDefaultArgument {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let FunctionCallInClassDefaultArgument { name } = self;
+        if let Some(name) = name {
+            format!("Do not perform function call `{name}` in non-dataclass attribute defaults")
+        } else {
+            format!("Do not perform function call in non-dataclass attribute defaults")
+        }
+    }
+}
+
 fn is_mutable_expr(expr: &Expr) -> bool {
     matches!(
         &expr.node,
@@ -165,8 +195,13 @@ fn is_class_var_annotation(context: &Context, annotation: &Expr) -> bool {
     context.match_typing_expr(value, "ClassVar")
 }
 
-/// RUF009
-pub fn function_call_in_dataclass_defaults(checker: &mut Checker, body: &[Stmt]) {
+/// RUF009/RUF011
+pub fn function_call_in_class_defaults(
+    checker: &mut Checker,
+    body: &[Stmt],
+    is_dataclass: bool,
+    emit_dataclass_error: bool,
+) {
     let extend_immutable_calls: Vec<CallPath> = checker
         .settings
         .flake8_bugbear
@@ -186,23 +221,41 @@ pub fn function_call_in_dataclass_defaults(checker: &mut Checker, body: &[Stmt])
                 continue;
             }
             if let ExprKind::Call { func, .. } = &expr.node {
-                if !is_immutable_func(&checker.ctx, func, &extend_immutable_calls)
-                    && !is_allowed_dataclass_function(&checker.ctx, func)
+                if !(is_immutable_func(&checker.ctx, func, &extend_immutable_calls)
+                    || is_dataclass && is_allowed_dataclass_function(&checker.ctx, func))
                 {
-                    checker.diagnostics.push(Diagnostic::new(
-                        FunctionCallInDataclassDefaultArgument {
-                            name: compose_call_path(func),
-                        },
-                        expr.range(),
-                    ));
+                    let diagnostic: Diagnostic = if emit_dataclass_error {
+                        Diagnostic::new(
+                            FunctionCallInDataclassDefaultArgument {
+                                name: compose_call_path(func),
+                            },
+                            expr.range(),
+                        )
+                    } else {
+                        Diagnostic::new(
+                            FunctionCallInClassDefaultArgument {
+                                name: compose_call_path(func),
+                            },
+                            expr.range(),
+                        )
+                    };
+                    checker.diagnostics.push(diagnostic);
                 }
             }
         }
     }
 }
 
-/// RUF008
-pub fn mutable_dataclass_default(checker: &mut Checker, body: &[Stmt]) {
+/// RUF008/RUF010
+pub fn mutable_class_default(checker: &mut Checker, emit_dataclass_error: bool, body: &[Stmt]) {
+    fn diagnostic(emit_dataclass_error: bool, value: &Expr) -> Diagnostic {
+        if emit_dataclass_error {
+            Diagnostic::new(MutableDataclassDefault, value.range())
+        } else {
+            Diagnostic::new(MutableClassDefault, value.range())
+        }
+    }
+
     for statement in body {
         match &statement.node {
             StmtKind::AnnAssign {
@@ -216,14 +269,14 @@ pub fn mutable_dataclass_default(checker: &mut Checker, body: &[Stmt]) {
                 {
                     checker
                         .diagnostics
-                        .push(Diagnostic::new(MutableDataclassDefault, value.range()));
+                        .push(diagnostic(emit_dataclass_error, value));
                 }
             }
             StmtKind::Assign { value, .. } => {
                 if is_mutable_expr(value) {
                     checker
                         .diagnostics
-                        .push(Diagnostic::new(MutableDataclassDefault, value.range()));
+                        .push(diagnostic(emit_dataclass_error, value));
                 }
             }
             _ => (),

crates/ruff/src/rules/ruff/snapshots/ruff__rules__ruff__tests__RUF010_RUF010.py.snap

@@ -0,0 +1,42 @@
+---
+source: crates/ruff/src/rules/ruff/mod.rs
+---
+RUF010.py:8:34: RUF010 Do not use mutable default values for class attributes
+   |
+ 8 | class A:
+ 9 |     mutable_default: list[int] = []
+   |                                  ^^ RUF010
+10 |     immutable_annotation: typing.Sequence[int] = []
+11 |     without_annotation = []
+   |
+
+RUF010.py:10:26: RUF010 Do not use mutable default values for class attributes
+   |
+10 |     mutable_default: list[int] = []
+11 |     immutable_annotation: typing.Sequence[int] = []
+12 |     without_annotation = []
+   |                          ^^ RUF010
+13 |     ignored_via_comment: list[int] = []  # noqa: RUF010
+14 |     correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
+   |
+
+RUF010.py:16:34: RUF010 Do not use mutable default values for class attributes
+   |
+16 | class B:
+17 |     mutable_default: list[int] = []
+   |                                  ^^ RUF010
+18 |     immutable_annotation: Sequence[int] = []
+19 |     without_annotation = []
+   |
+
+RUF010.py:18:26: RUF010 Do not use mutable default values for class attributes
+   |
+18 |     mutable_default: list[int] = []
+19 |     immutable_annotation: Sequence[int] = []
+20 |     without_annotation = []
+   |                          ^^ RUF010
+21 |     ignored_via_comment: list[int] = []  # noqa: RUF010
+22 |     correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
+   |
+
+