Don't mask warnings, clean them up!

Cargo.toml

@@ -25,7 +25,7 @@ version = "1.0"
 default-features = false
 
 [dev-dependencies]
-compiletest_rs = "0.2.1"
+compiletest_rs = "0.3"
 docopt = "0.7"
 futures = "0.1.7"
 rand = "0.3"

rayon-core/src/join/mod.rs

@@ -1,5 +1,4 @@
 use latch::{LatchProbe, SpinLatch};
-#[allow(unused_imports)]
 use log::Event::*;
 use job::StackJob;
 use registry::{self, WorkerThread};

rayon-core/src/lib.rs

@@ -24,13 +24,6 @@
 #![deny(missing_debug_implementations)]
 #![cfg_attr(test, feature(conservative_impl_trait))]
 
-// If you're not compiling the unstable code, it often happens that
-// there is stuff that is considered "dead code" and so forth. So
-// disable warnings in that scenario.
-#![cfg_attr(not(rayon_unstable), allow(warnings))]
-
-#[allow(unused_imports)]
-use log::Event::*;
 use std::any::Any;
 use std::env;
 use std::error::Error;

rayon-core/src/registry.rs

@@ -1,10 +1,11 @@
 use ::{Configuration, ExitHandler, PanicHandler, StartHandler};
 use coco::deque::{self, Worker, Stealer};
-use job::{Job, JobRef, StackJob};
+use job::{JobRef, StackJob};
+#[cfg(rayon_unstable)]
+use job::Job;
 #[cfg(rayon_unstable)]
 use internal::task::Task;
 use latch::{LatchProbe, Latch, CountLatch, LockLatch, SpinLatch, TickleLatch};
-#[allow(unused_imports)]
 use log::Event::*;
 use rand::{self, Rng};
 use sleep::Sleep;
@@ -153,6 +154,7 @@ impl Registry {
         Ok(registry.clone())
     }
 
+    #[cfg(rayon_unstable)]
     pub fn global() -> Arc<Registry> {
         global_registry().clone()
     }
