Elide lifetimes in Pin<&mut Self>

Author: taiki-e

futures-io/src/lib.rs

@@ -319,8 +319,8 @@ mod if_std {
         /// `Interrupted`.  Implementations must convert `WouldBlock` into
         /// `Poll::Pending` and either internally retry or convert
         /// `Interrupted` into another error kind.
-        fn poll_fill_buf<'a>(self: Pin<&'a mut Self>, cx: &mut Context<'_>)
-            -> Poll<Result<&'a [u8]>>;
+        fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>)
+            -> Poll<Result<&[u8]>>;
 
         /// Tells this buffer that `amt` bytes have been consumed from the buffer,
         /// so they should no longer be returned in calls to [`poll_read`].
@@ -597,8 +597,8 @@ mod if_std {
 
     macro_rules! deref_async_buf_read {
         () => {
-            fn poll_fill_buf<'a>(self: Pin<&'a mut Self>, cx: &mut Context<'_>)
-                -> Poll<Result<&'a [u8]>>
+            fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>)
+                -> Poll<Result<&[u8]>>
             {
                 Pin::new(&mut **self.get_mut()).poll_fill_buf(cx)
             }
@@ -622,8 +622,8 @@ mod if_std {
         P: DerefMut + Unpin,
         P::Target: AsyncBufRead,
     {
-        fn poll_fill_buf<'a>(self: Pin<&'a mut Self>, cx: &mut Context<'_>)
-            -> Poll<Result<&'a [u8]>>
+        fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>)
+            -> Poll<Result<&[u8]>>
         {
             self.get_mut().as_mut().poll_fill_buf(cx)
         }
@@ -635,8 +635,8 @@ mod if_std {
 
     macro_rules! delegate_async_buf_read_to_stdio {
         () => {
-            fn poll_fill_buf<'a>(self: Pin<&'a mut Self>, _: &mut Context<'_>)
-                -> Poll<Result<&'a [u8]>>
+            fn poll_fill_buf(self: Pin<&mut Self>, _: &mut Context<'_>)
+                -> Poll<Result<&[u8]>>
             {
                 Poll::Ready(io::BufRead::fill_buf(self.get_mut()))
             }

futures-test/src/interleave_pending.rs

@@ -47,7 +47,7 @@ impl<T> InterleavePending<T> {
 
     /// Acquires a pinned mutable reference to the underlying I/O object that
     /// this adaptor is wrapping.
-    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut T> {
+    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
         self.project().0
     }
 
@@ -56,7 +56,7 @@ impl<T> InterleavePending<T> {
         self.inner
     }
 
-    fn project<'a>(self: Pin<&'a mut Self>) -> (Pin<&'a mut T>, &'a mut bool) {
+    fn project(self: Pin<&mut Self>) -> (Pin<&mut T>, &mut bool) {
         unsafe {
             let this = self.get_unchecked_mut();
             (Pin::new_unchecked(&mut this.inner), &mut this.pended)
@@ -185,10 +185,10 @@ impl<R: AsyncRead> AsyncRead for InterleavePending<R> {
 }
 
 impl<R: AsyncBufRead> AsyncBufRead for InterleavePending<R> {
-    fn poll_fill_buf<'a>(
-        self: Pin<&'a mut Self>,
+    fn poll_fill_buf(
+        self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<io::Result<&'a [u8]>> {
+    ) -> Poll<io::Result<&[u8]>> {
         let (reader, pended) = self.project();
         if *pended {
             let next = reader.poll_fill_buf(cx);

futures-test/src/io/limited.rs

@@ -42,7 +42,7 @@ impl<Io> Limited<Io> {
 
     /// Acquires a pinned mutable reference to the underlying I/O object that
     /// this adaptor is wrapping.
-    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut Io> {
+    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut Io> {
         self.io()
     }
 
@@ -89,10 +89,10 @@ impl<R: AsyncRead> AsyncRead for Limited<R> {
 }
 
 impl<R: AsyncBufRead> AsyncBufRead for Limited<R> {
-    fn poll_fill_buf<'a>(
-        self: Pin<&'a mut Self>,
+    fn poll_fill_buf(
+        self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<io::Result<&'a [u8]>> {
+    ) -> Poll<io::Result<&[u8]>> {
         self.io().poll_fill_buf(cx)
     }
 

futures-util/src/future/either.rs

@@ -278,10 +278,10 @@ mod if_std {
         A: AsyncBufRead,
         B: AsyncBufRead,
     {
-        fn poll_fill_buf<'a>(
-            self: Pin<&'a mut Self>,
+        fn poll_fill_buf(
+            self: Pin<&mut Self>,
             cx: &mut Context<'_>,
-        ) -> Poll<Result<&'a [u8]>> {
+        ) -> Poll<Result<&[u8]>> {
             unsafe {
                 match self.get_unchecked_mut() {
                     Either::Left(x) => Pin::new_unchecked(x).poll_fill_buf(cx),

futures-util/src/future/flatten_stream.rs

@@ -41,7 +41,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>> {
+    fn get_pin_mut(self: Pin<&mut Self>) -> State<Pin<&mut Fut>, Pin<&mut St>> {
         // safety: data is never moved via the resulting &mut reference
         match unsafe { self.get_unchecked_mut() } {
             // safety: the future we're re-pinning here will never be moved;

futures-util/src/future/join_all.rs

@@ -23,7 +23,7 @@ impl<F> ElemState<F>
 where
     F: Future,
 {
-    fn pending_pin_mut<'a>(self: Pin<&'a mut Self>) -> Option<Pin<&'a mut F>> {
+    fn pending_pin_mut(self: Pin<&mut Self>) -> Option<Pin<&mut F>> {
         // Safety: Basic enum pin projection, no drop + optionally Unpin based
         // on the type of this variant
         match unsafe { self.get_unchecked_mut() } {

futures-util/src/future/maybe_done.rs

@@ -50,7 +50,7 @@ impl<Fut: Future> MaybeDone<Fut> {
     /// future has been completed and [`take_output`](MaybeDone::take_output)
     /// has not yet been called.
     #[inline]
-    pub fn output_mut<'a>(self: Pin<&'a mut Self>) -> Option<&'a mut Fut::Output> {
+    pub fn output_mut(self: Pin<&mut Self>) -> Option<&mut Fut::Output> {
         unsafe {
             let this = self.get_unchecked_mut();
             match this {

futures-util/src/io/allow_std.rs

@@ -157,8 +157,8 @@ impl<T> io::BufRead for AllowStdIo<T> where T: io::BufRead {
 }
 
 impl<T> AsyncBufRead for AllowStdIo<T> where T: io::BufRead {
-    fn poll_fill_buf<'a>(mut self: Pin<&'a mut Self>, _: &mut Context<'_>)
-        -> Poll<io::Result<&'a [u8]>>
+    fn poll_fill_buf(mut self: Pin<&mut Self>, _: &mut Context<'_>)
+        -> Poll<io::Result<&[u8]>>
     {
         let this: *mut Self = &mut *self as *mut _;
         Poll::Ready(Ok(try_with_interrupt!(unsafe { &mut *this }.0.fill_buf())))

futures-util/src/io/buf_reader.rs

@@ -75,7 +75,7 @@ impl<R: AsyncRead> BufReader<R> {
     /// Gets a pinned mutable reference to the underlying reader.
     ///
     /// It is inadvisable to directly read from the underlying reader.
-    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut R> {
+    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R> {
         self.inner()
     }
 
@@ -172,10 +172,10 @@ impl<R: AsyncRead> AsyncRead for BufReader<R> {
 }
 
 impl<R: AsyncRead> AsyncBufRead for BufReader<R> {
-    fn poll_fill_buf<'a>(
-        self: Pin<&'a mut Self>,
+    fn poll_fill_buf(
+        self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<io::Result<&'a [u8]>> {
+    ) -> Poll<io::Result<&[u8]>> {
         let Self { inner, buf, cap, pos } = unsafe { self.get_unchecked_mut() };
         let mut inner = unsafe { Pin::new_unchecked(inner) };
 

futures-util/src/io/buf_writer.rs

@@ -96,7 +96,7 @@ impl<W: AsyncWrite> BufWriter<W> {
     /// Gets a pinned mutable reference to the underlying writer.
     ///
     /// It is inadvisable to directly write to the underlying writer.
-    pub fn get_pin_mut<'a>(self: Pin<&'a mut Self>) -> Pin<&'a mut W> {
+    pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W> {
         self.inner()
     }