Elide more lifetimes

taiki-e · cramertj · commit 6780d74dcf48 · 2019-04-18T11:42:43.000-07:00
diff --git a/futures-channel/src/lock.rs b/futures-channel/src/lock.rs
@@ -61,7 +61,7 @@ impl<T> Lock<T> {
     }
 }
 
-impl<'a, T> Deref for TryLock<'a, T> {
+impl<T> Deref for TryLock<'_, T> {
     type Target = T;
     fn deref(&self) -> &T {
         // The existence of `TryLock` represents that we own the lock, so we
@@ -70,7 +70,7 @@ impl<'a, T> Deref for TryLock<'a, T> {
     }
 }
 
-impl<'a, T> DerefMut for TryLock<'a, T> {
+impl<T> DerefMut for TryLock<'_, T> {
     fn deref_mut(&mut self) -> &mut T {
         // The existence of `TryLock` represents that we own the lock, so we
         // can safely access the data here.
@@ -81,7 +81,7 @@ impl<'a, T> DerefMut for TryLock<'a, T> {
     }
 }
 
-impl<'a, T> Drop for TryLock<'a, T> {
+impl<T> Drop for TryLock<'_, T> {
     fn drop(&mut self) {
         self.__ptr.locked.store(false, SeqCst);
     }
diff --git a/futures-core/src/future/future_obj.rs b/futures-core/src/future/future_obj.rs
@@ -19,7 +19,7 @@ pub struct LocalFutureObj<'a, T> {
     _marker: PhantomData<&'a ()>,
 }
 
-impl<'a, T> Unpin for LocalFutureObj<'a, T> {}
+impl<T> Unpin for LocalFutureObj<'_, T> {}
 
 impl<'a, T> LocalFutureObj<'a, T> {
     /// Create a `LocalFutureObj` from a custom trait object representation.
@@ -43,7 +43,7 @@ impl<'a, T> LocalFutureObj<'a, T> {
     }
 }
 
-impl<'a, T> fmt::Debug for LocalFutureObj<'a, T> {
+impl<T> fmt::Debug for LocalFutureObj<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("LocalFutureObj")
             .finish()
@@ -57,7 +57,7 @@ impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T> {
     }
 }
 
-impl<'a, T> Future for LocalFutureObj<'a, T> {
+impl<T> Future for LocalFutureObj<'_, T> {
     type Output = T;
 
     #[inline]
@@ -68,7 +68,7 @@ impl<'a, T> Future for LocalFutureObj<'a, T> {
     }
 }
 
-impl<'a, T> Drop for LocalFutureObj<'a, T> {
+impl<T> Drop for LocalFutureObj<'_, T> {
     fn drop(&mut self) {
         unsafe {
             (self.drop_fn)(self.ptr)
@@ -89,8 +89,8 @@ impl<'a, T> Drop for LocalFutureObj<'a, T> {
 ///   information #44874)
 pub struct FutureObj<'a, T>(LocalFutureObj<'a, T>);
 
-impl<'a, T> Unpin for FutureObj<'a, T> {}
-unsafe impl<'a, T> Send for FutureObj<'a, T> {}
+impl<T> Unpin for FutureObj<'_, T> {}
+unsafe impl<T> Send for FutureObj<'_, T> {}
 
 impl<'a, T> FutureObj<'a, T> {
     /// Create a `FutureObj` from a custom trait object representation.
@@ -100,19 +100,19 @@ impl<'a, T> FutureObj<'a, T> {
     }
 }
 
-impl<'a, T> fmt::Debug for FutureObj<'a, T> {
+impl<T> fmt::Debug for FutureObj<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("FutureObj")
             .finish()
     }
 }
 
-impl<'a, T> Future for FutureObj<'a, T> {
+impl<T> Future for FutureObj<'_, T> {
     type Output = T;
 
     #[inline]
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
-        let pinned_field: Pin<&mut LocalFutureObj<'a, T>> = unsafe {
+        let pinned_field: Pin<&mut LocalFutureObj<'_, T>> = unsafe {
             Pin::map_unchecked_mut(self, |x| &mut x.0)
         };
         LocalFutureObj::poll(pinned_field, cx)
diff --git a/futures-core/src/stream/mod.rs b/futures-core/src/stream/mod.rs
@@ -58,7 +58,7 @@ pub trait Stream {
     ) -> Poll<Option<Self::Item>>;
 }
 
-impl<'a, S: ?Sized + Stream + Unpin> Stream for &'a mut S {
+impl<S: ?Sized + Stream + Unpin> Stream for &mut S {
     type Item = S::Item;
 
     fn poll_next(
diff --git a/futures-core/src/stream/stream_obj.rs b/futures-core/src/stream/stream_obj.rs
@@ -17,7 +17,7 @@ pub struct LocalStreamObj<'a, T> {
     _marker: PhantomData<&'a ()>,
 }
 
-impl<'a, T> Unpin for LocalStreamObj<'a, T> {}
+impl<T> Unpin for LocalStreamObj<'_, T> {}
 
 impl<'a, T> LocalStreamObj<'a, T> {
     /// Create a `LocalStreamObj` from a custom trait object representation.
@@ -41,7 +41,7 @@ impl<'a, T> LocalStreamObj<'a, T> {
     }
 }
 
-impl<'a, T> fmt::Debug for LocalStreamObj<'a, T> {
+impl<T> fmt::Debug for LocalStreamObj<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("LocalStreamObj").finish()
     }
@@ -54,7 +54,7 @@ impl<'a, T> From<StreamObj<'a, T>> for LocalStreamObj<'a, T> {
     }
 }
 
-impl<'a, T> Stream for LocalStreamObj<'a, T> {
+impl<T> Stream for LocalStreamObj<'_, T> {
     type Item = T;
 
     #[inline]
@@ -66,7 +66,7 @@ impl<'a, T> Stream for LocalStreamObj<'a, T> {
     }
 }
 
-impl<'a, T> Drop for LocalStreamObj<'a, T> {
+impl<T> Drop for LocalStreamObj<'_, T> {
     fn drop(&mut self) {
         unsafe { (self.drop_fn)(self.ptr) }
     }
@@ -85,8 +85,8 @@ impl<'a, T> Drop for LocalStreamObj<'a, T> {
 ///   information #44874)
 pub struct StreamObj<'a, T>(LocalStreamObj<'a, T>);
 
-impl<'a, T> Unpin for StreamObj<'a, T> {}
-unsafe impl<'a, T> Send for StreamObj<'a, T> {}
+impl<T> Unpin for StreamObj<'_, T> {}
+unsafe impl<T> Send for StreamObj<'_, T> {}
 
 impl<'a, T> StreamObj<'a, T> {
     /// Create a `StreamObj` from a custom trait object representation.
@@ -96,13 +96,13 @@ impl<'a, T> StreamObj<'a, T> {
     }
 }
 
-impl<'a, T> fmt::Debug for StreamObj<'a, T> {
+impl<T> fmt::Debug for StreamObj<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("StreamObj").finish()
     }
 }
 
-impl<'a, T> Stream for StreamObj<'a, T> {
+impl<T> Stream for StreamObj<'_, T> {
     type Item = T;
 
     #[inline]
diff --git a/futures-io/src/lib.rs b/futures-io/src/lib.rs
@@ -266,11 +266,11 @@ mod if_std {
         deref_async_read!();
     }
 
-    impl<'a, T: ?Sized + AsyncRead + Unpin> AsyncRead for &'a mut T {
+    impl<T: ?Sized + AsyncRead + Unpin> AsyncRead for &mut T {
         deref_async_read!();
     }
 
-    impl<'a, T: ?Sized + AsyncRead> AsyncRead for Pin<&'a mut T> {
+    impl<T: ?Sized + AsyncRead> AsyncRead for Pin<&mut T> {
         unsafe fn initializer(&self) -> Initializer {
             (**self).initializer()
         }
@@ -304,7 +304,7 @@ mod if_std {
         }
     }
 
-    impl<'a> AsyncRead for &'a [u8] {
+    impl AsyncRead for &[u8] {
         unsafe_delegate_async_read_to_stdio!();
     }
 
@@ -344,11 +344,11 @@ mod if_std {
         deref_async_write!();
     }
 
-    impl<'a, T: ?Sized + AsyncWrite + Unpin> AsyncWrite for &'a mut T {
+    impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for &mut T {
         deref_async_write!();
     }
 
-    impl<'a, T: ?Sized + AsyncWrite> AsyncWrite for Pin<&'a mut T> {
+    impl<T: ?Sized + AsyncWrite> AsyncWrite for Pin<&mut T> {
         fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8])
             -> Poll<Result<usize>>
         {
diff --git a/futures-sink/src/channel_impls.rs b/futures-sink/src/channel_impls.rs
@@ -45,7 +45,7 @@ impl<T> Sink<T> for UnboundedSender<T> {
     }
 }
 
-impl<'a, T> Sink<T> for &'a UnboundedSender<T> {
+impl<T> Sink<T> for &UnboundedSender<T> {
     type SinkError = SendError;
 
     fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
diff --git a/futures-sink/src/lib.rs b/futures-sink/src/lib.rs
@@ -110,7 +110,7 @@ pub trait Sink<Item> {
     fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>>;
 }
 
-impl<'a, S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for &'a mut S {
+impl<S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for &mut S {
     type SinkError = S::SinkError;
 
     fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
@@ -130,7 +130,7 @@ impl<'a, S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for &'a mut S {
     }
 }
 
-impl<'a, S: ?Sized + Sink<Item>, Item> Sink<Item> for Pin<&'a mut S> {
+impl<S: ?Sized + Sink<Item>, Item> Sink<Item> for Pin<&mut S> {
     type SinkError = S::SinkError;
 
     fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {
diff --git a/futures-util/src/compat/compat01as03.rs b/futures-util/src/compat/compat01as03.rs
@@ -316,8 +316,8 @@ struct NotifyWaker(task03::Waker);
 #[derive(Clone)]
 struct WakerToHandle<'a>(&'a task03::Waker);
 
-impl<'a> From<WakerToHandle<'a>> for NotifyHandle01 {
-    fn from(handle: WakerToHandle<'a>) -> NotifyHandle01 {
+impl From<WakerToHandle<'_>> for NotifyHandle01 {
+    fn from(handle: WakerToHandle<'_>) -> NotifyHandle01 {
         let ptr = Box::new(NotifyWaker(handle.0.clone()));
 
         unsafe { NotifyHandle01::new(Box::into_raw(ptr)) }
diff --git a/futures-util/src/future/shared.rs b/futures-util/src/future/shared.rs
@@ -219,7 +219,7 @@ where
 
         struct Reset<'a>(&'a AtomicUsize);
 
-        impl<'a> Drop for Reset<'a> {
+        impl Drop for Reset<'_> {
             fn drop(&mut self) {
                 use std::thread;
 
diff --git a/futures-util/src/lock/bilock.rs b/futures-util/src/lock/bilock.rs
@@ -229,20 +229,20 @@ pub struct BiLockGuard<'a, T> {
     bilock: &'a BiLock<T>,
 }
 
-impl<'a, T> Deref for BiLockGuard<'a, T> {
+impl<T> Deref for BiLockGuard<'_, T> {
     type Target = T;
     fn deref(&self) -> &T {
         unsafe { &*self.bilock.arc.value.as_ref().unwrap().get() }
     }
 }
 
-impl<'a, T: Unpin> DerefMut for BiLockGuard<'a, T> {
+impl<T: Unpin> DerefMut for BiLockGuard<'_, T> {
     fn deref_mut(&mut self) -> &mut T {
         unsafe { &mut *self.bilock.arc.value.as_ref().unwrap().get() }
     }
 }
 
-impl<'a, T> BiLockGuard<'a, T> {
+impl<T> BiLockGuard<'_, T> {
     /// Get a mutable pinned reference to the locked value.
     pub fn as_pin_mut(&mut self) -> Pin<&mut T> {
         // Safety: we never allow moving a !Unpin value out of a bilock, nor
@@ -251,7 +251,7 @@ impl<'a, T> BiLockGuard<'a, T> {
     }
 }
 
-impl<'a, T> Drop for BiLockGuard<'a, T> {
+impl<T> Drop for BiLockGuard<'_, T> {
     fn drop(&mut self) {
         self.bilock.unlock();
     }
@@ -266,7 +266,7 @@ pub struct BiLockAcquire<'a, T> {
 }
 
 // Pinning is never projected to fields
-impl<'a, T> Unpin for BiLockAcquire<'a, T> {}
+impl<T> Unpin for BiLockAcquire<'_, T> {}
 
 impl<'a, T> Future for BiLockAcquire<'a, T> {
     type Output = BiLockGuard<'a, T>;
diff --git a/futures-util/src/stream/futures_unordered/mod.rs b/futures-util/src/stream/futures_unordered/mod.rs
@@ -64,7 +64,7 @@ unsafe impl<Fut: Send> Send for FuturesUnordered<Fut> {}
 unsafe impl<Fut: Sync> Sync for FuturesUnordered<Fut> {}
 impl<Fut> Unpin for FuturesUnordered<Fut> {}
 
-impl<'a> Spawn for FuturesUnordered<FutureObj<'a, ()>> {
+impl Spawn for FuturesUnordered<FutureObj<'_, ()>> {
     fn spawn_obj(&mut self, future_obj: FutureObj<'static, ()>)
         -> Result<(), SpawnError>
     {
@@ -73,7 +73,7 @@ impl<'a> Spawn for FuturesUnordered<FutureObj<'a, ()>> {
     }
 }
 
-impl<'a> LocalSpawn for FuturesUnordered<LocalFutureObj<'a, ()>> {
+impl LocalSpawn for FuturesUnordered<LocalFutureObj<'_, ()>> {
     fn spawn_local_obj(&mut self, future_obj: LocalFutureObj<'static, ()>)
         -> Result<(), SpawnError>
     {
@@ -376,7 +376,7 @@ impl<Fut: Future> Stream for FuturesUnordered<Fut> {
                 task: Option<Arc<Task<Fut>>>,
             }
 
-            impl<'a, Fut> Drop for Bomb<'a, Fut> {
+            impl<Fut> Drop for Bomb<'_, Fut> {
                 fn drop(&mut self) {
                     if let Some(task) = self.task.take() {
                         self.queue.release_task(task);
diff --git a/futures-util/src/stream/select_next_some.rs b/futures-util/src/stream/select_next_some.rs
@@ -18,13 +18,13 @@ impl<'a, St> SelectNextSome<'a, St> {
     }
 }
 
-impl<'a, St: FusedStream> FusedFuture for SelectNextSome<'a, St> {
+impl<St: FusedStream> FusedFuture for SelectNextSome<'_, St> {
     fn is_terminated(&self) -> bool {
         self.stream.is_terminated()
     }
 }
 
-impl<'a, St: Stream + FusedStream + Unpin> Future for SelectNextSome<'a, St> {
+impl<St: Stream + FusedStream + Unpin> Future for SelectNextSome<'_, St> {
     type Output = St::Item;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
diff --git a/futures-util/src/task/waker_ref.rs b/futures-util/src/task/waker_ref.rs
@@ -16,7 +16,7 @@ pub struct WakerRef<'a> {
     _marker: PhantomData<&'a ()>,
 }
 
-impl<'a> WakerRef<'a> {
+impl WakerRef<'_> {
     /// Create a new [`WakerRef`] from a [`Waker`].
     ///
     /// Note: this function is safe, but it is generally only used
@@ -30,7 +30,7 @@ impl<'a> WakerRef<'a> {
     }
 }
 
-impl<'a> Deref for WakerRef<'a> {
+impl Deref for WakerRef<'_> {
     type Target = Waker;
 
     fn deref(&self) -> &Waker {
diff --git a/futures/tests/future_obj.rs b/futures/tests/future_obj.rs
@@ -15,15 +15,15 @@ fn dropping_drops_the_future() {
 
     struct Inc<'a>(&'a mut u32);
 
-    impl<'a> Future for Inc<'a> {
+    impl Future for Inc<'_> {
         type Output = ();
 
         fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<()> {
             unimplemented!()
         }
     }
 
-    impl<'a> Drop for Inc<'a> {
+    impl Drop for Inc<'_> {
         fn drop(&mut self) {
             *self.0 += 1;
         }

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ impl<T> Lock<T> {`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`-impl<'a, T> Deref for TryLock<'a, T> {`
	`64`	`+impl<T> Deref for TryLock<'_, T> {`
`65`	`65`	`type Target = T;`
`66`	`66`	`fn deref(&self) -> &T {`
`67`	`67`	// The existence of `TryLock` represents that we own the lock, so we
`@@ -70,7 +70,7 @@ impl<'a, T> Deref for TryLock<'a, T> {`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
`73`		`-impl<'a, T> DerefMut for TryLock<'a, T> {`
	`73`	`+impl<T> DerefMut for TryLock<'_, T> {`
`74`	`74`	`fn deref_mut(&mut self) -> &mut T {`
`75`	`75`	// The existence of `TryLock` represents that we own the lock, so we
`76`	`76`	`// can safely access the data here.`
`@@ -81,7 +81,7 @@ impl<'a, T> DerefMut for TryLock<'a, T> {`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`84`		`-impl<'a, T> Drop for TryLock<'a, T> {`
	`84`	`+impl<T> Drop for TryLock<'_, T> {`
`85`	`85`	`fn drop(&mut self) {`
`86`	`86`	`self.__ptr.locked.store(false, SeqCst);`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ pub struct LocalFutureObj<'a, T> {`
`19`	`19`	`_marker: PhantomData<&'a ()>,`
`20`	`20`	`}`
`21`	`21`
`22`		`-impl<'a, T> Unpin for LocalFutureObj<'a, T> {}`
	`22`	`+impl<T> Unpin for LocalFutureObj<'_, T> {}`
`23`	`23`
`24`	`24`	`impl<'a, T> LocalFutureObj<'a, T> {`
`25`	`25`	/// Create a `LocalFutureObj` from a custom trait object representation.
`@@ -43,7 +43,7 @@ impl<'a, T> LocalFutureObj<'a, T> {`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`-impl<'a, T> fmt::Debug for LocalFutureObj<'a, T> {`
	`46`	`+impl<T> fmt::Debug for LocalFutureObj<'_, T> {`
`47`	`47`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`48`	`48`	`f.debug_struct("LocalFutureObj")`
`49`	`49`	`.finish()`
`@@ -57,7 +57,7 @@ impl<'a, T> From<FutureObj<'a, T>> for LocalFutureObj<'a, T> {`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`-impl<'a, T> Future for LocalFutureObj<'a, T> {`
	`60`	`+impl<T> Future for LocalFutureObj<'_, T> {`
`61`	`61`	`type Output = T;`
`62`	`62`
`63`	`63`	`#[inline]`
`@@ -68,7 +68,7 @@ impl<'a, T> Future for LocalFutureObj<'a, T> {`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`-impl<'a, T> Drop for LocalFutureObj<'a, T> {`
	`71`	`+impl<T> Drop for LocalFutureObj<'_, T> {`
`72`	`72`	`fn drop(&mut self) {`
`73`	`73`	`unsafe {`
`74`	`74`	`(self.drop_fn)(self.ptr)`
`@@ -89,8 +89,8 @@ impl<'a, T> Drop for LocalFutureObj<'a, T> {`
`89`	`89`	`/// information #44874)`
`90`	`90`	`pub struct FutureObj<'a, T>(LocalFutureObj<'a, T>);`
`91`	`91`
`92`		`-impl<'a, T> Unpin for FutureObj<'a, T> {}`
`93`		`-unsafe impl<'a, T> Send for FutureObj<'a, T> {}`
	`92`	`+impl<T> Unpin for FutureObj<'_, T> {}`
	`93`	`+unsafe impl<T> Send for FutureObj<'_, T> {}`
`94`	`94`
`95`	`95`	`impl<'a, T> FutureObj<'a, T> {`
`96`	`96`	/// Create a `FutureObj` from a custom trait object representation.
`@@ -100,19 +100,19 @@ impl<'a, T> FutureObj<'a, T> {`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`103`		`-impl<'a, T> fmt::Debug for FutureObj<'a, T> {`
	`103`	`+impl<T> fmt::Debug for FutureObj<'_, T> {`
`104`	`104`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`105`	`105`	`f.debug_struct("FutureObj")`
`106`	`106`	`.finish()`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
`110`		`-impl<'a, T> Future for FutureObj<'a, T> {`
	`110`	`+impl<T> Future for FutureObj<'_, T> {`
`111`	`111`	`type Output = T;`
`112`	`112`
`113`	`113`	`#[inline]`
`114`	`114`	`fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {`
`115`		`- let pinned_field: Pin<&mut LocalFutureObj<'a, T>> = unsafe {`
	`115`	`+ let pinned_field: Pin<&mut LocalFutureObj<'_, T>> = unsafe {`
`116`	`116`	`Pin::map_unchecked_mut(self, \|x\| &mut x.0)`
`117`	`117`	`};`
`118`	`118`	`LocalFutureObj::poll(pinned_field, cx)`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ pub trait Stream {`
`58`	`58`	`) -> Poll<Option<Self::Item>>;`
`59`	`59`	`}`
`60`	`60`
`61`		`-impl<'a, S: ?Sized + Stream + Unpin> Stream for &'a mut S {`
	`61`	`+impl<S: ?Sized + Stream + Unpin> Stream for &mut S {`
`62`	`62`	`type Item = S::Item;`
`63`	`63`
`64`	`64`	`fn poll_next(`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ pub struct LocalStreamObj<'a, T> {`
`17`	`17`	`_marker: PhantomData<&'a ()>,`
`18`	`18`	`}`
`19`	`19`
`20`		`-impl<'a, T> Unpin for LocalStreamObj<'a, T> {}`
	`20`	`+impl<T> Unpin for LocalStreamObj<'_, T> {}`
`21`	`21`
`22`	`22`	`impl<'a, T> LocalStreamObj<'a, T> {`
`23`	`23`	/// Create a `LocalStreamObj` from a custom trait object representation.
`@@ -41,7 +41,7 @@ impl<'a, T> LocalStreamObj<'a, T> {`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`		`-impl<'a, T> fmt::Debug for LocalStreamObj<'a, T> {`
	`44`	`+impl<T> fmt::Debug for LocalStreamObj<'_, T> {`
`45`	`45`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`46`	`46`	`f.debug_struct("LocalStreamObj").finish()`
`47`	`47`	`}`
`@@ -54,7 +54,7 @@ impl<'a, T> From<StreamObj<'a, T>> for LocalStreamObj<'a, T> {`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`57`		`-impl<'a, T> Stream for LocalStreamObj<'a, T> {`
	`57`	`+impl<T> Stream for LocalStreamObj<'_, T> {`
`58`	`58`	`type Item = T;`
`59`	`59`
`60`	`60`	`#[inline]`
`@@ -66,7 +66,7 @@ impl<'a, T> Stream for LocalStreamObj<'a, T> {`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`		`-impl<'a, T> Drop for LocalStreamObj<'a, T> {`
	`69`	`+impl<T> Drop for LocalStreamObj<'_, T> {`
`70`	`70`	`fn drop(&mut self) {`
`71`	`71`	`unsafe { (self.drop_fn)(self.ptr) }`
`72`	`72`	`}`
`@@ -85,8 +85,8 @@ impl<'a, T> Drop for LocalStreamObj<'a, T> {`
`85`	`85`	`/// information #44874)`
`86`	`86`	`pub struct StreamObj<'a, T>(LocalStreamObj<'a, T>);`
`87`	`87`
`88`		`-impl<'a, T> Unpin for StreamObj<'a, T> {}`
`89`		`-unsafe impl<'a, T> Send for StreamObj<'a, T> {}`
	`88`	`+impl<T> Unpin for StreamObj<'_, T> {}`
	`89`	`+unsafe impl<T> Send for StreamObj<'_, T> {}`
`90`	`90`
`91`	`91`	`impl<'a, T> StreamObj<'a, T> {`
`92`	`92`	/// Create a `StreamObj` from a custom trait object representation.
`@@ -96,13 +96,13 @@ impl<'a, T> StreamObj<'a, T> {`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`99`		`-impl<'a, T> fmt::Debug for StreamObj<'a, T> {`
	`99`	`+impl<T> fmt::Debug for StreamObj<'_, T> {`
`100`	`100`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`101`	`101`	`f.debug_struct("StreamObj").finish()`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`-impl<'a, T> Stream for StreamObj<'a, T> {`
	`105`	`+impl<T> Stream for StreamObj<'_, T> {`
`106`	`106`	`type Item = T;`
`107`	`107`
`108`	`108`	`#[inline]`
Original file line number	Diff line number	Diff line change
`@@ -266,11 +266,11 @@ mod if_std {`
`266`	`266`	`deref_async_read!();`
`267`	`267`	`}`
`268`	`268`
`269`		`- impl<'a, T: ?Sized + AsyncRead + Unpin> AsyncRead for &'a mut T {`
	`269`	`+ impl<T: ?Sized + AsyncRead + Unpin> AsyncRead for &mut T {`
`270`	`270`	`deref_async_read!();`
`271`	`271`	`}`
`272`	`272`
`273`		`- impl<'a, T: ?Sized + AsyncRead> AsyncRead for Pin<&'a mut T> {`
	`273`	`+ impl<T: ?Sized + AsyncRead> AsyncRead for Pin<&mut T> {`
`274`	`274`	`unsafe fn initializer(&self) -> Initializer {`
`275`	`275`	`(**self).initializer()`
`276`	`276`	`}`
`@@ -304,7 +304,7 @@ mod if_std {`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`
`307`		`- impl<'a> AsyncRead for &'a [u8] {`
	`307`	`+ impl AsyncRead for &[u8] {`
`308`	`308`	`unsafe_delegate_async_read_to_stdio!();`
`309`	`309`	`}`
`310`	`310`
`@@ -344,11 +344,11 @@ mod if_std {`
`344`	`344`	`deref_async_write!();`
`345`	`345`	`}`
`346`	`346`
`347`		`- impl<'a, T: ?Sized + AsyncWrite + Unpin> AsyncWrite for &'a mut T {`
	`347`	`+ impl<T: ?Sized + AsyncWrite + Unpin> AsyncWrite for &mut T {`
`348`	`348`	`deref_async_write!();`
`349`	`349`	`}`
`350`	`350`
`351`		`- impl<'a, T: ?Sized + AsyncWrite> AsyncWrite for Pin<&'a mut T> {`
	`351`	`+ impl<T: ?Sized + AsyncWrite> AsyncWrite for Pin<&mut T> {`
`352`	`352`	`fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8])`
`353`	`353`	`-> Poll<Result<usize>>`
`354`	`354`	`{`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ impl<T> Sink<T> for UnboundedSender<T> {`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`48`		`-impl<'a, T> Sink<T> for &'a UnboundedSender<T> {`
	`48`	`+impl<T> Sink<T> for &UnboundedSender<T> {`
`49`	`49`	`type SinkError = SendError;`
`50`	`50`
`51`	`51`	`fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ pub trait Sink<Item> {`
`110`	`110`	`fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>>;`
`111`	`111`	`}`
`112`	`112`
`113`		`-impl<'a, S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for &'a mut S {`
	`113`	`+impl<S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for &mut S {`
`114`	`114`	`type SinkError = S::SinkError;`
`115`	`115`
`116`	`116`	`fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {`
`@@ -130,7 +130,7 @@ impl<'a, S: ?Sized + Sink<Item> + Unpin, Item> Sink<Item> for &'a mut S {`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`-impl<'a, S: ?Sized + Sink<Item>, Item> Sink<Item> for Pin<&'a mut S> {`
	`133`	`+impl<S: ?Sized + Sink<Item>, Item> Sink<Item> for Pin<&mut S> {`
`134`	`134`	`type SinkError = S::SinkError;`
`135`	`135`
`136`	`136`	`fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::SinkError>> {`
Original file line number	Diff line number	Diff line change
`@@ -229,20 +229,20 @@ pub struct BiLockGuard<'a, T> {`
`229`	`229`	`bilock: &'a BiLock<T>,`
`230`	`230`	`}`
`231`	`231`
`232`		`-impl<'a, T> Deref for BiLockGuard<'a, T> {`
	`232`	`+impl<T> Deref for BiLockGuard<'_, T> {`
`233`	`233`	`type Target = T;`
`234`	`234`	`fn deref(&self) -> &T {`
`235`	`235`	`unsafe { &*self.bilock.arc.value.as_ref().unwrap().get() }`
`236`	`236`	`}`
`237`	`237`	`}`
`238`	`238`
`239`		`-impl<'a, T: Unpin> DerefMut for BiLockGuard<'a, T> {`
	`239`	`+impl<T: Unpin> DerefMut for BiLockGuard<'_, T> {`
`240`	`240`	`fn deref_mut(&mut self) -> &mut T {`
`241`	`241`	`unsafe { &mut *self.bilock.arc.value.as_ref().unwrap().get() }`
`242`	`242`	`}`
`243`	`243`	`}`
`244`	`244`
`245`		`-impl<'a, T> BiLockGuard<'a, T> {`
	`245`	`+impl<T> BiLockGuard<'_, T> {`
`246`	`246`	`/// Get a mutable pinned reference to the locked value.`
`247`	`247`	`pub fn as_pin_mut(&mut self) -> Pin<&mut T> {`
`248`	`248`	`// Safety: we never allow moving a !Unpin value out of a bilock, nor`
`@@ -251,7 +251,7 @@ impl<'a, T> BiLockGuard<'a, T> {`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
`254`		`-impl<'a, T> Drop for BiLockGuard<'a, T> {`
	`254`	`+impl<T> Drop for BiLockGuard<'_, T> {`
`255`	`255`	`fn drop(&mut self) {`
`256`	`256`	`self.bilock.unlock();`
`257`	`257`	`}`
`@@ -266,7 +266,7 @@ pub struct BiLockAcquire<'a, T> {`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`// Pinning is never projected to fields`
`269`		`-impl<'a, T> Unpin for BiLockAcquire<'a, T> {}`
	`269`	`+impl<T> Unpin for BiLockAcquire<'_, T> {}`
`270`	`270`
`271`	`271`	`impl<'a, T> Future for BiLockAcquire<'a, T> {`
`272`	`272`	`type Output = BiLockGuard<'a, T>;`