Replace await! macro with await syntax

Author: taiki-e

futures-channel/tests/channel.rs

@@ -1,4 +1,4 @@
-#![feature(async_await, await_macro)]
+#![feature(async_await)]
 
 use futures::channel::mpsc;
 use futures::executor::block_on;
@@ -28,7 +28,7 @@ fn sequence() {
 
 async fn send_sequence(n: u32, mut sender: mpsc::Sender<u32>) {
     for x in 0..n {
-        await!(sender.send(n - x)).unwrap();
+        sender.send(n - x).await.unwrap();
     }
 }
 

futures-channel/tests/mpsc.rs

@@ -1,4 +1,4 @@
-#![feature(async_await, await_macro)]
+#![feature(async_await)]
 
 use futures::channel::{mpsc, oneshot};
 use futures::executor::{block_on, block_on_stream};
@@ -357,7 +357,7 @@ fn stress_drop_sender() {
 
 async fn send_one_two_three(mut tx: mpsc::Sender<i32>) {
     for i in 1..=3 {
-        await!(tx.send(i)).unwrap();
+        tx.send(i).await.unwrap();
     }
 }
 
@@ -403,7 +403,7 @@ fn stress_close_receiver() {
 
 async fn stress_poll_ready_sender(mut sender: mpsc::Sender<u32>, count: u32) {
     for i in (1..=count).rev() {
-        await!(sender.send(i)).unwrap();
+        sender.send(i).await.unwrap();
     }
 }
 

futures-select-macro/src/lib.rs

@@ -246,8 +246,9 @@ pub fn select(input: TokenStream) -> TokenStream {
             };
         }
     } else {
+        // TODO: should we use `r#await`?
         quote! {
-            match r#await!(#futures_crate::future::poll_fn(__poll_fn)) {
+            match #futures_crate::future::poll_fn(__poll_fn).await {
                 #branches
             }
         }

futures-util/src/async_await/join.rs

@@ -3,7 +3,7 @@
 /// Polls multiple futures simultaneously, returning a tuple
 /// of all results once complete.
 ///
-/// While `join!(a, b)` is similar to `(await!(a), await!(b))`,
+/// While `join!(a, b)` is similar to `(a.await, b.await)`,
 /// `join!` polls both futures concurrently and therefore is more efficent.
 ///
 /// This macro is only usable inside of async functions, closures, and blocks.
@@ -13,7 +13,7 @@
 /// # Examples
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::{join, future};
 ///
@@ -31,7 +31,7 @@ macro_rules! join {
             // is no longer accessible by the end user.
             let mut $fut = $crate::future::maybe_done($fut);
         )*
-        await!($crate::future::poll_fn(move |cx| {
+        $crate::future::poll_fn(move |cx| {
             let mut all_done = true;
             $(
                 all_done &= $crate::core_reexport::future::Future::poll(
@@ -44,7 +44,7 @@ macro_rules! join {
             } else {
                 $crate::core_reexport::task::Poll::Pending
             }
-        }))
+        }).await
     } }
 }
 
