chore: replace all doctest usage of pin_mut with pin (#2940)

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

Author: tisonkun

futures-test/src/assert.rs

@@ -9,15 +9,16 @@ pub fn assert_is_unpin_stream<S: Stream + Unpin>(_: &mut S) {}
 /// # Examples
 ///
 /// ```
+/// use core::pin::pin;
+///
 /// use futures::stream;
 /// use futures_test::future::FutureTestExt;
-/// use futures_test::{
-///     assert_stream_pending, assert_stream_next, assert_stream_done,
-/// };
-/// use futures::pin_mut;
+/// use futures_test::assert_stream_pending;
+/// use futures_test::assert_stream_next;
+/// use futures_test::assert_stream_done;
 ///
 /// let stream = stream::once((async { 5 }).pending_once());
-/// pin_mut!(stream);
+/// let mut stream = pin!(stream);
 ///
 /// assert_stream_pending!(stream);
 /// assert_stream_next!(stream, 5);
@@ -46,15 +47,16 @@ macro_rules! assert_stream_pending {
 /// # Examples
 ///
 /// ```
+/// use core::pin::pin;
+///
 /// use futures::stream;
 /// use futures_test::future::FutureTestExt;
-/// use futures_test::{
-///     assert_stream_pending, assert_stream_next, assert_stream_done,
-/// };
-/// use futures::pin_mut;
+/// use futures_test::assert_stream_pending;
+/// use futures_test::assert_stream_next;
+/// use futures_test::assert_stream_done;
 ///
 /// let stream = stream::once((async { 5 }).pending_once());
-/// pin_mut!(stream);
+/// let mut stream = pin!(stream);
 ///
 /// assert_stream_pending!(stream);
 /// assert_stream_next!(stream, 5);
@@ -90,15 +92,16 @@ macro_rules! assert_stream_next {
 /// # Examples
 ///
 /// ```
+/// use core::pin::pin;
+///
 /// use futures::stream;
 /// use futures_test::future::FutureTestExt;
-/// use futures_test::{
-///     assert_stream_pending, assert_stream_next, assert_stream_done,
-/// };
-/// use futures::pin_mut;
+/// use futures_test::assert_stream_pending;
+/// use futures_test::assert_stream_next;
+/// use futures_test::assert_stream_done;
 ///
 /// let stream = stream::once((async { 5 }).pending_once());
-/// pin_mut!(stream);
+/// let mut stream = pin!(stream);
 ///
 /// assert_stream_pending!(stream);
 /// assert_stream_next!(stream, 5);

futures-test/src/future/mod.rs

@@ -32,14 +32,15 @@ pub trait FutureTestExt: Future {
     /// # Examples
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::future::FutureExt;
     /// use futures_test::task::noop_context;
     /// use futures_test::future::FutureTestExt;
-    /// use futures::pin_mut;
     ///
     /// let future = (async { 5 }).pending_once();
-    /// pin_mut!(future);
+    /// let mut future = pin!(future);
     ///
     /// let mut cx = noop_context();
     ///
@@ -84,14 +85,15 @@ pub trait FutureTestExt: Future {
     /// # Examples
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::future::{self, Future};
     /// use futures_test::task::noop_context;
     /// use futures_test::future::FutureTestExt;
-    /// use futures::pin_mut;
     ///
     /// let future = future::ready(1).interleave_pending();
-    /// pin_mut!(future);
+    /// let mut future = pin!(future);
     ///
     /// let mut cx = noop_context();
     ///

futures-test/src/io/read/mod.rs

@@ -29,14 +29,15 @@ pub trait AsyncReadTestExt: AsyncRead {
     /// # Examples
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::io::{AsyncRead, Cursor};
     /// use futures_test::task::noop_context;
     /// use futures_test::io::AsyncReadTestExt;
-    /// use futures::pin_mut;
     ///
     /// let reader = Cursor::new(&[1, 2, 3]).interleave_pending();
-    /// pin_mut!(reader);
+    /// let mut reader = pin!(reader);
     ///
     /// let mut cx = noop_context();
     ///
@@ -59,14 +60,15 @@ pub trait AsyncReadTestExt: AsyncRead {
     /// The returned reader will also implement `AsyncBufRead` if the underlying reader does.
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::io::{AsyncBufRead, Cursor};
     /// use futures_test::task::noop_context;
     /// use futures_test::io::AsyncReadTestExt;
-    /// use futures::pin_mut;
     ///
     /// let reader = Cursor::new(&[1, 2, 3]).interleave_pending();
-    /// pin_mut!(reader);
+    /// let mut reader = pin!(reader);
     ///
     /// let mut cx = noop_context();
     ///
@@ -93,14 +95,15 @@ pub trait AsyncReadTestExt: AsyncRead {
     /// # Examples
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::io::{AsyncRead, Cursor};
     /// use futures_test::task::noop_context;
     /// use futures_test::io::AsyncReadTestExt;
-    /// use futures::pin_mut;
     ///
     /// let reader = Cursor::new(&[1, 2, 3, 4, 5]).limited(2);
-    /// pin_mut!(reader);
+    /// let mut reader = pin!(reader);
     ///
     /// let mut cx = noop_context();
     ///

futures-test/src/io/write/mod.rs

@@ -30,14 +30,15 @@ pub trait AsyncWriteTestExt: AsyncWrite {
     /// # Examples
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::io::{AsyncWrite, Cursor};
     /// use futures_test::task::noop_context;
     /// use futures_test::io::AsyncWriteTestExt;
-    /// use futures::pin_mut;
     ///
     /// let writer = Cursor::new(vec![0u8; 4].into_boxed_slice()).interleave_pending_write();
-    /// pin_mut!(writer);
+    /// let mut writer = pin!(writer);
     ///
     /// let mut cx = noop_context();
     ///
@@ -70,14 +71,15 @@ pub trait AsyncWriteTestExt: AsyncWrite {
     /// # Examples
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::io::{AsyncWrite, Cursor};
     /// use futures_test::task::noop_context;
     /// use futures_test::io::AsyncWriteTestExt;
-    /// use futures::pin_mut;
     ///
     /// let writer = Cursor::new(vec![0u8; 4].into_boxed_slice()).limited_write(2);
-    /// pin_mut!(writer);
+    /// let mut writer = pin!(writer);
     ///
     /// let mut cx = noop_context();
     ///

futures-test/src/stream/mod.rs

@@ -28,14 +28,15 @@ pub trait StreamTestExt: Stream {
     /// # Examples
     ///
     /// ```
+    /// use core::pin::pin;
+    ///
     /// use futures::task::Poll;
     /// use futures::stream::{self, Stream};
     /// use futures_test::task::noop_context;
     /// use futures_test::stream::StreamTestExt;
-    /// use futures::pin_mut;
     ///
     /// let stream = stream::iter(vec![1, 2]).interleave_pending();
-    /// pin_mut!(stream);
+    /// let mut stream = pin!(stream);
     ///
     /// let mut cx = noop_context();
     ///

futures-test/src/task/context.rs

@@ -22,13 +22,14 @@ pub fn panic_context() -> Context<'static> {
 /// # Examples
 ///
 /// ```
+/// use core::pin::pin;
+///
 /// use futures::future::Future;
 /// use futures::task::Poll;
 /// use futures_test::task::noop_context;
-/// use futures::pin_mut;
 ///
 /// let future = async { 5 };
-/// pin_mut!(future);
+/// let future = pin!(future);
 ///
 /// assert_eq!(future.poll(&mut noop_context()), Poll::Ready(5));
 /// ```

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