[ruff] Analyze deferred annotations before enforcing mutable-(data)class-default and function-call-in-dataclass-default-argument (RUF008,RUF009,RUF012)

crates/ruff_linter/resources/test/fixtures/ruff/RUF008.py

@@ -23,3 +23,14 @@ class B:
     correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
     perfectly_fine: list[int] = field(default_factory=list)
     class_variable: ClassVar[list[int]] = []
+
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+@dataclass
+class AWithQuotes:
+    mutable_default: 'list[int]' = []
+    immutable_annotation: 'typing.Sequence[int]' = []
+    without_annotation = []
+    correct_code: 'list[int]' = KNOWINGLY_MUTABLE_DEFAULT
+    perfectly_fine: 'list[int]' = field(default_factory=list)
+    class_variable: 'typing.ClassVar[list[int]]'= []

crates/ruff_linter/resources/test/fixtures/ruff/RUF008_deferred.py

@@ -0,0 +1,19 @@
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+
+from __future__ import annotations
+
+import typing
+from dataclasses import dataclass
+
+
+@dataclass
+class Example():
+    """Class that uses ClassVar."""
+
+    options: ClassVar[dict[str, str]] = {}
+
+
+if typing.TYPE_CHECKING:
+    from typing import ClassVar
+

crates/ruff_linter/resources/test/fixtures/ruff/RUF009_deferred.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass 
+from typing import TYPE_CHECKING
+
+
+def default_function() ->list[int]:
+    return []
+
+@dataclass()
+class A:
+    hidden_mutable_default: list[int] = default_function()
+    class_variable: typing.ClassVar[list[int]] = default_function()
+    another_class_var: ClassVar[list[int]] = default_function()
+
+if TYPE_CHECKING:
+    from typing import ClassVar

crates/ruff_linter/resources/test/fixtures/ruff/RUF012.py

@@ -103,3 +103,18 @@ class K(SQLModel):
 class L(SQLModel):
     id: int
     i_j: list[K] = list()
+
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+class AWithQuotes:
+    __slots__ = {
+        "mutable_default": "A mutable default value",
+    }
+
+    mutable_default: 'list[int]' = []
+    immutable_annotation: 'Sequence[int]'= []
+    without_annotation = []
+    class_variable: 'ClassVar[list[int]]' = []
+    final_variable: 'Final[list[int]]' = []
+    class_variable_without_subscript: 'ClassVar' = []
+    final_variable_without_subscript: 'Final' = []

crates/ruff_linter/resources/test/fixtures/ruff/RUF012_deferred.py

@@ -0,0 +1,16 @@
+# Lint should account for deferred annotations
+# See https://github.com/astral-sh/ruff/issues/15857
+
+from __future__ import annotations
+
+import typing
+
+
+class Example():
+    """Class that uses ClassVar."""
+
+    options: ClassVar[dict[str, str]] = {}
+
+
+if typing.TYPE_CHECKING:
+    from typing import ClassVar

crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs

@@ -18,11 +18,14 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
         Rule::AsyncioDanglingTask,
         Rule::BadStaticmethodArgument,
         Rule::BuiltinAttributeShadowing,
+        Rule::FunctionCallInDataclassDefaultArgument,
         Rule::GlobalVariableNotAssigned,
         Rule::ImportPrivateName,
         Rule::ImportShadowedByLoopVar,
         Rule::InvalidFirstArgumentNameForClassMethod,
         Rule::InvalidFirstArgumentNameForMethod,
+        Rule::MutableClassDefault,
+        Rule::MutableDataclassDefault,
         Rule::NoSelfUse,
         Rule::RedefinedArgumentFromLocal,
         Rule::RedefinedWhileUnused,
@@ -380,6 +383,19 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                     &mut diagnostics,
                 );
             }
+            if checker.enabled(Rule::FunctionCallInDataclassDefaultArgument) {
+                ruff::rules::function_call_in_dataclass_default(
+                    checker,
+                    class_def,
+                    &mut diagnostics,
+                );
+            }
+            if checker.enabled(Rule::MutableClassDefault) {
+                ruff::rules::mutable_class_default(checker, class_def, &mut diagnostics);
+            }
+            if checker.enabled(Rule::MutableDataclassDefault) {
+                ruff::rules::mutable_dataclass_default(checker, class_def, &mut diagnostics);
+            }
         }
 
         if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Lambda(_)) {

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -512,15 +512,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::NonUniqueEnums) {
                 flake8_pie::rules::non_unique_enums(checker, stmt, body);
             }
-            if checker.enabled(Rule::MutableClassDefault) {
-                ruff::rules::mutable_class_default(checker, class_def);
-            }
-            if checker.enabled(Rule::MutableDataclassDefault) {
-                ruff::rules::mutable_dataclass_default(checker, class_def);
-            }
-            if checker.enabled(Rule::FunctionCallInDataclassDefaultArgument) {
-                ruff::rules::function_call_in_dataclass_default(checker, class_def);
-            }
             if checker.enabled(Rule::FStringDocstring) {
                 flake8_bugbear::rules::f_string_docstring(checker, body);
             }

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

