s/Async::/Poll::/

Signed-off-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Author: yoshuawuyts

futures-channel/src/mpsc/mod.rs

@@ -548,8 +548,8 @@ impl<T> SenderInner<T> {
     ///
     /// This method returns:
     ///
-    /// - `Ok(Async::Ready(_))` if there is sufficient capacity;
-    /// - `Ok(Async::Pending)` if the channel may not have
+    /// - `Ok(Poll::Ready(_))` if there is sufficient capacity;
+    /// - `Ok(Poll::Pending)` if the channel may not have
     ///   capacity, in which case the current task is queued to be notified once
     ///   capacity is available;
     /// - `Err(SendError)` if the receiver has been dropped.
@@ -642,8 +642,8 @@ impl<T> Sender<T> {
     ///
     /// This method returns:
     ///
-    /// - `Ok(Async::Ready(_))` if there is sufficient capacity;
-    /// - `Ok(Async::Pending)` if the channel may not have
+    /// - `Ok(Poll::Ready(_))` if there is sufficient capacity;
+    /// - `Ok(Poll::Pending)` if the channel may not have
     ///   capacity, in which case the current task is queued to be notified once
     ///   capacity is available;
     /// - `Err(SendError)` if the receiver has been dropped.

futures-channel/tests/oneshot.rs

@@ -155,7 +155,7 @@ fn cancel_sends() {
 //         type Error = ();
 //
 //         fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-//             Ok(Async::Pending)
+//             Ok(Poll::Pending)
 //         }
 //     }
 //
@@ -217,7 +217,7 @@ fn cancel_sends() {
 //         type Error = ();
 //
 //         fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-//             Ok(Async::Pending)
+//             Ok(Poll::Pending)
 //         }
 //     }
 //

futures-io/src/lib.rs

@@ -96,18 +96,18 @@ mod if_std {
 
         /// Attempt to read from the `AsyncRead` into `buf`.
         ///
-        /// On success, returns `Ok(Async::Ready(num_bytes_read))`.
+        /// On success, returns `Ok(Poll::Ready(num_bytes_read))`.
         ///
         /// If no data is available for reading, the method returns
-        /// `Ok(Async::Pending)` and arranges for the current task (via
+        /// `Ok(Poll::Pending)` and arranges for the current task (via
         /// `waker.wake()`) to receive a notification when the object becomes
         /// readable or is closed.
         ///
         /// # Implementation
         ///
         /// This function may not return errors of kind `WouldBlock` or
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
-        /// `Async::Pending` and either internally retry or convert
+        /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
         fn poll_read(self: Pin<&mut Self>, waker: &Waker, buf: &mut [u8])
             -> Poll<Result<usize>>;
@@ -118,10 +118,10 @@ mod if_std {
         /// This method is similar to `poll_read`, but allows data to be read
         /// into multiple buffers using a single operation.
         ///
-        /// On success, returns `Ok(Async::Ready(num_bytes_read))`.
+        /// On success, returns `Ok(Poll::Ready(num_bytes_read))`.
         ///
         /// If no data is available for reading, the method returns
-        /// `Ok(Async::Pending)` and arranges for the current task (via
+        /// `Ok(Poll::Pending)` and arranges for the current task (via
         /// `waker.wake()`) to receive a notification when the object becomes
         /// readable or is closed.
         /// By default, this method delegates to using `poll_read` on the first
@@ -132,7 +132,7 @@ mod if_std {
         ///
         /// This function may not return errors of kind `WouldBlock` or
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
-        /// `Async::Pending` and either internally retry or convert
+        /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
         fn poll_vectored_read(self: Pin<&mut Self>, waker: &Waker, vec: &mut [&mut IoVec])
             -> Poll<Result<usize>>
@@ -156,18 +156,18 @@ mod if_std {
     pub trait AsyncWrite {
         /// Attempt to write bytes from `buf` into the object.
         ///
-        /// On success, returns `Ok(Async::Ready(num_bytes_written))`.
+        /// On success, returns `Ok(Poll::Ready(num_bytes_written))`.
         ///
         /// If the object is not ready for writing, the method returns
-        /// `Ok(Async::Pending)` and arranges for the current task (via
+        /// `Ok(Poll::Pending)` and arranges for the current task (via
         /// `waker.wake()`) to receive a notification when the object becomes
         /// readable or is closed.
         ///
         /// # Implementation
         ///
         /// This function may not return errors of kind `WouldBlock` or
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
-        /// `Async::Pending` and either internally retry or convert
+        /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
         fn poll_write(self: Pin<&mut Self>, waker: &Waker, buf: &[u8])
             -> Poll<Result<usize>>;
@@ -178,10 +178,10 @@ mod if_std {
         /// This method is similar to `poll_write`, but allows data from multiple buffers to be written
         /// using a single operation.
         ///
-        /// On success, returns `Ok(Async::Ready(num_bytes_written))`.
+        /// On success, returns `Ok(Poll::Ready(num_bytes_written))`.
         ///
         /// If the object is not ready for writing, the method returns
-        /// `Ok(Async::Pending)` and arranges for the current task (via
+        /// `Ok(Poll::Pending)` and arranges for the current task (via
         /// `waker.wake()`) to receive a notification when the object becomes
         /// readable or is closed.
         ///
@@ -193,7 +193,7 @@ mod if_std {
         ///
         /// This function may not return errors of kind `WouldBlock` or
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
-        /// `Async::Pending` and either internally retry or convert
+        /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
         fn poll_vectored_write(self: Pin<&mut Self>, waker: &Waker, vec: &[&IoVec])
             -> Poll<Result<usize>>
@@ -209,35 +209,35 @@ mod if_std {
         /// Attempt to flush the object, ensuring that any buffered data reach
         /// their destination.
         ///
-        /// On success, returns `Ok(Async::Ready(()))`.
+        /// On success, returns `Ok(Poll::Ready(()))`.
         ///
         /// If flushing cannot immediately complete, this method returns
-        /// `Ok(Async::Pending)` and arranges for the current task (via
+        /// `Ok(Poll::Pending)` and arranges for the current task (via
         /// `waker.wake()`) to receive a notification when the object can make
         /// progress towards flushing.
         ///
         /// # Implementation
         ///
         /// This function may not return errors of kind `WouldBlock` or
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
-        /// `Async::Pending` and either internally retry or convert
+        /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
         fn poll_flush(self: Pin<&mut Self>, waker: &Waker) -> Poll<Result<()>>;
 
         /// Attempt to close the object.
         ///
-        /// On success, returns `Ok(Async::Ready(()))`.
+        /// On success, returns `Ok(Poll::Ready(()))`.
         ///
         /// If closing cannot immediately complete, this function returns
-        /// `Ok(Async::Pending)` and arranges for the current task (via
+        /// `Ok(Poll::Pending)` and arranges for the current task (via
         /// `waker.wake()`) to receive a notification when the object can make
         /// progress towards closing.
         ///
         /// # Implementation
         ///
         /// This function may not return errors of kind `WouldBlock` or
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
-        /// `Async::Pending` and either internally retry or convert
+        /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
         fn poll_close(self: Pin<&mut Self>, waker: &Waker) -> Poll<Result<()>>;
     }

futures-sink/src/lib.rs

@@ -58,7 +58,7 @@ pub trait Sink<Item> {
     /// each call to `start_send`.
     ///
     /// This method returns `Poll::Ready` once the underlying sink is ready to
-    /// receive data. If this method returns `Async::Pending`, the current task
+    /// receive data. If this method returns `Poll::Pending`, the current task
     /// is registered to be notified (via `waker.wake()`) when `poll_ready`
     /// should be called again.
     ///
@@ -94,7 +94,7 @@ pub trait Sink<Item> {
     /// value is returned then it is guaranteed that all previous values sent
     /// via `start_send` have been flushed.
     ///
-    /// Returns `Ok(Async::Pending)` if there is more work left to do, in which
+    /// Returns `Ok(Poll::Pending)` if there is more work left to do, in which
     /// case the current task is scheduled (via `waker.wake()`) to wake up when
     /// `poll_flush` should be called again.
     ///
@@ -107,7 +107,7 @@ pub trait Sink<Item> {
     /// Returns `Ok(Poll::Ready(()))` when no buffered items remain and the sink
     /// has been successfully closed.
     ///
-    /// Returns `Ok(Async::Pending)` if there is more work left to do, in which
+    /// Returns `Ok(Poll::Pending)` if there is more work left to do, in which
     /// case the current task is scheduled (via `waker.wake()`) to wake up when
     /// `poll_close` should be called again.
     ///

futures-util/benches_disabled/bilock.rs

@@ -48,8 +48,8 @@ impl Stream for LockStream {
 
     fn poll_next(&mut self, waker: &Waker) -> Poll<Option<Self::Item>, Self::Error> {
         self.lock.poll(waker).map(|a| match a {
-            Async::Ready(a) => Async::Ready(Some(a)),
-            Async::Pending => Async::Pending,
+            Poll::Ready(a) => Poll::Ready(Some(a)),
+            Poll::Pending => Poll::Pending,
         })
     }
 }
@@ -71,20 +71,20 @@ fn contended(b: &mut Bencher) {
 
         for _ in 0..1000 {
             let x_guard = match x.poll_next(&mut waker) {
-                Ok(Async::Ready(Some(guard))) => guard,
+                Ok(Poll::Ready(Some(guard))) => guard,
                 _ => panic!(),
             };
 
             // Try poll second lock while first lock still holds the lock
             match y.poll_next(&mut waker) {
-                Ok(Async::Pending) => (),
+                Ok(Poll::Pending) => (),
                 _ => panic!(),
             };
 
             x.release_lock(x_guard);
 
             let y_guard = match y.poll_next(&mut waker) {
-                Ok(Async::Ready(Some(guard))) => guard,
+                Ok(Poll::Ready(Some(guard))) => guard,
                 _ => panic!(),
             };
 
@@ -110,14 +110,14 @@ fn lock_unlock(b: &mut Bencher) {
 
         for _ in 0..1000 {
             let x_guard = match x.poll_next(&mut waker) {
-                Ok(Async::Ready(Some(guard))) => guard,
+                Ok(Poll::Ready(Some(guard))) => guard,
                 _ => panic!(),
             };
 
             x.release_lock(x_guard);
 
             let y_guard = match y.poll_next(&mut waker) {
-                Ok(Async::Ready(Some(guard))) => guard,
+                Ok(Poll::Ready(Some(guard))) => guard,
                 _ => panic!(),
             };
 

futures-util/bilock.rs

@@ -14,8 +14,8 @@ fn smoke() {
 
         {
             let mut lock = match a.poll_lock() {
-                Async::Ready(l) => l,
-                Async::Pending => panic!("poll not ready"),
+                Poll::Ready(l) => l,
+                Poll::Pending => panic!("poll not ready"),
             };
             assert_eq!(*lock, 1);
             *lock = 2;
@@ -29,8 +29,8 @@ fn smoke() {
 
         {
             let lock = match b.poll_lock() {
-                Async::Ready(l) => l,
-                Async::Pending => panic!("poll not ready"),
+                Poll::Ready(l) => l,
+                Poll::Pending => panic!("poll not ready"),
             };
             assert_eq!(*lock, 2);
         }
@@ -67,12 +67,12 @@ fn concurrent() {
     let a = t1.join().unwrap().expect("a error");
 
     match a.poll_lock() {
-        Async::Ready(l) => assert_eq!(*l, 2 * N),
-        Async::Pending => panic!("poll not ready"),
+        Poll::Ready(l) => assert_eq!(*l, 2 * N),
+        Poll::Pending => panic!("poll not ready"),
     }
     match b.poll_lock() {
-        Async::Ready(l) => assert_eq!(*l, 2 * N),
-        Async::Pending => panic!("poll not ready"),
+        Poll::Ready(l) => assert_eq!(*l, 2 * N),
+        Poll::Pending => panic!("poll not ready"),
     }
 
     assert_eq!(a.reunite(b).expect("bilock/concurrent: reunite error"), 2 * N);
@@ -94,8 +94,8 @@ fn concurrent() {
 
                 let a = self.a.as_ref().unwrap();
                 let mut a = match a.poll_lock() {
-                    Async::Ready(l) => l,
-                    Async::Pending => return Ok(Async::Pending),
+                    Poll::Ready(l) => l,
+                    Poll::Pending => return Ok(Poll::Pending),
                 };
                 self.remaining -= 1;
                 *a += 1;

futures-util/src/future/disabled/select.rs

@@ -22,13 +22,13 @@ impl<A, B> Future for Select<A, B> where A: Future, B: Future {
         let (mut a, mut b) = self.inner.take().expect("cannot poll Select twice");
         match a.poll(waker) {
             Err(e) => Err(Either::Left((e, b))),
-            Ok(Async::Ready(x)) => Ok(Async::Ready(Either::Left((x, b)))),
-            Ok(Async::Pending) => match b.poll(waker) {
+            Ok(Poll::Ready(x)) => Ok(Poll::Ready(Either::Left((x, b)))),
+            Ok(Poll::Pending) => match b.poll(waker) {
                 Err(e) => Err(Either::Right((e, a))),
-                Ok(Async::Ready(x)) => Ok(Async::Ready(Either::Right((x, a)))),
-                Ok(Async::Pending) => {
+                Ok(Poll::Ready(x)) => Ok(Poll::Ready(Either::Right((x, a)))),
+                Ok(Poll::Pending) => {
                     self.inner = Some((a, b));
-                    Ok(Async::Pending)
+                    Ok(Poll::Pending)
                 }
             }
         }

futures-util/src/future/disabled/select_all.rs

@@ -49,8 +49,8 @@ impl<A> Future for SelectAll<A>
     fn poll(&mut self, waker: &Waker) -> Poll<Self::Item, Self::Error> {
         let item = self.inner.iter_mut().enumerate().filter_map(|(i, f)| {
             match f.poll(waker) {
-                Ok(Async::Pending) => None,
-                Ok(Async::Ready(e)) => Some((i, Ok(e))),
+                Ok(Poll::Pending) => None,
+                Ok(Poll::Ready(e)) => Some((i, Ok(e))),
                 Err(e) => Some((i, Err(e))),
             }
         }).next();
@@ -59,11 +59,11 @@ impl<A> Future for SelectAll<A>
                 self.inner.remove(idx);
                 let rest = mem::replace(&mut self.inner, Vec::new());
                 match res {
-                    Ok(e) => Ok(Async::Ready((e, idx, rest))),
+                    Ok(e) => Ok(Poll::Ready((e, idx, rest))),
                     Err(e) => Err((e, idx, rest)),
                 }
             }
-            None => Ok(Async::Pending),
+            None => Ok(Poll::Pending),
         }
     }
 }

futures-util/src/future/disabled/select_ok.rs

@@ -46,8 +46,8 @@ impl<A> Future for SelectOk<A> where A: Future {
         loop {
             let item = self.inner.iter_mut().enumerate().filter_map(|(i, f)| {
                 match f.poll(waker) {
-                    Ok(Async::Pending) => None,
-                    Ok(Async::Ready(e)) => Some((i, Ok(e))),
+                    Ok(Poll::Pending) => None,
+                    Ok(Poll::Ready(e)) => Some((i, Ok(e))),
                     Err(e) => Some((i, Err(e))),
                 }
             }).next();
@@ -59,7 +59,7 @@ impl<A> Future for SelectOk<A> where A: Future {
                     match res {
                         Ok(e) => {
                             let rest = mem::replace(&mut self.inner, Vec::new());
-                            return Ok(Async::Ready((e, rest)))
+                            return Ok(Poll::Ready((e, rest)))
                         },
                         Err(e) => {
                             if self.inner.is_empty() {
@@ -70,7 +70,7 @@ impl<A> Future for SelectOk<A> where A: Future {
                 }
                 None => {
                     // based on the filter above, nothing is ready, return
-                    return Ok(Async::Pending)
+                    return Ok(Poll::Pending)
                 },
             }
         }

futures-util/src/lock/bilock.rs

@@ -75,12 +75,12 @@ impl<T> BiLock<T> {
     ///
     /// This function will acquire the lock in a nonblocking fashion, returning
     /// immediately if the lock is already held. If the lock is successfully
-    /// acquired then `Async::Ready` is returned with a value that represents
+    /// acquired then `Poll::Ready` is returned with a value that represents
     /// the locked value (and can be used to access the protected data). The
     /// lock is unlocked when the returned `BiLockGuard` is dropped.
     ///
     /// If the lock is already held then this function will return
-    /// `Async::Pending`. In this case the current task will also be scheduled
+    /// `Poll::Pending`. In this case the current task will also be scheduled
     /// to receive a notification when the lock would otherwise become
     /// available.
     ///