Merge rust-bitcoin#5282: Fix all the lint warnings on 0.32.x branch

a2fe08c Use explicit link for feature gated rustdoc (Jamil Lambert, PhD)
4eb5f0a Fix stale rustdoc (Jamil Lambert, PhD)
d6c29d0 Run the formatter on nightly (Jamil Lambert, PhD)
fc91680 Clippy allow large error (Jamil Lambert, PhD)
d8724cf Use canonical PartialOrd impl (Jamil Lambert, PhD)
2bee284 Remove manual implementation of ok (Jamil Lambert, PhD)
f4993ec Fix rustdoc indenting (Jamil Lambert, PhD)
f50deb7 Remove unneeded returns (Jamil Lambert, PhD)
2d9df5d Fix rustdoc syntax (Jamil Lambert, PhD)
ae7733b Suppress lint warning about MSRV (Jamil Lambert, PhD)
2f59eb6 Elide lifetime to fix lint error (Jamil Lambert, PhD)
dc9c9d1 Fix hiden lifetime lint (Jamil Lambert, PhD)

Pull request description:

  See rust-bitcoin#5281 for reason.
  
  Use the current version of nightly on master (2025-09-26) to lint and format the v0.32.x branch.
  
  Fix all of the lint errors.
  
  Run the formatter.
  
  Fix some rustdoc issues.
  
  Closes rust-bitcoin#5281


ACKs for top commit:
  apoelstra:
    utACK a2fe08c ran my local CI on the tip


Tree-SHA512: 51152a07d5d7a5c55af69fc37584a93218b316837625438589d13c4883bd76656b42895d703ece46834f7a48bb9375dc378be5ad44e72914d468aa33a08c29f9

Author: apoelstra

base58/src/lib.rs

@@ -204,12 +204,12 @@ impl<T: Default + Copy> SmallVec<T> {
         }
     }
 