@@ -30,6 +30,7 @@ mod tests {
     #[test_case(Rule::ZipInsteadOfPairwise, Path::new("RUF007.py"))]
     #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008.py"))]
     #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008_attrs.py"))]
+    #[test_case(Rule::MutableDataclassDefault, Path::new("RUF008_deferred.py"))]
     #[test_case(Rule::FunctionCallInDataclassDefaultArgument, Path::new("RUF009.py"))]
     #[test_case(
         Rule::FunctionCallInDataclassDefaultArgument,
@@ -39,8 +40,13 @@ mod tests {
         Rule::FunctionCallInDataclassDefaultArgument,
         Path::new("RUF009_attrs_auto_attribs.py")
     )]
+    #[test_case(
+        Rule::FunctionCallInDataclassDefaultArgument,
+        Path::new("RUF009_deferred.py")
+    )]
     #[test_case(Rule::ExplicitFStringTypeConversion, Path::new("RUF010.py"))]
     #[test_case(Rule::MutableClassDefault, Path::new("RUF012.py"))]
+    #[test_case(Rule::MutableClassDefault, Path::new("RUF012_deferred.py"))]
     #[test_case(Rule::ImplicitOptional, Path::new("RUF013_0.py"))]
     #[test_case(Rule::ImplicitOptional, Path::new("RUF013_1.py"))]
     #[test_case(Rule::ImplicitOptional, Path::new("RUF013_2.py"))]

crates/ruff_linter/src/rules/ruff/rules/function_call_in_dataclass_default.rs

@@ -75,8 +75,9 @@ impl Violation for FunctionCallInDataclassDefaultArgument {
 
 /// RUF009
 pub(crate) fn function_call_in_dataclass_default(
-    checker: &mut Checker,
+    checker: &Checker,
     class_def: &ast::StmtClassDef,
+    diagnostics: &mut Vec<Diagnostic>,
 ) {
     let semantic = checker.semantic();
 
@@ -152,7 +153,7 @@ pub(crate) fn function_call_in_dataclass_default(
         };
         let diagnostic = Diagnostic::new(kind, expr.range());
 
-        checker.diagnostics.push(diagnostic);
+        diagnostics.push(diagnostic);
     }
 }
 

crates/ruff_linter/src/rules/ruff/rules/mutable_class_default.rs

@@ -51,7 +51,11 @@ impl Violation for MutableClassDefault {
 }
 
 /// RUF012
