fixup! chore: replace all doctest usage of pin_mut with pin

Signed-off-by: tison <[email protected]>

Author: tisonkun

futures-util/src/async_await/select_mod.rs

@@ -58,7 +58,7 @@ macro_rules! document_select_macro {
         /// select! {
         ///     x = st.next() => assert_eq!(Some(2), x),
         ///     _ = fut => panic!(),
-        /// };
+        /// }
         /// # });
         /// ```
         ///
@@ -87,14 +87,15 @@ macro_rules! document_select_macro {
         /// If a similar async function is called outside of `select` to produce
         /// a `Future`, the `Future` must be pinned in order to be able to pass
         /// it to `select`. This can be achieved via `Box::pin` for pinning a
-        /// `Future` on the heap or the `pin_mut!` macro for pinning a `Future`
+        /// `Future` on the heap or the `pin!` macro for pinning a `Future`
         /// on the stack.
         ///
         /// ```
         /// # futures::executor::block_on(async {
+        /// use core::pin::pin;
+        ///
         /// use futures::future::FutureExt;
         /// use futures::select;
-        /// use futures::pin_mut;
         ///
         /// // Calling the following async fn returns a Future which does not
         /// // implement Unpin
@@ -105,7 +106,7 @@ macro_rules! document_select_macro {
         /// let fut_1 = async_identity_fn(1).fuse();
         /// let fut_2 = async_identity_fn(2).fuse();
         /// let mut fut_1 = Box::pin(fut_1); // Pins the Future on the heap
-        /// pin_mut!(fut_2); // Pins the Future on the stack
+        /// let mut fut_2 = pin!(fut_2); // Pins the Future on the stack
         ///
         /// let res = select! {
         ///     a_res = fut_1 => a_res,
@@ -138,7 +139,7 @@ macro_rules! document_select_macro {
         ///         b = b_fut => total += b,
         ///         complete => break,
         ///         default => panic!(), // never runs (futures run first, then complete)
-        ///     };
+        ///     }
         /// }
         /// assert_eq!(total, 10);
         /// # });
@@ -209,7 +210,7 @@ macro_rules! document_select_macro {
         /// select_biased! {
         ///     x = st.next() => assert_eq!(Some(2), x),
         ///     _ = fut => panic!(),
-        /// };
+        /// }
         /// # });
         /// ```
         ///
@@ -238,14 +239,15 @@ macro_rules! document_select_macro {
         /// If a similar async function is called outside of `select_biased` to produce
         /// a `Future`, the `Future` must be pinned in order to be able to pass
         /// it to `select_biased`. This can be achieved via `Box::pin` for pinning a
-        /// `Future` on the heap or the `pin_mut!` macro for pinning a `Future`
+        /// `Future` on the heap or the `pin!` macro for pinning a `Future`
         /// on the stack.
         ///
         /// ```
         /// # futures::executor::block_on(async {
+        /// use core::pin::pin;
+        ///
         /// use futures::future::FutureExt;
         /// use futures::select_biased;
-        /// use futures::pin_mut;
         ///
         /// // Calling the following async fn returns a Future which does not
         /// // implement Unpin
@@ -256,7 +258,7 @@ macro_rules! document_select_macro {
         /// let fut_1 = async_identity_fn(1).fuse();
         /// let fut_2 = async_identity_fn(2).fuse();
         /// let mut fut_1 = Box::pin(fut_1); // Pins the Future on the heap
-        /// pin_mut!(fut_2); // Pins the Future on the stack
+        /// let mut fut_2 = pin!(fut_2); // Pins the Future on the stack
         ///
         /// let res = select_biased! {
         ///     a_res = fut_1 => a_res,
@@ -289,7 +291,7 @@ macro_rules! document_select_macro {
         ///         b = b_fut => total += b,
         ///         complete => break,
         ///         default => panic!(), // never runs (futures run first, then complete)
-        ///     };
+        ///     }
         /// }
         /// assert_eq!(total, 10);
         /// # });

futures-util/src/future/future/fuse.rs

@@ -29,11 +29,12 @@ impl<Fut: Future> Fuse<Fut> {
     ///
     /// ```
     /// # futures::executor::block_on(async {
+    /// use core::pin::pin;
+    ///
     /// use futures::channel::mpsc;
     /// use futures::future::{Fuse, FusedFuture, FutureExt};
     /// use futures::select;
     /// use futures::stream::StreamExt;
-    /// use futures::pin_mut;
     ///
     /// let (sender, mut stream) = mpsc::unbounded();
     ///
@@ -45,7 +46,7 @@ impl<Fut: Future> Fuse<Fut> {
     /// // Use `Fuse::terminated()` to create an already-terminated future
     /// // which may be instantiated later.
     /// let foo_printer = Fuse::terminated();
-    /// pin_mut!(foo_printer);
+    /// let mut foo_printer = pin!(foo_printer);
     ///
     /// loop {
     ///     select! {

futures-util/src/future/maybe_done.rs

@@ -29,11 +29,12 @@ impl<Fut: Future + Unpin> Unpin for MaybeDone<Fut> {}
 ///
 /// ```
 /// # futures::executor::block_on(async {
+/// use core::pin::pin;
+///
 /// use futures::future;
-/// use futures::pin_mut;
 ///
 /// let future = future::maybe_done(async { 5 });
-/// pin_mut!(future);
+/// let mut future = pin!(future);
 /// assert_eq!(future.as_mut().take_output(), None);
 /// let () = future.as_mut().await;
 /// assert_eq!(future.as_mut().take_output(), Some(5));

futures-util/src/future/poll_immediate.rs

@@ -48,17 +48,19 @@ impl<T: Future> FusedFuture for PollImmediate<T> {
 /// so polling it in a tight loop is worse than using a blocking synchronous function.
 /// ```
 /// # futures::executor::block_on(async {
+/// use core::pin::pin;
+///
 /// use futures::task::Poll;
-/// use futures::{StreamExt, future, pin_mut};
+/// use futures::{StreamExt, future};
 /// use future::FusedFuture;
 ///
 /// let f = async { 1_u32 };
-/// pin_mut!(f);
+/// let mut f = pin!(f);
 /// let mut r = future::poll_immediate(f);
 /// assert_eq!(r.next().await, Some(Poll::Ready(1)));
 ///
 /// let f = async {futures::pending!(); 42_u8};
-/// pin_mut!(f);
+/// let mut f = pin!(f);
 /// let mut p = future::poll_immediate(f);
 /// assert_eq!(p.next().await, Some(Poll::Pending));
 /// assert!(!p.is_terminated());
@@ -114,9 +116,12 @@ where
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::{future, pin_mut};
+/// use core::pin::pin;
+///
+/// use futures::future;
+///
 /// let f = async {futures::pending!(); 42_u8};
-/// pin_mut!(f);
+/// let mut f = pin!(f);
 /// assert_eq!(None, future::poll_immediate(&mut f).await);
 /// assert_eq!(42, f.await);
 /// # });

futures-util/src/future/select.rs

@@ -32,11 +32,10 @@ impl<A: Unpin, B: Unpin> Unpin for Select<A, B> {}
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::{
-///     pin_mut,
-///     future::Either,
-///     future::self,
-/// };
+/// use core::pin::pin;
+///
+/// use futures::future;
+/// use futures::future::Either;
 ///
 /// // These two futures have different types even though their outputs have the same type.
 /// let future1 = async {
@@ -48,8 +47,8 @@ impl<A: Unpin, B: Unpin> Unpin for Select<A, B> {}
 /// };
 ///
 /// // 'select' requires Future + Unpin bounds
-/// pin_mut!(future1);
-/// pin_mut!(future2);
+/// let mut future1 = pin!(future1);
+/// let mut future2 = pin!(future2);
 ///
 /// let value = match future::select(future1, future2).await {
 ///     Either::Left((value1, _)) => value1,  // `value1` is resolved from `future1`

futures-util/src/macros.rs

@@ -9,11 +9,11 @@
 /// # Example
 ///
 /// ```rust
-/// # use futures_util::pin_mut;
+/// # use core::pin::pin;
 /// # use core::pin::Pin;
 /// # struct Foo {}
 /// let foo = Foo { /* ... */ };
-/// pin_mut!(foo);
+/// let foo = pin!(foo);
 /// let _: Pin<&mut Foo> = foo;
 /// ```
 #[macro_export]

futures-util/src/sink/unfold.rs

@@ -23,7 +23,10 @@ pin_project! {
 ///
 /// ```
 /// # futures::executor::block_on(async {
-/// use futures::sink::{self, SinkExt};
+/// use core::pin::pin;
+///
+/// use futures::sink;
+/// use futures::sink::SinkExt;
 ///
 /// let unfold = sink::unfold(0, |mut sum, i: i32| {
 ///     async move {
@@ -32,7 +35,7 @@ pin_project! {
 ///         Ok::<_, std::convert::Infallible>(sum)
 ///     }
 /// });
-/// futures::pin_mut!(unfold);
+/// let mut unfold = pin!(unfold);
 /// unfold.send(5).await?;
 /// # Ok::<(), std::convert::Infallible>(()) }).unwrap();
 /// ```

futures-util/src/stream/stream/peek.rs

@@ -64,11 +64,13 @@ impl<St: Stream> Peekable<St> {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::stream::{self, StreamExt};
-    /// use futures::pin_mut;
+    /// use core::pin::pin;
+    ///
+    /// use futures::stream;
+    /// use futures::stream::StreamExt;
     ///
     /// let stream = stream::iter(vec![1, 2, 3]).peekable();
-    /// pin_mut!(stream);
+    /// let mut stream = pin!(stream);
     ///
     /// assert_eq!(stream.as_mut().peek_mut().await, Some(&mut 1));
     /// assert_eq!(stream.as_mut().next().await, Some(1));
@@ -117,11 +119,13 @@ impl<St: Stream> Peekable<St> {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::stream::{self, StreamExt};
-    /// use futures::pin_mut;
+    /// use core::pin::pin;
+    ///
+    /// use futures::stream;
+    /// use futures::stream::StreamExt;
     ///
     /// let stream = stream::iter(0..5).peekable();
-    /// pin_mut!(stream);
+    /// let mut stream = pin!(stream);
     /// // The first item of the stream is 0; consume it.
     /// assert_eq!(stream.as_mut().next_if(|&x| x == 0).await, Some(0));
     /// // The next item returned is now 1, so `consume` will return `false`.
@@ -135,11 +139,13 @@ impl<St: Stream> Peekable<St> {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::stream::{self, StreamExt};
-    /// use futures::pin_mut;
+    /// use core::pin::pin;
+    ///
+    /// use futures::stream;
+    /// use futures::stream::StreamExt;
     ///
     /// let stream = stream::iter(1..20).peekable();
-    /// pin_mut!(stream);
+    /// let mut stream = pin!(stream);
     /// // Consume all numbers less than 10
     /// while stream.as_mut().next_if(|&x| x < 10).await.is_some() {}
     /// // The next value returned will be 10
@@ -162,11 +168,13 @@ impl<St: Stream> Peekable<St> {
     ///
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::stream::{self, StreamExt};
-    /// use futures::pin_mut;
+    /// use core::pin::pin;
+    ///
+    /// use futures::stream;
+    /// use futures::stream::StreamExt;
     ///
     /// let stream = stream::iter(0..5).peekable();
-    /// pin_mut!(stream);
+    /// let mut stream = pin!(stream);
     /// // The first item of the stream is 0; consume it.
     /// assert_eq!(stream.as_mut().next_if_eq(&0).await, Some(0));
     /// // The next item returned is now 1, so `consume` will return `false`.

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

@@ -657,16 +657,19 @@ pub trait TryStreamExt: TryStream {
     /// # Examples
     /// ```
     /// # futures::executor::block_on(async {
-    /// use futures::stream::{self, StreamExt, TryStreamExt};
-    /// use futures::pin_mut;
+    /// use core::pin::pin;
+    ///
+    /// use futures::stream;
+    /// use futures::stream::StreamExt;
+    /// use futures::stream::TryStreamExt;
     ///
     /// let stream = stream::iter(vec![Ok(1i32), Ok(6i32), Err("error")]);
     /// let halves = stream.try_filter_map(|x| async move {
     ///     let ret = if x % 2 == 0 { Some(x / 2) } else { None };
     ///     Ok(ret)
     /// });
     ///
-    /// pin_mut!(halves);
+    /// let mut halves = pin!(halves);
     /// assert_eq!(halves.next().await, Some(Ok(3)));
     /// assert_eq!(halves.next().await, Some(Err("error")));
     /// # })