Fix clippy lints

rayon-core/src/compile_fail/rc_return.rs

@@ -2,9 +2,7 @@
 
 use std::rc::Rc;
 
-fn main() {
-    rayon_core::join(|| Rc::new(22), || ()); //~ ERROR
-}
+rayon_core::join(|| Rc::new(22), || ()); //~ ERROR
 
 ``` */
 mod left {}
@@ -13,9 +11,7 @@ mod left {}
 
 use std::rc::Rc;
 
-fn main() {
-    rayon_core::join(|| (), || Rc::new(23)); //~ ERROR
-}
+rayon_core::join(|| (), || Rc::new(23)); //~ ERROR
 
 ``` */
 mod right {}

rayon-core/src/compile_fail/rc_upvar.rs

@@ -2,10 +2,8 @@
 
 use std::rc::Rc;
 
-fn main() {
-    let r = Rc::new(22);
-    rayon_core::join(|| r.clone(), || r.clone());
-    //~^ ERROR
-}
+let r = Rc::new(22);
+rayon_core::join(|| r.clone(), || r.clone());
+//~^ ERROR
 
 ``` */

rayon-core/src/lib.rs

@@ -185,6 +185,7 @@ pub struct ThreadPoolBuilder<S = DefaultSpawn> {
 ///
 /// [`ThreadPoolBuilder`]: struct.ThreadPoolBuilder.html
 #[deprecated(note = "Use `ThreadPoolBuilder`")]
+#[derive(Default)]
 pub struct Configuration {
     builder: ThreadPoolBuilder,
 }
@@ -748,15 +749,6 @@ impl<S> fmt::Debug for ThreadPoolBuilder<S> {
     }
 }
 
-#[allow(deprecated)]
-impl Default for Configuration {
-    fn default() -> Self {
-        Configuration {
-            builder: Default::default(),
-        }
-    }
-}
-
 #[allow(deprecated)]
 impl fmt::Debug for Configuration {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

rayon-core/src/log.rs

@@ -124,25 +124,25 @@ impl Logger {
 
         let (sender, receiver) = crossbeam_channel::unbounded();
 
-        if env_log.starts_with("tail:") {
-            let filename = env_log["tail:".len()..].to_string();
+        if let Some(filename) = env_log.strip_prefix("tail:") {
+            let filename = filename.to_string();
             ::std::thread::spawn(move || {
                 Self::tail_logger_thread(num_workers, filename, 10_000, receiver)
             });
         } else if env_log == "all" {
             ::std::thread::spawn(move || Self::all_logger_thread(num_workers, receiver));
-        } else if env_log.starts_with("profile:") {
-            let filename = env_log["profile:".len()..].to_string();
+        } else if let Some(filename) = env_log.strip_prefix("profile:") {
+            let filename = filename.to_string();
             ::std::thread::spawn(move || {
                 Self::profile_logger_thread(num_workers, filename, 10_000, receiver)
             });
         } else {
             panic!("RAYON_LOG should be 'tail:<file>' or 'profile:<file>'");
         }
 
-        return Logger {
+        Logger {
             sender: Some(sender),
-        };
+        }
     }
 
     fn disabled() -> Logger {
@@ -219,31 +219,25 @@ impl Logger {
         let mut skipped = false;
 
         loop {
-            loop {
-                match receiver.recv_timeout(timeout) {
-                    Ok(event) => {
-                        if let Event::Flush = event {
-                            // We ignore Flush events in tail mode --
-                            // we're really just looking for
-                            // deadlocks.
-                            continue;
-                        } else {
-                            if events.len() == capacity {
-                                let event = events.pop_front().unwrap();
-                                state.simulate(&event);
-                                skipped = true;
-                            }
-
-                            events.push_back(event);
-                        }
+            while let Ok(event) = receiver.recv_timeout(timeout) {
+                if let Event::Flush = event {
+                    // We ignore Flush events in tail mode --
+                    // we're really just looking for
+                    // deadlocks.
+                    continue;
+                } else {
+                    if events.len() == capacity {
+                        let event = events.pop_front().unwrap();
+                        state.simulate(&event);
+                        skipped = true;
                     }
 
-                    Err(_) => break,
+                    events.push_back(event);
                 }
             }
 
             if skipped {
-                write!(writer, "...\n").unwrap();
+                writeln!(writer, "...").unwrap();
                 skipped = false;
             }
 
@@ -417,7 +411,7 @@ impl SimulatorState {
             }
         }
 
-        write!(w, "\n")?;
+        writeln!(w)?;
         Ok(())
     }
 }

rayon-core/src/registry.rs

@@ -41,7 +41,7 @@ impl ThreadBuilder {
 
     /// Gets the string that was specified by `ThreadPoolBuilder::name()`.
     pub fn name(&self) -> Option<&str> {
-        self.name.as_ref().map(String::as_str)
+        self.name.as_deref()
     }
 
     /// Gets the value that was specified by `ThreadPoolBuilder::stack_size()`.

rayon-core/src/scope/test.rs

@@ -42,7 +42,7 @@ fn scope_divide_and_conquer() {
     scope(|s| s.spawn(move |s| divide_and_conquer(s, counter_p, 1024)));
 
     let counter_s = &AtomicUsize::new(0);
-    divide_and_conquer_seq(&counter_s, 1024);
+    divide_and_conquer_seq(counter_s, 1024);
 
     let p = counter_p.load(Ordering::SeqCst);
     let s = counter_s.load(Ordering::SeqCst);
@@ -75,7 +75,7 @@ struct Tree<T: Send> {
 }
 
 impl<T: Send> Tree<T> {
-    fn iter<'s>(&'s self) -> vec::IntoIter<&'s T> {
+    fn iter(&self) -> vec::IntoIter<&T> {
         once(&self.value)
             .chain(self.children.iter().flat_map(Tree::iter))
             .collect::<Vec<_>>() // seems like it shouldn't be needed... but prevents overflow

rayon-core/src/sleep/counters.rs

@@ -61,10 +61,12 @@ const THREADS_BITS: usize = 8;
 
 /// Bits to shift to select the sleeping threads
 /// (used with `select_bits`).
+#[allow(clippy::erasing_op)]
 const SLEEPING_SHIFT: usize = 0 * THREADS_BITS;
 
 /// Bits to shift to select the inactive threads
 /// (used with `select_bits`).
+#[allow(clippy::identity_op)]
 const INACTIVE_SHIFT: usize = 1 * THREADS_BITS;
 
 /// Bits to shift to select the JEC

rayon-core/tests/double_init_fail.rs

@@ -4,7 +4,7 @@ use std::error::Error;
 #[test]
 fn double_init_fail() {
     let result1 = ThreadPoolBuilder::new().build_global();
-    assert_eq!(result1.unwrap(), ());
+    assert!(result1.is_ok());
     let err = ThreadPoolBuilder::new().build_global().unwrap_err();
     assert!(err.source().is_none());
     assert_eq!(

rayon-demo/src/life/mod.rs

@@ -19,7 +19,6 @@ use crate::cpu_time::{self, CpuMeasure};
 use rand::distributions::Standard;
 use rand::{thread_rng, Rng};
 use std::iter::repeat;
-use std::num::Wrapping;
 use std::sync::Arc;
 use std::thread;
 use std::time::{Duration, Instant};
@@ -131,14 +130,14 @@ impl Board {
     }
 
     fn living_neighbors(&self, x: usize, y: usize) -> usize {
-        let Wrapping(x_1) = Wrapping(x) - Wrapping(1);
-        let Wrapping(y_1) = Wrapping(y) - Wrapping(1);
+        let x_1 = x.wrapping_sub(1);
+        let y_1 = y.wrapping_sub(1);
         let neighbors = [
             self.cell_live(x_1, y_1),
             self.cell_live(x, y_1),
             self.cell_live(x + 1, y_1),
-            self.cell_live(x_1, y + 0),
-            self.cell_live(x + 1, y + 0),
+            self.cell_live(x_1, y),
+            self.cell_live(x + 1, y),
             self.cell_live(x_1, y + 1),
             self.cell_live(x, y + 1),
             self.cell_live(x + 1, y + 1),

rayon-demo/src/matmul/mod.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::uninit_vec)]
+
 const USAGE: &str = "
 Usage: matmul bench [--size N]
        matmul --help
@@ -16,11 +18,11 @@ pub struct Args {
     flag_size: usize,
 }
 
+use std::time::Instant;
+
 use docopt::Docopt;
 use rayon::prelude::*;
 
-use std::time::Instant;
-
 // TODO: Investigate other cache patterns for row-major order that may be more
 // parallelizable.
 // https://tavianator.com/a-quick-trick-for-faster-naive-matrix-multiplication/
@@ -116,6 +118,7 @@ pub fn seq_matmulz(a: &[f32], b: &[f32], dest: &mut [f32]) {
     }
 }
 
+#[allow(clippy::identity_op)]
 const MULT_CHUNK: usize = 1 * 1024;
 const LINEAR_CHUNK: usize = 64 * 1024;
 
@@ -152,6 +155,7 @@ where
     (r1, r2, r3, r4)
 }
 
+#[allow(clippy::too_many_arguments)]
 fn join8<F1, F2, F3, F4, F5, F6, F7, F8, R1, R2, R3, R4, R5, R6, R7, R8>(
     f1: F1,
     f2: F2,
@@ -253,6 +257,7 @@ pub fn matmul_strassen(a: &[f32], b: &[f32], dest: &mut [f32]) {
 
 fn raw_buffer(n: usize) -> Vec<f32> {
     let mut tmp = Vec::with_capacity(n);
+    // We always overwrite the buffer (using `rcopy`) before reading from it.
     unsafe {
         tmp.set_len(n);
     }

rayon-demo/src/mergesort/mod.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::uninit_vec)]
+
 use rand::distributions::Standard;
 use rand::Rng;
 

rayon-demo/src/nbody/mod.rs

@@ -3,6 +3,7 @@ use std::time::Instant;
 
 #[cfg(test)]
 mod bench;
+#[allow(clippy::module_inception)]
 mod nbody;
 mod visualize;
 use self::nbody::NBodyBenchmark;

rayon-demo/src/tsp/graph.rs

@@ -55,7 +55,7 @@ impl Graph {
         }
     }
 
-    pub fn edges<'a>(&'a self, source: Node) -> impl Iterator<Item = Edge> + 'a {
+    pub fn edges(&self, source: Node) -> impl Iterator<Item = Edge> + '_ {
         self.all_nodes().filter_map(move |target| {
             self.edge_weight(source, target).map(|weight| Edge {
                 source,

rayon-demo/src/tsp/mod.rs

@@ -5,6 +5,7 @@
 
 use docopt::Docopt;
 use std::error::Error;
+use std::fmt::Write;
 use std::fs::File;
 use std::io::prelude::*;
 use std::path::Path;
@@ -93,7 +94,7 @@ fn run_solver(datafile: &Path, seq_threshold: usize, from: usize) -> Result<(),
         println!("Cheapest path cost: {}", weight.to_usize());
         let mut output = "Cheapest path:".to_string();
         for node in path {
-            output.push_str(&format!(" {}", node.index()));
+            let _ = write!(output, " {}", node.index());
         }
         println!("{}", output);
     } else {

rayon-demo/src/tsp/parser.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::needless_lifetimes)]
+
 use regex::Regex;
 use std::collections::HashMap;
 use std::str::{FromStr, Lines};

rayon-demo/src/tsp/step.rs

@@ -180,7 +180,7 @@ fn complete_tour(solver: &SolverCx<'_>, path: &mut Vec<Node>, weight: Weight) {
     let last = *path.last().unwrap();
     if let Some(home_weight) = graph.edge_weight(last, home) {
         path.push(home);
-        solver.add_complete_tour(&path, weight + home_weight);
+        solver.add_complete_tour(path, weight + home_weight);
         path.pop();
     }
 }

src/collections/mod.rs

@@ -56,7 +56,7 @@ mod drain_guard {
         pub(super) fn new(collection: &'a mut C) -> Self {
             Self {
                 // Temporarily steal the inner `Vec` so we can drain in place.
-                vec: Vec::from(mem::replace(collection, C::default())),
+                vec: Vec::from(mem::take(collection)),
                 collection,
             }
         }
@@ -65,7 +65,7 @@ mod drain_guard {
     impl<'a, T, C: From<Vec<T>>> Drop for DrainGuard<'a, T, C> {
         fn drop(&mut self) {
             // Restore the collection from the `Vec` with its original capacity.
-            *self.collection = C::from(mem::replace(&mut self.vec, Vec::new()));
+            *self.collection = C::from(mem::take(&mut self.vec));
         }
     }
 

src/compile_fail/cannot_collect_filtermap_data.rs

@@ -5,12 +5,10 @@ use rayon::prelude::*;
 // zip requires data of exact size, but filter yields only bounded
 // size, so check that we cannot apply it.
 
-fn main() {
-    let a: Vec<usize> = (0..1024).collect();
-    let mut v = vec![];
-    a.par_iter()
-     .filter_map(|&x| Some(x as f32))
-     .collect_into_vec(&mut v); //~ ERROR no method
-}
+let a: Vec<usize> = (0..1024).collect();
+let mut v = vec![];
+a.par_iter()
+    .filter_map(|&x| Some(x as f32))
+    .collect_into_vec(&mut v); //~ ERROR no method
 
 ``` */

src/compile_fail/cannot_zip_filtered_data.rs

@@ -5,12 +5,10 @@ use rayon::prelude::*;
 // zip requires data of exact size, but filter yields only bounded
 // size, so check that we cannot apply it.
 
-fn main() {
-    let mut a: Vec<usize> = (0..1024).rev().collect();
-    let b: Vec<usize> = (0..1024).collect();
+let mut a: Vec<usize> = (0..1024).rev().collect();
+let b: Vec<usize> = (0..1024).collect();
 
-    a.par_iter()
-     .zip(b.par_iter().filter(|&&x| x > 3)); //~ ERROR
-}
+a.par_iter()
+    .zip(b.par_iter().filter(|&&x| x > 3)); //~ ERROR
 
 ``` */

src/compile_fail/cell_par_iter.rs

@@ -5,11 +5,9 @@
 use rayon::prelude::*;
 use std::cell::Cell;
 
-fn main() {
-    let c = Cell::new(42_i32);
-    (0_i32..1024).into_par_iter()
-             .map(|_| c.get()) //~ ERROR E0277
-             .min();
-}
+let c = Cell::new(42_i32);
+(0_i32..1024).into_par_iter()
+    .map(|_| c.get()) //~ ERROR E0277
+    .min();
 
 ``` */