Address many clippy warnings

Author: cuviper

rayon-core/src/job.rs

@@ -48,12 +48,9 @@ impl JobRef {
         let fn_ptr: unsafe fn(*const T) = <T as Job>::execute;
 
         // erase types:
-        let fn_ptr: unsafe fn(*const ()) = mem::transmute(fn_ptr);
-        let pointer = data as *const ();
-
         JobRef {
-            pointer: pointer,
-            execute_fn: fn_ptr,
+            pointer: data as *const (),
+            execute_fn: mem::transmute(fn_ptr),
         }
     }
 
@@ -86,7 +83,7 @@ where
 {
     pub fn new(func: F, latch: L) -> StackJob<L, F, R> {
         StackJob {
-            latch: latch,
+            latch,
             func: UnsafeCell::new(Some(func)),
             result: UnsafeCell::new(JobResult::None),
         }

rayon-core/src/join/mod.rs

@@ -171,7 +171,7 @@ where
             }
         }
 
-        return (result_a, job_b.into_result());
+        (result_a, job_b.into_result())
     })
 }
 

rayon-core/src/latch.rs

@@ -167,7 +167,7 @@ impl<'a, L: Latch> TickleLatch<'a, L> {
     pub fn new(latch: L, sleep: &'a Sleep) -> Self {
         TickleLatch {
             inner: latch,
-            sleep: sleep,
+            sleep,
         }
     }
 }

rayon-core/src/lib.rs

@@ -405,7 +405,7 @@ impl Configuration {
 
     /// Deprecated in favor of `ThreadPoolBuilder::build`.
     pub fn build(self) -> Result<ThreadPool, Box<Error + 'static>> {
-        self.builder.build().map_err(|e| e.into())
+        self.builder.build().map_err(Box::from)
     }
 
     /// Deprecated in favor of `ThreadPoolBuilder::thread_name`.
