Fix new Clippy lints (#1710)

newpavlov · web-flow · commit f575f2b9008e · 2024-11-13T19:28:21.000+03:00
diff --git a/.github/workflows/workspace.yml b/.github/workflows/workspace.yml
@@ -24,7 +24,7 @@ jobs:
       - uses: RustCrypto/actions/cargo-cache@master
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.81.0
+          toolchain: 1.82.0
           components: clippy
       - run: cargo clippy --all --all-features --tests -- -D warnings
 
diff --git a/aead/src/lib.rs b/aead/src/lib.rs
@@ -487,7 +487,7 @@ pub struct Payload<'msg, 'aad> {
 }
 
 #[cfg(feature = "alloc")]
-impl<'msg, 'aad> From<&'msg [u8]> for Payload<'msg, 'aad> {
+impl<'msg> From<&'msg [u8]> for Payload<'msg, '_> {
     fn from(msg: &'msg [u8]) -> Self {
         Self { msg, aad: b"" }
     }
diff --git a/cipher/src/block/ctx.rs b/cipher/src/block/ctx.rs
@@ -11,32 +11,32 @@ pub(super) struct BlockCtx<'inp, 'out, BS: BlockSizes> {
     pub block: InOut<'inp, 'out, Block<Self>>,
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockSizeUser for BlockCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockSizeUser for BlockCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockCipherEncClosure for BlockCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockCipherEncClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
         backend.encrypt_block(self.block);
     }
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockCipherDecClosure for BlockCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockCipherDecClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
         backend.decrypt_block(self.block);
     }
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockModeEncClosure for BlockCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockModeEncClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
         backend.encrypt_block(self.block);
     }
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockModeDecClosure for BlockCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockModeDecClosure for BlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
         backend.decrypt_block(self.block);
