clippy: fixup rust 1.83 warnings (#1640)

baloo · web-flow · commit a4f4ff7dcea3 · 2025-01-27T11:34:11.000-08:00
* pkcs12: clippy fixups

* crmf: clippy fixups

* cms: clippy fixups

* sec1: clippy fixups

* pkcs1: clippy fixups

* pkcs8: clippy fixups

* x509-cert: clippy fixups

* gss-api: clippy fixups

* spki: clippy fixups

* base64ct: clippy fixups

* der: clippy fixups

* pem-rfc7468: clippy fixups

* const-oid: clippy fixups

* serdect: clippy fixups

* tls-codec: clippy fixups

* const-oid: clippy fixup
diff --git a/base64ct/src/decoder.rs b/base64ct/src/decoder.rs
@@ -253,7 +253,7 @@ impl<'i, E: Encoding> Decoder<'i, E> {
 }
 
 #[cfg(feature = "std")]
-impl<'i, E: Encoding> io::Read for Decoder<'i, E> {
+impl<E: Encoding> io::Read for Decoder<'_, E> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         if self.is_finished() {
             return Ok(0);
@@ -344,7 +344,7 @@ pub struct Line<'i> {
     remaining: &'i [u8],
 }
 
-impl<'i> Default for Line<'i> {
+impl Default for Line<'_> {
     fn default() -> Self {
         Self::new(&[])
     }
diff --git a/base64ct/src/encoder.rs b/base64ct/src/encoder.rs
@@ -166,7 +166,7 @@ impl<'o, E: Encoding> Encoder<'o, E> {
 }
 
 #[cfg(feature = "std")]
-impl<'o, E: Encoding> io::Write for Encoder<'o, E> {
+impl<E: Encoding> io::Write for Encoder<'_, E> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.encode(buf)?;
         Ok(buf.len())
diff --git a/cms/src/builder.rs b/cms/src/builder.rs
@@ -179,7 +179,7 @@ impl<'s> SignerInfoBuilder<'s> {
     }
 }
 
-impl<'s> Builder for SignerInfoBuilder<'s> {
+impl Builder for SignerInfoBuilder<'_> {
     type Output = SignerInfo;
 
     /// Calculate the data to be signed
diff --git a/const-oid/src/arcs.rs b/const-oid/src/arcs.rs
@@ -111,7 +111,7 @@ impl<'a> Arcs<'a> {
     }
 }
 
-impl<'a> Iterator for Arcs<'a> {
+impl Iterator for Arcs<'_> {
     type Item = Arc;
 
     fn next(&mut self) -> Option<Arc> {
diff --git a/const-oid/src/encoder.rs b/const-oid/src/encoder.rs
@@ -132,7 +132,7 @@ const fn base128_byte(arc: Arc, pos: usize, total: usize) -> Result<u8> {
     debug_assert!(pos < total);
     let last_byte = checked_add!(pos, 1) == total;
     let mask = if last_byte { 0 } else { 0b10000000 };
-    let shift = checked_sub!(checked_sub!(total, pos), 1) * 7;
+    let shift = checked_mul!(checked_sub!(checked_sub!(total, pos), 1), 7);
     Ok(((arc >> shift) & 0b1111111) as u8 | mask)
 }
 
diff --git a/crmf/src/pop.rs b/crmf/src/pop.rs
@@ -248,7 +248,7 @@ impl<'a> ::der::Decode<'a> for EncKeyWithIdChoice<'a> {
         }
     }
 }
-impl<'a> ::der::EncodeValue for EncKeyWithIdChoice<'a> {
+impl ::der::EncodeValue for EncKeyWithIdChoice<'_> {
     fn encode_value(&self, encoder: &mut impl ::der::Writer) -> ::der::Result<()> {
         match self {
             Self::String(variant) => variant.encode_value(encoder),
diff --git a/der/src/arrayvec.rs b/der/src/arrayvec.rs
@@ -125,7 +125,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
 }
 
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
+impl<T> ExactSizeIterator for Iter<'_, T> {}
 
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
diff --git a/der/src/asn1/bit_string.rs b/der/src/asn1/bit_string.rs
@@ -190,7 +190,7 @@ impl<'a> TryFrom<BitStringRef<'a>> for &'a [u8] {
     }
 }
 
-impl<'a> FixedTag for BitStringRef<'a> {
+impl FixedTag for BitStringRef<'_> {
     const TAG: Tag = Tag::BitString;
 }
 
@@ -401,7 +401,7 @@ pub struct BitStringIter<'a> {
     position: usize,
 }
 
