Rename noop/panic waker and fix other compilation issue

Author: Matthias247

.travis.yml

@@ -25,7 +25,7 @@ matrix:
 
     # When updating this, the reminder to update the minimum required version in README.md.
     - name: cargo test (minimum required version)
-      rust: nightly-2019-01-11
+      rust: nightly-2019-02-15
 
     - name: cargo clippy
       rust: nightly

README.md

@@ -39,7 +39,7 @@ Now, you can use futures-rs:
 use futures::future::Future; // Note: It's not `futures_preview`
 ```
 
-The current version of futures-rs requires Rust nightly 2019-01-11 or later.
+The current version of futures-rs requires Rust nightly 2019-02-15 or later.
 
 ### Feature `std`
 

futures-channel/benches/sync_mpsc.rs

@@ -11,14 +11,14 @@ use {
         sink::Sink,
         task::{Waker, Poll},
     },
-    futures_test::task::noop_local_waker_ref,
+    futures_test::task::noop_waker_ref,
     std::pin::Pin,
 };
 
 /// Single producer, single consumer
 #[bench]
 fn unbounded_1_tx(b: &mut Bencher) {
-    let waker = noop_local_waker_ref();
+    let waker = noop_waker_ref();
     b.iter(|| {
         let (tx, mut rx) = mpsc::unbounded();
 
@@ -40,7 +40,7 @@ fn unbounded_1_tx(b: &mut Bencher) {
 /// 100 producers, single consumer
 #[bench]
 fn unbounded_100_tx(b: &mut Bencher) {
-    let waker = noop_local_waker_ref();
+    let waker = noop_waker_ref();
     b.iter(|| {
         let (tx, mut rx) = mpsc::unbounded();
 
@@ -61,7 +61,7 @@ fn unbounded_100_tx(b: &mut Bencher) {
 
 #[bench]
 fn unbounded_uncontended(b: &mut Bencher) {
-    let waker = noop_local_waker_ref();
+    let waker = noop_waker_ref();
     b.iter(|| {
         let (tx, mut rx) = mpsc::unbounded();
 
@@ -101,7 +101,7 @@ impl Stream for TestSender {
 /// Single producers, single consumer
 #[bench]
 fn bounded_1_tx(b: &mut Bencher) {
-    let waker = noop_local_waker_ref();
+    let waker = noop_waker_ref();
     b.iter(|| {
         let (tx, mut rx) = mpsc::channel(0);
 
@@ -118,7 +118,7 @@ fn bounded_1_tx(b: &mut Bencher) {
 /// 100 producers, single consumer
 #[bench]
 fn bounded_100_tx(b: &mut Bencher) {
-    let waker = noop_local_waker_ref();
+    let waker = noop_waker_ref();
     b.iter(|| {
         // Each sender can send one item after specified capacity
         let (tx, mut rx) = mpsc::channel(0);

futures-channel/src/mpsc/mod.rs

@@ -649,12 +649,12 @@ impl<T> Sender<T> {
     /// - `Err(SendError)` if the receiver has been dropped.
     pub fn poll_ready(
         &mut self,
-        lw: &LocalWaker
+        waker: &Waker
     ) -> Poll<Result<(), SendError>> {
         let inner = self.0.as_mut().ok_or(SendError {
             kind: SendErrorKind::Disconnected,
         })?;
-        inner.poll_ready(lw)
+        inner.poll_ready(waker)
     }
 
     /// Returns whether this channel is closed without needing a context.

futures-channel/tests/mpsc.rs

@@ -6,7 +6,7 @@ use futures::future::{FutureExt, poll_fn};
 use futures::stream::{Stream, StreamExt};
 use futures::sink::{Sink, SinkExt};
 use futures::task::Poll;
-use futures_test::task::noop_local_waker_ref;
+use futures_test::task::noop_waker_ref;
 use pin_utils::pin_mut;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -304,7 +304,7 @@ fn stress_receiver_multi_task_bounded_hard() {
                     } else {
                         // Just poll
                         let n = n.clone();
-                        match rx.poll_next_unpin(noop_local_waker_ref()) {
+                        match rx.poll_next_unpin(noop_waker_ref()) {
                             Poll::Ready(Some(_)) => {
                                 n.fetch_add(1, Ordering::Relaxed);
                             }

futures-executor/benches/thread_notify.rs

@@ -89,7 +89,7 @@ fn thread_yield_multi_thread(b: &mut Bencher) {
                 Poll::Ready(())
             } else {
                 self.rem -= 1;
-                self.tx.send(waker.clone().into_waker()).unwrap();
+                self.tx.send(waker.clone()).unwrap();
                 Poll::Pending
             }
         }

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 = waker_ref(thread_notify);
+        let waker: WakerRef<'_> = waker_ref(thread_notify);
         loop {
             if let Poll::Ready(t) = f(&waker) {
                 return t;

futures-select-macro/src/lib.rs

@@ -235,7 +235,7 @@ pub fn select(input: TokenStream) -> TokenStream {
     let await_and_select = if let Some(default_expr) = parsed.default {
         quote! {
             if let #futures_crate::task::Poll::Ready(x) =
-                __poll_fn(#futures_crate::task::noop_local_waker_ref())
+                __poll_fn(#futures_crate::task::noop_waker_ref())
             {
                 match x { #branches }
             } else {

futures-test/src/assert.rs

@@ -30,7 +30,7 @@ macro_rules! assert_stream_pending {
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
         let stream = $crate::std_reexport::pin::Pin::new(stream);
-        let lw = &$crate::task::noop_local_waker_ref();
+        let lw = &$crate::task::noop_waker_ref();
         let poll = $crate::futures_core_reexport::stream::Stream::poll_next(
             stream, lw,
         );
@@ -67,7 +67,7 @@ macro_rules! assert_stream_next {
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
         let stream = $crate::std_reexport::pin::Pin::new(stream);
-        let lw = &$crate::task::noop_local_waker_ref();
+        let lw = &$crate::task::noop_waker_ref();
         match $crate::futures_core_reexport::stream::Stream::poll_next(stream, lw) {
             $crate::futures_core_reexport::task::Poll::Ready(Some(x)) => {
                 assert_eq!(x, $item);
@@ -110,7 +110,7 @@ macro_rules! assert_stream_done {
         let mut stream = &mut $stream;
         $crate::assert::assert_is_unpin_stream(stream);
         let stream = $crate::std_reexport::pin::Pin::new(stream);
-        let lw = &$crate::task::noop_local_waker_ref();
+        let lw = &$crate::task::noop_waker_ref();
         match $crate::futures_core_reexport::stream::Stream::poll_next(stream, lw) {
             $crate::futures_core_reexport::task::Poll::Ready(Some(_)) => {
                 panic!("assertion failed: expected stream to be done but had more elements");

futures-test/src/future/assert_unmoved.rs

@@ -64,7 +64,7 @@ mod tests {
     use futures_core::future::Future;
     use futures_core::task::Poll;
     use futures_util::future::empty;
-    use futures_util::task::noop_local_waker;
+    use futures_util::task::noop_waker;
     use std::pin::Pin;
 
     use super::AssertUnmoved;
@@ -80,7 +80,7 @@ mod tests {
     #[should_panic(expected = "Future moved between poll calls")]
     fn dont_double_panic() {
         // This test should only panic, not abort the process.
-        let waker = noop_local_waker();
+        let waker = noop_waker();
 
         // First we allocate the future on the stack and poll it.
         let mut future = AssertUnmoved::new(empty::<()>());

futures-test/src/future/mod.rs

@@ -43,7 +43,7 @@ pub trait FutureTestExt: Future {
     /// let future = (async { 5 }).pending_once();
     /// pin_mut!(future);
     ///
-    /// let lw = &task::noop_local_waker_ref();
+    /// let lw = &task::noop_waker_ref();
     ///
     /// assert_eq!(future.poll_unpin(lw), Poll::Pending);
     /// assert_eq!(future.poll_unpin(lw), Poll::Ready(5));

futures-test/src/task/mod.rs

@@ -5,9 +5,9 @@
 //! [`Spawn`](futures_core::task::Spawn) implementations.
 //!
 //! Test wakers:
-//! - [`noop_local_waker`] creates a waker that ignores calls to
+//! - [`noop_waker`] creates a waker that ignores calls to
 //!   [`wake`](futures_core::task::Waker).
-//! - [`panic_local_waker`] creates a waker that panics when
+//! - [`panic_waker`] creates a waker that panics when
 //!   [`wake`](futures_core::task::Waker) is called.
 //! - [`new_count_waker`] creates a waker that increments a counter whenever
 //!   [`wake`](futures_core::task::Waker) is called.
@@ -20,19 +20,19 @@
 //! - [`RecordSpawner`] records the spawned futures.
 //!
 //! For convenience there additionally exist various functions that directly
-//! return waker/spawner references: [`noop_local_waker_ref`],
-//! [`panic_local_waker_ref`], [`noop_spawner_mut`] and [`panic_spawner_mut`].
+//! return waker/spawner references: [`noop_waker_ref`],
+//! [`panic_waker_ref`], [`noop_spawner_mut`] and [`panic_spawner_mut`].
 
 mod noop_spawner;
 pub use self::noop_spawner::{noop_spawner_mut, NoopSpawner};
 
-pub use futures_util::task::{noop_local_waker, noop_local_waker_ref};
+pub use futures_util::task::{noop_waker, noop_waker_ref};
 
 mod panic_spawner;
 pub use self::panic_spawner::{panic_spawner_mut, PanicSpawner};
 
 mod panic_waker;
-pub use self::panic_waker::{panic_local_waker, panic_local_waker_ref};
+pub use self::panic_waker::{panic_waker, panic_waker_ref};
 
 mod record_spawner;
 pub use self::record_spawner::RecordSpawner;

futures-test/src/task/panic_waker.rs

@@ -31,12 +31,12 @@ fn raw_panic_waker() -> RawWaker {
 ///
 /// ```should_panic
 /// #![feature(futures_api)]
