chore: replace all internal usage of pin_mut

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

Author: tisonkun

futures-channel/tests/mpsc.rs

@@ -1,7 +1,7 @@
+use std::pin::pin;
 use futures::channel::{mpsc, oneshot};
 use futures::executor::{block_on, block_on_stream};
 use futures::future::{poll_fn, FutureExt};
-use futures::pin_mut;
 use futures::sink::{Sink, SinkExt};
 use futures::stream::{Stream, StreamExt};
 use futures::task::{Context, Poll};
@@ -30,7 +30,8 @@ fn send_recv_no_buffer() {
     // Run on a task context
     block_on(poll_fn(move |cx| {
         let (tx, rx) = mpsc::channel::<i32>(0);
-        pin_mut!(tx, rx);
+        let mut tx = pin!(tx);
+        let mut rx = pin!(rx);
 
         assert!(tx.as_mut().poll_flush(cx).is_ready());
         assert!(tx.as_mut().poll_ready(cx).is_ready());

futures-executor/src/local_pool.rs

@@ -4,11 +4,11 @@ use futures_core::stream::Stream;
 use futures_core::task::{Context, Poll};
 use futures_task::{waker_ref, ArcWake};
 use futures_task::{FutureObj, LocalFutureObj, LocalSpawn, Spawn, SpawnError};
-use futures_util::pin_mut;
 use futures_util::stream::FuturesUnordered;
 use futures_util::stream::StreamExt;
 use std::cell::RefCell;
 use std::ops::{Deref, DerefMut};
+use std::pin::pin;
 use std::rc::{Rc, Weak};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
@@ -155,7 +155,7 @@ impl LocalPool {
     /// one of the pool's run or poll methods. While the function is running,
     /// however, all tasks in the pool will try to make progress.
     pub fn run_until<F: Future>(&mut self, future: F) -> F::Output {
-        pin_mut!(future);
+        let mut future = pin!(future);
 
         run_executor(|cx| {
             {
@@ -312,7 +312,7 @@ impl Default for LocalPool {
 ///
 /// Use a [`LocalPool`] if you need finer-grained control over spawned tasks.
 pub fn block_on<F: Future>(f: F) -> F::Output {
-    pin_mut!(f);
+    let mut f = pin!(f);
     run_executor(|cx| f.as_mut().poll(cx))
 }
 

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

@@ -7,10 +7,9 @@
 use alloc::boxed::Box;
 use core::convert::Infallible;
 use core::pin::Pin;
-
+use std::pin::pin;
 use crate::fns::{inspect_fn, into_fn, ok_fn, InspectFn, IntoFn, OkFn};
 use crate::future::{assert_future, Either};
-use crate::pin_mut;
 use crate::stream::assert_stream;
 #[cfg(feature = "alloc")]
 use futures_core::future::{BoxFuture, LocalBoxFuture};
@@ -592,8 +591,7 @@ pub trait FutureExt: Future {
         let noop_waker = crate::task::noop_waker();
         let mut cx = Context::from_waker(&noop_waker);
 
-        let this = self;
-        pin_mut!(this);
+        let this = pin!(self);
         match this.poll(&mut cx) {
             Poll::Ready(x) => Some(x),
             _ => None,

futures/tests/async_await_macros.rs

@@ -5,15 +5,15 @@ use futures::sink::SinkExt;
 use futures::stream::StreamExt;
 use futures::task::{Context, Poll};
 use futures::{
-    join, pending, pin_mut, poll, select, select_biased, stream, stream_select, try_join,
+    join, pending, poll, select, select_biased, stream, stream_select, try_join,
 };
-use std::mem;
+use std::pin::pin;
 
 #[test]
 fn poll_and_pending() {
     let pending_once = async { pending!() };
     block_on(async {
-        pin_mut!(pending_once);
+        let mut pending_once = pin!(pending_once);
         assert_eq!(Poll::Pending, poll!(&mut pending_once));
         assert_eq!(Poll::Ready(()), poll!(&mut pending_once));
     });
@@ -30,7 +30,7 @@ fn join() {
     };
 
     block_on(async {
-        pin_mut!(fut);
+        let mut fut = pin!(fut);
         assert_eq!(Poll::Pending, poll!(&mut fut));
         tx1.send(1).unwrap();
         assert_eq!(Poll::Pending, poll!(&mut fut));
@@ -124,7 +124,7 @@ fn select_streams() {
                 },
                 // runs last
                 complete => break,
-            };
+            }
         }
     });
     assert!(ran);
@@ -181,7 +181,7 @@ fn select_size() {
             _ = ready => {},
         }
     };
-    assert_eq!(mem::size_of_val(&fut), 24);
+    assert_eq!(size_of_val(&fut), 24);
 
     let fut = async {
         let mut ready1 = future::ready(0i32);
@@ -191,7 +191,7 @@ fn select_size() {
             _ = ready2 => {},
         }
     };
-    assert_eq!(mem::size_of_val(&fut), 40);
+    assert_eq!(size_of_val(&fut), 40);
 }
 
 #[test]
@@ -204,7 +204,7 @@ fn select_on_non_unpin_expressions() {
         select! {
             value_1 = make_non_unpin_fut().fuse() => select_res = value_1,
             value_2 = make_non_unpin_fut().fuse() => select_res = value_2,
-        };
+        }
         select_res
     });
     assert_eq!(res, 5);
@@ -221,7 +221,7 @@ fn select_on_non_unpin_expressions_with_default() {
             value_1 = make_non_unpin_fut().fuse() => select_res = value_1,
             value_2 = make_non_unpin_fut().fuse() => select_res = value_2,
             default => select_res = 7,
-        };
+        }
         select_res
     });
     assert_eq!(res, 5);
@@ -238,11 +238,11 @@ fn select_on_non_unpin_size() {
         select! {
             value_1 = make_non_unpin_fut().fuse() => select_res = value_1,
             value_2 = make_non_unpin_fut().fuse() => select_res = value_2,
-        };
+        }
         select_res
     };
 
-    assert_eq!(32, mem::size_of_val(&fut));
+    assert_eq!(32, size_of_val(&fut));
 }
 
 #[test]
@@ -364,14 +364,14 @@ fn join_size() {
         let ready = future::ready(0i32);
         join!(ready)
     };
-    assert_eq!(mem::size_of_val(&fut), 24);
+    assert_eq!(size_of_val(&fut), 24);
 
     let fut = async {
         let ready1 = future::ready(0i32);
         let ready2 = future::ready(0i32);
         join!(ready1, ready2)
     };
-    assert_eq!(mem::size_of_val(&fut), 40);
+    assert_eq!(size_of_val(&fut), 40);
 }
 
 #[cfg_attr(not(target_pointer_width = "64"), ignore)]