-impl<'a> Iterator for BitStringIter<'a> {
+impl Iterator for BitStringIter<'_> {
     type Item = bool;
 
     #[allow(clippy::arithmetic_side_effects)]
@@ -417,13 +417,13 @@ impl<'a> Iterator for BitStringIter<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for BitStringIter<'a> {
+impl ExactSizeIterator for BitStringIter<'_> {
     fn len(&self) -> usize {
         self.bit_string.bit_len()
     }
 }
 
-impl<'a> FusedIterator for BitStringIter<'a> {}
+impl FusedIterator for BitStringIter<'_> {}
 
 #[cfg(feature = "flagset")]
 impl<T: flagset::Flags> FixedTag for flagset::FlagSet<T> {
diff --git a/der/src/asn1/context_specific.rs b/der/src/asn1/context_specific.rs
@@ -234,7 +234,7 @@ impl<'a, T> ContextSpecificRef<'a, T> {
     }
 }
 
-impl<'a, T> EncodeValue for ContextSpecificRef<'a, T>
+impl<T> EncodeValue for ContextSpecificRef<'_, T>
 where
     T: EncodeValue + Tagged,
 {
@@ -247,7 +247,7 @@ where
     }
 }
 
-impl<'a, T> Tagged for ContextSpecificRef<'a, T>
+impl<T> Tagged for ContextSpecificRef<'_, T>
 where
     T: Tagged,
 {
diff --git a/der/src/asn1/integer/int.rs b/der/src/asn1/integer/int.rs
@@ -151,7 +151,7 @@ impl<'a> DecodeValue<'a> for IntRef<'a> {
     }
 }
 
-impl<'a> EncodeValue for IntRef<'a> {
+impl EncodeValue for IntRef<'_> {
     fn value_len(&self) -> Result<Length> {
         // Signed integers always hold their full encoded form.
         Ok(self.inner.len())
@@ -168,11 +168,11 @@ impl<'a> From<&IntRef<'a>> for IntRef<'a> {
     }
 }
 
-impl<'a> FixedTag for IntRef<'a> {
+impl FixedTag for IntRef<'_> {
     const TAG: Tag = Tag::Integer;
 }
 
-impl<'a> OrdIsValueOrd for IntRef<'a> {}
+impl OrdIsValueOrd for IntRef<'_> {}
 
 #[cfg(feature = "alloc")]
 mod allocating {
diff --git a/der/src/asn1/integer/uint.rs b/der/src/asn1/integer/uint.rs
@@ -134,7 +134,7 @@ impl<'a> DecodeValue<'a> for UintRef<'a> {
     }
 }
 
-impl<'a> EncodeValue for UintRef<'a> {
+impl EncodeValue for UintRef<'_> {
     fn value_len(&self) -> Result<Length> {
         encoded_len(self.inner.as_slice())
     }
@@ -155,11 +155,11 @@ impl<'a> From<&UintRef<'a>> for UintRef<'a> {
     }
 }
 
-impl<'a> FixedTag for UintRef<'a> {
+impl FixedTag for UintRef<'_> {
     const TAG: Tag = Tag::Integer;
 }
 
-impl<'a> OrdIsValueOrd for UintRef<'a> {}
+impl OrdIsValueOrd for UintRef<'_> {}
 
 #[cfg(feature = "alloc")]
 mod allocating {
diff --git a/der/src/asn1/sequence_of.rs b/der/src/asn1/sequence_of.rs
@@ -127,7 +127,7 @@ impl<'a, T> Iterator for SequenceOfIter<'a, T> {
     }
 }
 
-impl<'a, T> ExactSizeIterator for SequenceOfIter<'a, T> {}
+impl<T> ExactSizeIterator for SequenceOfIter<'_, T> {}
 
 impl<'a, T, const N: usize> DecodeValue<'a> for [T; N]
 where
diff --git a/der/src/asn1/set_of.rs b/der/src/asn1/set_of.rs
@@ -193,7 +193,7 @@ impl<'a, T> Iterator for SetOfIter<'a, T> {
     }
 }
 
