par_iter able to handle biding inside main closure

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mate"
-version = "0.1.3"
+version = "0.1.4"
 authors = [
     "Cameron Low <[email protected]>",
     "Luca Carlig <[email protected]",

lints/par_iter/Cargo.toml

@@ -18,7 +18,7 @@ utils = { workspace = true }
 [dev-dependencies]
 dylint_testing = "3.0.0"
 rayon = "1.9.0"
-futures = "*"
+futures = "0.3.30"
 
 [package.metadata.rust-analyzer]
 rustc_private = true

lints/par_iter/src/lib.rs

@@ -157,18 +157,22 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'_> for Validator<'a, 'tcx> {
 
             for arg in args {
                 if let hir::ExprKind::Closure(closure) = arg.kind {
+                    let mut params = hir::HirIdSet::default();
                     let mut mut_params = hir::HirIdSet::default();
                     let body = self.cx.tcx.hir().body(closure.body);
 
-                    if self.is_mut {
-                        for param in body.params {
-                            if let hir::PatKind::Binding(_, hir_id, _, _) = param.pat.kind {
+                    for param in body.params {
+                        if let hir::PatKind::Binding(_, hir_id, _, _) = param.pat.kind {
+                            if self.is_mut {
                                 mut_params.insert(hir_id);
+                            } else {
+                                params.insert(hir_id);
                             }
                         }
                     }
 
-                    self.is_valid &= check_variables(self.cx, closure.def_id, body, &mut_params);
+                    self.is_valid &=
+                        check_variables(self.cx, closure.def_id, body, &mut_params, &params);
                 }
             }
         }

lints/par_iter/src/variable_check.rs

@@ -17,6 +17,7 @@ use crate::constants::TRAIT_PATHS;
 
 pub(crate) struct MutablyUsedVariablesCtxt<'tcx> {
     mutably_used_vars: hir::HirIdSet,
+    locally_bind_vars: hir::HirIdSet,
     all_vars: FxHashSet<Ty<'tcx>>,
     prev_bind: Option<hir::HirId>,
     /// In async functions, the inner AST is composed of multiple layers until we reach the code
@@ -34,14 +35,17 @@ pub(crate) fn check_variables<'tcx>(
     body_owner: hir::def_id::LocalDefId,
     body: &hir::Body<'tcx>,
     mut_params: &hir::HirIdSet,
+    params: &hir::HirIdSet,
 ) -> bool {
     let MutablyUsedVariablesCtxt {
         mut mutably_used_vars,
         all_vars,
+        mut locally_bind_vars,
         ..
     } = {
         let mut ctx = MutablyUsedVariablesCtxt {
             mutably_used_vars: hir::HirIdSet::default(),
+            locally_bind_vars: hir::HirIdSet::default(),
             all_vars: FxHashSet::default(),
             prev_bind: None,
             prev_move_to_closure: hir::HirIdSet::default(),
@@ -78,7 +82,9 @@ pub(crate) fn check_variables<'tcx>(
     for ty in all_vars {
         res &= is_type_valid(cx, ty);
     }
+    locally_bind_vars.retain(|&item| !params.contains(&item));
     mutably_used_vars.retain(|&item| !mut_params.contains(&item));
+    mutably_used_vars.retain(|&item| !locally_bind_vars.contains(&item));
 
     res &= mutably_used_vars.is_empty();
 
@@ -315,11 +321,10 @@ impl<'tcx> euv::Delegate<'tcx> for MutablyUsedVariablesCtxt<'tcx> {
                     var_path: UpvarPath { hir_id: vid },
                     ..
                 }),
-            base_ty,
             ..
         } = &cmt.place
         {
-            self.all_vars.insert(*base_ty);
+            self.locally_bind_vars.insert(*vid);
             if self.is_in_unsafe_block(id) {
                 self.add_mutably_used_var(*vid);
             }

lints/par_iter/ui/main.fixed

@@ -464,3 +464,17 @@ fn simple_iter_mut() {
     numbers.par_iter_mut().for_each(|num| *num *= 2); // Double each number
     println!("{:?}", numbers);
 }
+
+// should parallelize
+fn mut_var_declared_in_closure() {
+    let numbers = vec![1, 2, 3, 4, 5];
+    let doubled_numbers: Vec<i32> = numbers
+        .into_par_iter()
+        .map(|num| {
+            let mut doubled = num * 2; // Mutable variable inside the closure
+            doubled += 1; // Modify the mutable variable
+            doubled // Return the modified value
+        })
+        .collect();
+    println!("{:?}", doubled_numbers);
+}

lints/par_iter/ui/main.rs

@@ -464,3 +464,17 @@ fn simple_iter_mut() {
     numbers.iter_mut().for_each(|num| *num *= 2); // Double each number
     println!("{:?}", numbers);
 }
+
+// should parallelize
+fn mut_var_declared_in_closure() {
+    let numbers = vec![1, 2, 3, 4, 5];
+    let doubled_numbers: Vec<i32> = numbers
+        .into_iter()
+        .map(|num| {
+            let mut doubled = num * 2; // Mutable variable inside the closure
+            doubled += 1; // Modify the mutable variable
+            doubled // Return the modified value
+        })
+        .collect();
+    println!("{:?}", doubled_numbers);
+}

lints/par_iter/ui/main.stderr

@@ -109,5 +109,19 @@ warning: found iterator that can be parallelized
 LL |     numbers.iter_mut().for_each(|num| *num *= 2); // Double each number
    |     ^^^^^^^^^^^^^^^^^^ help: try using a parallel iterator: `numbers.par_iter_mut()`
 
-warning: 13 warnings emitted
+warning: found iterator that can be parallelized
+  --> $DIR/main.rs:471:37
+   |
+LL |       let doubled_numbers: Vec<i32> = numbers
+   |  _____________________________________^
+LL | |         .into_iter()
+   | |____________________^
+   |
+help: try using a parallel iterator
+   |
+LL ~     let doubled_numbers: Vec<i32> = numbers
+LL +         .into_par_iter()
+   |
+
+warning: 14 warnings emitted
 

lints/par_iter/ui/main2.fixed

@@ -43,18 +43,3 @@ fn main() {}
 // pub fn iter_returned_in_variable() {
 //     let _: Range<i32> = (0..100).into_iter();
 // }
-
-// // should parallelize
-// fn mut_var_declared_in_closure() {
-//     let numbers = vec![1, 2, 3, 4, 5];
-//     let doubled_numbers: Vec<i32> = numbers
-//         .into_iter()
-//         .map(|num| {
-//             let mut doubled = num * 2; // Mutable variable inside the closure
-//             doubled += 1; // Modify the mutable variable
-//             doubled // Return the modified value
-//         })
-//         .collect();
-//     println!("{:?}", doubled_numbers);
-// }
-//

lints/par_iter/ui/main2.rs

@@ -43,18 +43,3 @@ fn main() {}
 // pub fn iter_returned_in_variable() {
 //     let _: Range<i32> = (0..100).into_iter();
 // }
-
-// // should parallelize
-// fn mut_var_declared_in_closure() {
-//     let numbers = vec![1, 2, 3, 4, 5];
-//     let doubled_numbers: Vec<i32> = numbers
-//         .into_iter()
-//         .map(|num| {
-//             let mut doubled = num * 2; // Mutable variable inside the closure
-//             doubled += 1; // Modify the mutable variable
-//             doubled // Return the modified value
-//         })
-//         .collect();
-//     println!("{:?}", doubled_numbers);
-// }
-//