Fix remaining compilation errors

Author: Matthias247

futures-core/src/task/mod.rs

@@ -6,4 +6,3 @@ pub mod __internal;
 pub use self::spawn::{Spawn, LocalSpawn, SpawnError};
 
 pub use core::task::{Poll, Waker, RawWaker, RawWakerVTable};
-pub use self::Waker as LocalWaker;

futures-executor/src/local_pool.rs

@@ -67,7 +67,7 @@ fn run_executor<T, F: FnMut(&Waker) -> Poll<T>>(mut f: F) -> T {
                  another executor");
 
     CURRENT_THREAD_NOTIFY.with(|thread_notify| {
-        let waker: WakerRef = unsafe { waker_ref(thread_notify) };
+        let waker: WakerRef = waker_ref(thread_notify);
         loop {
             if let Poll::Ready(t) = f(&waker) {
                 return t;

futures-executor/src/thread_pool.rs

@@ -1,9 +1,9 @@
 use crate::enter;
 use crate::unpark_mutex::UnparkMutex;
 use futures_core::future::{Future, FutureObj};
-use futures_core::task::{Poll, ArcWake, Spawn, SpawnError};
+use futures_core::task::{Poll, Spawn, SpawnError};
 use futures_util::future::FutureExt;
-use futures_util::task::waker_ref;
+use futures_util::task::{ArcWake, waker_ref};
 use num_cpus;
 use std::io;
 use std::prelude::v1::*;

futures-test/src/task/panic_waker.rs

@@ -13,10 +13,6 @@ unsafe fn wake_panic(_data: *const()) {
     panic!("should not be woken");
 }
 
-unsafe fn noop_into_waker(_data: *const()) -> Option<RawWaker> {
-    Some(raw_panic_waker())
-}
-
 const PANIC_WAKER_VTABLE: RawWakerVTable = RawWakerVTable {
     clone: noop_clone,
     drop_fn: noop,

futures-test/src/task/wake_counter.rs

@@ -1,4 +1,4 @@
-use futures_core::task::{local_waker_from_nonlocal, Waker, Wake};
+use futures_core::task::{Waker};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use futures_util::task::ArcWake;

futures-util/src/future/shared.rs

@@ -126,7 +126,7 @@ where
         };
 
         if self.waker_key == NULL_WAKER_KEY {
-            self.waker_key = wakers.insert(Some(waker.clone().into_waker()));
+            self.waker_key = wakers.insert(Some(waker.clone()));
         } else {
             let waker_slot = &mut wakers[self.waker_key];
             let needs_replacement = if let Some(_old_waker) = waker_slot {
@@ -139,7 +139,7 @@ where
                 true
             };
             if needs_replacement {
-                *waker_slot = Some(waker.clone().into_waker());
+                *waker_slot = Some(waker.clone());
             }
         }
         debug_assert!(self.waker_key != NULL_WAKER_KEY);

futures-util/src/lock/mutex.rs

@@ -40,7 +40,7 @@ impl Waiter {
     fn register(&mut self, waker: &Waker) {
         match self {
             Waiter::Waiting(waker) if waker.will_wake(waker) => {},
-            _ => *self = Waiter::Waiting(waker.clone().into_waker()),
+            _ => *self = Waiter::Waiting(waker.clone()),
         }
     }
 

futures-util/src/stream/futures_unordered/mod.rs

@@ -1,6 +1,6 @@
 //! An unbounded set of futures.
 
-use crate::task::AtomicWaker;
+use crate::task::{AtomicWaker};
 use futures_core::future::{Future, FutureObj, LocalFutureObj};
 use futures_core::stream::{FusedStream, Stream};
 use futures_core::task::{Waker, Poll, Spawn, LocalSpawn, SpawnError};
@@ -402,7 +402,7 @@ impl<Fut: Future> Stream for FuturesUnordered<Fut> {
             // the internal allocation, appropriately accessing fields and
             // deallocating the task if need be.
             let res = {
-                let waker = Task::local_waker(bomb.task.as_ref().unwrap());
+                let waker = Task::waker_ref(bomb.task.as_ref().unwrap());
 
                 // Safety: We won't move the future ever again
                 let future = unsafe { Pin::new_unchecked(future) };

futures-util/src/stream/futures_unordered/task.rs

@@ -3,7 +3,7 @@ use std::sync::{Arc, Weak};
 use std::sync::atomic::{AtomicPtr, AtomicBool};
 use std::sync::atomic::Ordering::SeqCst;
 
-use crate::task::{ArcWake};
+use crate::task::{ArcWake, WakerRef, waker_ref};
 use super::ReadyToRunQueue;
 use super::abort::abort;
 
@@ -62,6 +62,13 @@ impl<Fut> ArcWake for Task<Fut> {
     }
 }
 
+impl<Fut> Task<Fut> {
+    /// Returns a waker reference for this task without cloning the Arc.
+    pub(super) fn waker_ref<'a>(this: &'a Arc<Task<Fut>>) -> WakerRef<'a> {
+        waker_ref(this)
+    }
+}
+
 impl<Fut> Drop for Task<Fut> {
     fn drop(&mut self) {
         // Since `Task<Fut>` is sent across all threads for any lifetime,

futures-util/src/task/arc_wake.rs

@@ -1,13 +1,23 @@
 use std::sync::Arc;
 use std::task::{Waker, RawWaker, RawWakerVTable};
 
+macro_rules! waker_vtable {
+    ($ty:ident) => {
+        &RawWakerVTable {
+            clone: clone_arc_raw::<$ty>,
+            drop_fn: drop_arc_raw::<$ty>,
+            wake: wake_arc_raw::<$ty>,
+        }
+    };
+}
+
 /// A way of waking up a specific task.
 ///
 /// By implementing this trait, types that are expected to be wrapped in an `Arc`
 /// can be converted into `Waker` objects.
 /// Those Wakers can be used to signal executors that a task it owns
 /// is ready to be `poll`ed again.
-pub trait ArcWake: Send + Sync {
+pub trait ArcWake {
     /// Indicates that the associated task is ready to make progress and should
     /// be `poll`ed.
     ///
@@ -30,21 +40,11 @@ pub trait ArcWake: Send + Sync {
             Waker::new_unchecked(RawWaker{
                 data: ptr,
                 vtable: waker_vtable!(Self),
-            }
+            })
         }
     }
 }
 
-macro_rules! waker_vtable {
-    ($ty:ident) => {
-        &RawWakerVTable {
-            clone: clone_arc_raw::<$ty>,
-            drop_fn: drop_arc_raw::<$ty>,
-            wake: wake_arc_raw::<$ty>,
-        }
-    };
-}
-
 unsafe fn increase_refcount<T: ArcWake>(data: *const()) {
     // Retain Arc by creating a copy
     let arc: Arc<T> = Arc::from_raw(data as *const T);
@@ -76,6 +76,7 @@ unsafe fn wake_arc_raw<T: ArcWake>(data: *const()) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::sync::Mutex;
 
     struct CountingWaker {
         nr_wake: Mutex<i32>,
@@ -106,6 +107,7 @@ mod tests {
 
         let w1: Waker = ArcWake::into_waker(some_w.clone());
         assert_eq!(2, Arc::strong_count(&some_w));
+        w1.wake();
         assert_eq!(1, some_w.wakes());
 
         let w2 = w1.clone();