@@ -470,7 +470,7 @@ impl Configuration {
 
 impl ThreadPoolBuildError {
     fn new(kind: ErrorKind) -> ThreadPoolBuildError {
-        ThreadPoolBuildError { kind: kind }
+        ThreadPoolBuildError { kind }
     }
 }
 
@@ -498,7 +498,7 @@ impl fmt::Display for ThreadPoolBuildError {
 #[deprecated(note = "use `ThreadPoolBuilder::build_global`")]
 #[allow(deprecated)]
 pub fn initialize(config: Configuration) -> Result<(), Box<Error>> {
-    config.into_builder().build_global().map_err(|e| e.into())
+    config.into_builder().build_global().map_err(Box::from)
 }
 
 impl fmt::Debug for ThreadPoolBuilder {
@@ -567,7 +567,7 @@ impl FnContext {
     #[inline]
     fn new(migrated: bool) -> Self {
         FnContext {
-            migrated: migrated,
+            migrated,
             _marker: PhantomData,
         }
     }

rayon-core/src/registry.rs

@@ -13,6 +13,7 @@ use std::cell::Cell;
 use std::collections::hash_map::DefaultHasher;
 use std::hash::Hasher;
 use std::mem;
+use std::ptr;
 #[allow(deprecated)]
 use std::sync::atomic::ATOMIC_USIZE_INIT;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -113,7 +114,7 @@ impl Registry {
             .unzip();
 
         let registry = Arc::new(Registry {
-            thread_infos: stealers.into_iter().map(|s| ThreadInfo::new(s)).collect(),
+            thread_infos: stealers.into_iter().map(ThreadInfo::new).collect(),
             sleep: Sleep::new(),
             injected_jobs: SegQueue::new(),
             terminate_latch: CountLatch::new(),
@@ -462,7 +463,7 @@ impl ThreadInfo {
         ThreadInfo {
             primed: LockLatch::new(),
             stopped: LockLatch::new(),
-            stealer: stealer,
+            stealer,
         }
     }
 }
@@ -491,8 +492,7 @@ pub struct WorkerThread {
 // worker is fully unwound. Using an unsafe pointer avoids the need
 // for a RefCell<T> etc.
 thread_local! {
-    static WORKER_THREAD_STATE: Cell<*const WorkerThread> =
-        Cell::new(0 as *const WorkerThread)
+    static WORKER_THREAD_STATE: Cell<*const WorkerThread> = Cell::new(ptr::null());
 }
 
 impl WorkerThread {
@@ -501,7 +501,7 @@ impl WorkerThread {
     /// anywhere on the current thread.
     #[inline]
     pub fn current() -> *const WorkerThread {
-        WORKER_THREAD_STATE.with(|t| t.get())
+        WORKER_THREAD_STATE.with(Cell::get)
     }
 
     /// Sets `self` as the worker thread index for the current thread.
@@ -654,9 +654,9 @@ impl WorkerThread {
 
 unsafe fn main_loop(worker: Worker<JobRef>, registry: Arc<Registry>, index: usize) {
     let worker_thread = WorkerThread {
-        worker: worker,
+        worker,
         fifo: JobFifo::new(),
-        index: index,
+        index,
         rng: XorShift64Star::new(),
         registry: registry.clone(),
     };

rayon-core/src/thread_pool/internal.rs

@@ -31,7 +31,7 @@ impl ThreadPoolScopeHandle {
     /// Caller asserts that the registry has not yet terminated.
     unsafe fn new(registry: Arc<Registry>) -> Self {
         registry.increment_terminate_count();
-        ThreadPoolScopeHandle { registry: registry }
+        ThreadPoolScopeHandle { registry }
     }
 }
 

rayon-core/src/thread_pool/mod.rs

@@ -55,15 +55,15 @@ pub struct ThreadPool {
 
 pub fn build(builder: ThreadPoolBuilder) -> Result<ThreadPool, ThreadPoolBuildError> {
     let registry = try!(Registry::new(builder));
-    Ok(ThreadPool { registry: registry })
+    Ok(ThreadPool { registry })
 }
 
 impl ThreadPool {
     #[deprecated(note = "Use `ThreadPoolBuilder::build`")]
     #[allow(deprecated)]
     /// Deprecated in favor of `ThreadPoolBuilder::build`.
     pub fn new(configuration: Configuration) -> Result<ThreadPool, Box<Error>> {
-        build(configuration.into_builder()).map_err(|e| e.into())
+        build(configuration.into_builder()).map_err(Box::from)
     }
 
     /// Returns a handle to the global thread pool. This is the pool
@@ -166,13 +166,11 @@ impl ThreadPool {
     #[inline]
     pub fn current_thread_index(&self) -> Option<usize> {
         unsafe {
-            let curr = WorkerThread::current();
-            if curr.is_null() {
-                None
-            } else if (*curr).registry().id() != self.registry.id() {
-                None
+            let curr = WorkerThread::current().as_ref()?;
+            if curr.registry().id() == self.registry.id() {
+                Some(curr.index())
             } else {
-                Some((*curr).index())
+                None
             }
         }
     }
@@ -201,13 +199,11 @@ impl ThreadPool {
     #[inline]
     pub fn current_thread_has_pending_tasks(&self) -> Option<bool> {
         unsafe {
-            let curr = WorkerThread::current();
-            if curr.is_null() {
-                None
-            } else if (*curr).registry().id() != self.registry.id() {
-                None
-            } else {
+            let curr = WorkerThread::current().as_ref()?;
+            if curr.registry().id() == self.registry.id() {
                 Some(!(*curr).local_deque_is_empty())
+            } else {
+                None
             }
         }
     }

src/iter/chain.rs

@@ -28,7 +28,7 @@ where
     A: ParallelIterator,
     B: ParallelIterator<Item = A::Item>,
 {
-    Chain { a: a, b: b }
+    Chain { a, b }
 }
 
 impl<A, B> ParallelIterator for Chain<A, B>
@@ -92,8 +92,8 @@ where
     {
         let a_len = self.a.len();
         return self.a.with_producer(CallbackA {
-            callback: callback,
-            a_len: a_len,
+            callback,
+            a_len,
             b: self.b,
         });
 
@@ -114,11 +114,11 @@ where
             where
                 A: Producer<Item = B::Item>,
             {
-                return self.b.with_producer(CallbackB {
+                self.b.with_producer(CallbackB {
                     callback: self.callback,
                     a_len: self.a_len,
-                    a_producer: a_producer,
-                });
+                    a_producer,
+                })
             }
         }
 
@@ -164,11 +164,7 @@ where
     B: Producer<Item = A::Item>,
 {
     fn new(a_len: usize, a: A, b: B) -> Self {
-        ChainProducer {
-            a_len: a_len,
-            a: a,
-            b: b,
-        }
+        ChainProducer { a_len, a, b }
     }
 }
 

src/iter/chunks.rs

@@ -27,7 +27,7 @@ pub fn new<I>(i: I, size: usize) -> Chunks<I>
 where
     I: IndexedParallelIterator,
 {
-    Chunks { i: i, size: size }
+    Chunks { i, size }
 }
 
 impl<I> ParallelIterator for Chunks<I>
@@ -70,8 +70,8 @@ where
         let len = self.i.len();
         return self.i.with_producer(Callback {
             size: self.size,
-            len: len,
-            callback: callback,
+            len,
+            callback,
         });
 
         struct Callback<CB> {
@@ -93,7 +93,7 @@ where
                 self.callback.callback(ChunkProducer {
                     chunk_size: self.size,
                     len: self.len,
-                    base: base,
+                    base,
                 })
             }
         }

src/iter/cloned.rs

@@ -22,7 +22,7 @@ pub fn new<I>(base: I) -> Cloned<I>
 where
     I: ParallelIterator,
 {
-    Cloned { base: base }
+    Cloned { base }
 }
 
 impl<'a, T, I> ParallelIterator for Cloned<I>
@@ -66,7 +66,7 @@ where
     where
         CB: ProducerCallback<Self::Item>,
     {
-        return self.base.with_producer(Callback { callback: callback });
+        return self.base.with_producer(Callback { callback });
 
         struct Callback<CB> {
             callback: CB,
@@ -83,7 +83,7 @@ where
             where
                 P: Producer<Item = &'a T>,
             {
-                let producer = ClonedProducer { base: base };
+                let producer = ClonedProducer { base };
                 self.callback.callback(producer)
             }
         }
@@ -141,7 +141,7 @@ struct ClonedConsumer<C> {
 
 impl<C> ClonedConsumer<C> {
     fn new(base: C) -> Self {
-        ClonedConsumer { base: base }
+        ClonedConsumer { base }
     }
 }