[perflint] Add PERF101 with autofix

crates/ruff/resources/test/fixtures/perflint/PERF101.py

@@ -0,0 +1,35 @@
+foo_tuple = (1, 2, 3)
+foo_list = [1, 2, 3]
+foo_set = {1, 2, 3}
+foo_dict = {1: 2, 3: 4}
+foo_int = 123
+
+for i in list(foo_tuple):  # PERF101
+    pass
+
+for i in list(foo_list):  # PERF101
+    pass
+
+for i in list(foo_set):  # PERF101
+    pass
+
+
+for i in list((1, 2, 3)):  # PERF101
+    pass
+
+for i in list([1, 2, 3]):  # PERF101
+    pass
+
+for i in list({1, 2, 3}):  # PERF101
+    pass
+
+
+for i in list(foo_dict):  # Ok
+    pass
+
+
+for i in list(1):  # Ok
+    pass
+
+for i in list(foo_int):  # Ok
+    pass

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

@@ -1481,6 +1481,9 @@ where
                 if self.enabled(Rule::IncorrectDictIterator) {
                     perflint::rules::incorrect_dict_iterator(self, target, iter);
                 }
+                if self.enabled(Rule::UnnecessaryListCast) {
+                    perflint::rules::unnecessary_list_cast(self, iter);
+                }
             }
             Stmt::Try(ast::StmtTry {
                 body,

crates/ruff/src/codes.rs

@@ -784,6 +784,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Airflow, "001") => (RuleGroup::Unspecified, rules::airflow::rules::AirflowVariableNameTaskIdMismatch),
 
         // perflint
+        (Perflint, "101") => (RuleGroup::Unspecified, rules::perflint::rules::UnnecessaryListCast),
         (Perflint, "102") => (RuleGroup::Unspecified, rules::perflint::rules::IncorrectDictIterator),
 
         // flake8-fixme

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

@@ -13,6 +13,7 @@ mod tests {
     use crate::settings::Settings;
     use crate::test::test_path;
 
+    #[test_case(Rule::UnnecessaryListCast, Path::new("PERF101.py"))]
     #[test_case(Rule::IncorrectDictIterator, Path::new("PERF102.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());

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

@@ -1,3 +1,5 @@
 pub(crate) use incorrect_dict_iterator::{incorrect_dict_iterator, IncorrectDictIterator};
+pub(crate) use unnecessary_list_cast::{unnecessary_list_cast, UnnecessaryListCast};
 
 mod incorrect_dict_iterator;
+mod unnecessary_list_cast;

crates/ruff/src/rules/perflint/rules/unnecessary_list_cast.rs

@@ -0,0 +1,100 @@
+use ruff_text_size::{TextRange, TextSize};
+use rustpython_parser::ast;
+use rustpython_parser::ast::Expr;
+
+use ruff_diagnostics::{AlwaysAutofixableViolation, Diagnostic, Edit, Fix};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::prelude::Stmt;
+
+use crate::checkers::ast::Checker;
+use crate::registry::AsRule;
+
+/// ## What it does
+/// Checks for explicit usages of `list()` on an iterable to iterate over them in a for-loop
+///
+/// ## Why is this bad?
+/// Using a `list()` call to eagerly iterate over an already iterable type is inefficient as a
+/// second list iterator is created, after first iterating the value:
+///
+/// ## Example
+/// ```python
+/// items = (1, 2, 3)
+/// for i in list(items):
+///     print(i)
+/// ```
+///
+/// Use instead:
+/// ```python
+/// items = (1, 2, 3)
+/// for i in items:
+///     print(i)
+/// ```
+#[violation]
+pub struct UnnecessaryListCast;
+
+impl AlwaysAutofixableViolation for UnnecessaryListCast {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        format!("Do not cast an iterable to `list` before iterating over it")
+    }
+
+    fn autofix_title(&self) -> String {
+        format!("Remove `list()` cast")
+    }
+}
+
+/// PERF101
+pub(crate) fn unnecessary_list_cast(checker: &mut Checker, iter: &Expr) {
+    let Expr::Call(ast::ExprCall{ func, args, range, ..}) = iter else {
+        return;
+    };
+
+    if args.is_empty() {
+        return;
+    }
+
+    if let Expr::Name(ast::ExprName { id, .. }) = func.as_ref() {
+        if id != "list" || !checker.semantic().is_builtin("list") {
+            return;
+        }
+    };
+
+    match &args[0] {
+        Expr::Tuple(_) | Expr::List(_) | Expr::Set(_) => fix_incorrect_list_cast(checker, *range),
+        Expr::Name(ast::ExprName { id, .. }) => {
+            let scope = checker.semantic().scope();
+            if let Some(binding_id) = scope.get(id) {
+                let binding = &checker.semantic().bindings[binding_id];
+                if binding.kind.is_assignment() || binding.kind.is_named_expr_assignment() {
+                    if let Some(parent_id) = binding.source {
+                        let parent = checker.semantic().stmts[parent_id];
+                        match parent {
+                            Stmt::Assign(ast::StmtAssign { value, .. })
+                            | Stmt::AnnAssign(ast::StmtAnnAssign {
+                                value: Some(value), ..
+                            }) => match value.as_ref() {
+                                Expr::Tuple(_) | Expr::List(_) | Expr::Set(_) => {
+                                    fix_incorrect_list_cast(checker, *range);
+                                }
+                                _ => {}
+                            },
+                            _ => (),
+                        }
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+}
+
+fn fix_incorrect_list_cast(checker: &mut Checker, range: TextRange) {
+    let mut diagnostic = Diagnostic::new(UnnecessaryListCast, range);
+    if checker.patch(diagnostic.kind.rule()) {
+        diagnostic.set_fix(Fix::automatic_edits(
+            Edit::deletion(range.start(), range.start() + TextSize::from(5)),
+            [Edit::deletion(range.end() - TextSize::from(1), range.end())],
+        ));
+    }
+    checker.diagnostics.push(diagnostic);
+}

crates/ruff/src/rules/perflint/snapshots/ruff__rules__perflint__tests__PERF101_PERF101.py.snap

@@ -0,0 +1,122 @@
+---
+source: crates/ruff/src/rules/perflint/mod.rs
+---
+PERF101.py:7:10: PERF101 [*] Do not cast an iterable to `list` before iterating over it
+  |
+5 | foo_int = 123
+6 | 
+7 | for i in list(foo_tuple):  # PERF101
+  |          ^^^^^^^^^^^^^^^ PERF101
+8 |     pass
+  |
+  = help: Remove `list()` cast
+
+ℹ Fix
+4 4 | foo_dict = {1: 2, 3: 4}
+5 5 | foo_int = 123
+6 6 | 
+7   |-for i in list(foo_tuple):  # PERF101
+  7 |+for i in foo_tuple:  # PERF101
+8 8 |     pass
+9 9 | 
+10 10 | for i in list(foo_list):  # PERF101
+
+PERF101.py:10:10: PERF101 [*] Do not cast an iterable to `list` before iterating over it
+   |
+ 8 |     pass
+ 9 | 
+10 | for i in list(foo_list):  # PERF101
+   |          ^^^^^^^^^^^^^^ PERF101
+11 |     pass
+   |
+   = help: Remove `list()` cast
+
+ℹ Fix
+7  7  | for i in list(foo_tuple):  # PERF101
+8  8  |     pass
+9  9  | 
+10    |-for i in list(foo_list):  # PERF101
+   10 |+for i in foo_list:  # PERF101
+11 11 |     pass
+12 12 | 
+13 13 | for i in list(foo_set):  # PERF101
+
+PERF101.py:13:10: PERF101 [*] Do not cast an iterable to `list` before iterating over it
+   |
+11 |     pass
+12 | 
+13 | for i in list(foo_set):  # PERF101
+   |          ^^^^^^^^^^^^^ PERF101
+14 |     pass
+   |
+   = help: Remove `list()` cast
+
+ℹ Fix
+10 10 | for i in list(foo_list):  # PERF101
+11 11 |     pass
+12 12 | 
+13    |-for i in list(foo_set):  # PERF101
+   13 |+for i in foo_set:  # PERF101
+14 14 |     pass
+15 15 | 
+16 16 | 
+
+PERF101.py:17:10: PERF101 [*] Do not cast an iterable to `list` before iterating over it
+   |
+17 | for i in list((1, 2, 3)):  # PERF101
+   |          ^^^^^^^^^^^^^^^ PERF101
+18 |     pass
+   |
+   = help: Remove `list()` cast
+
+ℹ Fix
+14 14 |     pass
+15 15 | 
+16 16 | 
+17    |-for i in list((1, 2, 3)):  # PERF101
+   17 |+for i in (1, 2, 3):  # PERF101
+18 18 |     pass
+19 19 | 
+20 20 | for i in list([1, 2, 3]):  # PERF101
+
+PERF101.py:20:10: PERF101 [*] Do not cast an iterable to `list` before iterating over it
+   |
+18 |     pass
+19 | 
+20 | for i in list([1, 2, 3]):  # PERF101
+   |          ^^^^^^^^^^^^^^^ PERF101
+21 |     pass
+   |
+   = help: Remove `list()` cast
+
+ℹ Fix
+17 17 | for i in list((1, 2, 3)):  # PERF101
+18 18 |     pass
+19 19 | 
+20    |-for i in list([1, 2, 3]):  # PERF101
+   20 |+for i in [1, 2, 3]:  # PERF101
+21 21 |     pass
+22 22 | 
+23 23 | for i in list({1, 2, 3}):  # PERF101
+
+PERF101.py:23:10: PERF101 [*] Do not cast an iterable to `list` before iterating over it
+   |
+21 |     pass
+22 | 
+23 | for i in list({1, 2, 3}):  # PERF101
+   |          ^^^^^^^^^^^^^^^ PERF101
+24 |     pass
+   |
+   = help: Remove `list()` cast
+
+ℹ Fix
+20 20 | for i in list([1, 2, 3]):  # PERF101
+21 21 |     pass
+22 22 | 
+23    |-for i in list({1, 2, 3}):  # PERF101
+   23 |+for i in {1, 2, 3}:  # PERF101
+24 24 |     pass
+25 25 | 
+26 26 | 
+
+