-impl<'a, T> ExactSizeIterator for SetOfIter<'a, T> {}
+impl<T> ExactSizeIterator for SetOfIter<'_, T> {}
 
 /// ASN.1 `SET OF` backed by a [`Vec`].
 ///
diff --git a/der/src/asn1/utf8_string.rs b/der/src/asn1/utf8_string.rs
@@ -76,7 +76,7 @@ impl<'a> TryFrom<&'a str> for Utf8StringRef<'a> {
     }
 }
 
-impl<'a> fmt::Debug for Utf8StringRef<'a> {
+impl fmt::Debug for Utf8StringRef<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Utf8String({:?})", self.as_str())
     }
diff --git a/der/src/asn1/videotex_string.rs b/der/src/asn1/videotex_string.rs
@@ -75,7 +75,7 @@ impl<'a> From<VideotexStringRef<'a>> for &'a [u8] {
     }
 }
 
-impl<'a> fmt::Debug for VideotexStringRef<'a> {
+impl fmt::Debug for VideotexStringRef<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "VideotexString({:?})", self.as_str())
     }
diff --git a/der/src/encode_ref.rs b/der/src/encode_ref.rs
@@ -8,13 +8,13 @@ use core::cmp::Ordering;
 /// type which impls the same.
 pub struct EncodeRef<'a, T>(pub &'a T);
 
-impl<'a, T> AsRef<T> for EncodeRef<'a, T> {
+impl<T> AsRef<T> for EncodeRef<'_, T> {
     fn as_ref(&self) -> &T {
         self.0
     }
 }
 
-impl<'a, T> Encode for EncodeRef<'a, T>
+impl<T> Encode for EncodeRef<'_, T>
 where
     T: Encode,
 {
@@ -33,13 +33,13 @@ where
 /// By virtue of the blanket impl, this type also impls `Encode`.
 pub struct EncodeValueRef<'a, T>(pub &'a T);
 
-impl<'a, T> AsRef<T> for EncodeValueRef<'a, T> {
+impl<T> AsRef<T> for EncodeValueRef<'_, T> {
     fn as_ref(&self) -> &T {
         self.0
     }
 }
 
-impl<'a, T> EncodeValue for EncodeValueRef<'a, T>
+impl<T> EncodeValue for EncodeValueRef<'_, T>
 where
     T: EncodeValue,
 {
@@ -52,7 +52,7 @@ where
     }
 }
 
-impl<'a, T> Tagged for EncodeValueRef<'a, T>
+impl<T> Tagged for EncodeValueRef<'_, T>
 where
     T: Tagged,
 {
@@ -61,7 +61,7 @@ where
     }
 }
 
-impl<'a, T> ValueOrd for EncodeValueRef<'a, T>
+impl<T> ValueOrd for EncodeValueRef<'_, T>
 where
     T: ValueOrd,
 {
diff --git a/der/src/str_ref.rs b/der/src/str_ref.rs
@@ -70,7 +70,7 @@ impl<'a> DecodeValue<'a> for StrRef<'a> {
     }
 }
 
-impl<'a> EncodeValue for StrRef<'a> {
+impl EncodeValue for StrRef<'_> {
     fn value_len(&self) -> Result<Length> {
         Ok(self.length)
     }
diff --git a/der/src/writer/slice.rs b/der/src/writer/slice.rs
@@ -126,7 +126,7 @@ impl<'a> SliceWriter<'a> {
     }
 }
 
