chore: cargo +nightly clippy --fix

quinn-proto/src/connection/datagrams.rs

@@ -15,7 +15,7 @@ pub struct Datagrams<'a> {
     pub(super) conn: &'a mut Connection,
 }
 
-impl<'a> Datagrams<'a> {
+impl Datagrams<'_> {
     /// Queue an unreliable, unordered datagram for immediate transmission
     ///
     /// If `drop` is true, previously queued datagrams which are still unsent may be discarded to

quinn-proto/src/connection/streams/mod.rs

@@ -32,6 +32,7 @@ pub struct Streams<'a> {
     pub(super) conn_state: &'a super::State,
 }
 
+#[allow(clippy::needless_lifetimes)] // Needed for cfg(fuzzing)
 impl<'a> Streams<'a> {
     #[cfg(fuzzing)]
     pub fn new(state: &'a mut StreamsState, conn_state: &'a super::State) -> Self {
@@ -106,7 +107,7 @@ pub struct RecvStream<'a> {
     pub(super) pending: &'a mut Retransmits,
 }
 
-impl<'a> RecvStream<'a> {
+impl RecvStream<'_> {
     /// Read from the given recv stream
     ///
     /// `max_length` limits the maximum size of the returned `Bytes` value; passing `usize::MAX`
@@ -198,6 +199,7 @@ pub struct SendStream<'a> {
     pub(super) conn_state: &'a super::State,
 }
 
+#[allow(clippy::needless_lifetimes)] // Needed for cfg(fuzzing)
 impl<'a> SendStream<'a> {
     #[cfg(fuzzing)]
     pub fn new(

quinn-proto/src/connection/streams/recv.rs

@@ -379,7 +379,7 @@ impl<'a> Chunks<'a> {
     }
 }
 
-impl<'a> Drop for Chunks<'a> {
+impl Drop for Chunks<'_> {
     fn drop(&mut self) {
         let _ = self.finalize_inner();
     }

quinn-proto/src/connection/streams/send.rs

@@ -163,7 +163,7 @@ impl<'a> BytesArray<'a> {
     }
 }
 
-impl<'a> BytesSource for BytesArray<'a> {
+impl BytesSource for BytesArray<'_> {
     fn pop_chunk(&mut self, limit: usize) -> (Bytes, usize) {
         // The loop exists to skip empty chunks while still marking them as
         // consumed
@@ -208,7 +208,7 @@ impl<'a> ByteSlice<'a> {
     }
 }
 
-impl<'a> BytesSource for ByteSlice<'a> {
+impl BytesSource for ByteSlice<'_> {
     fn pop_chunk(&mut self, limit: usize) -> (Bytes, usize) {
         let limit = limit.min(self.data.len());
         if limit == 0 {

quinn-proto/src/frame.rs

@@ -803,7 +803,7 @@ impl<'a> AckIter<'a> {
     }
 }
 
-impl<'a> Iterator for AckIter<'a> {
+impl Iterator for AckIter<'_> {
     type Item = RangeInclusive<u64>;
     fn next(&mut self) -> Option<RangeInclusive<u64>> {
         if !self.data.has_remaining() {

quinn-proto/src/range_set/btree_range_set.rs

@@ -212,15 +212,15 @@ impl RangeSet {
 
 pub struct Iter<'a>(btree_map::Iter<'a, u64, u64>);
 
-impl<'a> Iterator for Iter<'a> {
+impl Iterator for Iter<'_> {
     type Item = Range<u64>;
     fn next(&mut self) -> Option<Range<u64>> {
         let (&start, &end) = self.0.next()?;
         Some(start..end)
     }
 }
 
-impl<'a> DoubleEndedIterator for Iter<'a> {
+impl DoubleEndedIterator for Iter<'_> {
     fn next_back(&mut self) -> Option<Range<u64>> {
         let (&start, &end) = self.0.next_back()?;
         Some(start..end)
@@ -241,7 +241,7 @@ pub struct EltIter<'a> {
     end: u64,
 }
 
-impl<'a> Iterator for EltIter<'a> {
+impl Iterator for EltIter<'_> {
     type Item = u64;
     fn next(&mut self) -> Option<u64> {
         if self.next == self.end {
@@ -255,7 +255,7 @@ impl<'a> Iterator for EltIter<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator for EltIter<'a> {
+impl DoubleEndedIterator for EltIter<'_> {
     fn next_back(&mut self) -> Option<u64> {
         if self.next == self.end {
             let (&start, &end) = self.inner.next_back()?;

quinn-udp/src/cmsg/mod.rs

@@ -72,7 +72,7 @@ impl<'a, M: MsgHdr> Encoder<'a, M> {
 
 // Statically guarantees that the encoding operation is "finished" before the control buffer is read
 // by `sendmsg` like API.
-impl<'a, M: MsgHdr> Drop for Encoder<'a, M> {
+impl<M: MsgHdr> Drop for Encoder<'_, M> {
     fn drop(&mut self) {
         self.hdr.set_control_len(self.len as _);
     }

quinn/src/endpoint.rs

@@ -633,7 +633,7 @@ pin_project! {
     }
 }
 
-impl<'a> Future for Accept<'a> {
+impl Future for Accept<'_> {
     type Output = Option<Incoming>;
     fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.project();

quinn/src/mutex.rs

@@ -146,15 +146,15 @@ mod non_tracking {
         guard: std::sync::MutexGuard<'a, T>,
     }
 
-    impl<'a, T> Deref for MutexGuard<'a, T> {
+    impl<T> Deref for MutexGuard<'_, T> {
         type Target = T;
 
         fn deref(&self) -> &Self::Target {
             self.guard.deref()
         }
     }
 
-    impl<'a, T> DerefMut for MutexGuard<'a, T> {
+    impl<T> DerefMut for MutexGuard<'_, T> {
         fn deref_mut(&mut self) -> &mut Self::Target {
             self.guard.deref_mut()
         }

quinn/src/recv_stream.rs

@@ -603,7 +603,7 @@ struct Read<'a> {
     buf: ReadBuf<'a>,
 }
 
-impl<'a> Future for Read<'a> {
+impl Future for Read<'_> {
     type Output = Result<Option<usize>, ReadError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
@@ -625,7 +625,7 @@ struct ReadExact<'a> {
     buf: ReadBuf<'a>,
 }
 
-impl<'a> Future for ReadExact<'a> {
+impl Future for ReadExact<'_> {
     type Output = Result<(), ReadExactError>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -663,7 +663,7 @@ struct ReadChunk<'a> {
     ordered: bool,
 }
 
-impl<'a> Future for ReadChunk<'a> {
+impl Future for ReadChunk<'_> {
     type Output = Result<Option<Chunk>, ReadError>;
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let (max_length, ordered) = (self.max_length, self.ordered);
@@ -680,7 +680,7 @@ struct ReadChunks<'a> {
     bufs: &'a mut [Bytes],
 }
 
-impl<'a> Future for ReadChunks<'a> {
+impl Future for ReadChunks<'_> {
     type Output = Result<Option<usize>, ReadError>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let this = self.get_mut();

quinn/src/send_stream.rs

@@ -327,7 +327,7 @@ struct Write<'a> {
     buf: &'a [u8],
 }
 
-impl<'a> Future for Write<'a> {
+impl Future for Write<'_> {
     type Output = Result<usize, WriteError>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -345,7 +345,7 @@ struct WriteAll<'a> {
     buf: &'a [u8],
 }
 
-impl<'a> Future for WriteAll<'a> {
+impl Future for WriteAll<'_> {
     type Output = Result<(), WriteError>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -369,7 +369,7 @@ struct WriteChunks<'a> {
     bufs: &'a mut [Bytes],
 }
 
-impl<'a> Future for WriteChunks<'a> {
+impl Future for WriteChunks<'_> {
     type Output = Result<Written, WriteError>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -387,7 +387,7 @@ struct WriteChunk<'a> {
     buf: [Bytes; 1],
 }
 
-impl<'a> Future for WriteChunk<'a> {
+impl Future for WriteChunk<'_> {
     type Output = Result<(), WriteError>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let this = self.get_mut();
@@ -411,7 +411,7 @@ struct WriteAllChunks<'a> {
     offset: usize,
 }
 
-impl<'a> Future for WriteAllChunks<'a> {
+impl Future for WriteAllChunks<'_> {
     type Output = Result<(), WriteError>;
     fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         let this = self.get_mut();