@@ -261,9 +263,8 @@ impl Registry {
 
         /// A little newtype wrapper for `T`, just because I did not
         /// want to implement `Job` for all `T: Task`.
-        #[allow(dead_code)]
         struct TaskJob<T: Task> {
-            data: T
+            _data: T
         }
 
         impl<T: Task> TaskJob<T> {

rayon-core/src/scope/internal.rs

@@ -1,11 +1,11 @@
-#[cfg(rayon_unstable)]
+#![cfg(rayon_unstable)]
+
 use internal::task::{ScopeHandle, ToScopeHandle, Task};
 use std::any::Any;
 use std::mem;
 use std::sync::Arc;
 use super::Scope;
 
-#[cfg(rayon_unstable)]
 impl<'scope> ToScopeHandle<'scope> for Scope<'scope> {
     type ScopeHandle = LocalScopeHandle<'scope>;
 
@@ -42,7 +42,6 @@ impl<'scope> Drop for LocalScopeHandle<'scope> {
 /// We assert that the `Self` type remains valid until a
 /// method is called, and that `'scope` will not end until
 /// that point.
-#[cfg(rayon_unstable)]
 unsafe impl<'scope> ScopeHandle<'scope> for LocalScopeHandle<'scope> {
     unsafe fn spawn_task<T: Task + 'scope>(&self, task: Arc<T>) {
         let scope = &*self.scope;

rayon-core/src/spawn/mod.rs

@@ -1,5 +1,3 @@
-#[allow(unused_imports)]
-use latch::{Latch, SpinLatch};
 use job::*;
 use registry::Registry;
 use std::mem;

rayon-core/src/thread_pool/internal.rs

@@ -1,12 +1,12 @@
-#[cfg(rayon_unstable)]
+#![cfg(rayon_unstable)]
+
 use internal::task::{ScopeHandle, ToScopeHandle, Task};
 use registry::Registry;
 use std::any::Any;
 use std::fmt;
 use std::sync::Arc;
 use super::ThreadPool;
 
-#[cfg(rayon_unstable)]
 impl ToScopeHandle<'static> for ThreadPool {
     type ScopeHandle = ThreadPoolScopeHandle;
 
@@ -52,7 +52,6 @@ impl Drop for ThreadPoolScopeHandle {
 /// (b) the lifetime `'static` will not end until a completion
 ///     method is called. This is true because `'static` doesn't
 ///     end until the end of the program.
-#[cfg(rayon_unstable)]
 unsafe impl ScopeHandle<'static> for ThreadPoolScopeHandle {
     unsafe fn spawn_task<T: Task + 'static>(&self, task: Arc<T>) {
         self.registry.submit_task(task);

rayon-core/src/thread_pool/mod.rs

@@ -1,6 +1,4 @@
 use Configuration;
-#[allow(unused_imports)]
-use log::Event::*;
 use join;
 use {scope, Scope};
 use spawn;

rayon-demo/src/tsp/mod.rs

@@ -3,8 +3,6 @@
 //! Based on code developed at ETH by Christoph von Praun, Florian
 //! Schneider, Nicholas Matsakis, and Thomas Gross.
 
-#![allow(dead_code)]
-
 use docopt::Docopt;
 use std::error::Error;
 use std::fs::File;

rayon-demo/src/tsp/weight.rs

@@ -37,15 +37,6 @@ impl Weight {
     pub fn to_priority(self) -> Priority {
         Priority { priority: usize::MAX - self.weight }
     }
-
-    pub fn average(self, w: Weight) -> Weight {
-        if self < w {
-            let half_diff = (w.weight - self.weight) / 2;
-            Weight::new(self.weight + half_diff)
-        } else {
-            w.average(self)
-        }
-    }
 }
 
 impl Add for Weight {

rayon-futures/Cargo.toml

@@ -16,4 +16,4 @@ rayon-core = { version = "1.2.2", path = "../rayon-core" }
 futures = "0.1.7"
 
 [dev-dependencies]
-compiletest_rs = "0.2.1"
+compiletest_rs = "0.3"

rayon-futures/src/test.rs

@@ -11,7 +11,7 @@ use rayon_core::{scope, ThreadPool, Configuration};
 use super::ScopeFutureExt;
 
 fn run_compiletest(mode: &str, path: &str) {
-    let mut config = compiletest::default_config();
+    let mut config = compiletest::Config::default();
     config.mode = mode.parse().ok().expect("Invalid mode");
     config.src_base = PathBuf::from(path);
     config.target_rustcflags = Some("-L ../target/debug/ -L ../target/debug/deps/".to_owned());

src/iter/internal.rs

@@ -4,7 +4,6 @@
 //! See `README.md` for a high-level overview.
 
 use join_context;
-use FnContext;
 
 use super::IndexedParallelIterator;
 

src/lib.rs

@@ -4,11 +4,6 @@
 #![cfg_attr(test, feature(conservative_impl_trait))]
 #![cfg_attr(test, feature(i128_type))]
 
-// If you're not compiling the unstable code, it often happens that
-// there is stuff that is considered "dead code" and so forth. So
-// disable warnings in that scenario.
-#![cfg_attr(not(rayon_unstable), allow(warnings))]
-
 //! Data-parallelism library that is easy to convert sequential computations into parallel.
 //!
 //! Rayon is lightweight and convenient for application to existing code.  It guarantees

src/slice/test.rs

@@ -2,7 +2,6 @@
 
 use rand::{thread_rng, Rng};
 use std::cmp::Ordering::{Equal, Greater, Less};
-use std::mem;
 use super::ParallelSliceMut;
 
 macro_rules! sort {

src/test.rs

@@ -5,7 +5,7 @@ extern crate compiletest_rs as compiletest;
 use std::path::PathBuf;
 
 fn run_compiletest(mode: &str, path: &str) {
-    let mut config = compiletest::default_config();
+    let mut config = compiletest::Config::default();
     config.mode = mode.parse().ok().expect("Invalid mode");
     config.src_base = PathBuf::from(path);
     config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/".to_owned());