-    fn iter(&self) -> iter::Chain<slice::Iter<T>, slice::Iter<T>> {
+    fn iter(&self) -> iter::Chain<slice::Iter<'_, T>, slice::Iter<'_, T>> {
         // If len<100 then we just append an empty vec
         self.stack[0..self.len].iter().chain(self.heap.iter())
     }
 
-    fn iter_mut(&mut self) -> iter::Chain<slice::IterMut<T>, slice::IterMut<T>> {
+    fn iter_mut(&mut self) -> iter::Chain<slice::IterMut<'_, T>, slice::IterMut<'_, T>> {
         // If len<100 then we just append an empty vec
         self.stack[0..self.len].iter_mut().chain(self.heap.iter_mut())
     }

bitcoin/src/address/mod.rs

@@ -75,7 +75,7 @@ pub enum AddressType {
     /// Pay to taproot.
     P2tr,
     /// Pay to anchor.
-    P2a
+    P2a,
 }
 
 impl fmt::Display for AddressType {
@@ -249,17 +249,17 @@ pub enum AddressData {
     /// Data encoded by a P2PKH address.
     P2pkh {
         /// The pubkey hash used to encumber outputs to this address.
-        pubkey_hash: PubkeyHash
+        pubkey_hash: PubkeyHash,
     },
     /// Data encoded by a P2SH address.
     P2sh {
         /// The script hash used to encumber outputs to this address.
-        script_hash: ScriptHash
+        script_hash: ScriptHash,
     },
     /// Data encoded by a Segwit address.
     Segwit {
         /// The witness program used to encumber outputs to this address.
-        witness_program: WitnessProgram
+        witness_program: WitnessProgram,
     },
 }
 
@@ -565,7 +565,10 @@ impl Address {
     pub fn is_spend_standard(&self) -> bool { self.address_type().is_some() }
 
     /// Constructs an [`Address`] from an output script (`scriptPubkey`).
-    pub fn from_script(script: &Script, params: impl AsRef<Params>) -> Result<Address, FromScriptError> {
+    pub fn from_script(
+        script: &Script,
+        params: impl AsRef<Params>,
+    ) -> Result<Address, FromScriptError> {
         let network = params.as_ref().network;
         if script.is_p2pkh() {
             let bytes = script.as_bytes()[3..23].try_into().expect("statically 20B long");

bitcoin/src/bip32.rs

@@ -298,7 +298,7 @@ impl IntoDerivationPath for String {
     fn into_derivation_path(self) -> Result<DerivationPath, Error> { self.parse() }
 }
 
-impl<'a> IntoDerivationPath for &'a str {
+impl IntoDerivationPath for &str {
     fn into_derivation_path(self) -> Result<DerivationPath, Error> { self.parse() }
 }
 
@@ -405,17 +405,17 @@ impl DerivationPath {
 
     /// Get an [Iterator] over the children of this [DerivationPath]
     /// starting with the given [ChildNumber].
-    pub fn children_from(&self, cn: ChildNumber) -> DerivationPathIterator {
+    pub fn children_from(&self, cn: ChildNumber) -> DerivationPathIterator<'_> {
         DerivationPathIterator::start_from(self, cn)
     }
 
     /// Get an [Iterator] over the unhardened children of this [DerivationPath].
-    pub fn normal_children(&self) -> DerivationPathIterator {
+    pub fn normal_children(&self) -> DerivationPathIterator<'_> {
         DerivationPathIterator::start_from(self, ChildNumber::Normal { index: 0 })
     }
 
     /// Get an [Iterator] over the hardened children of this [DerivationPath].
-    pub fn hardened_children(&self) -> DerivationPathIterator {
+    pub fn hardened_children(&self) -> DerivationPathIterator<'_> {
         DerivationPathIterator::start_from(self, ChildNumber::Hardened { index: 0 })
     }
 

bitcoin/src/blockdata/constants.rs

@@ -261,8 +261,8 @@ mod test {
     use hex::test_hex_unwrap as hex;
 
     use super::*;
-    use crate::consensus::params;
     use crate::consensus::encode::serialize;
+    use crate::consensus::params;
 
     #[test]
     fn bitcoin_genesis_first_transaction() {

bitcoin/src/blockdata/locktime/absolute.rs

@@ -42,6 +42,8 @@ pub use units::locktime::absolute::{
 /// consensus encoding to order it. We also implement [`ordered::ArbitraryOrd`] if the "ordered"
 /// feature is enabled.
 ///
+/// [`ordered::ArbitraryOrd`]: <https://docs.rs/ordered/latest/ordered/trait.ArbitraryOrd.html>
+///
 /// ### Relevant BIPs
 ///
 /// * [BIP-65 OP_CHECKLOCKTIMEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
@@ -297,25 +299,19 @@ impl FromStr for LockTime {
 impl TryFrom<&str> for LockTime {
     type Error = ParseIntError;
 
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        LockTime::from_str(s)
-    }
+    fn try_from(s: &str) -> Result<Self, Self::Error> { LockTime::from_str(s) }
 }
 
 impl TryFrom<String> for LockTime {
     type Error = ParseIntError;
 
-    fn try_from(s: String) -> Result<Self, Self::Error> {
-        LockTime::from_str(&s)
-    }
+    fn try_from(s: String) -> Result<Self, Self::Error> { LockTime::from_str(&s) }
 }
 
 impl TryFrom<Box<str>> for LockTime {
     type Error = ParseIntError;
 
-    fn try_from(s: Box<str>) -> Result<Self, Self::Error> {
-        LockTime::from_str(&s)
-    }
+    fn try_from(s: Box<str>) -> Result<Self, Self::Error> { LockTime::from_str(&s) }
 }
 
 impl From<Height> for LockTime {

bitcoin/src/blockdata/locktime/relative.rs

@@ -30,7 +30,9 @@ pub use units::locktime::relative::{Height, Time, TimeOverflowError};
 ///
 /// Locktimes may be height- or time-based, and these metrics are incommensurate; there is no total
 /// ordering on locktimes. We therefore have implemented [`PartialOrd`] but not [`Ord`]. We also
-/// implement [`ordered::ArbitraryOrd`] if the "ordered" feature is enabled.
+/// implement [`ordered::ArbitraryOrd`].
+///
+/// [`ordered::ArbitraryOrd`]: <https://docs.rs/ordered/latest/ordered/trait.ArbitraryOrd.html>
 ///
 /// ### Relevant BIPs
 ///

bitcoin/src/blockdata/script/borrowed.rs

@@ -547,7 +547,7 @@ impl Script {
     ///
     /// To force minimal pushes, use [`instructions_minimal`](Self::instructions_minimal).
     #[inline]
-    pub fn instructions(&self) -> Instructions {
+    pub fn instructions(&self) -> Instructions<'_> {
         Instructions { data: self.0.iter(), enforce_minimal: false }
     }
 
@@ -556,7 +556,7 @@ impl Script {
     /// This is similar to [`instructions`](Self::instructions) but an error is returned if a push
     /// is not minimal.
     #[inline]
-    pub fn instructions_minimal(&self) -> Instructions {
+    pub fn instructions_minimal(&self) -> Instructions<'_> {
         Instructions { data: self.0.iter(), enforce_minimal: true }
     }
 
@@ -568,7 +568,7 @@ impl Script {
     ///
     /// To force minimal pushes, use [`Self::instruction_indices_minimal`].
     #[inline]
-    pub fn instruction_indices(&self) -> InstructionIndices {
+    pub fn instruction_indices(&self) -> InstructionIndices<'_> {
         InstructionIndices::from_instructions(self.instructions())
     }
 
@@ -577,7 +577,7 @@ impl Script {
     /// This is similar to [`instruction_indices`](Self::instruction_indices) but an error is
     /// returned if a push is not minimal.
     #[inline]
-    pub fn instruction_indices_minimal(&self) -> InstructionIndices {
+    pub fn instruction_indices_minimal(&self) -> InstructionIndices<'_> {
         InstructionIndices::from_instructions(self.instructions_minimal())
     }
 

bitcoin/src/blockdata/script/instruction.rs

@@ -45,12 +45,8 @@ impl<'a> Instruction<'a> {
                     _ => None,
                 }
             }
-            Instruction::PushBytes(bytes) => {
-                match super::read_scriptint_non_minimal(bytes.as_bytes()) {
-                    Ok(v) => Some(v),
-                    _ => None,
-                }
-            }
+            Instruction::PushBytes(bytes) =>
+                super::read_scriptint_non_minimal(bytes.as_bytes()).ok(),
         }
     }
 

bitcoin/src/blockdata/script/witness_program.rs

@@ -25,7 +25,7 @@ pub const MIN_SIZE: usize = 2;
 pub const MAX_SIZE: usize = 40;
 
 /// The P2A program which is given by 0x4e73.
-pub(crate) const P2A_PROGRAM: [u8;2] = [78, 115];
+pub(crate) const P2A_PROGRAM: [u8; 2] = [78, 115];
 
 /// The segregated witness program.
 ///

bitcoin/src/blockdata/transaction.rs

@@ -11,8 +11,8 @@
 //! This module provides the structures and functions needed to support transactions.
 //!
 
-use core::{cmp, fmt};
 use core::str::FromStr;
+use core::{cmp, fmt};
 
 use hashes::{sha256d, Hash};
 use internals::write_err;
@@ -539,25 +539,19 @@ impl FromStr for Sequence {
 impl TryFrom<&str> for Sequence {
     type Error = ParseIntError;
 
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        Sequence::from_str(s)
-    }
+    fn try_from(s: &str) -> Result<Self, Self::Error> { Sequence::from_str(s) }
 }
 
 impl TryFrom<String> for Sequence {
     type Error = ParseIntError;
 
-    fn try_from(s: String) -> Result<Self, Self::Error> {
-        Sequence::from_str(&s)
-    }
+    fn try_from(s: String) -> Result<Self, Self::Error> { Sequence::from_str(&s) }
 }
 
 impl TryFrom<Box<str>> for Sequence {
     type Error = ParseIntError;
 
-    fn try_from(s: Box<str>) -> Result<Self, Self::Error> {
-        Sequence::from_str(&s)
-    }
+    fn try_from(s: Box<str>) -> Result<Self, Self::Error> { Sequence::from_str(&s) }
 }
 
 /// Bitcoin transaction output.
@@ -1020,11 +1014,7 @@ impl Transaction {
                 1
             } else if witness_program.is_p2wsh() {
                 // Treat the last item of the witness as the witnessScript
-                return witness
-                    .last()
-                    .map(Script::from_bytes)
-                    .map(|s| s.count_sigops())
-                    .unwrap_or(0);
+                witness.last().map(Script::from_bytes).map(|s| s.count_sigops()).unwrap_or(0)
             } else {
                 0
             }