-pub(crate) fn mutable_class_default(checker: &mut Checker, class_def: &ast::StmtClassDef) {
+pub(crate) fn mutable_class_default(
+    checker: &Checker,
+    class_def: &ast::StmtClassDef,
+    diagnostics: &mut Vec<Diagnostic>,
+) {
     for statement in &class_def.body {
         match statement {
             Stmt::AnnAssign(ast::StmtAnnAssign {
@@ -75,9 +79,7 @@ pub(crate) fn mutable_class_default(checker: &mut Checker, class_def: &ast::Stmt
                         return;
                     }
 
-                    checker
-                        .diagnostics
-                        .push(Diagnostic::new(MutableClassDefault, value.range()));
+                    diagnostics.push(Diagnostic::new(MutableClassDefault, value.range()));
                 }
             }
             Stmt::Assign(ast::StmtAssign { value, targets, .. }) => {
@@ -89,9 +91,7 @@ pub(crate) fn mutable_class_default(checker: &mut Checker, class_def: &ast::Stmt
                         return;
                     }
 
-                    checker
-                        .diagnostics
-                        .push(Diagnostic::new(MutableClassDefault, value.range()));
+                    diagnostics.push(Diagnostic::new(MutableClassDefault, value.range()));
                 }
             }
             _ => (),

crates/ruff_linter/src/rules/ruff/rules/mutable_dataclass_default.rs

@@ -65,7 +65,11 @@ impl Violation for MutableDataclassDefault {
 }
 
 /// RUF008
-pub(crate) fn mutable_dataclass_default(checker: &mut Checker, class_def: &ast::StmtClassDef) {
+pub(crate) fn mutable_dataclass_default(
+    checker: &Checker,
+    class_def: &ast::StmtClassDef,
+    diagnostics: &mut Vec<Diagnostic>,
+) {
     let semantic = checker.semantic();
 
     if dataclass_kind(class_def, semantic).is_none() {
@@ -88,7 +92,7 @@ pub(crate) fn mutable_dataclass_default(checker: &mut Checker, class_def: &ast::
         {
             let diagnostic = Diagnostic::new(MutableDataclassDefault, value.range());
 
-            checker.diagnostics.push(diagnostic);
+            diagnostics.push(diagnostic);
         }
     }
 }

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF008_RUF008.py.snap

@@ -1,6 +1,5 @@
 ---
 source: crates/ruff_linter/src/rules/ruff/mod.rs
-snapshot_kind: text
 ---
 RUF008.py:10:34: RUF008 Do not use mutable default values for dataclass attributes
    |
@@ -21,3 +20,31 @@ RUF008.py:20:34: RUF008 Do not use mutable default values for dataclass attribut
 21 |     immutable_annotation: Sequence[int] = []
 22 |     without_annotation = []
    |
+
+RUF008.py:31:36: RUF008 Do not use mutable default values for dataclass attributes
+   |
+29 | @dataclass
+30 | class AWithQuotes:
+31 |     mutable_default: 'list[int]' = []
+   |                                    ^^ RUF008
+32 |     immutable_annotation: 'typing.Sequence[int]' = []
+33 |     without_annotation = []
+   |
+
+RUF008.py:32:52: RUF008 Do not use mutable default values for dataclass attributes
+   |
+30 | class AWithQuotes:
+31 |     mutable_default: 'list[int]' = []
+32 |     immutable_annotation: 'typing.Sequence[int]' = []
+   |                                                    ^^ RUF008
+33 |     without_annotation = []
+34 |     correct_code: 'list[int]' = KNOWINGLY_MUTABLE_DEFAULT
+   |
+
+RUF008.py:36:51: RUF008 Do not use mutable default values for dataclass attributes
+   |
+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
+   |

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF008_RUF008_deferred.py.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF009_RUF009_deferred.py.snap

@@ -0,0 +1,21 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF009_deferred.py:10:41: RUF009 Do not perform function call `default_function` in dataclass defaults
+   |
+ 8 | @dataclass()
+ 9 | class A:
+10 |     hidden_mutable_default: list[int] = default_function()
+   |                                         ^^^^^^^^^^^^^^^^^^ RUF009
+11 |     class_variable: typing.ClassVar[list[int]] = default_function()
+12 |     another_class_var: ClassVar[list[int]] = default_function()
+   |
+
+RUF009_deferred.py:11:50: RUF009 Do not perform function call `default_function` in dataclass defaults
+   |
+ 9 | class A:
+10 |     hidden_mutable_default: list[int] = default_function()
+11 |     class_variable: typing.ClassVar[list[int]] = default_function()
+   |                                                  ^^^^^^^^^^^^^^^^^^ RUF009
+12 |     another_class_var: ClassVar[list[int]] = default_function()
+   |

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF012_RUF012.py.snap

@@ -40,3 +40,69 @@ RUF012.py:89:38: RUF012 Mutable class attributes should be annotated with `typin
 90 |
 91 | from sqlmodel import SQLModel
    |
+
+RUF012.py:114:36: RUF012 Mutable class attributes should be annotated with `typing.ClassVar`
+    |
+112 |     }
+113 |
+114 |     mutable_default: 'list[int]' = []
+    |                                    ^^ RUF012
+115 |     immutable_annotation: 'Sequence[int]'= []
+116 |     without_annotation = []
+    |
+
+RUF012.py:115:44: RUF012 Mutable class attributes should be annotated with `typing.ClassVar`
+    |
+114 |     mutable_default: 'list[int]' = []
+115 |     immutable_annotation: 'Sequence[int]'= []
+    |                                            ^^ RUF012
+116 |     without_annotation = []
+117 |     class_variable: 'ClassVar[list[int]]' = []
+    |
+
+RUF012.py:116:26: RUF012 Mutable class attributes should be annotated with `typing.ClassVar`
+    |
+114 |     mutable_default: 'list[int]' = []
+115 |     immutable_annotation: 'Sequence[int]'= []
+116 |     without_annotation = []
+    |                          ^^ RUF012
+117 |     class_variable: 'ClassVar[list[int]]' = []
+118 |     final_variable: 'Final[list[int]]' = []
+    |
+
+RUF012.py:117:45: RUF012 Mutable class attributes should be annotated with `typing.ClassVar`
+    |
+115 |     immutable_annotation: 'Sequence[int]'= []
+116 |     without_annotation = []
+117 |     class_variable: 'ClassVar[list[int]]' = []
+    |                                             ^^ RUF012
+118 |     final_variable: 'Final[list[int]]' = []
+119 |     class_variable_without_subscript: 'ClassVar' = []
+    |
+
+RUF012.py:118:42: RUF012 Mutable class attributes should be annotated with `typing.ClassVar`
+    |
+116 |     without_annotation = []
+117 |     class_variable: 'ClassVar[list[int]]' = []
+118 |     final_variable: 'Final[list[int]]' = []
+    |                                          ^^ RUF012
+119 |     class_variable_without_subscript: 'ClassVar' = []
+120 |     final_variable_without_subscript: 'Final' = []
+    |
+
+RUF012.py:119:52: RUF012 Mutable class attributes should be annotated with `typing.ClassVar`
+    |
+117 |     class_variable: 'ClassVar[list[int]]' = []
+118 |     final_variable: 'Final[list[int]]' = []
+119 |     class_variable_without_subscript: 'ClassVar' = []
+    |                                                    ^^ RUF012
+120 |     final_variable_without_subscript: 'Final' = []
+    |
+
+RUF012.py:120:49: RUF012 Mutable class attributes should be annotated with `typing.ClassVar`
+    |
+118 |     final_variable: 'Final[list[int]]' = []
+119 |     class_variable_without_subscript: 'ClassVar' = []
+120 |     final_variable_without_subscript: 'Final' = []
+    |                                                 ^^ RUF012
+    |

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__RUF012_RUF012_deferred.py.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+