Generalize PIE807 to handle dict literals

crates/ruff_linter/resources/test/fixtures/flake8_pie/PIE807.py

@@ -1,27 +1,37 @@
 @dataclass
 class Foo:
     foo: List[str] = field(default_factory=lambda: [])  # PIE807
+    bar: Dict[str, int] = field(default_factory=lambda: {})  # PIE807
 
 
 class FooTable(BaseTable):
-    bar = fields.ListField(default=lambda: [])  # PIE807
+    foo = fields.ListField(default=lambda: [])  # PIE807
+    bar = fields.ListField(default=lambda: {})  # PIE807
 
 
 class FooTable(BaseTable):
-    bar = fields.ListField(lambda: [])  # PIE807
+    foo = fields.ListField(lambda: [])  # PIE807
+    bar = fields.ListField(default=lambda: {})  # PIE807
 
 
 @dataclass
 class Foo:
     foo: List[str] = field(default_factory=list)
+    bar: Dict[str, int] = field(default_factory=dict)
 
 
 class FooTable(BaseTable):
-    bar = fields.ListField(list)
+    foo = fields.ListField(list)
+    bar = fields.ListField(dict)
 
 
 lambda *args, **kwargs: []
+lambda *args, **kwargs: {}
 
 lambda *args: []
+lambda *args: {}
 
 lambda **kwargs: []
+lambda **kwargs: {}
+
+lambda: {**unwrap}

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

@@ -18,8 +18,8 @@ pub(crate) fn deferred_lambdas(checker: &mut Checker) {
             if checker.enabled(Rule::UnnecessaryLambda) {
                 pylint::rules::unnecessary_lambda(checker, lambda);
             }
-            if checker.enabled(Rule::ReimplementedListBuiltin) {
-                flake8_pie::rules::reimplemented_list_builtin(checker, lambda);
+            if checker.enabled(Rule::ReimplementedContainerBuiltin) {
+                flake8_pie::rules::reimplemented_container_builtin(checker, lambda);
             }
         }
     }

crates/ruff_linter/src/codes.rs

@@ -772,7 +772,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Pie, "796") => (RuleGroup::Stable, rules::flake8_pie::rules::NonUniqueEnums),
         (Flake8Pie, "800") => (RuleGroup::Stable, rules::flake8_pie::rules::UnnecessarySpread),
         (Flake8Pie, "804") => (RuleGroup::Stable, rules::flake8_pie::rules::UnnecessaryDictKwargs),
-        (Flake8Pie, "807") => (RuleGroup::Stable, rules::flake8_pie::rules::ReimplementedListBuiltin),
+        (Flake8Pie, "807") => (RuleGroup::Stable, rules::flake8_pie::rules::ReimplementedContainerBuiltin),
         (Flake8Pie, "808") => (RuleGroup::Stable, rules::flake8_pie::rules::UnnecessaryRangeStart),
         (Flake8Pie, "810") => (RuleGroup::Stable, rules::flake8_pie::rules::MultipleStartsEndsWith),
 

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

