Call Pin::get_* as method

taiki-e · cramertj · commit db79aef50445 · 2019-06-10T10:17:35.000-07:00
diff --git a/futures-core/src/stream/mod.rs b/futures-core/src/stream/mod.rs
@@ -79,7 +79,7 @@ where
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
-        Pin::get_mut(self).as_mut().poll_next(cx)
+        self.get_mut().as_mut().poll_next(cx)
     }
 }
 
diff --git a/futures-io/src/lib.rs b/futures-io/src/lib.rs
@@ -376,13 +376,13 @@ mod if_std {
         fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8])
             -> Poll<Result<usize>>
         {
-            Pin::get_mut(self).as_mut().poll_read(cx, buf)
+            self.get_mut().as_mut().poll_read(cx, buf)
         }
 
         fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>])
             -> Poll<Result<usize>>
         {
-            Pin::get_mut(self).as_mut().poll_read_vectored(cx, bufs)
+            self.get_mut().as_mut().poll_read_vectored(cx, bufs)
         }
     }
 
@@ -464,21 +464,21 @@ mod if_std {
         fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8])
             -> Poll<Result<usize>>
         {
-            Pin::get_mut(self).as_mut().poll_write(cx, buf)
+            self.get_mut().as_mut().poll_write(cx, buf)
         }
 
         fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>])
             -> Poll<Result<usize>>
         {
-            Pin::get_mut(self).as_mut().poll_write_vectored(cx, bufs)
+            self.get_mut().as_mut().poll_write_vectored(cx, bufs)
         }
 
         fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-            Pin::get_mut(self).as_mut().poll_flush(cx)
+            self.get_mut().as_mut().poll_flush(cx)
         }
 
         fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {
-            Pin::get_mut(self).as_mut().poll_close(cx)
+            self.get_mut().as_mut().poll_close(cx)
         }
     }
 
diff --git a/futures-sink/src/lib.rs b/futures-sink/src/lib.rs
@@ -139,19 +139,19 @@ where
     type SinkError = <P::Target as Sink<Item>>::SinkError;
 
     fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
-        Pin::get_mut(self).as_mut().poll_ready(cx)
+        self.get_mut().as_mut().poll_ready(cx)
     }
 
     fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::SinkError> {
-        Pin::get_mut(self).as_mut().start_send(item)
+        self.get_mut().as_mut().start_send(item)
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
-        Pin::get_mut(self).as_mut().poll_flush(cx)
+        self.get_mut().as_mut().poll_flush(cx)
     }
 
     fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
-        Pin::get_mut(self).as_mut().poll_close(cx)
+        self.get_mut().as_mut().poll_close(cx)
     }
 }
 