-/// use futures_test::task::panic_local_waker;
+/// use futures_test::task::panic_waker;
 ///
-/// let lw = panic_local_waker();
+/// let lw = panic_waker();
 /// lw.wake(); // Will panic
 /// ```
-pub fn panic_local_waker() -> Waker {
+pub fn panic_waker() -> Waker {
     unsafe { Waker::new_unchecked(raw_panic_waker()) }
 }
 
@@ -49,15 +49,15 @@ pub fn panic_local_waker() -> Waker {
 /// ```should_panic
 /// #![feature(async_await, futures_api)]
 /// use futures::task;
-/// use futures_test::task::panic_local_waker_ref;
+/// use futures_test::task::panic_waker_ref;
 ///
-/// let lw = panic_local_waker_ref();
+/// let lw = panic_waker_ref();
 /// lw.wake(); // Will panic
 /// ```
-pub fn panic_local_waker_ref() -> &'static Waker {
+pub fn panic_waker_ref() -> &'static Waker {
     thread_local! {
         static PANIC_WAKER_INSTANCE: UnsafeCell<Waker> =
-            UnsafeCell::new(panic_local_waker());
+            UnsafeCell::new(panic_waker());
     }
     PANIC_WAKER_INSTANCE.with(|l| unsafe { &*l.get() })
 }

futures-util/src/compat/compat01as03.rs

@@ -29,7 +29,7 @@ impl<T> Compat01As03<T> {
     }
 
     fn in_notify<R>(&mut self, waker: &Waker, f: impl FnOnce(&mut T) -> R) -> R {
-        let notify = &WakerToHandle(waker.as_waker());
+        let notify = &WakerToHandle(waker);
         self.inner.poll_fn_notify(notify, 0, f)
     }
 }

