[refurb] Implement reimplemented-starmap rule (FURB140)

crates/ruff/resources/test/fixtures/refurb/FURB140.py

@@ -0,0 +1,41 @@
+def zipped():
+    return zip([1, 2, 3], "ABC")
+
+# Errors.
+
+# FURB140
+[print(x, y) for x, y in zipped()]
+
+# FURB140
+(print(x, y) for x, y in zipped())
+
+# FURB140
+{print(x, y) for x, y in zipped()}
+
+
+from itertools import starmap as sm
+
+# FURB140
+[print(x, y) for x, y in zipped()]
+
+# FURB140
+(print(x, y) for x, y in zipped())
+
+# FURB140
+{print(x, y) for x, y in zipped()}
+
+# Non-errors.
+
+[print(x, int) for x, _ in zipped()]
+
+[print(x, y, 1) for x, y in zipped()]
+
+[print(y, x) for x, y in zipped()]
+
+[print(x + 1, y) for x, y in zipped()]
+
+[print(x) for x in range(100)]
+
+[print() for x, y in zipped()]
+
+[print(x, end=y) for x, y in zipped()]

crates/ruff/src/checkers/ast/analyze/expression.rs

@@ -16,7 +16,7 @@ use crate::rules::{
     flake8_future_annotations, flake8_gettext, flake8_implicit_str_concat, flake8_logging_format,
     flake8_pie, flake8_print, flake8_pyi, flake8_pytest_style, flake8_self, flake8_simplify,
     flake8_tidy_imports, flake8_use_pathlib, flynt, numpy, pandas_vet, pep8_naming, pycodestyle,
-    pyflakes, pygrep_hooks, pylint, pyupgrade, ruff,
+    pyflakes, pygrep_hooks, pylint, pyupgrade, refurb, ruff,
 };
 use crate::settings::types::PythonVersion;
 
@@ -1259,16 +1259,13 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_simplify::rules::twisted_arms_in_ifexpr(checker, expr, test, body, orelse);
             }
         }
-        Expr::ListComp(ast::ExprListComp {
-            elt,
-            generators,
-            range: _,
-        })
-        | Expr::SetComp(ast::ExprSetComp {
-            elt,
-            generators,
-            range: _,
-        }) => {
+        Expr::ListComp(
+            comp @ ast::ExprListComp {
+                elt,
+                generators,
+                range: _,
+            },
+        ) => {
             if checker.enabled(Rule::UnnecessaryComprehension) {
                 flake8_comprehensions::rules::unnecessary_list_set_comprehension(
                     checker, expr, elt, generators,
@@ -1282,6 +1279,33 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     pylint::rules::iteration_over_set(checker, &generator.iter);
                 }
             }
+            if checker.enabled(Rule::ReimplementedStarmap) {
+                refurb::rules::reimplemented_starmap(checker, comp);
+            }
+        }
+        Expr::SetComp(
+            comp @ ast::ExprSetComp {
+                elt,
+                generators,
+                range: _,
+            },
+        ) => {
+            if checker.enabled(Rule::UnnecessaryComprehension) {
+                flake8_comprehensions::rules::unnecessary_list_set_comprehension(
+                    checker, expr, elt, generators,
+                );
+            }
+            if checker.enabled(Rule::FunctionUsesLoopVariable) {
+                flake8_bugbear::rules::function_uses_loop_variable(checker, &Node::Expr(expr));
+            }
+            if checker.enabled(Rule::IterationOverSet) {
+                for generator in generators {
+                    pylint::rules::iteration_over_set(checker, &generator.iter);
+                }
+            }
+            if checker.enabled(Rule::ReimplementedStarmap) {
+                refurb::rules::reimplemented_starmap(checker, comp);
+            }
         }
         Expr::DictComp(ast::ExprDictComp {
             key,
@@ -1306,11 +1330,13 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 ruff::rules::static_key_dict_comprehension(checker, key);
             }
         }
-        Expr::GeneratorExp(ast::ExprGeneratorExp {
-            generators,
-            elt: _,
-            range: _,
-        }) => {
+        Expr::GeneratorExp(
+            generator @ ast::ExprGeneratorExp {
+                generators,
+                elt: _,
+                range: _,
+            },
+        ) => {
             if checker.enabled(Rule::FunctionUsesLoopVariable) {
                 flake8_bugbear::rules::function_uses_loop_variable(checker, &Node::Expr(expr));
             }
@@ -1319,6 +1345,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     pylint::rules::iteration_over_set(checker, &generator.iter);
                 }
             }
+            if checker.enabled(Rule::ReimplementedStarmap) {
+                refurb::rules::reimplemented_starmap(checker, generator);
+            }
         }
         Expr::BoolOp(
             bool_op @ ast::ExprBoolOp {

crates/ruff/src/codes.rs

@@ -869,6 +869,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Refurb, "113") => (RuleGroup::Nursery, rules::refurb::rules::RepeatedAppend),
         (Refurb, "131") => (RuleGroup::Nursery, rules::refurb::rules::DeleteFullSlice),
         (Refurb, "132") => (RuleGroup::Nursery, rules::refurb::rules::CheckAndRemoveFromSet),
+        (Refurb, "140") => (RuleGroup::Nursery, rules::refurb::rules::ReimplementedStarmap),
 
         _ => return None,
     })

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

@@ -16,6 +16,7 @@ mod tests {
     #[test_case(Rule::RepeatedAppend, Path::new("FURB113.py"))]
     #[test_case(Rule::DeleteFullSlice, Path::new("FURB131.py"))]
     #[test_case(Rule::CheckAndRemoveFromSet, Path::new("FURB132.py"))]
+    #[test_case(Rule::ReimplementedStarmap, Path::new("FURB140.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
         let diagnostics = test_path(

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

@@ -1,7 +1,9 @@
 pub(crate) use check_and_remove_from_set::*;
 pub(crate) use delete_full_slice::*;
+pub(crate) use reimplemented_starmap::*;
 pub(crate) use repeated_append::*;
 
 mod check_and_remove_from_set;
 mod delete_full_slice;
+mod reimplemented_starmap;
 mod repeated_append;