chore: apply rustfmt to all crates (#917)

tokio-current-thread/src/scheduler.rs

@@ -1,20 +1,20 @@
 use super::Borrow;
-use tokio_executor::Enter;
 use tokio_executor::park::Unpark;
+use tokio_executor::Enter;
 
-use futures::{Future, Async};
-use futures::executor::{self, Spawn, UnsafeNotify, NotifyHandle};
+use futures::executor::{self, NotifyHandle, Spawn, UnsafeNotify};
+use futures::{Async, Future};
 
 use std::cell::UnsafeCell;
 use std::fmt::{self, Debug};
+use std::marker::PhantomData;
 use std::mem;
 use std::ptr;
-use std::sync::atomic::Ordering::{Relaxed, SeqCst, Acquire, Release, AcqRel};
+use std::sync::atomic::Ordering::{AcqRel, Acquire, Relaxed, Release, SeqCst};
 use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize};
 use std::sync::{Arc, Weak};
-use std::usize;
 use std::thread;
-use std::marker::PhantomData;
+use std::usize;
 
 /// A generic task-aware scheduler.
 ///
@@ -135,7 +135,8 @@ pub struct Scheduled<'a, U: 'a> {
 }
 
 impl<U> Scheduler<U>
-where U: Unpark,
+where
+    U: Unpark,
 {
     /// Constructs a new, empty `Scheduler`
     ///
@@ -200,9 +201,7 @@ where U: Unpark,
     pub fn has_pending_futures(&mut self) -> bool {
         // See function definition for why the unsafe is needed and
         // correctly used here
-        unsafe {
-            self.inner.has_pending_futures()
-        }
+        unsafe { self.inner.has_pending_futures() }
     }
 
     /// Advance the scheduler state, returning `true` if any futures were
@@ -210,11 +209,9 @@ where U: Unpark,
     ///
     /// This function should be called whenever the caller is notified via a
     /// wakeup.
-    pub fn tick(&mut self, eid: u64, enter: &mut Enter, num_futures: &AtomicUsize) -> bool
-    {
+    pub fn tick(&mut self, eid: u64, enter: &mut Enter, num_futures: &AtomicUsize) -> bool {
         let mut ret = false;
-        let tick = self.inner.tick_num.fetch_add(1, SeqCst)
-            .wrapping_add(1);
+        let tick = self.inner.tick_num.fetch_add(1, SeqCst).wrapping_add(1);
 
         loop {
             let node = match unsafe { self.inner.dequeue(Some(tick)) } {
@@ -246,7 +243,7 @@ where U: Unpark,
                     let node = ptr2arc(node);
                     assert!((*node.next_all.get()).is_null());
                     assert!((*node.prev_all.get()).is_null());
-                    continue
+                    continue;
                 };
 
                 // We're going to need to be very careful if the `poll`
@@ -369,8 +366,7 @@ impl Task {
 
 impl fmt::Debug for Task {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Task")
-            .finish()
+        fmt.debug_struct("Task").finish()
     }
 }
 
@@ -580,7 +576,7 @@ impl<U> List<U> {
 
         self.len += 1;
 
-        return ptr
+        return ptr;
     }
 
     /// Pop an element from the front of the list
@@ -632,7 +628,7 @@ impl<U> List<U> {
 
         self.len -= 1;
 
-        return node
+        return node;
     }
 }
 
@@ -749,7 +745,7 @@ impl<U> Drop for Node<U> {
 fn arc2ptr<T>(ptr: Arc<T>) -> *const T {
     let addr = &*ptr as *const T;
     mem::forget(ptr);
-    return addr
+    return addr;
 }
 
 unsafe fn ptr2arc<T>(ptr: *const T) -> Arc<T> {