@@ -18,7 +18,7 @@ mod tests {
     #[test_case(Rule::UnnecessaryRangeStart, Path::new("PIE808.py"))]
     #[test_case(Rule::UnnecessaryPass, Path::new("PIE790.py"))]
     #[test_case(Rule::UnnecessarySpread, Path::new("PIE800.py"))]
-    #[test_case(Rule::ReimplementedListBuiltin, Path::new("PIE807.py"))]
+    #[test_case(Rule::ReimplementedContainerBuiltin, Path::new("PIE807.py"))]
     #[test_case(Rule::NonUniqueEnums, Path::new("PIE796.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());

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

@@ -1,7 +1,7 @@
 pub(crate) use duplicate_class_field_definition::*;
 pub(crate) use multiple_starts_ends_with::*;
 pub(crate) use non_unique_enums::*;
-pub(crate) use reimplemented_list_builtin::*;
+pub(crate) use reimplemented_container_builtin::*;
 pub(crate) use unnecessary_dict_kwargs::*;
 pub(crate) use unnecessary_pass::*;
 pub(crate) use unnecessary_range_start::*;
@@ -10,7 +10,7 @@ pub(crate) use unnecessary_spread::*;
 mod duplicate_class_field_definition;
 mod multiple_starts_ends_with;
 mod non_unique_enums;
-mod reimplemented_list_builtin;
+mod reimplemented_container_builtin;
 mod unnecessary_dict_kwargs;
 mod unnecessary_pass;
 mod unnecessary_range_start;

crates/ruff_linter/src/rules/flake8_pie/rules/reimplemented_list_builtin.rs → crates/ruff_linter/src/rules/flake8_pie/rules/reimplemented_container_builtin.rs

@@ -21,6 +21,7 @@ use crate::checkers::ast::Checker;
 /// @dataclass
 /// class Foo:
 ///     bar: list[int] = field(default_factory=lambda: [])
+///     baz: dict[str, int] = field(default_factory=lambda: {})
 /// ```
 ///
 /// Use instead:
@@ -31,46 +32,50 @@ use crate::checkers::ast::Checker;
 /// @dataclass
 /// class Foo:
 ///     bar: list[int] = field(default_factory=list)
+///     baz: dict[str, int] = field(default_factory=dict)
 /// ```
 ///
 /// ## References
 /// - [Python documentation: `list`](https://docs.python.org/3/library/functions.html#func-list)
 #[violation]
-pub struct ReimplementedListBuiltin;
+pub struct ReimplementedContainerBuiltin;
 
-impl Violation for ReimplementedListBuiltin {
+impl Violation for ReimplementedContainerBuiltin {
     const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
 
     #[derive_message_formats]
     fn message(&self) -> String {
-        format!("Prefer `list` over useless lambda")
+        format!("Prefer `list` or `dict` over useless lambda")
     }
 
     fn fix_title(&self) -> Option<String> {
-        Some("Replace with `list`".to_string())
+        Some("Replace with `list` or `dict`".to_string())
     }
 }
 
 /// PIE807
-pub(crate) fn reimplemented_list_builtin(checker: &mut Checker, expr: &ExprLambda) {
+pub(crate) fn reimplemented_container_builtin(checker: &mut Checker, expr: &ExprLambda) {
     let ExprLambda {
         parameters,
         body,
         range: _,
     } = expr;
 
     if parameters.is_none() {
-        if let Expr::List(ast::ExprList { elts, .. }) = body.as_ref() {
-            if elts.is_empty() {
-                let mut diagnostic = Diagnostic::new(ReimplementedListBuiltin, expr.range());
-                if checker.semantic().is_builtin("list") {
-                    diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
-                        "list".to_string(),
-                        expr.range(),
-                    )));
-                }
-                checker.diagnostics.push(diagnostic);
+        let builtin = match body.as_ref() {
+            Expr::List(ast::ExprList { elts, .. }) if elts.is_empty() => Some("list"),
+            Expr::Dict(ast::ExprDict { values, .. }) if values.is_empty() => Some("dict"),
+            _ => None,
+        };
+        if let Some(builtin) = builtin {
+            let mut diagnostic = Diagnostic::new(ReimplementedContainerBuiltin, expr.range());
+            if checker.semantic().is_builtin(builtin) {
+                diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
+                    builtin.to_string(),
+                    expr.range(),
+                )));
             }
+            checker.diagnostics.push(diagnostic);
         }
     }
 }

crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__PIE807_PIE807.py.snap

@@ -1,58 +1,118 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_pie/mod.rs
 ---
-PIE807.py:3:44: PIE807 [*] Prefer `list` over useless lambda
+PIE807.py:3:44: PIE807 [*] Prefer `list` or `dict` over useless lambda
   |
 1 | @dataclass
 2 | class Foo:
 3 |     foo: List[str] = field(default_factory=lambda: [])  # PIE807
   |                                            ^^^^^^^^^^ PIE807
+4 |     bar: Dict[str, int] = field(default_factory=lambda: {})  # PIE807
   |
-  = help: Replace with `list`
+  = help: Replace with `list` or `dict`
 
 ℹ Safe fix
 1 1 | @dataclass
 2 2 | class Foo:
 3   |-    foo: List[str] = field(default_factory=lambda: [])  # PIE807
   3 |+    foo: List[str] = field(default_factory=list)  # PIE807
-4 4 | 
+4 4 |     bar: Dict[str, int] = field(default_factory=lambda: {})  # PIE807
 5 5 | 
-6 6 | class FooTable(BaseTable):
+6 6 | 
 
-PIE807.py:7:36: PIE807 [*] Prefer `list` over useless lambda
+PIE807.py:4:49: PIE807 [*] Prefer `list` or `dict` over useless lambda
   |
