Update Tokio to Rust 2018 (#1082)

tokio-sync/src/mpsc/block.rs

@@ -1,9 +1,8 @@
-use loom::{
+use crate::loom::{
     self,
     sync::atomic::{AtomicPtr, AtomicUsize},
     sync::CausalCell,
 };
-
 use std::mem::{self, ManuallyDrop};
 use std::ops;
 use std::ptr::{self, NonNull};

tokio-sync/src/mpsc/bounded.rs

@@ -1,7 +1,5 @@
 use super::chan;
-
 use futures::{Poll, Sink, StartSend, Stream};
-
 use std::fmt;
 
 /// Send values to the associated `Receiver`.
@@ -20,7 +18,7 @@ impl<T> Clone for Sender<T> {
 }
 
 impl<T> fmt::Debug for Sender<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Sender")
             .field("chan", &self.chan)
             .finish()
@@ -36,7 +34,7 @@ pub struct Receiver<T> {
 }
 
 impl<T> fmt::Debug for Receiver<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Receiver")
             .field("chan", &self.chan)
             .finish()
@@ -80,9 +78,6 @@ pub struct RecvError(());
 /// # Examples
 ///
 /// ```rust
-/// extern crate futures;
-/// extern crate tokio;
-///
 /// use tokio::sync::mpsc::channel;
 /// use tokio::prelude::*;
 /// use futures::future::lazy;
@@ -114,7 +109,7 @@ pub struct RecvError(());
 /// ```
 pub fn channel<T>(buffer: usize) -> (Sender<T>, Receiver<T>) {
     assert!(buffer > 0, "mpsc bounded channel requires buffer > 0");
-    let semaphore = (::semaphore::Semaphore::new(buffer), buffer);
+    let semaphore = (crate::semaphore::Semaphore::new(buffer), buffer);
     let (tx, rx) = chan::channel(semaphore);
 
     let tx = Sender::new(tx);
@@ -125,7 +120,7 @@ pub fn channel<T>(buffer: usize) -> (Sender<T>, Receiver<T>) {
 
 /// Channel semaphore is a tuple of the semaphore implementation and a `usize`
 /// representing the channel bound.
-type Semaphore = (::semaphore::Semaphore, usize);
+type Semaphore = (crate::semaphore::Semaphore, usize);
 
 impl<T> Receiver<T> {
     pub(crate) fn new(chan: chan::Rx<T, Semaphore>) -> Receiver<T> {
@@ -218,7 +213,7 @@ impl<T> Sink for Sender<T> {
 // ===== impl SendError =====
 
 impl fmt::Display for SendError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         use std::error::Error;
         write!(fmt, "{}", self.description())
     }
@@ -258,7 +253,7 @@ impl<T> TrySendError<T> {
 }
 
 impl<T: fmt::Debug> fmt::Display for TrySendError<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         use std::error::Error;
         write!(fmt, "{}", self.description())
     }
@@ -288,7 +283,7 @@ impl<T> From<(T, chan::TrySendError)> for TrySendError<T> {
 // ===== impl RecvError =====
 
 impl fmt::Display for RecvError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         use std::error::Error;
         write!(fmt, "{}", self.description())
     }

tokio-sync/src/mpsc/chan.rs

@@ -1,12 +1,10 @@
 use super::list;
-use futures::Poll;
-
-use loom::{
+use crate::loom::{
     futures::AtomicTask,
     sync::atomic::AtomicUsize,
     sync::{Arc, CausalCell},
 };
-
+use futures::Poll;
 use std::fmt;
 use std::process;
 use std::sync::atomic::Ordering::{AcqRel, Relaxed};
@@ -22,7 +20,7 @@ where
     S::Permit: fmt::Debug,
     S: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Tx")
             .field("inner", &self.inner)
             .field("permit", &self.permit)
@@ -39,7 +37,7 @@ impl<T, S: Semaphore> fmt::Debug for Rx<T, S>
 where
     S: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Rx").field("inner", &self.inner).finish()
     }
 }
@@ -99,7 +97,7 @@ impl<T, S> fmt::Debug for Chan<T, S>
 where
     S: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Chan")
             .field("tx", &self.tx)
             .field("semaphore", &self.semaphore)
@@ -120,7 +118,7 @@ struct RxFields<T> {
 }
 
 impl<T> fmt::Debug for RxFields<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("RxFields")
             .field("list", &self.list)
             .field("rx_closed", &self.rx_closed)
@@ -337,7 +335,7 @@ impl<T, S> Drop for Chan<T, S> {
     }
 }
 
-use semaphore::TryAcquireError;
+use crate::semaphore::TryAcquireError;
 
 impl From<TryAcquireError> for TrySendError {
     fn from(src: TryAcquireError) -> TrySendError {
@@ -353,9 +351,9 @@ impl From<TryAcquireError> for TrySendError {
 
 // ===== impl Semaphore for (::Semaphore, capacity) =====
 
-use semaphore::Permit;
+use crate::semaphore::Permit;
 
-impl Semaphore for (::semaphore::Semaphore, usize) {
+impl Semaphore for (crate::semaphore::Semaphore, usize) {
     type Permit = Permit;
 
     fn new_permit() -> Permit {

tokio-sync/src/mpsc/list.rs

@@ -1,12 +1,10 @@
 //! A concurrent, lock-free, FIFO list.
 
 use super::block::{self, Block};
-
-use loom::{
+use crate::loom::{
     self,
     sync::atomic::{AtomicPtr, AtomicUsize},
 };
-
 use std::fmt;
 use std::ptr::NonNull;
 use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed, Release};
@@ -214,7 +212,7 @@ impl<T> Tx<T> {
 }
 
 impl<T> fmt::Debug for Tx<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Tx")
             .field("block_tail", &self.block_tail.load(Relaxed))
             .field("tail_position", &self.tail_position.load(Relaxed))
@@ -339,7 +337,7 @@ impl<T> Rx<T> {
 }
 
 impl<T> fmt::Debug for Rx<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Rx")
             .field("head", &self.head)
             .field("index", &self.index)

tokio-sync/src/mpsc/mod.rs

@@ -41,14 +41,12 @@ mod list;
 mod unbounded;
 
 pub use self::bounded::{channel, Receiver, Sender};
-
 pub use self::unbounded::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 
 pub mod error {
     //! Channel error types
 
     pub use super::bounded::{RecvError, SendError, TrySendError};
-
     pub use super::unbounded::{UnboundedRecvError, UnboundedSendError, UnboundedTrySendError};
 }
 

tokio-sync/src/mpsc/unbounded.rs

@@ -1,8 +1,6 @@
 use super::chan;
-
+use crate::loom::sync::atomic::AtomicUsize;
 use futures::{Poll, Sink, StartSend, Stream};
-use loom::sync::atomic::AtomicUsize;
-
 use std::fmt;
 
 /// Send values to the associated `UnboundedReceiver`.
@@ -22,7 +20,7 @@ impl<T> Clone for UnboundedSender<T> {
 }
 
 impl<T> fmt::Debug for UnboundedSender<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("UnboundedSender")
             .field("chan", &self.chan)
             .finish()
@@ -39,7 +37,7 @@ pub struct UnboundedReceiver<T> {
 }
 
 impl<T> fmt::Debug for UnboundedReceiver<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("UnboundedReceiver")
             .field("chan", &self.chan)
             .finish()
@@ -140,7 +138,7 @@ impl<T> Sink for UnboundedSender<T> {
 // ===== impl UnboundedSendError =====
 
 impl fmt::Display for UnboundedSendError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         use std::error::Error;
         write!(fmt, "{}", self.description())
     }
@@ -162,7 +160,7 @@ impl<T> UnboundedTrySendError<T> {
 }
 
 impl<T: fmt::Debug> fmt::Display for UnboundedTrySendError<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         use std::error::Error;
         write!(fmt, "{}", self.description())
     }
@@ -184,7 +182,7 @@ impl<T> From<(T, chan::TrySendError)> for UnboundedTrySendError<T> {
 // ===== impl UnboundedRecvError =====
 
 impl fmt::Display for UnboundedRecvError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         use std::error::Error;
         write!(fmt, "{}", self.description())
     }