fix: clippy lint updates for rust version 1.89.0 (#2750)

Author: jouho

common/s2n-codec/src/decoder/mod.rs

@@ -227,7 +227,7 @@ macro_rules! impl_buffer {
                 // TODO add doctest
 
                 #[inline]
-                pub fn get_checked_range(&self, range: &crate::CheckedRange) -> DecoderBuffer {
+                pub fn get_checked_range(&self, range: &crate::CheckedRange) -> DecoderBuffer<'_> {
                     range.get(self.bytes).into()
                 }
             }
@@ -286,7 +286,7 @@ macro_rules! impl_buffer {
             pub fn peek_range(
                 &self,
                 range: core::ops::Range<usize>,
-            ) -> Result<crate::DecoderBuffer, DecoderError> {
+            ) -> Result<crate::DecoderBuffer<'_>, DecoderError> {
                 let end = range.end;
                 self.bytes
                     .get(range)

dc/s2n-quic-dc-benches/src/datagram/recv.rs

@@ -28,7 +28,7 @@ macro_rules! impl_recv {
             #[allow(dead_code)]
             pub fn parse(
                 buffer: &mut [u8],
-            ) -> Option<s2n_quic_dc::packet::datagram::decoder::Packet> {
+            ) -> Option<s2n_quic_dc::packet::datagram::decoder::Packet<'_>> {
                 let buffer = s2n_codec::DecoderBufferMut::new(buffer);
                 let (packet, _buffer) = s2n_quic_dc::packet::datagram::decoder::Packet::decode(
                     buffer,

dc/s2n-quic-dc/src/msg/send.rs

@@ -325,7 +325,7 @@ impl Message {
     }
 
     #[inline]
-    pub fn drain(&mut self) -> Drain {
+    pub fn drain(&mut self) -> Drain<'_> {
         Drain {
             message: self,
             index: 0,

dc/s2n-quic-dc/src/packet/control/decoder.rs

@@ -130,7 +130,7 @@ impl Packet<'_> {
     }
 
     #[inline]
-    pub fn control_frames_mut(&mut self) -> ControlFramesMut {
+    pub fn control_frames_mut(&mut self) -> ControlFramesMut<'_> {
         ControlFramesMut {
             buffer: self.control_data.get_mut(self.header),
         }

dc/s2n-quic-dc/src/path/secret/map/state.rs

@@ -400,7 +400,7 @@ where
         self.ids = Default::default();
     }
 
-    pub(super) fn subscriber(&self) -> event::EndpointPublisherSubscriber<S> {
+    pub(super) fn subscriber(&self) -> event::EndpointPublisherSubscriber<'_, S> {
         use event::IntoEvent as _;
 
         let timestamp = self.clock.get_time().into_event();

dc/s2n-quic-dc/src/stream/environment.rs

@@ -36,7 +36,7 @@ pub trait Environment {
 
     /// Creates an endpoint publisher with the environment's subscriber
     #[inline]
-    fn endpoint_publisher(&self) -> event::EndpointPublisherSubscriber<Self::Subscriber> {
+    fn endpoint_publisher(&self) -> event::EndpointPublisherSubscriber<'_, Self::Subscriber> {
         use s2n_quic_core::time::Clock as _;
 
         self.endpoint_publisher_with_time(self.clock().get_time())
@@ -46,7 +46,7 @@ pub trait Environment {
     fn endpoint_publisher_with_time(
         &self,
         timestamp: Timestamp,
-    ) -> event::EndpointPublisherSubscriber<Self::Subscriber> {
+    ) -> event::EndpointPublisherSubscriber<'_, Self::Subscriber> {
         use s2n_quic_core::event::IntoEvent;
 
         let timestamp = timestamp.into_event();

dc/s2n-quic-dc/src/stream/recv/dispatch/queue.rs

@@ -299,7 +299,7 @@ impl<T> Queue<T> {
     }
 
     #[inline]
-    fn lock(&self) -> Result<std::sync::MutexGuard<Inner<T>>, Closed> {
+    fn lock(&self) -> Result<std::sync::MutexGuard<'_, Inner<T>>, Closed> {
         self.inner.lock().map_err(|_| Closed)
     }
 }

dc/s2n-quic-dc/src/stream/recv/shared.rs

@@ -208,7 +208,7 @@ impl State {
     }
 
     #[inline]
-    pub fn worker_try_lock(&self) -> io::Result<Option<MutexGuard<Inner>>> {
+    pub fn worker_try_lock(&self) -> io::Result<Option<MutexGuard<'_, Inner>>> {
         match self.inner.try_lock() {
             Ok(lock) => Ok(Some(lock)),
             Err(std::sync::TryLockError::WouldBlock) => Ok(None),

dc/s2n-quic-dc/src/stream/shared.rs

@@ -207,23 +207,23 @@ where
     }
 
     #[inline]
-    pub fn publisher(&self) -> event::ConnectionPublisherSubscriber<Sub> {
+    pub fn publisher(&self) -> event::ConnectionPublisherSubscriber<'_, Sub> {
         self.publisher_with_timestamp(self.clock.get_time())
     }
 
     #[inline]
     pub fn publisher_with_timestamp(
         &self,
         timestamp: Timestamp,
-    ) -> event::ConnectionPublisherSubscriber<Sub> {
+    ) -> event::ConnectionPublisherSubscriber<'_, Sub> {
         self.subscriber.publisher(timestamp)
     }
 
     #[inline]
     pub fn endpoint_publisher(
         &self,
         timestamp: Timestamp,
-    ) -> event::EndpointPublisherSubscriber<Sub> {
+    ) -> event::EndpointPublisherSubscriber<'_, Sub> {
         self.subscriber.endpoint_publisher(timestamp)
     }
 }
@@ -241,7 +241,7 @@ where
     Sub: event::Subscriber,
 {
     #[inline]
-    pub fn publisher(&self, timestamp: Timestamp) -> event::ConnectionPublisherSubscriber<Sub> {
+    pub fn publisher(&self, timestamp: Timestamp) -> event::ConnectionPublisherSubscriber<'_, Sub> {
         event::ConnectionPublisherSubscriber::new(
             event::builder::ConnectionMeta {
                 id: 0, // TODO
@@ -257,7 +257,7 @@ where
     pub fn endpoint_publisher(
         &self,
         timestamp: Timestamp,
-    ) -> event::EndpointPublisherSubscriber<Sub> {
+    ) -> event::EndpointPublisherSubscriber<'_, Sub> {
         event::EndpointPublisherSubscriber::new(
             event::builder::EndpointMeta {
                 timestamp: timestamp.into_event(),

dc/s2n-quic-dc/src/sync/ring_deque.rs

@@ -225,14 +225,14 @@ impl<T, W: RecvWaker> RingDeque<T, W> {
     }
 
     #[inline]
-    fn lock(&self) -> Result<std::sync::MutexGuard<Inner<T, W>>, Closed> {
+    fn lock(&self) -> Result<std::sync::MutexGuard<'_, Inner<T, W>>, Closed> {
         let inner = self.inner.lock().unwrap();
         ensure!(inner.open, Err(Closed));
         Ok(inner)
     }
 
     #[inline]
-    fn try_lock(&self) -> Result<Option<std::sync::MutexGuard<Inner<T, W>>>, Closed> {
+    fn try_lock(&self) -> Result<Option<std::sync::MutexGuard<'_, Inner<T, W>>>, Closed> {
         use std::sync::TryLockError;
         let inner = match self.inner.try_lock() {
             Ok(inner) => inner,