@@ -47,11 +47,11 @@ pub(super) struct BlocksCtx<'inp, 'out, BS: BlockSizes> {
     pub blocks: InOutBuf<'inp, 'out, Block<Self>>,
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockSizeUser for BlocksCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockSizeUser for BlocksCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -68,7 +68,7 @@ impl<'inp, 'out, BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'inp, 'out,
     }
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -85,7 +85,7 @@ impl<'inp, 'out, BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'inp, 'out,
     }
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -102,7 +102,7 @@ impl<'inp, 'out, BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'inp, 'out, B
     }
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockModeDecClosure for BlocksCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockModeDecClosure for BlocksCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {
         if B::ParBlocksSize::USIZE > 1 {
diff --git a/cipher/src/stream/core_api.rs b/cipher/src/stream/core_api.rs
@@ -190,10 +190,10 @@ impl_counter! { u32 u64 u128 }
 struct WriteBlockCtx<'a, BS: BlockSizes> {
     block: &'a mut Block<Self>,
 }
-impl<'a, BS: BlockSizes> BlockSizeUser for WriteBlockCtx<'a, BS> {
+impl<BS: BlockSizes> BlockSizeUser for WriteBlockCtx<'_, BS> {
     type BlockSize = BS;
 }
-impl<'a, BS: BlockSizes> StreamCipherClosure for WriteBlockCtx<'a, BS> {
+impl<BS: BlockSizes> StreamCipherClosure for WriteBlockCtx<'_, BS> {
     #[inline(always)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {
         backend.gen_ks_block(self.block);
@@ -203,10 +203,10 @@ impl<'a, BS: BlockSizes> StreamCipherClosure for WriteBlockCtx<'a, BS> {
 struct WriteBlocksCtx<'a, BS: BlockSizes> {
     blocks: &'a mut [Block<Self>],
 }
-impl<'a, BS: BlockSizes> BlockSizeUser for WriteBlocksCtx<'a, BS> {
+impl<BS: BlockSizes> BlockSizeUser for WriteBlocksCtx<'_, BS> {
     type BlockSize = BS;
 }
-impl<'a, BS: BlockSizes> StreamCipherClosure for WriteBlocksCtx<'a, BS> {
+impl<BS: BlockSizes> StreamCipherClosure for WriteBlocksCtx<'_, BS> {
     #[inline(always)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {
         if B::ParBlocksSize::USIZE > 1 {
@@ -227,11 +227,11 @@ struct ApplyBlockCtx<'inp, 'out, BS: BlockSizes> {
     block: InOut<'inp, 'out, Block<Self>>,
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockSizeUser for ApplyBlockCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockSizeUser for ApplyBlockCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<'inp, 'out, BS: BlockSizes> StreamCipherClosure for ApplyBlockCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> StreamCipherClosure for ApplyBlockCtx<'_, '_, BS> {
     #[inline(always)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(mut self, backend: &mut B) {
         let mut t = Default::default();
@@ -244,11 +244,11 @@ struct ApplyBlocksCtx<'inp, 'out, BS: BlockSizes> {
     blocks: InOutBuf<'inp, 'out, Block<Self>>,
 }
 
-impl<'inp, 'out, BS: BlockSizes> BlockSizeUser for ApplyBlocksCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> BlockSizeUser for ApplyBlocksCtx<'_, '_, BS> {
     type BlockSize = BS;
 }
 
-impl<'inp, 'out, BS: BlockSizes> StreamCipherClosure for ApplyBlocksCtx<'inp, 'out, BS> {
+impl<BS: BlockSizes> StreamCipherClosure for ApplyBlocksCtx<'_, '_, BS> {
     #[inline(always)]
     #[allow(clippy::needless_range_loop)]
     fn call<B: StreamCipherBackend<BlockSize = BS>>(self, backend: &mut B) {
diff --git a/cipher/src/stream/wrapper.rs b/cipher/src/stream/wrapper.rs
@@ -106,8 +106,7 @@ impl<T: StreamCipherCore> StreamCipherCoreWrapper<T> {
         };
 
         let bs = T::BlockSize::USIZE;
-        // TODO: use div_ceil on 1.73+ MSRV bump
-        let blocks = (data_len + bs - 1) / bs;
+        let blocks = data_len.div_ceil(bs);
         if blocks > rem_blocks {
             Err(StreamCipherError)
         } else {
diff --git a/password-hash/src/ident.rs b/password-hash/src/ident.rs
@@ -91,13 +91,13 @@ impl<'a> Ident<'a> {
     }
 }
 
-impl<'a> AsRef<str> for Ident<'a> {
+impl AsRef<str> for Ident<'_> {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 
-impl<'a> Deref for Ident<'a> {
+impl Deref for Ident<'_> {
     type Target = str;
 
     fn deref(&self) -> &str {
@@ -115,13 +115,13 @@ impl<'a> TryFrom<&'a str> for Ident<'a> {
     }
 }
 
-impl<'a> fmt::Display for Ident<'a> {
+impl fmt::Display for Ident<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(self)
     }
 }
 
-impl<'a> fmt::Debug for Ident<'a> {
+impl fmt::Debug for Ident<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("Ident").field(&self.as_ref()).finish()
     }
diff --git a/password-hash/src/lib.rs b/password-hash/src/lib.rs
@@ -250,7 +250,7 @@ impl<'a> TryFrom<&'a str> for PasswordHash<'a> {
     }
 }
 
-impl<'a> fmt::Display for PasswordHash<'a> {
+impl fmt::Display for PasswordHash<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}{}", PASSWORD_HASH_SEPARATOR, self.algorithm)?;
 
diff --git a/password-hash/src/salt.rs b/password-hash/src/salt.rs
@@ -163,7 +163,7 @@ impl<'a> Salt<'a> {
     }
 }
 
-impl<'a> AsRef<str> for Salt<'a> {
+impl AsRef<str> for Salt<'_> {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
@@ -177,13 +177,13 @@ impl<'a> TryFrom<&'a str> for Salt<'a> {
     }
 }
 
-impl<'a> fmt::Display for Salt<'a> {
+impl fmt::Display for Salt<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(self.as_str())
     }
 }
 
-impl<'a> fmt::Debug for Salt<'a> {
+impl fmt::Debug for Salt<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Salt({:?})", self.as_str())
     }
diff --git a/password-hash/src/value.rs b/password-hash/src/value.rs
@@ -154,7 +154,7 @@ impl<'a> Value<'a> {
     }
 }
 
-impl<'a> AsRef<str> for Value<'a> {
+impl AsRef<str> for Value<'_> {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
@@ -184,7 +184,7 @@ impl<'a> TryFrom<&Value<'a>> for Decimal {
     }
 }
 
-impl<'a> fmt::Display for Value<'a> {
+impl fmt::Display for Value<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(self.as_str())
     }
diff --git a/universal-hash/src/lib.rs b/universal-hash/src/lib.rs
@@ -64,11 +64,11 @@ pub trait UniversalHash: BlockSizeUser + Sized {
             blocks: &'a [Block<Self>],
         }
 
-        impl<'a, BS: BlockSizes> BlockSizeUser for Ctx<'a, BS> {
+        impl<BS: BlockSizes> BlockSizeUser for Ctx<'_, BS> {
             type BlockSize = BS;
         }
 
-        impl<'a, BS: BlockSizes> UhfClosure for Ctx<'a, BS> {
+        impl<BS: BlockSizes> UhfClosure for Ctx<'_, BS> {
             #[inline(always)]
             fn call<B: UhfBackend<BlockSize = BS>>(self, backend: &mut B) {
                 let pb = B::ParBlocksSize::USIZE;

Original file line number	Diff line number	Diff line change
`@@ -487,7 +487,7 @@ pub struct Payload<'msg, 'aad> {`
`487`	`487`	`}`
`488`	`488`
`489`	`489`	`#[cfg(feature = "alloc")]`
`490`		`-impl<'msg, 'aad> From<&'msg [u8]> for Payload<'msg, 'aad> {`
	`490`	`+impl<'msg> From<&'msg [u8]> for Payload<'msg, '_> {`
`491`	`491`	`fn from(msg: &'msg [u8]) -> Self {`
`492`	`492`	`Self { msg, aad: b"" }`
`493`	`493`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,32 +11,32 @@ pub(super) struct BlockCtx<'inp, 'out, BS: BlockSizes> {`
`11`	`11`	`pub block: InOut<'inp, 'out, Block<Self>>,`
`12`	`12`	`}`
`13`	`13`
`14`		`-impl<'inp, 'out, BS: BlockSizes> BlockSizeUser for BlockCtx<'inp, 'out, BS> {`
	`14`	`+impl<BS: BlockSizes> BlockSizeUser for BlockCtx<'_, '_, BS> {`
`15`	`15`	`type BlockSize = BS;`
`16`	`16`	`}`
`17`	`17`
`18`		`-impl<'inp, 'out, BS: BlockSizes> BlockCipherEncClosure for BlockCtx<'inp, 'out, BS> {`
	`18`	`+impl<BS: BlockSizes> BlockCipherEncClosure for BlockCtx<'_, '_, BS> {`
`19`	`19`	`#[inline(always)]`
`20`	`20`	`fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {`
`21`	`21`	`backend.encrypt_block(self.block);`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`-impl<'inp, 'out, BS: BlockSizes> BlockCipherDecClosure for BlockCtx<'inp, 'out, BS> {`
	`25`	`+impl<BS: BlockSizes> BlockCipherDecClosure for BlockCtx<'_, '_, BS> {`
`26`	`26`	`#[inline(always)]`
`27`	`27`	`fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {`
`28`	`28`	`backend.decrypt_block(self.block);`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`-impl<'inp, 'out, BS: BlockSizes> BlockModeEncClosure for BlockCtx<'inp, 'out, BS> {`
	`32`	`+impl<BS: BlockSizes> BlockModeEncClosure for BlockCtx<'_, '_, BS> {`
`33`	`33`	`#[inline(always)]`
`34`	`34`	`fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {`
`35`	`35`	`backend.encrypt_block(self.block);`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`-impl<'inp, 'out, BS: BlockSizes> BlockModeDecClosure for BlockCtx<'inp, 'out, BS> {`
	`39`	`+impl<BS: BlockSizes> BlockModeDecClosure for BlockCtx<'_, '_, BS> {`
`40`	`40`	`#[inline(always)]`
`41`	`41`	`fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {`
`42`	`42`	`backend.decrypt_block(self.block);`
`@@ -47,11 +47,11 @@ pub(super) struct BlocksCtx<'inp, 'out, BS: BlockSizes> {`
`47`	`47`	`pub blocks: InOutBuf<'inp, 'out, Block<Self>>,`
`48`	`48`	`}`
`49`	`49`
`50`		`-impl<'inp, 'out, BS: BlockSizes> BlockSizeUser for BlocksCtx<'inp, 'out, BS> {`
	`50`	`+impl<BS: BlockSizes> BlockSizeUser for BlocksCtx<'_, '_, BS> {`
`51`	`51`	`type BlockSize = BS;`
`52`	`52`	`}`
`53`	`53`
`54`		`-impl<'inp, 'out, BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'inp, 'out, BS> {`
	`54`	`+impl<BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'_, '_, BS> {`
`55`	`55`	`#[inline(always)]`
`56`	`56`	`fn call<B: BlockCipherEncBackend<BlockSize = BS>>(self, backend: &B) {`
`57`	`57`	`if B::ParBlocksSize::USIZE > 1 {`
`@@ -68,7 +68,7 @@ impl<'inp, 'out, BS: BlockSizes> BlockCipherEncClosure for BlocksCtx<'inp, 'out,`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`-impl<'inp, 'out, BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'inp, 'out, BS> {`
	`71`	`+impl<BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'_, '_, BS> {`
`72`	`72`	`#[inline(always)]`
`73`	`73`	`fn call<B: BlockCipherDecBackend<BlockSize = BS>>(self, backend: &B) {`
`74`	`74`	`if B::ParBlocksSize::USIZE > 1 {`
`@@ -85,7 +85,7 @@ impl<'inp, 'out, BS: BlockSizes> BlockCipherDecClosure for BlocksCtx<'inp, 'out,`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`88`		`-impl<'inp, 'out, BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'inp, 'out, BS> {`
	`88`	`+impl<BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'_, '_, BS> {`
`89`	`89`	`#[inline(always)]`
`90`	`90`	`fn call<B: BlockModeEncBackend<BlockSize = BS>>(self, backend: &mut B) {`
`91`	`91`	`if B::ParBlocksSize::USIZE > 1 {`
`@@ -102,7 +102,7 @@ impl<'inp, 'out, BS: BlockSizes> BlockModeEncClosure for BlocksCtx<'inp, 'out, B`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`-impl<'inp, 'out, BS: BlockSizes> BlockModeDecClosure for BlocksCtx<'inp, 'out, BS> {`
	`105`	`+impl<BS: BlockSizes> BlockModeDecClosure for BlocksCtx<'_, '_, BS> {`
`106`	`106`	`#[inline(always)]`
`107`	`107`	`fn call<B: BlockModeDecBackend<BlockSize = BS>>(self, backend: &mut B) {`
`108`	`108`	`if B::ParBlocksSize::USIZE > 1 {`
Original file line number	Diff line number	Diff line change
`@@ -91,13 +91,13 @@ impl<'a> Ident<'a> {`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`-impl<'a> AsRef<str> for Ident<'a> {`
	`94`	`+impl AsRef<str> for Ident<'_> {`
`95`	`95`	`fn as_ref(&self) -> &str {`
`96`	`96`	`self.as_str()`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
`100`		`-impl<'a> Deref for Ident<'a> {`
	`100`	`+impl Deref for Ident<'_> {`
`101`	`101`	`type Target = str;`
`102`	`102`
`103`	`103`	`fn deref(&self) -> &str {`
`@@ -115,13 +115,13 @@ impl<'a> TryFrom<&'a str> for Ident<'a> {`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`-impl<'a> fmt::Display for Ident<'a> {`
	`118`	`+impl fmt::Display for Ident<'_> {`
`119`	`119`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`120`	`120`	`f.write_str(self)`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`		`-impl<'a> fmt::Debug for Ident<'a> {`
	`124`	`+impl fmt::Debug for Ident<'_> {`
`125`	`125`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`126`	`126`	`f.debug_tuple("Ident").field(&self.as_ref()).finish()`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,7 @@ impl<'a> TryFrom<&'a str> for PasswordHash<'a> {`
`250`	`250`	`}`
`251`	`251`	`}`
`252`	`252`
`253`		`-impl<'a> fmt::Display for PasswordHash<'a> {`
	`253`	`+impl fmt::Display for PasswordHash<'_> {`
`254`	`254`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`255`	`255`	`write!(f, "{}{}", PASSWORD_HASH_SEPARATOR, self.algorithm)?;`
`256`	`256`
Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ impl<'a> Salt<'a> {`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`166`		`-impl<'a> AsRef<str> for Salt<'a> {`
	`166`	`+impl AsRef<str> for Salt<'_> {`
`167`	`167`	`fn as_ref(&self) -> &str {`
`168`	`168`	`self.as_str()`
`169`	`169`	`}`
`@@ -177,13 +177,13 @@ impl<'a> TryFrom<&'a str> for Salt<'a> {`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`-impl<'a> fmt::Display for Salt<'a> {`
	`180`	`+impl fmt::Display for Salt<'_> {`
`181`	`181`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`182`	`182`	`f.write_str(self.as_str())`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`
`186`		`-impl<'a> fmt::Debug for Salt<'a> {`
	`186`	`+impl fmt::Debug for Salt<'_> {`
`187`	`187`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`188`	`188`	`write!(f, "Salt({:?})", self.as_str())`
`189`	`189`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ impl<'a> Value<'a> {`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`157`		`-impl<'a> AsRef<str> for Value<'a> {`
	`157`	`+impl AsRef<str> for Value<'_> {`
`158`	`158`	`fn as_ref(&self) -> &str {`
`159`	`159`	`self.as_str()`
`160`	`160`	`}`
`@@ -184,7 +184,7 @@ impl<'a> TryFrom<&Value<'a>> for Decimal {`
`184`	`184`	`}`
`185`	`185`	`}`
`186`	`186`
`187`		`-impl<'a> fmt::Display for Value<'a> {`
	`187`	`+impl fmt::Display for Value<'_> {`
`188`	`188`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`189`	`189`	`f.write_str(self.as_str())`
`190`	`190`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,11 +64,11 @@ pub trait UniversalHash: BlockSizeUser + Sized {`
`64`	`64`	`blocks: &'a [Block<Self>],`
`65`	`65`	`}`
`66`	`66`
`67`		`- impl<'a, BS: BlockSizes> BlockSizeUser for Ctx<'a, BS> {`
	`67`	`+ impl<BS: BlockSizes> BlockSizeUser for Ctx<'_, BS> {`
`68`	`68`	`type BlockSize = BS;`
`69`	`69`	`}`
`70`	`70`
`71`		`- impl<'a, BS: BlockSizes> UhfClosure for Ctx<'a, BS> {`
	`71`	`+ impl<BS: BlockSizes> UhfClosure for Ctx<'_, BS> {`
`72`	`72`	`#[inline(always)]`
`73`	`73`	`fn call<B: UhfBackend<BlockSize = BS>>(self, backend: &mut B) {`
`74`	`74`	`let pb = B::ParBlocksSize::USIZE;`