@@ -381,14 +381,14 @@ fn try_join_size() {
         let ready = future::ready(Ok::<i32, i32>(0));
         try_join!(ready)
     };
-    assert_eq!(mem::size_of_val(&fut), 24);
+    assert_eq!(size_of_val(&fut), 24);
 
     let fut = async {
         let ready1 = future::ready(Ok::<i32, i32>(0));
         let ready2 = future::ready(Ok::<i32, i32>(0));
         try_join!(ready1, ready2)
     };
-    assert_eq!(mem::size_of_val(&fut), 48);
+    assert_eq!(size_of_val(&fut), 48);
 }
 
 #[allow(clippy::let_underscore_future)]

futures/tests/future_join_all.rs

@@ -1,14 +1,14 @@
 use futures::executor::block_on;
 use futures::future::{join_all, ready, Future, JoinAll};
-use futures::pin_mut;
 use std::fmt::Debug;
+use std::pin::pin;
 
 #[track_caller]
 fn assert_done<T>(actual_fut: impl Future<Output = T>, expected: T)
 where
     T: PartialEq + Debug,
 {
-    pin_mut!(actual_fut);
+    let actual_fut = pin!(actual_fut);
     let output = block_on(actual_fut);
     assert_eq!(output, expected);
 }

futures/tests/future_try_join_all.rs

@@ -1,14 +1,14 @@
 use futures::executor::block_on;
 use futures::future::{err, ok, try_join_all, Future, TryJoinAll};
-use futures::pin_mut;
 use std::fmt::Debug;
+use std::pin::pin;
 
 #[track_caller]
 fn assert_done<T>(actual_fut: impl Future<Output = T>, expected: T)
 where
     T: PartialEq + Debug,
 {
-    pin_mut!(actual_fut);
+    let actual_fut = pin!(actual_fut);
     let output = block_on(actual_fut);
     assert_eq!(output, expected);
 }

futures/tests/io_buf_reader.rs

@@ -4,13 +4,12 @@ use futures::io::{
     AllowStdIo, AsyncBufRead, AsyncBufReadExt, AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt,
     BufReader, SeekFrom,
 };
-use futures::pin_mut;
 use futures::task::{Context, Poll};
 use futures_test::task::noop_context;
 use pin_project::pin_project;
 use std::cmp;
 use std::io;