@@ -64,7 +64,7 @@ macro_rules! join {
 /// `Ok` of a tuple of the values:
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::{try_join, future};
 ///
@@ -79,7 +79,7 @@ macro_rules! join {
 /// that error:
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::{try_join, future};
 ///
@@ -98,7 +98,7 @@ macro_rules! try_join {
             let mut $fut = $crate::future::maybe_done($fut);
         )*
 
-        let res: $crate::core_reexport::result::Result<_, _> = await!($crate::future::poll_fn(move |cx| {
+        let res: $crate::core_reexport::result::Result<_, _> = $crate::future::poll_fn(move |cx| {
             let mut all_done = true;
             $(
                 if $crate::core_reexport::future::Future::poll(
@@ -126,7 +126,7 @@ macro_rules! try_join {
             } else {
                 $crate::core_reexport::task::Poll::Pending
             }
-        }));
+        }).await;
 
         res
     } }

futures-util/src/async_await/pending.rs

@@ -15,7 +15,7 @@ use futures_core::task::{Context, Poll};
 #[macro_export]
 macro_rules! pending {
     () => {
-        await!($crate::async_await::pending_once())
+        $crate::async_await::pending_once().await
     }
 }
 

futures-util/src/async_await/poll.rs

@@ -11,7 +11,7 @@ use futures_core::task::{Context, Poll};
 #[macro_export]
 macro_rules! poll {
     ($x:expr) => {
-        await!($crate::async_await::poll($x))
+        $crate::async_await::poll($x).await
     }
 }
 

futures-util/src/async_await/select_mod.rs

@@ -26,7 +26,7 @@ macro_rules! document_select_macro {
         /// # Examples
         ///
         /// ```
-        /// #![feature(async_await, await_macro)]
+        /// #![feature(async_await)]
         /// # futures::executor::block_on(async {
         /// use futures::future::{self, FutureExt};
         /// use futures::select;
@@ -42,7 +42,7 @@ macro_rules! document_select_macro {
         /// ```
         ///
         /// ```
-        /// #![feature(async_await, await_macro)]
+        /// #![feature(async_await)]
         /// # futures::executor::block_on(async {
         /// use futures::future::{self, FutureExt};
         /// use futures::stream::{self, StreamExt};
@@ -64,7 +64,7 @@ macro_rules! document_select_macro {
         /// the case where all futures have completed.
         ///
         /// ```
-        /// #![feature(async_await, await_macro)]
+        /// #![feature(async_await)]
         /// # futures::executor::block_on(async {
         /// use futures::future::{self, FutureExt};
         /// use futures::select;

futures-util/src/compat/compat01as03.rs

@@ -52,14 +52,14 @@ pub trait Future01CompatExt: Future01 {
     /// [`Future<Output = Result<T, E>>`](futures_core::future::Future).
     ///
     /// ```
-    /// #![feature(async_await, await_macro)]
+    /// #![feature(async_await)]
     /// # futures::executor::block_on(async {
     /// # // TODO: These should be all using `futures::compat`, but that runs up against Cargo
     /// # // feature issues
     /// use futures_util::compat::Future01CompatExt;
     ///
     /// let future = futures_01::future::ok::<u32, ()>(1);
-    /// assert_eq!(await!(future.compat()), Ok(1));
+    /// assert_eq!(future.compat().await, Ok(1));
     /// # });
     /// ```
     fn compat(self) -> Compat01As03<Self>
@@ -79,15 +79,15 @@ pub trait Stream01CompatExt: Stream01 {
     /// [`Stream<Item = Result<T, E>>`](futures_core::stream::Stream).
     ///
     /// ```
-    /// #![feature(async_await, await_macro)]
+    /// #![feature(async_await)]
     /// # futures::executor::block_on(async {
     /// use futures::stream::StreamExt;
     /// use futures_util::compat::Stream01CompatExt;
     ///
     /// let stream = futures_01::stream::once::<u32, ()>(Ok(1));
     /// let mut stream = stream.compat();
-    /// assert_eq!(await!(stream.next()), Some(Ok(1)));
-    /// assert_eq!(await!(stream.next()), None);
+    /// assert_eq!(stream.next().await, Some(Ok(1)));
+    /// assert_eq!(stream.next().await, None);
     /// # });
     /// ```
     fn compat(self) -> Compat01As03<Self>
@@ -107,18 +107,18 @@ pub trait Sink01CompatExt: Sink01 {
     /// [`Sink<SinkItem = T, SinkError = E>`](futures_sink::sink::Sink).
     ///
     /// ```
-    /// #![feature(async_await, await_macro)]
+    /// #![feature(async_await)]
     /// # futures::executor::block_on(async {
     /// use futures::{sink::SinkExt, stream::StreamExt};
     /// use futures_util::compat::{Stream01CompatExt, Sink01CompatExt};
     ///
     /// let (tx, rx) = futures_01::unsync::mpsc::channel(1);
     /// let (mut tx, mut rx) = (tx.sink_compat(), rx.compat());
     ///
-    /// await!(tx.send(1)).unwrap();
+    /// tx.send(1).await.unwrap();
     /// drop(tx);
-    /// assert_eq!(await!(rx.next()), Some(Ok(1)));
-    /// assert_eq!(await!(rx.next()), None);
+    /// assert_eq!(rx.next().await, Some(Ok(1)));
+    /// assert_eq!(rx.next().await, None);
     /// # });
     /// ```
     fn sink_compat(self) -> Compat01As03Sink<Self, Self::SinkItem>
@@ -356,7 +356,7 @@ mod io {
         /// [`AsyncRead`](futures_io::AsyncRead).
         ///
         /// ```
-        /// #![feature(async_await, await_macro, impl_trait_in_bindings)]
+        /// #![feature(async_await, impl_trait_in_bindings)]
         /// # futures::executor::block_on(async {
         /// use futures::io::AsyncReadExt;
         /// use futures_util::compat::AsyncRead01CompatExt;
@@ -366,7 +366,7 @@ mod io {
         /// let mut reader: impl futures::io::AsyncRead + Unpin = reader.compat();
         ///
         /// let mut output = Vec::with_capacity(12);
-        /// await!(reader.read_to_end(&mut output)).unwrap();
+        /// reader.read_to_end(&mut output).await.unwrap();
         /// assert_eq!(output, input);
         /// # });
         /// ```
@@ -385,7 +385,7 @@ mod io {
         /// [`AsyncWrite`](futures_io::AsyncWrite).
         ///
         /// ```
-        /// #![feature(async_await, await_macro, impl_trait_in_bindings)]
+        /// #![feature(async_await, impl_trait_in_bindings)]
         /// # futures::executor::block_on(async {
         /// use futures::io::AsyncWriteExt;
         /// use futures_util::compat::AsyncWrite01CompatExt;
@@ -394,7 +394,7 @@ mod io {
         /// let mut cursor = std::io::Cursor::new(Vec::with_capacity(12));
         ///
         /// let mut writer = (&mut cursor).compat();
-        /// await!(writer.write_all(input)).unwrap();
+        /// writer.write_all(input).await.unwrap();
         ///
         /// assert_eq!(cursor.into_inner(), input);
         /// # });

futures-util/src/compat/executor.rs

@@ -22,7 +22,7 @@ pub trait Executor01CompatExt: Executor01<Executor01Future> +
     /// futures 0.3 [`Spawn`](futures_core::task::Spawn).
     ///
     /// ```
-    /// #![feature(async_await, await_macro)]
+    /// #![feature(async_await)]
     /// use futures::Future;
     /// use futures::task::SpawnExt;
     /// use futures::future::{FutureExt, TryFutureExt};

futures-util/src/future/empty.rs

@@ -22,12 +22,12 @@ impl<T> FusedFuture for Empty<T> {
 /// # Examples
 ///
 /// ```ignore
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
 /// let future = future::empty();
-/// let () = await!(future);
+/// let () = future.await;
 /// unreachable!();
 /// # });
 /// ```

futures-util/src/future/fuse.rs

@@ -27,7 +27,7 @@ impl<Fut: Future> Fuse<Fut> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(async_await, await_macro, futures_api)]
+    /// #![feature(async_await, futures_api)]
     /// # futures::executor::block_on(async {
     /// use futures::channel::mpsc;
     /// use futures::future::{Fuse, FusedFuture, FutureExt};

futures-util/src/future/join.rs

@@ -90,15 +90,15 @@ generate! {
 /// # Examples
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
 /// let a = future::ready(1);
 /// let b = future::ready(2);
 /// let pair = future::join(a, b);
 ///
-/// assert_eq!(await!(pair), (1, 2));
+/// assert_eq!(pair.await, (1, 2));
 /// # });
 /// ```
 pub fn join<Fut1, Fut2>(future1: Fut1, future2: Fut2) -> Join<Fut1, Fut2>
@@ -115,7 +115,7 @@ where
 /// # Examples
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
@@ -124,7 +124,7 @@ where
 /// let c = future::ready(3);
 /// let tuple = future::join3(a, b, c);
 ///
-/// assert_eq!(await!(tuple), (1, 2, 3));
+/// assert_eq!(tuple.await, (1, 2, 3));
 /// # });
 /// ```
 pub fn join3<Fut1, Fut2, Fut3>(
@@ -145,7 +145,7 @@ where
 /// # Examples
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
@@ -155,7 +155,7 @@ where
 /// let d = future::ready(4);
 /// let tuple = future::join4(a, b, c, d);
 ///
-/// assert_eq!(await!(tuple), (1, 2, 3, 4));
+/// assert_eq!(tuple.await, (1, 2, 3, 4));
 /// # });
 /// ```
 pub fn join4<Fut1, Fut2, Fut3, Fut4>(
@@ -179,7 +179,7 @@ where
 /// # Examples
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
@@ -190,7 +190,7 @@ where
 /// let e = future::ready(5);
 /// let tuple = future::join5(a, b, c, d, e);
 ///
-/// assert_eq!(await!(tuple), (1, 2, 3, 4, 5));
+/// assert_eq!(tuple.await, (1, 2, 3, 4, 5));
 /// # });
 /// ```
 pub fn join5<Fut1, Fut2, Fut3, Fut4, Fut5>(

futures-util/src/future/join_all.rs

@@ -99,15 +99,15 @@ where
 /// # Examples
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::future::{join_all};
 ///
 /// async fn foo(i: u32) -> u32 { i }
 ///
 /// let futures = vec![foo(1), foo(2), foo(3)];
 ///
-/// assert_eq!(await!(join_all(futures)), [1, 2, 3]);
+/// assert_eq!(join_all(futures).await, [1, 2, 3]);
 /// # });
 /// ```
 pub fn join_all<I>(i: I) -> JoinAll<I::Item>

futures-util/src/future/lazy.rs

@@ -19,12 +19,12 @@ impl<F> Unpin for Lazy<F> {}
 /// # Examples
 ///
 /// ```
-/// #![feature(async_await, await_macro)]
+/// #![feature(async_await)]
 /// # futures::executor::block_on(async {
 /// use futures::future;
 ///
 /// let a = future::lazy(|_| 1);
-/// assert_eq!(await!(a), 1);
+/// assert_eq!(a.await, 1);
 ///
 /// let b = future::lazy(|_| -> i32 {
 ///     panic!("oh no!")