[ruff] Detect mutable defaults in field calls (RUF008) (#23046)

eureka0928 · ntBre · web-flow · commit b43a20408daf · 2026-02-04T15:28:12.000Z
## Summary Resolves #16495. RUF008 previously only caught bare mutable defaults like `mutable_default: list[int] = []` in dataclass attributes, but missed mutable defaults wrapped in `field(default=...)` calls. For example, the following was not flagged: ```python @define class A: mutable_default: list[int] = attrs.field(default=[]) ``` This PR modifies `mutable_dataclass_default()` to look inside recognized dataclass field calls (`dataclasses.field()`, `attrs.field()`, `attr.ib()`, `attr.attrib()`) and check the `default` keyword argument for mutability. The approach mirrors how RUF009 already uses `is_dataclass_field()` to identify field calls — RUF008 now reuses the same helper to extract and inspect the `default` keyword argument. No duplicate diagnostics are introduced since RUF009 already skips field calls entirely. ## Test Plan `cargo nextest run -p ruff_linter` and `cargo clippy`. Added test cases covering: - Positive: `field(default=[])`, `attrs.field(default={})`, `attr.ib(default=[])`, `attr.attrib(default=set())`, `field(default=dict())` - Negative: `factory=list`, `default=()`, `default="hello"`, `default=1`, `default=KNOWINGLY_MUTABLE_DEFAULT`, `ClassVar` annotation with `field(default=[])` --------- Co-authored-by: Brent Westbrook <36778786+ntBre@users.noreply.github.com> Co-authored-by: Brent Westbrook <brentrwestbrook@gmail.com>
diff --git a/crates/ruff_linter/resources/test/fixtures/ruff/RUF008.py b/crates/ruff_linter/resources/test/fixtures/ruff/RUF008.py
@@ -34,3 +34,18 @@ class AWithQuotes:
     correct_code: 'list[int]' = KNOWINGLY_MUTABLE_DEFAULT
     perfectly_fine: 'list[int]' = field(default_factory=list)
     class_variable: 'typing.ClassVar[list[int]]'= []
+
+
+# Mutable defaults wrapped in field() calls
+@dataclass
+class C:
+    mutable_default: list[int] = field(default=[])  # RUF008
+    mutable_default2: dict[str, int] = field(default={})  # RUF008
+    mutable_default3: set[int] = field(default=set())  # RUF008
+    mutable_default4: dict[str, int] = field(default=dict())  # RUF008
+    correct_factory: list[int] = field(default_factory=list)  # okay
+    immutable_default: tuple[int, ...] = field(default=())  # okay
+    immutable_default2: str = field(default="hello")  # okay
+    immutable_default3: int = field(default=1)  # okay
+    non_mutable_var: list[int] = field(default=KNOWINGLY_MUTABLE_DEFAULT)  # okay
+    class_variable: ClassVar[list[int]] = field(default=[])  # okay
diff --git a/crates/ruff_linter/resources/test/fixtures/ruff/RUF008_attrs.py b/crates/ruff_linter/resources/test/fixtures/ruff/RUF008_attrs.py
@@ -1,7 +1,7 @@
 import typing
 from typing import ClassVar, Sequence
 
-import attr
+import attr, attrs
 from attr import s
 from attrs import define, frozen
 
@@ -45,3 +45,33 @@ class D:
     correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
     perfectly_fine: list[int] = field(default_factory=list)
     class_variable: ClassVar[list[int]] = []
+
+
+# Mutable defaults wrapped in field() calls
+@define
+class E:
+    mutable_default: list[int] = attrs.field(default=[])  # RUF008
+    mutable_default2: dict[str, int] = attrs.field(default={})  # RUF008
+    mutable_default3: set[int] = attrs.field(default=set())  # RUF008
+    mutable_default4: dict[str, int] = attrs.field(default=dict())  # RUF008
+    correct_factory: list[int] = attrs.field(factory=list)  # okay
+    immutable_default: tuple[int, ...] = attrs.field(default=())  # okay
+    immutable_default2: str = attrs.field(default="hello")  # okay
+    immutable_default3: int = attrs.field(default=1)  # okay
+    non_mutable_var: list[int] = attrs.field(default=KNOWINGLY_MUTABLE_DEFAULT)  # okay
+    class_variable: ClassVar[list[int]] = attrs.field(default=[])  # okay
+
+
+@attr.s
+class F:
+    mutable_default: list[int] = attr.ib(default=[])  # RUF008
+    mutable_default2: dict[str, int] = attr.ib(default={})  # RUF008
+    correct_factory: list[int] = attr.ib(factory=list)  # okay
+    immutable_default: tuple[int, ...] = attr.ib(default=())  # okay
+
+
+@attr.s
+class G:
+    mutable_default: list[int] = attr.attrib(default=[])  # RUF008
+    mutable_default2: set[int] = attr.attrib(default=set())  # RUF008
+    correct_factory: list[int] = attr.attrib(factory=list)  # okay
diff --git a/crates/ruff_linter/src/preview.rs b/crates/ruff_linter/src/preview.rs
@@ -265,3 +265,10 @@ pub(crate) const fn is_ble001_exc_info_suppression_enabled(settings: &LinterSett
 pub(crate) const fn is_py315_support_enabled(settings: &LinterSettings) -> bool {
     settings.preview.is_enabled()
 }
+
+// https://github.com/astral-sh/ruff/pull/23046
+pub(crate) const fn is_mutable_default_in_dataclass_field_enabled(
+    settings: &LinterSettings,
+) -> bool {
+    settings.preview.is_enabled()
+}
diff --git a/crates/ruff_linter/src/rules/ruff/mod.rs b/crates/ruff_linter/src/rules/ruff/mod.rs
@@ -611,6 +611,8 @@ mod tests {
         Ok(())
     }
 
+    #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008.py"))]
+    #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008_attrs.py"))]
     #[test_case(Rule::UnrawRePattern, Path::new("RUF039.py"))]
     #[test_case(Rule::UnrawRePattern, Path::new("RUF039_concat.py"))]
     #[test_case(Rule::UnnecessaryRegularExpression, Path::new("RUF055_0.py"))]
diff --git a/crates/ruff_linter/src/rules/ruff/rules/mutable_dataclass_default.rs b/crates/ruff_linter/src/rules/ruff/rules/mutable_dataclass_default.rs
@@ -1,12 +1,13 @@
-use ruff_python_ast::{self as ast, Stmt};
+use ruff_python_ast::{self as ast, Expr, Stmt};
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_semantic::analyze::typing::{is_immutable_annotation, is_mutable_expr};
 use ruff_text_size::Ranged;
 
 use crate::Violation;
 use crate::checkers::ast::Checker;
-use crate::rules::ruff::helpers::{dataclass_kind, is_class_var_annotation};
+use crate::preview::is_mutable_default_in_dataclass_field_enabled;
+use crate::rules::ruff::helpers::{dataclass_kind, is_class_var_annotation, is_dataclass_field};
 
 /// ## What it does
 /// Checks for mutable default values in dataclass attributes.
@@ -22,6 +23,10 @@ use crate::rules::ruff::helpers::{dataclass_kind, is_class_var_annotation};
 /// If the default value is intended to be mutable, it must be annotated with
 /// `typing.ClassVar`; otherwise, a `ValueError` will be raised.
 ///
+/// In [preview](https://docs.astral.sh/ruff/preview/) this rule also detects mutable defaults passed via the `default` keyword
+/// argument in `field()` (for stdlib dataclasses), `attrs.field()`, `attr.ib()`,
+/// and `attr.attrib()` calls.
+///
 /// ## Example
 /// ```python
 /// from dataclasses import dataclass
@@ -69,9 +74,9 @@ impl Violation for MutableDataclassDefault {
 pub(crate) fn mutable_dataclass_default(checker: &Checker, class_def: &ast::StmtClassDef) {
     let semantic = checker.semantic();
 
-    if dataclass_kind(class_def, semantic).is_none() {
+    let Some((dataclass_kind, _)) = dataclass_kind(class_def, semantic) else {
         return;
-    }
+    };
 
     for statement in &class_def.body {
         let Stmt::AnnAssign(ast::StmtAnnAssign {
@@ -83,6 +88,21 @@ pub(crate) fn mutable_dataclass_default(checker: &Checker, class_def: &ast::Stmt
             continue;
         };
 
+        let value = match &**value {
+            Expr::Call(ast::ExprCall {
+                func, arguments, ..
+            }) if is_mutable_default_in_dataclass_field_enabled(checker.settings())
+                && is_dataclass_field(func, checker.semantic(), dataclass_kind) =>
+            {
+                arguments.find_argument_value("default", 0)
+            }
+            value => Some(value),
+        };
+
+        let Some(value) = value else {
+            continue;
+        };
+
         if is_mutable_expr(value, checker.semantic())
             && !is_class_var_annotation(annotation, checker.semantic())
             && !is_immutable_annotation(annotation, checker.semantic(), &[])
diff --git a/crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__preview__RUF008_RUF008.py.snap b/crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__preview__RUF008_RUF008.py.snap
@@ -0,0 +1,99 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:10:34
+   |
+ 8 | @dataclass
+ 9 | class A:
+10 |     mutable_default: list[int] = []
+   |                                  ^^
+11 |     immutable_annotation: typing.Sequence[int] = []
+12 |     without_annotation = []
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:20:34
+   |
+18 | @dataclass
+19 | class B:
+20 |     mutable_default: list[int] = []
+   |                                  ^^
+21 |     immutable_annotation: Sequence[int] = []
+22 |     without_annotation = []
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:31:36
+   |
+29 | @dataclass
+30 | class AWithQuotes:
+31 |     mutable_default: 'list[int]' = []
+   |                                    ^^
+32 |     immutable_annotation: 'typing.Sequence[int]' = []
+33 |     without_annotation = []
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:32:52
+   |
+30 | class AWithQuotes:
+31 |     mutable_default: 'list[int]' = []
+32 |     immutable_annotation: 'typing.Sequence[int]' = []
+   |                                                    ^^
+33 |     without_annotation = []
+34 |     correct_code: 'list[int]' = KNOWINGLY_MUTABLE_DEFAULT
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:36:51
+   |
+34 |     correct_code: 'list[int]' = KNOWINGLY_MUTABLE_DEFAULT
+35 |     perfectly_fine: 'list[int]' = field(default_factory=list)
+36 |     class_variable: 'typing.ClassVar[list[int]]'= []
+   |                                                   ^^
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:42:48
+   |
+40 | @dataclass
+41 | class C:
+42 |     mutable_default: list[int] = field(default=[])  # RUF008
+   |                                                ^^
+43 |     mutable_default2: dict[str, int] = field(default={})  # RUF008
+44 |     mutable_default3: set[int] = field(default=set())  # RUF008
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:43:54
+   |
+41 | class C:
+42 |     mutable_default: list[int] = field(default=[])  # RUF008
+43 |     mutable_default2: dict[str, int] = field(default={})  # RUF008
+   |                                                      ^^
+44 |     mutable_default3: set[int] = field(default=set())  # RUF008
+45 |     mutable_default4: dict[str, int] = field(default=dict())  # RUF008
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:44:48
+   |
+42 |     mutable_default: list[int] = field(default=[])  # RUF008
+43 |     mutable_default2: dict[str, int] = field(default={})  # RUF008
+44 |     mutable_default3: set[int] = field(default=set())  # RUF008
+   |                                                ^^^^^
+45 |     mutable_default4: dict[str, int] = field(default=dict())  # RUF008
+46 |     correct_factory: list[int] = field(default_factory=list)  # okay
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008.py:45:54
+   |
+43 |     mutable_default2: dict[str, int] = field(default={})  # RUF008
+44 |     mutable_default3: set[int] = field(default=set())  # RUF008
+45 |     mutable_default4: dict[str, int] = field(default=dict())  # RUF008
+   |                                                      ^^^^^^
+46 |     correct_factory: list[int] = field(default_factory=list)  # okay
+47 |     immutable_default: tuple[int, ...] = field(default=())  # okay
+   |
diff --git a/crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__preview__RUF008_RUF008_attrs.py.snap b/crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__preview__RUF008_RUF008_attrs.py.snap
@@ -0,0 +1,133 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:13:34
+   |
+11 | @define
+12 | class A:
+13 |     mutable_default: list[int] = []
+   |                                  ^^
+14 |     immutable_annotation: typing.Sequence[int] = []
+15 |     without_annotation = []
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:23:34
+   |
+21 | @frozen
+22 | class B:
+23 |     mutable_default: list[int] = []
+   |                                  ^^
+24 |     immutable_annotation: Sequence[int] = []
+25 |     without_annotation = []
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:33:34
+   |
+31 | @attr.s
+32 | class C:
+33 |     mutable_default: list[int] = []
+   |                                  ^^
+34 |     immutable_annotation: Sequence[int] = []
+35 |     without_annotation = []
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:42:34
+   |
+40 | @s
+41 | class D:
+42 |     mutable_default: list[int] = []
+   |                                  ^^
+43 |     immutable_annotation: Sequence[int] = []
+44 |     without_annotation = []
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:53:54
+   |
+51 | @define
+52 | class E:
+53 |     mutable_default: list[int] = attrs.field(default=[])  # RUF008
+   |                                                      ^^
+54 |     mutable_default2: dict[str, int] = attrs.field(default={})  # RUF008
+55 |     mutable_default3: set[int] = attrs.field(default=set())  # RUF008
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:54:60
+   |
+52 | class E:
+53 |     mutable_default: list[int] = attrs.field(default=[])  # RUF008
+54 |     mutable_default2: dict[str, int] = attrs.field(default={})  # RUF008
+   |                                                            ^^
+55 |     mutable_default3: set[int] = attrs.field(default=set())  # RUF008
+56 |     mutable_default4: dict[str, int] = attrs.field(default=dict())  # RUF008
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:55:54
+   |
+53 |     mutable_default: list[int] = attrs.field(default=[])  # RUF008
+54 |     mutable_default2: dict[str, int] = attrs.field(default={})  # RUF008
+55 |     mutable_default3: set[int] = attrs.field(default=set())  # RUF008
+   |                                                      ^^^^^
+56 |     mutable_default4: dict[str, int] = attrs.field(default=dict())  # RUF008
+57 |     correct_factory: list[int] = attrs.field(factory=list)  # okay
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:56:60
+   |
+54 |     mutable_default2: dict[str, int] = attrs.field(default={})  # RUF008
+55 |     mutable_default3: set[int] = attrs.field(default=set())  # RUF008
+56 |     mutable_default4: dict[str, int] = attrs.field(default=dict())  # RUF008
+   |                                                            ^^^^^^
+57 |     correct_factory: list[int] = attrs.field(factory=list)  # okay
+58 |     immutable_default: tuple[int, ...] = attrs.field(default=())  # okay
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:67:50
+   |
+65 | @attr.s
+66 | class F:
+67 |     mutable_default: list[int] = attr.ib(default=[])  # RUF008
+   |                                                  ^^
+68 |     mutable_default2: dict[str, int] = attr.ib(default={})  # RUF008
+69 |     correct_factory: list[int] = attr.ib(factory=list)  # okay
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:68:56
+   |
+66 | class F:
+67 |     mutable_default: list[int] = attr.ib(default=[])  # RUF008
+68 |     mutable_default2: dict[str, int] = attr.ib(default={})  # RUF008
+   |                                                        ^^
+69 |     correct_factory: list[int] = attr.ib(factory=list)  # okay
+70 |     immutable_default: tuple[int, ...] = attr.ib(default=())  # okay
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:75:54
+   |
+73 | @attr.s
+74 | class G:
+75 |     mutable_default: list[int] = attr.attrib(default=[])  # RUF008
+   |                                                      ^^
+76 |     mutable_default2: set[int] = attr.attrib(default=set())  # RUF008
+77 |     correct_factory: list[int] = attr.attrib(factory=list)  # okay
+   |
+
+RUF008 Do not use mutable default values for dataclass attributes
+  --> RUF008_attrs.py:76:54
+   |
+74 | class G:
+75 |     mutable_default: list[int] = attr.attrib(default=[])  # RUF008
+76 |     mutable_default2: set[int] = attr.attrib(default=set())  # RUF008
+   |                                                      ^^^^^
+77 |     correct_factory: list[int] = attr.attrib(factory=list)  # okay
+   |

Original file line number	Diff line number	Diff line change
`@@ -611,6 +611,8 @@ mod tests {`
`611`	`611`	`Ok(())`
`612`	`612`	`}`
`613`	`613`
	`614`	`+ #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008.py"))]`
	`615`	`+ #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008_attrs.py"))]`
`614`	`616`	`#[test_case(Rule::UnrawRePattern, Path::new("RUF039.py"))]`
`615`	`617`	`#[test_case(Rule::UnrawRePattern, Path::new("RUF039_concat.py"))]`
`616`	`618`	`#[test_case(Rule::UnnecessaryRegularExpression, Path::new("RUF055_0.py"))]`