par_iter can now handle multiple iterators in one_chain

Author: lucarlig

lints/par_iter/src/lib.rs

@@ -71,13 +71,26 @@ impl<'tcx> LateLintPass<'tcx> for ParIter {
                 allowed_methods.extend(get_methods(cx));
 
                 let mut top_expr = *recv;
+                let mut found_iter_method = false;
 
                 while let Some(parent_expr) = get_parent_expr(cx, top_expr) {
                     match parent_expr.kind {
                         hir::ExprKind::MethodCall(method_name, _, _, _) => {
+                            if ["into_iter", "iter", "iter_mut"]
+                                .contains(&method_name.ident.as_str())
+                            {
+                                if found_iter_method {
+                                    // Exit early on the second iteration method
+                                    break;
+                                }
+                                // Mark that we've found an iteration method
+                                found_iter_method = true;
+                            }
+
                             if !allowed_methods.contains(method_name.ident.as_str()) {
                                 return;
                             }
+
                             top_expr = parent_expr;
                         }
                         hir::ExprKind::Closure(_) => {

lints/par_iter/ui/main.fixed

@@ -423,3 +423,37 @@ fn nested_pars() {
         .cloned()
         .collect();
 }
+
+// 1st should parallelize, 2nd no
+fn multiple_iter_one_chain() {
+    let people = vec![
+        Person {
+            name: "Alice".to_string(),
+            age: 25,
+        },
+        Person {
+            name: "Bob".to_string(),
+            age: 35,
+        },
+        Person {
+            name: "Carol".to_string(),
+            age: 32,
+        },
+    ];
+
+    let mut counter = 0;
+
+    let names_over_30: Vec<String> = people
+        .par_iter()
+        .filter(|p| p.age > 30)
+        .map(|p| p.name.clone())
+        .collect::<Vec<String>>()
+        .into_iter()
+        .map(|name| {
+            counter += 1;
+            format!("{}: {}", counter, name)
+        })
+        .collect();
+
+    println!("{:?}", names_over_30);
+}

lints/par_iter/ui/main.rs

@@ -423,3 +423,37 @@ fn nested_pars() {
         .cloned()
         .collect();
 }
+
+// 1st should parallelize, 2nd no
+fn multiple_iter_one_chain() {
+    let people = vec![
+        Person {
+            name: "Alice".to_string(),
+            age: 25,
+        },
+        Person {
+            name: "Bob".to_string(),
+            age: 35,
+        },
+        Person {
+            name: "Carol".to_string(),
+            age: 32,
+        },
+    ];
+
+    let mut counter = 0;
+
+    let names_over_30: Vec<String> = people
+        .iter()
+        .filter(|p| p.age > 30)
+        .map(|p| p.name.clone())
+        .collect::<Vec<String>>()
+        .into_iter()
+        .map(|name| {
+            counter += 1;
+            format!("{}: {}", counter, name)
+        })
+        .collect();
+
+    println!("{:?}", names_over_30);
+}

lints/par_iter/ui/main.stderr

@@ -89,5 +89,19 @@ warning: found iterator that can be parallelized
 LL |         .chain(used_filtered.iter())
    |                ^^^^^^^^^^^^^^^^^^^^ help: try using a parallel iterator: `used_filtered.par_iter()`
 
-warning: 11 warnings emitted
+warning: found iterator that can be parallelized
+  --> $DIR/main.rs:446:38
+   |
+LL |       let names_over_30: Vec<String> = people
+   |  ______________________________________^
+LL | |         .iter()
+   | |_______________^
+   |
+help: try using a parallel iterator
+   |
+LL ~     let names_over_30: Vec<String> = people
+LL +         .par_iter()
+   |
+
+warning: 12 warnings emitted