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/catch_unwind.rs

@@ -29,7 +29,7 @@ impl<Fut> Future for CatchUnwind<Fut>
     type Output = Result<Fut::Output, Box<dyn Any + Send>>;
 
     fn poll(self: Pin<&mut Self>, waker: &Waker) -> Poll<Self::Output> {
-        match catch_unwind(AssertUnwindSafe(|| self.future().poll(lw))) {
+        match catch_unwind(AssertUnwindSafe(|| self.future().poll(waker))) {
             Ok(res) => res.map(Ok),
             Err(e) => Poll::Ready(Err(e))
         }

futures-util/src/future/join_all.rs

@@ -135,7 +135,7 @@ where
 
         for mut elem in iter_pin_mut(self.elems.as_mut()) {
             if let Some(pending) = elem.as_mut().pending_pin_mut() {
-                if let Poll::Ready(output) = pending.poll(lw) {
+                if let Poll::Ready(output) = pending.poll(waker) {
                     elem.set(ElemState::Done(Some(output)));
                 } else {
                     all_done = false;

futures-util/src/future/shared.rs

@@ -1,6 +1,6 @@
-use crate::task::local_waker_ref_from_nonlocal;
+use crate::task::{ArcWake, waker_ref};
 use futures_core::future::{FusedFuture, Future};
-use futures_core::task::{Waker, Poll, ArcWake};
+use futures_core::task::{Waker, Poll};
 use slab::Slab;
 use std::cell::UnsafeCell;
 use std::fmt;
@@ -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);
@@ -216,7 +216,7 @@ where
             _ => unreachable!(),
         }
 
-        let waker = local_waker_ref_from_nonlocal(&inner.notifier);
+        let waker = waker_ref(&inner.notifier);
         let waker = &waker;
 
         struct Reset<'a>(&'a AtomicUsize);

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) };