threadpool: update to Rust 2018

tokio-threadpool/Cargo.toml

@@ -9,6 +9,7 @@ name = "tokio-threadpool"
 # - Update CHANGELOG.md.
 # - Create "v0.1.x" git tag.
 version = "0.1.14"
+edition = "2018"
 documentation = "https://docs.rs/tokio-threadpool/0.1.14/tokio_threadpool"
 repository = "https://github.com/tokio-rs/tokio"
 homepage = "https://github.com/tokio-rs/tokio"
@@ -19,6 +20,7 @@ A task scheduler backed by a work-stealing thread pool.
 """
 keywords = ["futures", "tokio"]
 categories = ["concurrency", "asynchronous"]
+publish = false
 
 [dependencies]
 tokio-executor = "0.1.7"

tokio-threadpool/benches/basic.rs

@@ -1,11 +1,7 @@
 #![feature(test)]
-#![deny(warnings)]
+#![deny(warnings, rust_2018_idioms)]
 
-extern crate futures;
-extern crate futures_cpupool;
-extern crate num_cpus;
 extern crate test;
-extern crate tokio_threadpool;
 
 const NUM_SPAWN: usize = 10_000;
 const NUM_YIELD: usize = 1_000;
@@ -14,11 +10,10 @@ const TASKS_PER_CPU: usize = 50;
 mod threadpool {
     use futures::{future, task, Async};
     use num_cpus;
+    use tokio_threadpool::*;
     use std::sync::atomic::AtomicUsize;
     use std::sync::atomic::Ordering::SeqCst;
     use std::sync::{mpsc, Arc};
-    use test;
-    use tokio_threadpool::*;
 
     #[bench]
     fn spawn_many(b: &mut test::Bencher) {
@@ -97,7 +92,6 @@ mod cpupool {
     use std::sync::atomic::AtomicUsize;
     use std::sync::atomic::Ordering::SeqCst;
     use std::sync::{mpsc, Arc};
-    use test;
 
     #[bench]
     fn spawn_many(b: &mut test::Bencher) {

tokio-threadpool/benches/blocking.rs

@@ -1,17 +1,12 @@
 #![feature(test)]
-#![deny(warnings)]
+#![deny(warnings, rust_2018_idioms)]
 
-extern crate futures;
-extern crate rand;
 extern crate test;
-extern crate threadpool;
-extern crate tokio_threadpool;
 
 const ITER: usize = 1_000;
 
 mod blocking {
     use super::*;
-
     use futures::future::*;
     use tokio_threadpool::{blocking, Builder};
 
@@ -20,9 +15,9 @@ mod blocking {
         let pool = Builder::new().pool_size(2).max_blocking(20).build();
 
         b.iter(|| {
-            let count_down = Arc::new(CountDown::new(::ITER));
+            let count_down = Arc::new(CountDown::new(ITER));
 
-            for _ in 0..::ITER {
+            for _ in 0..ITER {
                 let count_down = count_down.clone();
 
                 pool.spawn(lazy(move || {
@@ -42,7 +37,6 @@ mod blocking {
 
 mod message_passing {
     use super::*;
-
     use futures::future::*;
     use futures::sync::oneshot;
     use tokio_threadpool::Builder;
@@ -54,9 +48,9 @@ mod message_passing {
         let blocking = threadpool::ThreadPool::new(20);
 
         b.iter(|| {
-            let count_down = Arc::new(CountDown::new(::ITER));
+            let count_down = Arc::new(CountDown::new(ITER));
 
-            for _ in 0..::ITER {
+            for _ in 0..ITER {
                 let count_down = count_down.clone();
                 let blocking = blocking.clone();
 

tokio-threadpool/benches/depth.rs

@@ -1,18 +1,13 @@
 #![feature(test)]
-#![deny(warnings)]
+#![deny(warnings, rust_2018_idioms)]
 
-extern crate futures;
-extern crate futures_cpupool;
-extern crate num_cpus;
 extern crate test;
-extern crate tokio_threadpool;
 
 const ITER: usize = 20_000;
 
 mod us {
     use futures::future;
     use std::sync::mpsc;
-    use test;
     use tokio_threadpool::*;
 
     #[bench]
@@ -47,7 +42,6 @@ mod cpupool {
     use futures_cpupool::*;
     use num_cpus;
     use std::sync::mpsc;
-    use test;
 
     #[bench]
     fn chained_spawn(b: &mut test::Bencher) {

tokio-threadpool/src/blocking.rs

@@ -1,7 +1,5 @@
-use worker::Worker;
-
-use futures::Poll;
-
+use crate::worker::Worker;
+use futures::{try_ready, Poll};
 use std::error::Error;
 use std::fmt;
 
@@ -157,13 +155,13 @@ where
 }
 
 impl fmt::Display for BlockingError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "{}", self.description())
     }
 }
 
 impl fmt::Debug for BlockingError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("BlockingError")
             .field("reason", &self.description())
             .finish()

tokio-threadpool/src/builder.rs

@@ -1,23 +1,22 @@
-use callback::Callback;
-use config::{Config, MAX_WORKERS};
-use park::{BoxPark, BoxedPark, DefaultPark};
-use pool::{Pool, MAX_BACKUP};
-use shutdown::ShutdownTrigger;
-use thread_pool::ThreadPool;
-use worker::{self, Worker, WorkerId};
-
+use crate::callback::Callback;
+use crate::config::{Config, MAX_WORKERS};
+use crate::park::{BoxPark, BoxedPark, DefaultPark};
+use crate::pool::{Pool, MAX_BACKUP};
+use crate::shutdown::ShutdownTrigger;
+use crate::thread_pool::ThreadPool;
+use crate::worker::{self, Worker, WorkerId};
+use crossbeam_deque::Injector;
+use log::trace;
+use num_cpus;
+use tokio_executor::park::Park;
+use tokio_executor::Enter;
 use std::any::Any;
 use std::cmp::max;
 use std::error::Error;
 use std::fmt;
 use std::sync::Arc;
 use std::time::Duration;
 
-use crossbeam_deque::Injector;
-use num_cpus;
-use tokio_executor::park::Park;
-use tokio_executor::Enter;
-
 /// Builds a thread pool with custom configuration values.
 ///
 /// Methods can be chained in order to set the configuration values. The thread
@@ -67,7 +66,7 @@ pub struct Builder {
     max_blocking: usize,
 
     /// Generates the `Park` instances
-    new_park: Box<Fn(&WorkerId) -> BoxPark>,
+    new_park: Box<dyn Fn(&WorkerId) -> BoxPark>,
 }
 
 impl Builder {
@@ -223,7 +222,7 @@ impl Builder {
     /// ```
     pub fn panic_handler<F>(&mut self, f: F) -> &mut Self
     where
-        F: Fn(Box<Any + Send>) + Send + Sync + 'static,
+        F: Fn(Box<dyn Any + Send>) + Send + Sync + 'static,
     {
         self.config.panic_handler = Some(Arc::new(f));
         self
@@ -466,7 +465,7 @@ impl Builder {
 }
 
 impl fmt::Debug for Builder {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Builder")
             .field("config", &self.config)
             .field("pool_size", &self.pool_size)

tokio-threadpool/src/callback.rs

@@ -1,13 +1,11 @@
-use worker::Worker;
-
+use crate::worker::Worker;
+use tokio_executor::Enter;
 use std::fmt;
 use std::sync::Arc;
 
-use tokio_executor::Enter;
-
 #[derive(Clone)]
 pub(crate) struct Callback {
-    f: Arc<Fn(&Worker, &mut Enter) + Send + Sync>,
+    f: Arc<dyn Fn(&Worker, &mut Enter) + Send + Sync>,
 }
 
 impl Callback {
@@ -24,7 +22,7 @@ impl Callback {
 }
 
 impl fmt::Debug for Callback {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "Fn")
     }
 }

tokio-threadpool/src/config.rs

@@ -1,5 +1,4 @@
-use callback::Callback;
-
+use crate::callback::Callback;
 use std::any::Any;
 use std::fmt;
 use std::sync::Arc;
@@ -13,9 +12,9 @@ pub(crate) struct Config {
     pub name_prefix: Option<String>,
     pub stack_size: Option<usize>,
     pub around_worker: Option<Callback>,
-    pub after_start: Option<Arc<Fn() + Send + Sync>>,
-    pub before_stop: Option<Arc<Fn() + Send + Sync>>,
-    pub panic_handler: Option<Arc<Fn(Box<Any + Send>) + Send + Sync>>,
+    pub after_start: Option<Arc<dyn Fn() + Send + Sync>>,
+    pub before_stop: Option<Arc<dyn Fn() + Send + Sync>>,
+    pub panic_handler: Option<Arc<dyn Fn(Box<dyn Any + Send>) + Send + Sync>>,
 }
 
 /// Max number of workers that can be part of a pool. This is the most that can
@@ -24,7 +23,7 @@ pub(crate) struct Config {
 pub(crate) const MAX_WORKERS: usize = 1 << 15;
 
 impl fmt::Debug for Config {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Config")
             .field("keep_alive", &self.keep_alive)
             .field("name_prefix", &self.name_prefix)

tokio-threadpool/src/lib.rs

@@ -1,5 +1,6 @@
 #![doc(html_root_url = "https://docs.rs/tokio-threadpool/0.1.14")]
-#![deny(warnings, missing_docs, missing_debug_implementations)]
+#![deny(missing_docs, missing_debug_implementations, rust_2018_idioms)]
+#![cfg_attr(test, deny(warnings))]
 
 //! A work-stealing based thread pool for executing futures.
 //!
@@ -77,20 +78,6 @@
 //! [`blocking`]: fn.blocking.html
 //! [`runtime`]: https://docs.rs/tokio/0.1/tokio/runtime/
 
-extern crate tokio_executor;
-
-extern crate crossbeam_deque;
-extern crate crossbeam_queue;
-extern crate crossbeam_utils;
-#[macro_use]
-extern crate futures;
-extern crate num_cpus;
-extern crate rand;
-extern crate slab;
-
-#[macro_use]
-extern crate log;
-
 // ## Crate layout
 //
 // The primary type, `Pool`, holds the majority of a thread pool's state,
@@ -155,9 +142,9 @@ mod task;
 mod thread_pool;
 mod worker;
 
-pub use blocking::{blocking, BlockingError};
-pub use builder::Builder;
-pub use sender::Sender;
-pub use shutdown::Shutdown;
-pub use thread_pool::{SpawnHandle, ThreadPool};
-pub use worker::{Worker, WorkerId};
+pub use crate::blocking::{blocking, BlockingError};
+pub use crate::builder::Builder;
+pub use crate::sender::Sender;
+pub use crate::shutdown::Shutdown;
+pub use crate::thread_pool::{SpawnHandle, ThreadPool};
+pub use crate::worker::{Worker, WorkerId};

tokio-threadpool/src/notifier.rs

@@ -1,12 +1,11 @@
-use pool::Pool;
-use task::Task;
-
+use crate::pool::Pool;
+use crate::task::Task;
+use futures::executor::Notify;
+use log::trace;
 use std::mem;
 use std::ops;
 use std::sync::Arc;
 
-use futures::executor::Notify;
-
 /// Implements the future `Notify` API.
 ///
 /// This is how external events are able to signal the task, informing it to try

tokio-threadpool/src/park/boxed.rs

@@ -1,10 +1,10 @@
+use log::warn;
 use tokio_executor::park::{Park, Unpark};
-
 use std::error::Error;
 use std::time::Duration;
 
-pub(crate) type BoxPark = Box<Park<Unpark = BoxUnpark, Error = ()> + Send>;
-pub(crate) type BoxUnpark = Box<Unpark>;
+pub(crate) type BoxPark = Box<dyn Park<Unpark = BoxUnpark, Error = ()> + Send>;
+pub(crate) type BoxUnpark = Box<dyn Unpark>;
 
 pub(crate) struct BoxedPark<T>(T);
 

tokio-threadpool/src/park/default_park.rs

@@ -1,11 +1,9 @@
 use tokio_executor::park::{Park, Unpark};
-
+use crossbeam_utils::sync::{Parker, Unparker};
 use std::error::Error;
 use std::fmt;
 use std::time::Duration;
 
-use crossbeam_utils::sync::{Parker, Unparker};
-
 /// Parks the thread.
 #[derive(Debug)]
 pub struct DefaultPark {
@@ -85,7 +83,7 @@ impl Unpark for DefaultUnpark {
 // ===== impl ParkError =====
 
 impl fmt::Display for ParkError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.description().fmt(fmt)
     }
 }

tokio-threadpool/src/pool/backup.rs

@@ -1,5 +1,5 @@
-use park::DefaultPark;
-use worker::WorkerId;
+use crate::park::DefaultPark;
+use crate::worker::WorkerId;
 
 use std::cell::UnsafeCell;
 use std::fmt;
@@ -298,7 +298,7 @@ impl From<State> for usize {
 }
 
 impl fmt::Debug for State {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("backup::State")
             .field("is_pushed", &self.is_pushed())
             .field("is_running", &self.is_running())

tokio-threadpool/src/pool/backup_stack.rs

@@ -1,4 +1,4 @@
-use pool::{Backup, BackupId};
+use crate::pool::{Backup, BackupId};
 
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::{AcqRel, Acquire};