-use std::pin::Pin;
+use std::pin::{pin, Pin};
 
 // helper for maybe_pending_* tests
 fn run<F: Future + Unpin>(mut f: F) -> F::Output {
@@ -157,7 +156,7 @@ fn test_buffered_reader_seek() {
     block_on(async {
         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
         let reader = BufReader::with_capacity(2, Cursor::new(inner));
-        pin_mut!(reader);
+        let mut reader =  pin!(reader);
 
         assert_eq!(reader.seek(SeekFrom::Start(3)).await.unwrap(), 3);
         assert_eq!(reader.as_mut().fill_buf().await.unwrap(), &[0, 1][..]);
@@ -175,7 +174,7 @@ fn test_buffered_reader_seek_relative() {
     block_on(async {
         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
         let reader = BufReader::with_capacity(2, Cursor::new(inner));
-        pin_mut!(reader);
+        let mut reader =  pin!(reader);
 
         assert!(reader.as_mut().seek_relative(3).await.is_ok());
         assert_eq!(reader.as_mut().fill_buf().await.unwrap(), &[0, 1][..]);
@@ -195,7 +194,7 @@ fn test_buffered_reader_invalidated_after_read() {
     block_on(async {
         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
         let reader = BufReader::with_capacity(3, Cursor::new(inner));
-        pin_mut!(reader);
+        let mut reader =  pin!(reader);
 
         assert_eq!(reader.as_mut().fill_buf().await.unwrap(), &[5, 6, 7][..]);
         reader.as_mut().consume(3);
@@ -216,7 +215,7 @@ fn test_buffered_reader_invalidated_after_seek() {
     block_on(async {
         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
         let reader = BufReader::with_capacity(3, Cursor::new(inner));
-        pin_mut!(reader);
+        let mut reader =  pin!(reader);
 
         assert_eq!(reader.as_mut().fill_buf().await.unwrap(), &[5, 6, 7][..]);
         reader.as_mut().consume(3);
@@ -265,7 +264,7 @@ fn test_buffered_reader_seek_underflow() {
 
     block_on(async {
         let reader = BufReader::with_capacity(5, AllowStdIo::new(PositionReader { pos: 0 }));
-        pin_mut!(reader);
+        let mut reader =  pin!(reader);
         assert_eq!(reader.as_mut().fill_buf().await.unwrap(), &[0, 1, 2, 3, 4][..]);
         assert_eq!(reader.seek(SeekFrom::End(-5)).await.unwrap(), u64::MAX - 5);
         assert_eq!(reader.as_mut().fill_buf().await.unwrap().len(), 5);
@@ -419,7 +418,7 @@ fn maybe_pending_seek() {
 
     let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
     let reader = BufReader::with_capacity(2, MaybePendingSeek::new(inner));
-    pin_mut!(reader);
+    let mut reader =  pin!(reader);
 
     assert_eq!(run(reader.seek(SeekFrom::Current(3))).ok(), Some(3));
     assert_eq!(run(reader.as_mut().fill_buf()).ok(), Some(&[0, 1][..]));

futures/tests/sink.rs

@@ -11,7 +11,7 @@ use std::collections::VecDeque;
 use std::convert::Infallible;
 use std::fmt;
 use std::mem;
-use std::pin::Pin;
+use std::pin::{pin, Pin};
 use std::rc::Rc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -509,7 +509,7 @@ fn sink_unfold() {
                 Ok::<_, String>(())
             }
         });
-        futures::pin_mut!(unfold);
+        let mut unfold = pin!(unfold);
         assert_eq!(unfold.as_mut().start_send(1), Ok(()));
         assert_eq!(unfold.as_mut().poll_flush(cx), Poll::Ready(Ok(())));
         assert_eq!(rx.try_next().unwrap(), Some(1));

futures/tests/stream_peekable.rs

@@ -1,17 +1,17 @@
+use std::pin::pin;
 use futures::executor::block_on;
-use futures::pin_mut;
 use futures::stream::{self, Peekable, StreamExt};
 
 #[test]
 fn peekable() {
     block_on(async {
         let peekable: Peekable<_> = stream::iter(vec![1u8, 2, 3]).peekable();
-        pin_mut!(peekable);
+        let mut peekable = pin!(peekable);
         assert_eq!(peekable.as_mut().peek().await, Some(&1u8));
         assert_eq!(peekable.collect::<Vec<u8>>().await, vec![1, 2, 3]);
 
         let s = stream::once(async { 1 }).peekable();
-        pin_mut!(s);
+        let mut s = pin!(s);
         assert_eq!(s.as_mut().peek().await, Some(&1u8));
         assert_eq!(s.collect::<Vec<u8>>().await, vec![1]);
     });
@@ -21,7 +21,7 @@ fn peekable() {
 fn peekable_mut() {
     block_on(async {
         let s = stream::iter(vec![1u8, 2, 3]).peekable();
-        pin_mut!(s);
+        let mut s = pin!(s);
         if let Some(p) = s.as_mut().peek_mut().await {
             if *p == 1 {
                 *p = 5;
@@ -36,7 +36,7 @@ fn peekable_next_if_eq() {
     block_on(async {
         // first, try on references
         let s = stream::iter(vec!["Heart", "of", "Gold"]).peekable();
-        pin_mut!(s);
+        let mut s = pin!(s);
         // try before `peek()`
         assert_eq!(s.as_mut().next_if_eq(&"trillian").await, None);
         assert_eq!(s.as_mut().next_if_eq(&"Heart").await, Some("Heart"));
@@ -49,7 +49,7 @@ fn peekable_next_if_eq() {
 
         // make sure comparison works for owned values
         let s = stream::iter(vec![String::from("Ludicrous"), "speed".into()]).peekable();
-        pin_mut!(s);
+        let mut s = pin!(s);
         // make sure basic functionality works
         assert_eq!(s.as_mut().next_if_eq("Ludicrous").await, Some("Ludicrous".into()));
         assert_eq!(s.as_mut().next_if_eq("speed").await, Some("speed".into()));