futures-util/src/compat/compat03as01.rs

@@ -7,8 +7,8 @@ use futures_core::{
     task as task03, TryFuture as TryFuture03, TryStream as TryStream03,
 };
 use futures_sink::Sink as Sink03;
-use futures_util::task::ArcWake as ArcWake03;
-use std::{marker::PhantomData, ops::Deref, pin::Pin, ptr::NonNull, sync::Arc};
+use crate::task::ArcWake as ArcWake03;
+use std::{pin::Pin, sync::Arc};
 
 /// Converts a futures 0.3 [`TryFuture`](futures_core::future::TryFuture),
 /// [`TryStream`](futures_core::stream::TryStream) or
@@ -115,9 +115,9 @@ impl Current {
         Current(task01::current())
     }
 
-    fn as_waker(&self) -> Waker {
+    fn as_waker(&self) -> task03::Waker {
         // For simplicity reasons wrap the Waker into an Arc.
-        // We can optmize this again later on and reintroduce WakerLt<'a> which
+        // We can optimize this again later on and reintroduce WakerLt<'a> which
         // derefs to Waker, and where cloning it through RawWakerVTable returns
         // an Arc version
         ArcWake03::into_waker(Arc::new(Current(self.0.clone())))

futures-util/src/task/mod.rs

@@ -6,7 +6,7 @@ mod arc_wake;
 pub use self::arc_wake::ArcWake;
 
 mod noop_waker;
-pub use self::noop_waker::{noop_local_waker, noop_local_waker_ref};
+pub use self::noop_waker::{noop_waker, noop_waker_ref};
 
 mod spawn;
 pub use self::spawn::{SpawnExt, LocalSpawnExt};

futures-util/src/task/noop_waker.rs

@@ -28,12 +28,12 @@ fn noop_raw_waker() -> RawWaker {
 ///
 /// ```
 /// #![feature(futures_api)]
-/// use futures::task::noop_local_waker;
-/// let lw = noop_local_waker();
+/// use futures::task::noop_waker;
+/// let lw = noop_waker();
 /// lw.wake();
 /// ```
 #[inline]
-pub fn noop_local_waker() -> Waker {
+pub fn noop_waker() -> Waker {
     unsafe {
         Waker::new_unchecked(noop_raw_waker())
     }
@@ -47,15 +47,15 @@ pub fn noop_local_waker() -> Waker {
 ///
 /// ```
 /// #![feature(futures_api)]
-/// use futures::task::noop_local_waker_ref;
-/// let lw = noop_local_waker_ref();
+/// use futures::task::noop_waker_ref;
+/// let lw = noop_waker_ref();
 /// lw.wake();
 /// ```
 #[inline]
-pub fn noop_local_waker_ref() -> &'static Waker {
+pub fn noop_waker_ref() -> &'static Waker {
     thread_local! {
         static NOOP_WAKER_INSTANCE: UnsafeCell<Waker> =
-            UnsafeCell::new(noop_local_waker());
+            UnsafeCell::new(noop_waker());
     }
     NOOP_WAKER_INSTANCE.with(|l| unsafe { &*l.get() })
 }

futures-util/src/try_stream/into_async_read.rs

@@ -103,11 +103,11 @@ mod tests {
     use super::*;
     use futures::stream::{self, StreamExt, TryStreamExt};
     use futures_io::AsyncRead;
-    use futures_test::task::noop_local_waker_ref;
+    use futures_test::task::noop_waker_ref;
 
     macro_rules! assert_read {
         ($reader:expr, $buf:expr, $item:expr) => {
-            let waker = noop_local_waker_ref();
+            let waker = noop_waker_ref();
             match $reader.poll_read(waker, $buf) {
                 Poll::Ready(Ok(x)) => {
                     assert_eq!(x, $item);

futures-util/tests/futures_unordered.rs

@@ -3,11 +3,11 @@
 use futures::future;
 use futures::task::Poll;
 use futures::stream::{FusedStream, FuturesUnordered, StreamExt};
-use futures_test::task::noop_local_waker_ref;
+use futures_test::task::noop_waker_ref;
 
 #[test]
 fn is_terminated() {
-    let lw = noop_local_waker_ref();
+    let lw = noop_waker_ref();
     let mut tasks = FuturesUnordered::new();
 
     assert_eq!(tasks.is_terminated(), false);

futures-util/tests/mutex.rs

@@ -6,22 +6,22 @@ use futures::lock::Mutex;
 use futures::stream::StreamExt;
 use futures::task::SpawnExt;
 use futures_test::future::FutureTestExt;
-use futures_test::task::{panic_local_waker_ref, new_count_waker};
+use futures_test::task::{panic_waker_ref, new_count_waker};
 use std::sync::Arc;
 
 #[test]
 fn mutex_acquire_uncontested() {
     let mutex = Mutex::new(());
     for _ in 0..10 {
-        assert!(mutex.lock().poll_unpin(panic_local_waker_ref()).is_ready());
+        assert!(mutex.lock().poll_unpin(panic_waker_ref()).is_ready());
     }
 }
 
 #[test]
 fn mutex_wakes_waiters() {
     let mutex = Mutex::new(());
     let (lw, counter) = new_count_waker();
-    let lock = mutex.lock().poll_unpin(panic_local_waker_ref());
+    let lock = mutex.lock().poll_unpin(panic_waker_ref());
     assert!(lock.is_ready());
 
     let mut waiter = mutex.lock();
@@ -31,7 +31,7 @@ fn mutex_wakes_waiters() {
     drop(lock);
 
     assert_eq!(counter, 1);
-    assert!(waiter.poll_unpin(panic_local_waker_ref()).is_ready());
+    assert!(waiter.poll_unpin(panic_waker_ref()).is_ready());
 }
 
 #[test]