-impl<'a> Writer for SliceWriter<'a> {
+impl Writer for SliceWriter<'_> {
     fn write(&mut self, slice: &[u8]) -> Result<()> {
         self.reserve(slice.len())?.copy_from_slice(slice);
         Ok(())
diff --git a/gss-api/src/lib.rs b/gss-api/src/lib.rs
@@ -54,7 +54,7 @@ pub struct InitialContextToken<'a> {
     pub inner_context_token: AnyRef<'a>,
 }
 
-impl<'a> FixedTag for InitialContextToken<'a> {
+impl FixedTag for InitialContextToken<'_> {
     const TAG: Tag = Tag::Application {
         constructed: true,
         number: TagNumber::new(0),
@@ -72,7 +72,7 @@ impl<'a> DecodeValue<'a> for InitialContextToken<'a> {
     }
 }
 
-impl<'a> EncodeValue for InitialContextToken<'a> {
+impl EncodeValue for InitialContextToken<'_> {
     fn value_len(&self) -> der::Result<Length> {
         self.this_mech.encoded_len()? + self.inner_context_token.encoded_len()?
     }
diff --git a/gss-api/src/negotiation.rs b/gss-api/src/negotiation.rs
@@ -145,7 +145,7 @@ pub struct NegTokenTarg<'a> {
     ///  processed by the target (accept_incomplete) and a mechToken
     ///  sent by the initiator and processed by the target
     ///  (accept_completed).
-    ///
+    //
     //  For those targets that support piggybacking the initial mechToken,
     //  an optimistic negotiation response is possible and includes in that
     //  case a responseToken which may continue the authentication exchange
@@ -154,7 +154,7 @@ pub struct NegTokenTarg<'a> {
     //  the responseToken is used to carry the tokens specific to the
     //  mechanism selected. For subsequent tokens (if any) returned by the
     //  target, negResult, and supportedMech are not present.
-
+    //
     //  For the last token returned by the target, the mechListMIC, when
     //  present, is a MIC computed over the MechTypes using the selected
     //  mechanism.
diff --git a/pem-rfc7468/src/decoder.rs b/pem-rfc7468/src/decoder.rs
@@ -145,7 +145,7 @@ impl<'i> From<Decoder<'i>> for Base64Decoder<'i> {
 }
 
 #[cfg(feature = "std")]
-impl<'i> io::Read for Decoder<'i> {
+impl io::Read for Decoder<'_> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.base64.read(buf)
     }
diff --git a/pem-rfc7468/src/encoder.rs b/pem-rfc7468/src/encoder.rs
@@ -286,7 +286,7 @@ impl<'l, 'o> Encoder<'l, 'o> {
 }
 
 #[cfg(feature = "std")]
-impl<'l, 'o> io::Write for Encoder<'l, 'o> {
+impl io::Write for Encoder<'_, '_> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.encode(buf)?;
         Ok(buf.len())
diff --git a/pkcs1/src/params.rs b/pkcs1/src/params.rs
@@ -168,7 +168,7 @@ impl<'a> RsaPssParams<'a> {
     }
 }
 
-impl<'a> Default for RsaPssParams<'a> {
+impl Default for RsaPssParams<'_> {
     fn default() -> Self {
         Self {
             hash: SHA_1_AI,
@@ -335,7 +335,7 @@ impl<'a> RsaOaepParams<'a> {
     }
 }
 
-impl<'a> Default for RsaOaepParams<'a> {
+impl Default for RsaOaepParams<'_> {
     fn default() -> Self {
         Self {
             hash: SHA_1_AI,
diff --git a/pkcs12/src/kdf.rs b/pkcs12/src/kdf.rs
@@ -105,8 +105,8 @@ where
         Pkcs12KeyType::Mac => vec![3u8; block_size],
     };
 
-    let slen = block_size * ((salt.len() + block_size - 1) / block_size);
-    let plen = block_size * ((pass.len() + block_size - 1) / block_size);
+    let slen = block_size * salt.len().div_ceil(block_size);
+    let plen = block_size * pass.len().div_ceil(block_size);
     let ilen = slen + plen;
     let mut init_key = vec![0u8; ilen];
     // 2. Concatenate copies of the salt together to create a string S of
diff --git a/pkcs12/src/safe_bag.rs b/pkcs12/src/safe_bag.rs
@@ -89,7 +89,7 @@ impl ::der::EncodeValue for SafeBag {
         Ok(())
     }
 }
-impl<'a> ::der::Sequence<'a> for SafeBag {}
+impl ::der::Sequence<'_> for SafeBag {}
 
 /// Version for the PrivateKeyInfo structure as defined in [RFC 5208 Section 5].
 ///
diff --git a/pkcs8/src/private_key_info.rs b/pkcs8/src/private_key_info.rs
@@ -378,7 +378,7 @@ pub trait BitStringLike {
     fn as_bit_string(&self) -> BitStringRef<'_>;
 }
 
-impl<'a> BitStringLike for BitStringRef<'a> {
+impl BitStringLike for BitStringRef<'_> {
     fn as_bit_string(&self) -> BitStringRef<'_> {
         BitStringRef::from(self)
     }
diff --git a/sec1/src/point.rs b/sec1/src/point.rs
@@ -458,7 +458,7 @@ pub enum Coordinates<'a, Size: ModulusSize> {
     },
 }
 
-impl<'a, Size: ModulusSize> Coordinates<'a, Size> {
+impl<Size: ModulusSize> Coordinates<'_, Size> {
     /// Get the tag octet needed to encode this set of [`Coordinates`]
     pub fn tag(&self) -> Tag {
         match self {
diff --git a/sec1/src/private_key.rs b/sec1/src/private_key.rs
@@ -146,7 +146,7 @@ impl<'a> TryFrom<&'a [u8]> for EcPrivateKey<'a> {
     }
 }
 
-impl<'a> fmt::Debug for EcPrivateKey<'a> {
+impl fmt::Debug for EcPrivateKey<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("EcPrivateKey")
             .field("parameters", &self.parameters)
diff --git a/serdect/src/common.rs b/serdect/src/common.rs
diff --git a/spki/src/spki.rs b/spki/src/spki.rs
diff --git a/tls_codec/src/quic_vec.rs b/tls_codec/src/quic_vec.rs
diff --git a/x509-cert/src/builder/profile/cabf/tls.rs b/x509-cert/src/builder/profile/cabf/tls.rs
diff --git a/x509-cert/src/time.rs b/x509-cert/src/time.rs

Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ impl<'i, E: Encoding> Decoder<'i, E> {`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`#[cfg(feature = "std")]`
`256`		`-impl<'i, E: Encoding> io::Read for Decoder<'i, E> {`
	`256`	`+impl<E: Encoding> io::Read for Decoder<'_, E> {`
`257`	`257`	`fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {`
`258`	`258`	`if self.is_finished() {`
`259`	`259`	`return Ok(0);`
`@@ -344,7 +344,7 @@ pub struct Line<'i> {`
`344`	`344`	`remaining: &'i [u8],`
`345`	`345`	`}`
`346`	`346`
`347`		`-impl<'i> Default for Line<'i> {`
	`347`	`+impl Default for Line<'_> {`
`348`	`348`	`fn default() -> Self {`
`349`	`349`	`Self::new(&[])`
`350`	`350`	`}`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ impl<'o, E: Encoding> Encoder<'o, E> {`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`#[cfg(feature = "std")]`
`169`		`-impl<'o, E: Encoding> io::Write for Encoder<'o, E> {`
	`169`	`+impl<E: Encoding> io::Write for Encoder<'_, E> {`
`170`	`170`	`fn write(&mut self, buf: &[u8]) -> io::Result<usize> {`
`171`	`171`	`self.encode(buf)?;`
`172`	`172`	`Ok(buf.len())`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,7 @@ impl<'s> SignerInfoBuilder<'s> {`
`179`	`179`	`}`
`180`	`180`	`}`
`181`	`181`
`182`		`-impl<'s> Builder for SignerInfoBuilder<'s> {`
	`182`	`+impl Builder for SignerInfoBuilder<'_> {`
`183`	`183`	`type Output = SignerInfo;`
`184`	`184`
`185`	`185`	`/// Calculate the data to be signed`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ impl<'a> Arcs<'a> {`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`		`-impl<'a> Iterator for Arcs<'a> {`
	`114`	`+impl Iterator for Arcs<'_> {`
`115`	`115`	`type Item = Arc;`
`116`	`116`
`117`	`117`	`fn next(&mut self) -> Option<Arc> {`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ const fn base128_byte(arc: Arc, pos: usize, total: usize) -> Result<u8> {`
`132`	`132`	`debug_assert!(pos < total);`
`133`	`133`	`let last_byte = checked_add!(pos, 1) == total;`
`134`	`134`	`let mask = if last_byte { 0 } else { 0b10000000 };`
`135`		`- let shift = checked_sub!(checked_sub!(total, pos), 1) * 7;`
	`135`	`+ let shift = checked_mul!(checked_sub!(checked_sub!(total, pos), 1), 7);`
`136`	`136`	`Ok(((arc >> shift) & 0b1111111) as u8 \| mask)`
`137`	`137`	`}`
`138`	`138`
Original file line number	Diff line number	Diff line change
`@@ -248,7 +248,7 @@ impl<'a> ::der::Decode<'a> for EncKeyWithIdChoice<'a> {`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`	`}`
`251`		`-impl<'a> ::der::EncodeValue for EncKeyWithIdChoice<'a> {`
	`251`	`+impl ::der::EncodeValue for EncKeyWithIdChoice<'_> {`
`252`	`252`	`fn encode_value(&self, encoder: &mut impl ::der::Writer) -> ::der::Result<()> {`
`253`	`253`	`match self {`
`254`	`254`	`Self::String(variant) => variant.encode_value(encoder),`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ impl<'a, T> Iterator for Iter<'a, T> {`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`128`		`-impl<'a, T> ExactSizeIterator for Iter<'a, T> {}`
	`128`	`+impl<T> ExactSizeIterator for Iter<'_, T> {}`
`129`	`129`
`130`	`130`	`#[cfg(test)]`
`131`	`131`	`#[allow(clippy::unwrap_used)]`
Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ impl<'a> TryFrom<BitStringRef<'a>> for &'a [u8] {`
`190`	`190`	`}`
`191`	`191`	`}`
`192`	`192`
`193`		`-impl<'a> FixedTag for BitStringRef<'a> {`
	`193`	`+impl FixedTag for BitStringRef<'_> {`
`194`	`194`	`const TAG: Tag = Tag::BitString;`
`195`	`195`	`}`
`196`	`196`
`@@ -401,7 +401,7 @@ pub struct BitStringIter<'a> {`
`401`	`401`	`position: usize,`
`402`	`402`	`}`
`403`	`403`
`404`		`-impl<'a> Iterator for BitStringIter<'a> {`
	`404`	`+impl Iterator for BitStringIter<'_> {`
`405`	`405`	`type Item = bool;`
`406`	`406`
`407`	`407`	`#[allow(clippy::arithmetic_side_effects)]`
`@@ -417,13 +417,13 @@ impl<'a> Iterator for BitStringIter<'a> {`
`417`	`417`	`}`
`418`	`418`	`}`
`419`	`419`
`420`		`-impl<'a> ExactSizeIterator for BitStringIter<'a> {`
	`420`	`+impl ExactSizeIterator for BitStringIter<'_> {`
`421`	`421`	`fn len(&self) -> usize {`
`422`	`422`	`self.bit_string.bit_len()`
`423`	`423`	`}`
`424`	`424`	`}`
`425`	`425`
`426`		`-impl<'a> FusedIterator for BitStringIter<'a> {}`
	`426`	`+impl FusedIterator for BitStringIter<'_> {}`
`427`	`427`
`428`	`428`	`#[cfg(feature = "flagset")]`
`429`	`429`	`impl<T: flagset::Flags> FixedTag for flagset::FlagSet<T> {`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,7 @@ impl<'a, T> ContextSpecificRef<'a, T> {`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`
`237`		`-impl<'a, T> EncodeValue for ContextSpecificRef<'a, T>`
	`237`	`+impl<T> EncodeValue for ContextSpecificRef<'_, T>`
`238`	`238`	`where`
`239`	`239`	`T: EncodeValue + Tagged,`
`240`	`240`	`{`
`@@ -247,7 +247,7 @@ where`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`
`250`		`-impl<'a, T> Tagged for ContextSpecificRef<'a, T>`
	`250`	`+impl<T> Tagged for ContextSpecificRef<'_, T>`
`251`	`251`	`where`
`252`	`252`	`T: Tagged,`
`253`	`253`	`{`
Original file line number	Diff line number	Diff line change
`@@ -151,7 +151,7 @@ impl<'a> DecodeValue<'a> for IntRef<'a> {`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`
`154`		`-impl<'a> EncodeValue for IntRef<'a> {`
	`154`	`+impl EncodeValue for IntRef<'_> {`
`155`	`155`	`fn value_len(&self) -> Result<Length> {`
`156`	`156`	`// Signed integers always hold their full encoded form.`
`157`	`157`	`Ok(self.inner.len())`
`@@ -168,11 +168,11 @@ impl<'a> From<&IntRef<'a>> for IntRef<'a> {`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`171`		`-impl<'a> FixedTag for IntRef<'a> {`
	`171`	`+impl FixedTag for IntRef<'_> {`
`172`	`172`	`const TAG: Tag = Tag::Integer;`
`173`	`173`	`}`
`174`	`174`
`175`		`-impl<'a> OrdIsValueOrd for IntRef<'a> {}`
	`175`	`+impl OrdIsValueOrd for IntRef<'_> {}`
`176`	`176`
`177`	`177`	`#[cfg(feature = "alloc")]`
`178`	`178`	`mod allocating {`