remove uncessary parens in closure body in library

Author: chenyukang

compiler/rustc_lint/src/unused.rs

@@ -913,8 +913,8 @@ trait UnusedDelimLint {
                     MethodCall(ref call) => (&call.args[..], UnusedDelimsCtx::MethodArg),
                     Closure(ref closure)
                         if matches!(closure.fn_decl.output, FnRetTy::Default(_))
-                            // skip `#[core::contracts::requires(...)]` and `#[core::contracts::ensures(...)]` which generate closure
-                            // with span that is same as the closure body span
+                            // skip `#[core::contracts::requires(...)]` and `#[core::contracts::ensures(...)]`
+                            // which generate closure expr with span that is same as the inner closure body span
                             && e.span != closure.body.span =>
                     {
                         (&[closure.body.clone()][..], UnusedDelimsCtx::ClosureBody)

compiler/rustc_mir_transform/src/coverage/tests.rs

@@ -217,7 +217,7 @@ fn print_mir_graphviz(name: &str, mir_body: &Body<'_>) {
                         mir_body
                             .basic_blocks
                             .successors(bb)
-                            .map(|successor| { format!("    {:?} -> {:?};", bb, successor) })
+                            .map(|successor| format!("    {:?} -> {:?};", bb, successor))
                             .join("\n")
                     )
                 })
@@ -241,7 +241,7 @@ fn print_coverage_graphviz(name: &str, mir_body: &Body<'_>, graph: &graph::Cover
                         mir_body[bcb_data.last_bb()].terminator().kind.name(),
                         graph
                             .successors(bcb)
-                            .map(|successor| { format!("    {:?} -> {:?};", bcb, successor) })
+                            .map(|successor| format!("    {:?} -> {:?};", bcb, successor))
                             .join("\n")
                     )
                 })

library/alloc/src/collections/btree/map/entry.rs

@@ -247,12 +247,12 @@ impl<'a, K: Ord, V, A: Allocator + Clone> Entry<'a, K, V, A> {
     /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
     ///
     /// map.entry("poneyland")
-    ///    .and_modify(|e| { *e += 1 })
+    ///    .and_modify(|e| *e += 1)
     ///    .or_insert(42);
     /// assert_eq!(map["poneyland"], 42);
     ///
     /// map.entry("poneyland")
-    ///    .and_modify(|e| { *e += 1 })
+    ///    .and_modify(|e| *e += 1)
     ///    .or_insert(42);
     /// assert_eq!(map["poneyland"], 43);
     /// ```

library/alloc/src/vec/mod.rs

@@ -3653,7 +3653,7 @@ impl<T, A: Allocator> Vec<T, A> {
     ///
     /// ```
     /// # use std::cmp::min;
-    /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 };
+    /// # let some_predicate = |x: &mut i32| *x == 2 || *x == 3 || *x == 6;
     /// # let mut vec = vec![1, 2, 3, 4, 5, 6];
     /// # let range = 1..4;
     /// let mut i = range.start;

library/std/src/collections/hash/map.rs

@@ -2029,13 +2029,13 @@ impl<'a, K, V, S> RawEntryMut<'a, K, V, S> {
     ///
     /// map.raw_entry_mut()
     ///    .from_key("poneyland")
-    ///    .and_modify(|_k, v| { *v += 1 })
+    ///    .and_modify(|_k, v| *v += 1)
     ///    .or_insert("poneyland", 42);
     /// assert_eq!(map["poneyland"], 42);
     ///
     /// map.raw_entry_mut()
     ///    .from_key("poneyland")
-    ///    .and_modify(|_k, v| { *v += 1 })
+    ///    .and_modify(|_k, v| *v += 1)
     ///    .or_insert("poneyland", 0);
     /// assert_eq!(map["poneyland"], 43);
     /// ```
@@ -2886,12 +2886,12 @@ impl<'a, K, V> Entry<'a, K, V> {
     /// let mut map: HashMap<&str, u32> = HashMap::new();
     ///
     /// map.entry("poneyland")
-    ///    .and_modify(|e| { *e += 1 })
+    ///    .and_modify(|e| *e += 1)
     ///    .or_insert(42);
     /// assert_eq!(map["poneyland"], 42);
     ///
     /// map.entry("poneyland")
-    ///    .and_modify(|e| { *e += 1 })
+    ///    .and_modify(|e| *e += 1)
     ///    .or_insert(42);
     /// assert_eq!(map["poneyland"], 43);
     /// ```

library/std/src/sync/poison/condvar.rs

@@ -238,7 +238,7 @@ impl Condvar {
     /// // Wait for the thread to start up.
     /// let (lock, cvar) = &*pair;
     /// // As long as the value inside the `Mutex<bool>` is `true`, we wait.
-    /// let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| { *pending }).unwrap();
+    /// let _guard = cvar.wait_while(lock.lock().unwrap(), |pending| *pending).unwrap();
     /// ```
     #[stable(feature = "wait_until", since = "1.42.0")]
     pub fn wait_while<'a, T, F>(

library/std/tests/env_modify.rs

@@ -91,9 +91,9 @@ fn test_env_set_var() {
     unsafe {
         set_var(&n, "VALUE");
     }
-    assert!(!e.any(|(k, v)| { &*k == &*n && &*v == "VALUE" }));
+    assert!(!e.any(|(k, v)| &*k == &*n && &*v == "VALUE"));
 
-    assert!(vars_os().any(|(k, v)| { &*k == &*n && &*v == "VALUE" }));
+    assert!(vars_os().any(|(k, v)| &*k == &*n && &*v == "VALUE"));
 }
 
 #[test]

src/etc/test-float-parse/src/lib.rs

@@ -443,9 +443,9 @@ fn launch_tests(tests: &mut [TestInfo], cfg: &Config) -> Duration {
             tests.iter().partition(|t| t.is_huge_test());
 
         // Run the actual tests
-        normal_tests.par_iter().for_each(|test| ((test.launch)(&tx, test, cfg)));
+        normal_tests.par_iter().for_each(|test| (test.launch)(&tx, test, cfg));
 
-        huge_tests.par_iter().for_each(|test| ((test.launch)(&tx, test, cfg)));
+        huge_tests.par_iter().for_each(|test| (test.launch)(&tx, test, cfg));
     });
 
     start.elapsed()