clippy: fix stable clippy issues

delta1 · delta1 · commit 7f39702832f2 · 2025-02-12T09:19:12.000+02:00
diff --git a/src/blech32/decode.rs b/src/blech32/decode.rs
@@ -439,15 +439,15 @@ pub struct ByteIter<'s> {
     iter: FesToBytes<AsciiToFe32Iter<iter::Copied<slice::Iter<'s, u8>>>>,
 }
 
-impl<'s> Iterator for ByteIter<'s> {
+impl Iterator for ByteIter<'_> {
     type Item = u8;
     #[inline]
     fn next(&mut self) -> Option<u8> { self.iter.next() }
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 
-impl<'s> ExactSizeIterator for ByteIter<'s> {
+impl ExactSizeIterator for ByteIter<'_> {
     #[inline]
     fn len(&self) -> usize { self.iter.len() }
 }
diff --git a/src/block.rs b/src/block.rs
@@ -55,7 +55,7 @@ impl<'de> Deserialize<'de> for ExtData {
         enum Enum { Unknown, Challenge, Solution, Current, Proposed, Witness }
         struct EnumVisitor;
 
-        impl<'de> de::Visitor<'de> for EnumVisitor {
+        impl de::Visitor<'_> for EnumVisitor {
             type Value = Enum;
 
             fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/src/confidential.rs b/src/confidential.rs
@@ -816,7 +816,7 @@ impl<'de> Deserialize<'de> for AssetBlindingFactor {
         if d.is_human_readable() {
             struct HexVisitor;
 
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
+            impl ::serde::de::Visitor<'_> for HexVisitor {
                 type Value = AssetBlindingFactor;
 
                 fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
@@ -830,7 +830,7 @@ impl<'de> Deserialize<'de> for AssetBlindingFactor {
                     if let Ok(hex) = ::std::str::from_utf8(v) {
                         AssetBlindingFactor::from_hex(hex).map_err(E::custom)
                     } else {
-                        return Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self));
+                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
                     }
                 }
 
@@ -846,7 +846,7 @@ impl<'de> Deserialize<'de> for AssetBlindingFactor {
         } else {
             struct BytesVisitor;
 
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
+            impl ::serde::de::Visitor<'_> for BytesVisitor {
                 type Value = AssetBlindingFactor;
 
                 fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
@@ -1019,7 +1019,7 @@ impl<'de> Deserialize<'de> for ValueBlindingFactor {
         if d.is_human_readable() {
             struct HexVisitor;
 
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
+            impl ::serde::de::Visitor<'_> for HexVisitor {
                 type Value = ValueBlindingFactor;
 
                 fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
@@ -1033,7 +1033,7 @@ impl<'de> Deserialize<'de> for ValueBlindingFactor {
                     if let Ok(hex) = ::std::str::from_utf8(v) {
                         ValueBlindingFactor::from_hex(hex).map_err(E::custom)
                     } else {
-                        return Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self));
+                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
                     }
                 }
 
@@ -1049,7 +1049,7 @@ impl<'de> Deserialize<'de> for ValueBlindingFactor {
         } else {
             struct BytesVisitor;
 
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
+            impl ::serde::de::Visitor<'_> for BytesVisitor {
                 type Value = ValueBlindingFactor;
 
                 fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
diff --git a/src/dynafed.rs b/src/dynafed.rs
@@ -27,18 +27,18 @@ use crate::Script;
 
 /// ad-hoc struct to fmt in hex
 struct HexBytes<'a>(&'a [u8]);
-impl<'a> fmt::Display for HexBytes<'a> {
+impl fmt::Display for HexBytes<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         crate::hex::format_hex(self.0, f)
     }
 }
-impl<'a> fmt::Debug for HexBytes<'a> {
+impl fmt::Debug for HexBytes<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&self, f)
     }
 }
 #[cfg(feature = "serde")]
-impl<'a> Serialize for HexBytes<'a> {
+impl Serialize for HexBytes<'_> {
     fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         if s.is_human_readable() {
             s.collect_str(self)
@@ -50,7 +50,7 @@ impl<'a> Serialize for HexBytes<'a> {
 
 /// ad-hoc struct to fmt in hex
 struct HexBytesArray<'a>(&'a [Vec<u8>]);
-impl<'a> fmt::Display for HexBytesArray<'a> {
+impl fmt::Display for HexBytesArray<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "[")?;
         for (i, e) in self.0.iter().enumerate() {
@@ -62,13 +62,13 @@ impl<'a> fmt::Display for HexBytesArray<'a> {
         write!(f, "]")
     }
 }
-impl<'a> fmt::Debug for HexBytesArray<'a> {
+impl fmt::Debug for HexBytesArray<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&self, f)
     }
 }
 #[cfg(feature = "serde")]
-impl<'a> Serialize for HexBytesArray<'a> {
+impl Serialize for HexBytesArray<'_> {
     fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
         let mut seq = s.serialize_seq(Some(self.0.len()))?;
         for b in self.0 {
@@ -420,7 +420,7 @@ impl<'de> Deserialize<'de> for Params {
         }
         struct EnumVisitor;
 
-        impl<'de> de::Visitor<'de> for EnumVisitor {
+        impl de::Visitor<'_> for EnumVisitor {
             type Value = Enum;
 
             fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/src/hex.rs b/src/hex.rs
@@ -104,7 +104,7 @@ fn chars_to_hex(hi: u8, lo: u8) -> Result<u8, Error> {
     Ok(ret as u8)
 }
 
-impl<'a> Iterator for HexIterator<'a> {
+impl Iterator for HexIterator<'_> {
     type Item = Result<u8, Error>;
 
     fn next(&mut self) -> Option<Result<u8, Error>> {
@@ -119,7 +119,7 @@ impl<'a> Iterator for HexIterator<'a> {
     }
 }
 
-impl<'a> io::Read for HexIterator<'a> {
+impl io::Read for HexIterator<'_> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let mut bytes_read = 0usize;
         for dst in buf {
@@ -135,15 +135,15 @@ impl<'a> io::Read for HexIterator<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator for HexIterator<'a> {
+impl DoubleEndedIterator for HexIterator<'_> {
     fn next_back(&mut self) -> Option<Result<u8, Error>> {
         let lo = self.iter.next_back()?;
         let hi = self.iter.next_back().unwrap();
         Some(chars_to_hex(hi, lo))
     }
 }
 
-impl<'a> ExactSizeIterator for HexIterator<'a> {}
+impl ExactSizeIterator for HexIterator<'_> {}
 
 /// Outputs hex into an object implementing `fmt::Write`.
 ///
diff --git a/src/issuance.rs b/src/issuance.rs
@@ -203,7 +203,7 @@ impl<'de> ::serde::Deserialize<'de> for AssetId {
         if d.is_human_readable() {
             struct HexVisitor;
 
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
+            impl ::serde::de::Visitor<'_> for HexVisitor {
                 type Value = AssetId;
 
                 fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
@@ -217,7 +217,7 @@ impl<'de> ::serde::Deserialize<'de> for AssetId {
                     if let Ok(hex) = ::std::str::from_utf8(v) {
                         AssetId::from_str(hex).map_err(E::custom)
                     } else {
-                        return Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self));
+                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
                     }
                 }
 
@@ -233,7 +233,7 @@ impl<'de> ::serde::Deserialize<'de> for AssetId {
         } else {
             struct BytesVisitor;
 
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
+            impl ::serde::de::Visitor<'_> for BytesVisitor {
                 type Value = AssetId;
 
                 fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
diff --git a/src/serde_utils.rs b/src/serde_utils.rs
@@ -242,7 +242,7 @@ pub mod hex_bytes {
     {
         struct Visitor<B>(::std::marker::PhantomData<B>);
 
-        impl<'de, B: FromHex> serde::de::Visitor<'de> for Visitor<B> {
+        impl<B: FromHex> serde::de::Visitor<'_> for Visitor<B> {
             type Value = B;
 
             fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
@@ -255,7 +255,7 @@ pub mod hex_bytes {
                 if let Ok(hex) = ::std::str::from_utf8(v) {
                     FromHex::from_hex(hex).map_err(E::custom)
                 } else {
-                    return Err(E::invalid_value(serde::de::Unexpected::Bytes(v), &self));
+                    Err(E::invalid_value(serde::de::Unexpected::Bytes(v), &self))
                 }
             }
 
diff --git a/src/sighash.rs b/src/sighash.rs
@@ -167,7 +167,7 @@ impl fmt::Display for Error {
 
 impl ::std::error::Error for Error {}
 
-impl<'u, T> Prevouts<'u, T> where T: Borrow<TxOut> {
+impl<T> Prevouts<'_, T> where T: Borrow<TxOut> {
     fn check_all(&self, tx: &Transaction) -> Result<(), Error> {
         if let Prevouts::All(prevouts) = self {
             if prevouts.len() != tx.input.len() {
@@ -866,7 +866,7 @@ impl<'a> Annex<'a> {
     }
 }
 
-impl<'a> Encodable for Annex<'a> {
+impl Encodable for Annex<'_> {
     fn consensus_encode<W: io::Write>(&self, writer: W) -> Result<usize, encode::Error> {
         encode::consensus_encode_with_size(self.0, writer)
     }

Original file line number	Diff line number	Diff line change
`@@ -439,15 +439,15 @@ pub struct ByteIter<'s> {`
`439`	`439`	`iter: FesToBytes<AsciiToFe32Iter<iter::Copied<slice::Iter<'s, u8>>>>,`
`440`	`440`	`}`
`441`	`441`
`442`		`-impl<'s> Iterator for ByteIter<'s> {`
	`442`	`+impl Iterator for ByteIter<'_> {`
`443`	`443`	`type Item = u8;`
`444`	`444`	`#[inline]`
`445`	`445`	`fn next(&mut self) -> Option<u8> { self.iter.next() }`
`446`	`446`	`#[inline]`
`447`	`447`	`fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }`
`448`	`448`	`}`
`449`	`449`
`450`		`-impl<'s> ExactSizeIterator for ByteIter<'s> {`
	`450`	`+impl ExactSizeIterator for ByteIter<'_> {`
`451`	`451`	`#[inline]`
`452`	`452`	`fn len(&self) -> usize { self.iter.len() }`
`453`	`453`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,18 +27,18 @@ use crate::Script;`
`27`	`27`
`28`	`28`	`/// ad-hoc struct to fmt in hex`
`29`	`29`	`struct HexBytes<'a>(&'a [u8]);`
`30`		`-impl<'a> fmt::Display for HexBytes<'a> {`
	`30`	`+impl fmt::Display for HexBytes<'_> {`
`31`	`31`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`32`	`32`	`crate::hex::format_hex(self.0, f)`
`33`	`33`	`}`
`34`	`34`	`}`
`35`		`-impl<'a> fmt::Debug for HexBytes<'a> {`
	`35`	`+impl fmt::Debug for HexBytes<'_> {`
`36`	`36`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`37`	`37`	`fmt::Display::fmt(&self, f)`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`	`#[cfg(feature = "serde")]`
`41`		`-impl<'a> Serialize for HexBytes<'a> {`
	`41`	`+impl Serialize for HexBytes<'_> {`
`42`	`42`	`fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {`
`43`	`43`	`if s.is_human_readable() {`
`44`	`44`	`s.collect_str(self)`
`@@ -50,7 +50,7 @@ impl<'a> Serialize for HexBytes<'a> {`
`50`	`50`
`51`	`51`	`/// ad-hoc struct to fmt in hex`
`52`	`52`	`struct HexBytesArray<'a>(&'a [Vec<u8>]);`
`53`		`-impl<'a> fmt::Display for HexBytesArray<'a> {`
	`53`	`+impl fmt::Display for HexBytesArray<'_> {`
`54`	`54`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`55`	`55`	`write!(f, "[")?;`
`56`	`56`	`for (i, e) in self.0.iter().enumerate() {`
`@@ -62,13 +62,13 @@ impl<'a> fmt::Display for HexBytesArray<'a> {`
`62`	`62`	`write!(f, "]")`
`63`	`63`	`}`
`64`	`64`	`}`
`65`		`-impl<'a> fmt::Debug for HexBytesArray<'a> {`
	`65`	`+impl fmt::Debug for HexBytesArray<'_> {`
`66`	`66`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`67`	`67`	`fmt::Display::fmt(&self, f)`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`	`#[cfg(feature = "serde")]`
`71`		`-impl<'a> Serialize for HexBytesArray<'a> {`
	`71`	`+impl Serialize for HexBytesArray<'_> {`
`72`	`72`	`fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {`
`73`	`73`	`let mut seq = s.serialize_seq(Some(self.0.len()))?;`
`74`	`74`	`for b in self.0 {`
`@@ -420,7 +420,7 @@ impl<'de> Deserialize<'de> for Params {`
`420`	`420`	`}`
`421`	`421`	`struct EnumVisitor;`
`422`	`422`
`423`		`- impl<'de> de::Visitor<'de> for EnumVisitor {`
	`423`	`+ impl de::Visitor<'_> for EnumVisitor {`
`424`	`424`	`type Value = Enum;`
`425`	`425`
`426`	`426`	`fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ fn chars_to_hex(hi: u8, lo: u8) -> Result<u8, Error> {`
`104`	`104`	`Ok(ret as u8)`
`105`	`105`	`}`
`106`	`106`
`107`		`-impl<'a> Iterator for HexIterator<'a> {`
	`107`	`+impl Iterator for HexIterator<'_> {`
`108`	`108`	`type Item = Result<u8, Error>;`
`109`	`109`
`110`	`110`	`fn next(&mut self) -> Option<Result<u8, Error>> {`
`@@ -119,7 +119,7 @@ impl<'a> Iterator for HexIterator<'a> {`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`
`122`		`-impl<'a> io::Read for HexIterator<'a> {`
	`122`	`+impl io::Read for HexIterator<'_> {`
`123`	`123`	`fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {`
`124`	`124`	`let mut bytes_read = 0usize;`
`125`	`125`	`for dst in buf {`
`@@ -135,15 +135,15 @@ impl<'a> io::Read for HexIterator<'a> {`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`138`		`-impl<'a> DoubleEndedIterator for HexIterator<'a> {`
	`138`	`+impl DoubleEndedIterator for HexIterator<'_> {`
`139`	`139`	`fn next_back(&mut self) -> Option<Result<u8, Error>> {`
`140`	`140`	`let lo = self.iter.next_back()?;`
`141`	`141`	`let hi = self.iter.next_back().unwrap();`
`142`	`142`	`Some(chars_to_hex(hi, lo))`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`
`146`		`-impl<'a> ExactSizeIterator for HexIterator<'a> {}`
	`146`	`+impl ExactSizeIterator for HexIterator<'_> {}`
`147`	`147`
`148`	`148`	/// Outputs hex into an object implementing `fmt::Write`.
`149`	`149`	`///`
Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ pub mod hex_bytes {`
`242`	`242`	`{`
`243`	`243`	`struct Visitor<B>(::std::marker::PhantomData<B>);`
`244`	`244`
`245`		`- impl<'de, B: FromHex> serde::de::Visitor<'de> for Visitor<B> {`
	`245`	`+ impl<B: FromHex> serde::de::Visitor<'_> for Visitor<B> {`
`246`	`246`	`type Value = B;`
`247`	`247`
`248`	`248`	`fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {`
`@@ -255,7 +255,7 @@ pub mod hex_bytes {`
`255`	`255`	`if let Ok(hex) = ::std::str::from_utf8(v) {`
`256`	`256`	`FromHex::from_hex(hex).map_err(E::custom)`
`257`	`257`	`} else {`
`258`		`- return Err(E::invalid_value(serde::de::Unexpected::Bytes(v), &self));`
	`258`	`+ Err(E::invalid_value(serde::de::Unexpected::Bytes(v), &self))`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,7 @@ impl fmt::Display for Error {`
`167`	`167`
`168`	`168`	`impl ::std::error::Error for Error {}`
`169`	`169`
`170`		`-impl<'u, T> Prevouts<'u, T> where T: Borrow<TxOut> {`
	`170`	`+impl<T> Prevouts<'_, T> where T: Borrow<TxOut> {`
`171`	`171`	`fn check_all(&self, tx: &Transaction) -> Result<(), Error> {`
`172`	`172`	`if let Prevouts::All(prevouts) = self {`
`173`	`173`	`if prevouts.len() != tx.input.len() {`
`@@ -866,7 +866,7 @@ impl<'a> Annex<'a> {`
`866`	`866`	`}`
`867`	`867`	`}`
`868`	`868`
`869`		`-impl<'a> Encodable for Annex<'a> {`
	`869`	`+impl Encodable for Annex<'_> {`
`870`	`870`	`fn consensus_encode<W: io::Write>(&self, writer: W) -> Result<usize, encode::Error> {`
`871`	`871`	`encode::consensus_encode_with_size(self.0, writer)`
`872`	`872`	`}`