@@ -176,7 +176,7 @@ mod if_alloc {
 
         fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::SinkError> {
             // TODO: impl<T> Unpin for Vec<T> {}
-            unsafe { Pin::get_unchecked_mut(self) }.push(item);
+            unsafe { self.get_unchecked_mut() }.push(item);
             Ok(())
         }
 
@@ -198,7 +198,7 @@ mod if_alloc {
 
         fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::SinkError> {
             // TODO: impl<T> Unpin for Vec<T> {}
-            unsafe { Pin::get_unchecked_mut(self) }.push_back(item);
+            unsafe { self.get_unchecked_mut() }.push_back(item);
             Ok(())
         }
 
diff --git a/futures-util/src/future/chain.rs b/futures-util/src/future/chain.rs
@@ -34,7 +34,7 @@ impl<Fut1, Fut2, Data> Chain<Fut1, Fut2, Data>
         let mut f = Some(f);
 
         // Safe to call `get_unchecked_mut` because we won't move the futures.
-        let this = unsafe { Pin::get_unchecked_mut(self) };
+        let this = unsafe { self.get_unchecked_mut() };
 
         loop {
             let (output, data) = match this {
diff --git a/futures-util/src/future/either.rs b/futures-util/src/future/either.rs
@@ -57,7 +57,7 @@ where
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<A::Output> {
         unsafe {
-            match Pin::get_unchecked_mut(self) {
+            match self.get_unchecked_mut() {
                 Either::Left(a) => Pin::new_unchecked(a).poll(cx),
                 Either::Right(b) => Pin::new_unchecked(b).poll(cx),
             }
@@ -74,7 +74,7 @@ where
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<A::Item>> {
         unsafe {
-            match Pin::get_unchecked_mut(self) {
+            match self.get_unchecked_mut() {
                 Either::Left(a) => Pin::new_unchecked(a).poll_next(cx),
                 Either::Right(b) => Pin::new_unchecked(b).poll_next(cx),
             }
@@ -91,7 +91,7 @@ where
 
     fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
         unsafe {
-            match Pin::get_unchecked_mut(self) {
+            match self.get_unchecked_mut() {
                 Either::Left(x) => Pin::new_unchecked(x).poll_ready(cx),
                 Either::Right(x) => Pin::new_unchecked(x).poll_ready(cx),
             }
@@ -100,7 +100,7 @@ where
 
     fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::SinkError> {
         unsafe {
-            match Pin::get_unchecked_mut(self) {
+            match self.get_unchecked_mut() {
                 Either::Left(x) => Pin::new_unchecked(x).start_send(item),
                 Either::Right(x) => Pin::new_unchecked(x).start_send(item),
             }
@@ -109,7 +109,7 @@ where
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
         unsafe {
-            match Pin::get_unchecked_mut(self) {
+            match self.get_unchecked_mut() {
                 Either::Left(x) => Pin::new_unchecked(x).poll_flush(cx),
                 Either::Right(x) => Pin::new_unchecked(x).poll_flush(cx),
             }
@@ -118,7 +118,7 @@ where
 
     fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
         unsafe {
-            match Pin::get_unchecked_mut(self) {
+            match self.get_unchecked_mut() {
                 Either::Left(x) => Pin::new_unchecked(x).poll_close(cx),
                 Either::Right(x) => Pin::new_unchecked(x).poll_close(cx),
             }
diff --git a/futures-util/src/future/flatten_stream.rs b/futures-util/src/future/flatten_stream.rs
@@ -43,7 +43,7 @@ enum State<Fut, St> {
 impl<Fut, St> State<Fut, St> {
     fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> State<Pin<&'a mut Fut>, Pin<&'a mut St>> {
         // safety: data is never moved via the resulting &mut reference
-        match unsafe { Pin::get_unchecked_mut(self) } {
+        match unsafe { self.get_unchecked_mut() } {
             // safety: the future we're re-pinning here will never be moved;
             // it will just be polled, then dropped in place
             State::Future(f) => State::Future(unsafe { Pin::new_unchecked(f) }),
diff --git a/futures-util/src/future/maybe_done.rs b/futures-util/src/future/maybe_done.rs
@@ -52,7 +52,7 @@ impl<Fut: Future> MaybeDone<Fut> {
     #[inline]
     pub fn output_mut<'a>(self: Pin<&'a mut Self>) -> Option<&'a mut Fut::Output> {
         unsafe {
-            let this = Pin::get_unchecked_mut(self);
+            let this = self.get_unchecked_mut();
             match this {
                 MaybeDone::Done(res) => Some(res),
                 _ => None,
@@ -65,7 +65,7 @@ impl<Fut: Future> MaybeDone<Fut> {
     #[inline]
     pub fn take_output(self: Pin<&mut Self>) -> Option<Fut::Output> {
         unsafe {
-            let this = Pin::get_unchecked_mut(self);
+            let this = self.get_unchecked_mut();
             match this {
                 MaybeDone::Done(_) => {},
                 MaybeDone::Future(_) | MaybeDone::Gone => return None,
@@ -93,7 +93,7 @@ impl<Fut: Future> Future for MaybeDone<Fut> {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let res = unsafe {
-            match Pin::get_unchecked_mut(self.as_mut()) {
+            match self.as_mut().get_unchecked_mut() {
                 MaybeDone::Future(a) => ready!(Pin::new_unchecked(a).poll(cx)),
                 MaybeDone::Done(_) => return Poll::Ready(()),
                 MaybeDone::Gone => panic!("MaybeDone polled after value taken"),
diff --git a/futures-util/src/io/buf_reader.rs b/futures-util/src/io/buf_reader.rs
@@ -176,7 +176,7 @@ impl<R: AsyncRead> AsyncBufRead for BufReader<R> {
         self: Pin<&'a mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<io::Result<&'a [u8]>> {
-        let Self { inner, buf, cap, pos } = unsafe { Pin::get_unchecked_mut(self) };
+        let Self { inner, buf, cap, pos } = unsafe { self.get_unchecked_mut() };
         let mut inner = unsafe { Pin::new_unchecked(inner) };
 
         // If we've reached the end of our internal buffer then we need to fetch
diff --git a/futures-util/src/io/buf_writer.rs b/futures-util/src/io/buf_writer.rs
@@ -53,7 +53,7 @@ impl<W: AsyncWrite> BufWriter<W> {
     }
 
     fn flush_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        let Self { inner, buf, written } = unsafe { Pin::get_unchecked_mut(self) };
+        let Self { inner, buf, written } = unsafe { self.get_unchecked_mut() };
         let mut inner = unsafe { Pin::new_unchecked(inner) };
 
         let len = buf.len();
diff --git a/futures-util/src/io/lines.rs b/futures-util/src/io/lines.rs
@@ -33,7 +33,7 @@ impl<R: AsyncBufRead> Stream for Lines<R> {
     type Item = io::Result<String>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let Self { reader, buf, bytes, read } = unsafe { Pin::get_unchecked_mut(self) };
+        let Self { reader, buf, bytes, read } = unsafe { self.get_unchecked_mut() };
         let reader = unsafe { Pin::new_unchecked(reader) };
         let n = ready!(read_line_internal(reader, buf, bytes, read, cx))?;
         if n == 0 && buf.is_empty() {
diff --git a/futures-util/src/sink/fanout.rs b/futures-util/src/sink/fanout.rs
@@ -36,7 +36,7 @@ impl<Si1, Si2> Fanout<Si1, Si2> {
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> (Pin<&'a mut Si1>, Pin<&'a mut Si2>)
         where Si1: Unpin, Si2: Unpin,
     {
-        let Self { sink1, sink2 } = Pin::get_mut(self);
+        let Self { sink1, sink2 } = self.get_mut();
         (Pin::new(sink1), Pin::new(sink2))
     }
 
diff --git a/futures-util/src/sink/with.rs b/futures-util/src/sink/with.rs
@@ -63,7 +63,7 @@ impl<Fut, T> State<Fut, T> {
         self: Pin<&'a mut Self>,
     ) -> State<Pin<&'a mut Fut>, Pin<&'a mut T>> {
         unsafe {
-            match Pin::get_unchecked_mut(self) {
+            match self.get_unchecked_mut() {
                 State::Empty =>
                     State::Empty,
                 State::Process(fut) =>
@@ -132,7 +132,7 @@ impl<Si, Item, U, Fut, F, E> With<Si, Item, U, Fut, F>
         if let Some(buffered) = buffered {
             self.as_mut().state().set(State::Buffered(buffered));
         }
-        if let State::Buffered(item) = unsafe { mem::replace(Pin::get_unchecked_mut(self.as_mut().state()), State::Empty) } {
+        if let State::Buffered(item) = unsafe { mem::replace(self.as_mut().state().get_unchecked_mut(), State::Empty) } {
             Poll::Ready(self.as_mut().sink().start_send(item).map_err(Into::into))
         } else {
             unreachable!()
diff --git a/futures-util/src/sink/with_flat_map.rs b/futures-util/src/sink/with_flat_map.rs
@@ -76,7 +76,7 @@ where
         cx: &mut Context<'_>,
     ) -> Poll<Result<(), Si::SinkError>> {
         let WithFlatMap { sink, stream, buffer, .. } =
-            unsafe { Pin::get_unchecked_mut(self) };
+            unsafe { self.get_unchecked_mut() };
         let mut sink = unsafe { Pin::new_unchecked(sink) };
         let mut stream = unsafe { Pin::new_unchecked(stream) };
 
diff --git a/futures-util/src/stream/into_future.rs b/futures-util/src/stream/into_future.rs
@@ -54,7 +54,7 @@ impl<St: Stream + Unpin> StreamFuture<St> {
     /// in order to return it to the caller of `Future::poll` if the stream yielded
     /// an element.
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Option<Pin<&'a mut St>> {
-        Pin::new(&mut Pin::get_mut(self).stream).as_pin_mut()
+        Pin::new(&mut self.get_mut().stream).as_pin_mut()
     }
 
     /// Consumes this combinator, returning the underlying stream.
diff --git a/futures-util/src/stream/select.rs b/futures-util/src/stream/select.rs
@@ -59,7 +59,7 @@ impl<St1, St2> Select<St1, St2> {
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> (Pin<&'a mut St1>, Pin<&'a mut St2>)
         where St1: Unpin, St2: Unpin,
     {
-        let Self { stream1, stream2, .. } = Pin::get_mut(self);
+        let Self { stream1, stream2, .. } = self.get_mut();
         (Pin::new(stream1.get_mut()), Pin::new(stream2.get_mut()))
     }
 
@@ -89,7 +89,7 @@ impl<St1, St2> Stream for Select<St1, St2>
         cx: &mut Context<'_>,
     ) -> Poll<Option<St1::Item>> {
         let Select { flag, stream1, stream2 } =
-            unsafe { Pin::get_unchecked_mut(self) };
+            unsafe { self.get_unchecked_mut() };
         let stream1 = unsafe { Pin::new_unchecked(stream1) };
         let stream2 = unsafe { Pin::new_unchecked(stream2) };
 
diff --git a/futures-util/src/stream/zip.rs b/futures-util/src/stream/zip.rs
@@ -60,7 +60,7 @@ impl<St1: Stream, St2: Stream> Zip<St1, St2> {
     pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> (Pin<&'a mut St1>, Pin<&'a mut St2>)
         where St1: Unpin, St2: Unpin,
     {
-        let Self { stream1, stream2, .. } = Pin::get_mut(self);
+        let Self { stream1, stream2, .. } = self.get_mut();
         (Pin::new(stream1.get_mut()), Pin::new(stream2.get_mut()))
     }
 
diff --git a/futures-util/src/try_future/flatten_stream_sink.rs b/futures-util/src/try_future/flatten_stream_sink.rs
@@ -59,7 +59,7 @@ enum State<Fut, S> {
 impl<Fut, S> State<Fut, S> {
     fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> State<Pin<&'a mut Fut>, Pin<&'a mut S>> {
         // safety: data is never moved via the resulting &mut reference
-        match unsafe { Pin::get_unchecked_mut(self) } {
+        match unsafe { self.get_unchecked_mut() } {
             // safety: the future we're re-pinning here will never be moved;
             // it will just be polled, then dropped in place
             State::Future(f) => State::Future(unsafe { Pin::new_unchecked(f) }),
diff --git a/futures-util/src/try_future/try_chain.rs b/futures-util/src/try_future/try_chain.rs
@@ -42,7 +42,7 @@ impl<Fut1, Fut2, Data> TryChain<Fut1, Fut2, Data>
         let mut f = Some(f);
 
         // Safe to call `get_unchecked_mut` because we won't move the futures.
-        let this = unsafe { Pin::get_unchecked_mut(self) };
+        let this = unsafe { self.get_unchecked_mut() };
 
         loop {
             let (output, data) = match this {

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ where`
`79`	`79`	`self: Pin<&mut Self>,`
`80`	`80`	`cx: &mut Context<'_>,`
`81`	`81`	`) -> Poll<Option<Self::Item>> {`
`82`		`- Pin::get_mut(self).as_mut().poll_next(cx)`
	`82`	`+ self.get_mut().as_mut().poll_next(cx)`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
Original file line number	Diff line number	Diff line change
`@@ -376,13 +376,13 @@ mod if_std {`
`376`	`376`	`fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8])`
`377`	`377`	`-> Poll<Result<usize>>`
`378`	`378`	`{`
`379`		`- Pin::get_mut(self).as_mut().poll_read(cx, buf)`
	`379`	`+ self.get_mut().as_mut().poll_read(cx, buf)`
`380`	`380`	`}`
`381`	`381`
`382`	`382`	`fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>])`
`383`	`383`	`-> Poll<Result<usize>>`
`384`	`384`	`{`
`385`		`- Pin::get_mut(self).as_mut().poll_read_vectored(cx, bufs)`
	`385`	`+ self.get_mut().as_mut().poll_read_vectored(cx, bufs)`
`386`	`386`	`}`
`387`	`387`	`}`
`388`	`388`
`@@ -464,21 +464,21 @@ mod if_std {`
`464`	`464`	`fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8])`
`465`	`465`	`-> Poll<Result<usize>>`
`466`	`466`	`{`
`467`		`- Pin::get_mut(self).as_mut().poll_write(cx, buf)`
	`467`	`+ self.get_mut().as_mut().poll_write(cx, buf)`
`468`	`468`	`}`
`469`	`469`
`470`	`470`	`fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>])`
`471`	`471`	`-> Poll<Result<usize>>`
`472`	`472`	`{`
`473`		`- Pin::get_mut(self).as_mut().poll_write_vectored(cx, bufs)`
	`473`	`+ self.get_mut().as_mut().poll_write_vectored(cx, bufs)`
`474`	`474`	`}`
`475`	`475`
`476`	`476`	`fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {`
`477`		`- Pin::get_mut(self).as_mut().poll_flush(cx)`
	`477`	`+ self.get_mut().as_mut().poll_flush(cx)`
`478`	`478`	`}`
`479`	`479`
`480`	`480`	`fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>> {`
`481`		`- Pin::get_mut(self).as_mut().poll_close(cx)`
	`481`	`+ self.get_mut().as_mut().poll_close(cx)`
`482`	`482`	`}`
`483`	`483`	`}`
`484`	`484`
Original file line number	Diff line number	Diff line change
`@@ -139,19 +139,19 @@ where`
`139`	`139`	`type SinkError = <P::Target as Sink<Item>>::SinkError;`
`140`	`140`
`141`	`141`	`fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {`
`142`		`- Pin::get_mut(self).as_mut().poll_ready(cx)`
	`142`	`+ self.get_mut().as_mut().poll_ready(cx)`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), Self::SinkError> {`
`146`		`- Pin::get_mut(self).as_mut().start_send(item)`
	`146`	`+ self.get_mut().as_mut().start_send(item)`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {`
`150`		`- Pin::get_mut(self).as_mut().poll_flush(cx)`
	`150`	`+ self.get_mut().as_mut().poll_flush(cx)`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {`
`154`		`- Pin::get_mut(self).as_mut().poll_close(cx)`
	`154`	`+ self.get_mut().as_mut().poll_close(cx)`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`
`@@ -176,7 +176,7 @@ mod if_alloc {`
`176`	`176`
`177`	`177`	`fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::SinkError> {`
`178`	`178`	`// TODO: impl<T> Unpin for Vec<T> {}`
`179`		`- unsafe { Pin::get_unchecked_mut(self) }.push(item);`
	`179`	`+ unsafe { self.get_unchecked_mut() }.push(item);`
`180`	`180`	`Ok(())`
`181`	`181`	`}`
`182`	`182`
`@@ -198,7 +198,7 @@ mod if_alloc {`
`198`	`198`
`199`	`199`	`fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::SinkError> {`
`200`	`200`	`// TODO: impl<T> Unpin for Vec<T> {}`
`201`		`- unsafe { Pin::get_unchecked_mut(self) }.push_back(item);`
	`201`	`+ unsafe { self.get_unchecked_mut() }.push_back(item);`
`202`	`202`	`Ok(())`
`203`	`203`	`}`
`204`	`204`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<W: AsyncWrite> BufWriter<W> {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`fn flush_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {`
`56`		`- let Self { inner, buf, written } = unsafe { Pin::get_unchecked_mut(self) };`
	`56`	`+ let Self { inner, buf, written } = unsafe { self.get_unchecked_mut() };`
`57`	`57`	`let mut inner = unsafe { Pin::new_unchecked(inner) };`
`58`	`58`
`59`	`59`	`let len = buf.len();`