-6 | class FooTable(BaseTable):
-7 |     bar = fields.ListField(default=lambda: [])  # PIE807
+2 | class Foo:
+3 |     foo: List[str] = field(default_factory=lambda: [])  # PIE807
+4 |     bar: Dict[str, int] = field(default_factory=lambda: {})  # PIE807
+  |                                                 ^^^^^^^^^^ PIE807
+  |
+  = help: Replace with `list` or `dict`
+
+ℹ Safe fix
+1 1 | @dataclass
+2 2 | class Foo:
+3 3 |     foo: List[str] = field(default_factory=lambda: [])  # PIE807
+4   |-    bar: Dict[str, int] = field(default_factory=lambda: {})  # PIE807
+  4 |+    bar: Dict[str, int] = field(default_factory=dict)  # PIE807
+5 5 | 
+6 6 | 
+7 7 | class FooTable(BaseTable):
+
+PIE807.py:8:36: PIE807 [*] Prefer `list` or `dict` over useless lambda
+  |
+7 | class FooTable(BaseTable):
+8 |     foo = fields.ListField(default=lambda: [])  # PIE807
   |                                    ^^^^^^^^^^ PIE807
+9 |     bar = fields.ListField(default=lambda: {})  # PIE807
   |
-  = help: Replace with `list`
+  = help: Replace with `list` or `dict`
 
 ℹ Safe fix
-4 4 | 
 5 5 | 
-6 6 | class FooTable(BaseTable):
-7   |-    bar = fields.ListField(default=lambda: [])  # PIE807
-  7 |+    bar = fields.ListField(default=list)  # PIE807
-8 8 | 
-9 9 | 
-10 10 | class FooTable(BaseTable):
-
-PIE807.py:11:28: PIE807 [*] Prefer `list` over useless lambda
+6 6 | 
+7 7 | class FooTable(BaseTable):
+8   |-    foo = fields.ListField(default=lambda: [])  # PIE807
+  8 |+    foo = fields.ListField(default=list)  # PIE807
+9 9 |     bar = fields.ListField(default=lambda: {})  # PIE807
+10 10 | 
+11 11 | 
+
+PIE807.py:9:36: PIE807 [*] Prefer `list` or `dict` over useless lambda
+  |
+7 | class FooTable(BaseTable):
+8 |     foo = fields.ListField(default=lambda: [])  # PIE807
+9 |     bar = fields.ListField(default=lambda: {})  # PIE807
+  |                                    ^^^^^^^^^^ PIE807
+  |
+  = help: Replace with `list` or `dict`
+
+ℹ Safe fix
+6  6  | 
+7  7  | class FooTable(BaseTable):
+8  8  |     foo = fields.ListField(default=lambda: [])  # PIE807
+9     |-    bar = fields.ListField(default=lambda: {})  # PIE807
+   9  |+    bar = fields.ListField(default=dict)  # PIE807
+10 10 | 
+11 11 | 
+12 12 | class FooTable(BaseTable):
+
+PIE807.py:13:28: PIE807 [*] Prefer `list` or `dict` over useless lambda
    |
-10 | class FooTable(BaseTable):
-11 |     bar = fields.ListField(lambda: [])  # PIE807
+12 | class FooTable(BaseTable):
+13 |     foo = fields.ListField(lambda: [])  # PIE807
    |                            ^^^^^^^^^^ PIE807
+14 |     bar = fields.ListField(default=lambda: {})  # PIE807
+   |
+   = help: Replace with `list` or `dict`
+
+ℹ Safe fix
+10 10 | 
+11 11 | 
+12 12 | class FooTable(BaseTable):
+13    |-    foo = fields.ListField(lambda: [])  # PIE807
+   13 |+    foo = fields.ListField(list)  # PIE807
+14 14 |     bar = fields.ListField(default=lambda: {})  # PIE807
+15 15 | 
+16 16 | 
+
+PIE807.py:14:36: PIE807 [*] Prefer `list` or `dict` over useless lambda
+   |
+12 | class FooTable(BaseTable):
+13 |     foo = fields.ListField(lambda: [])  # PIE807
+14 |     bar = fields.ListField(default=lambda: {})  # PIE807
+   |                                    ^^^^^^^^^^ PIE807
    |
-   = help: Replace with `list`
+   = help: Replace with `list` or `dict`
 
 ℹ Safe fix
-8  8  | 
-9  9  | 
-10 10 | class FooTable(BaseTable):
-11    |-    bar = fields.ListField(lambda: [])  # PIE807
-   11 |+    bar = fields.ListField(list)  # PIE807
-12 12 | 
-13 13 | 
-14 14 | @dataclass
+11 11 | 
+12 12 | class FooTable(BaseTable):
+13 13 |     foo = fields.ListField(lambda: [])  # PIE807
+14    |-    bar = fields.ListField(default=lambda: {})  # PIE807
+   14 |+    bar = fields.ListField(default=dict)  # PIE807
+15 15 | 
+16 16 | 
+17 17 | @dataclass