clippy: non-reference stuff

As in rust-bitcoin#835, I changed a test function that used 'A'..'Z' to use an
inclusive range, which is behavior-changing, and changed the impl
of OrdF64::partial_cmp to be correct.

Everything else is just syntactic.

I apologize for structuring this PR very differently from rust-bitcoin#835 so you
can't really range-diff. I tried rebasing and there were so many
conflicts that I simply redid the whole thing, and since I had some
experience I made some different decisions about what order to take
things in.

Author: apoelstra

Cargo.toml

@@ -25,7 +25,7 @@ base64 = ["bitcoin/base64"]
 [dependencies]
 bitcoin = { version = "0.30.0", default-features = false }
 hashbrown = { version = "0.11", optional = true }
-internals = { package = "bitcoin-private", version = "0.1.0", default_features = false }
+internals = { package = "bitcoin-private", version = "0.1.0", default-features = false }
 
 # Do NOT use this as a feature! Use the `serde` feature instead.
 actual-serde = { package = "serde", version = "1.0.103", optional = true }

bitcoind-tests/Cargo.toml

@@ -12,4 +12,4 @@ miniscript = {path = "../"}
 bitcoind = { version = "0.30.0" }
 actual-rand = { package = "rand", version = "0.8.4"}
 secp256k1 = {version = "0.27.0", features = ["rand-std"]}
-internals = { package = "bitcoin-private", version = "0.1.0", default_features = false }
+internals = { package = "bitcoin-private", version = "0.1.0", default-features = false }

clippy.toml

@@ -1 +1,9 @@
 msrv = "1.41.1"
+# PSBT API returns Self as an error type for an large-ish enum
+large-error-threshold = 512
+# A couple tests have huge tuples instead of structs. This is fixed
+# in a later major rev. For now we just turn down the lint.
+type-complexity-threshold = 1000
+# Some internal compiler functions take a gazillion arguments. Again,
+# this is fixed in a later major rev so just turn down the lint here.
+too-many-arguments-threshold = 9

examples/psbt_sign_finalize.rs

@@ -97,10 +97,11 @@ fn main() {
 
     let (outpoint, witness_utxo) = get_vout(&depo_tx, &bridge_descriptor.script_pubkey());
 
-    let mut txin = TxIn::default();
-    txin.previous_output = outpoint;
-
-    txin.sequence = Sequence::from_height(26); //Sequence::MAX; //
+    let txin = TxIn {
+        previous_output: outpoint,
+        sequence: Sequence::from_height(26),
+        ..TxIn::default()
+    };
     psbt.unsigned_tx.input.push(txin);
 
     psbt.unsigned_tx.output.push(TxOut {
@@ -147,13 +148,9 @@ fn main() {
     let pk2 = backup2_private.public_key(&secp256k1);
     assert!(secp256k1.verify_ecdsa(&msg, &sig2, &pk2.inner).is_ok());
 
-    psbt.inputs[0].partial_sigs.insert(
-        pk1,
-        bitcoin::ecdsa::Signature {
-            sig: sig1,
-            hash_ty: hash_ty,
-        },
-    );
+    psbt.inputs[0]
+        .partial_sigs
+        .insert(pk1, bitcoin::ecdsa::Signature { sig: sig1, hash_ty });
 
     println!("{:#?}", psbt);
 

examples/taproot.rs

@@ -138,8 +138,8 @@ fn hardcoded_xonlypubkeys() -> Vec<XOnlyPublicKey> {
         ],
     ];
     let mut keys: Vec<XOnlyPublicKey> = vec![];
-    for idx in 0..4 {
-        keys.push(XOnlyPublicKey::from_slice(&serialized_keys[idx][..]).unwrap());
+    for key in &serialized_keys {
+        keys.push(XOnlyPublicKey::from_slice(key).unwrap());
     }
     keys
 }

examples/verify_tx.rs

@@ -58,15 +58,12 @@ fn main() {
 
     for elem in interpreter.iter_assume_sigs() {
         // Don't bother checking signatures.
-        match elem.expect("no evaluation error") {
-            miniscript::interpreter::SatisfiedConstraint::PublicKey { key_sig } => {
-                let (key, sig) = key_sig
-                    .as_ecdsa()
-                    .expect("expected ecdsa sig, found schnorr sig");
-
-                println!("Signed with:\n key: {}\n sig: {}", key, sig);
-            }
-            _ => {}
+        if let Ok(miniscript::interpreter::SatisfiedConstraint::PublicKey { key_sig }) = elem {
+            let (key, sig) = key_sig
+                .as_ecdsa()
+                .expect("expected ecdsa sig, found schnorr sig");
+
+            println!("Signed with:\n key: {}\n sig: {}", key, sig);
         }
     }
 
@@ -83,12 +80,9 @@ fn main() {
     let prevouts = sighash::Prevouts::All::<bitcoin::TxOut>(&[]);
 
     for elem in interpreter.iter(&secp, &tx, 0, &prevouts) {
-        match elem.expect("no evaluation error") {
-            miniscript::interpreter::SatisfiedConstraint::PublicKey { key_sig } => {
-                let (key, sig) = key_sig.as_ecdsa().unwrap();
-                println!("Signed with:\n key: {}\n sig: {}", key, sig);
-            }
-            _ => {}
+        if let Ok(miniscript::interpreter::SatisfiedConstraint::PublicKey { key_sig }) = elem {
+            let (key, sig) = key_sig.as_ecdsa().unwrap();
+            println!("Signed with:\n key: {}\n sig: {}", key, sig);
         }
     }
 

src/descriptor/bare.rs

@@ -192,7 +192,7 @@ where
     where
         T: Translator<P, Q, E>,
     {
-        Ok(Bare::new(self.ms.translate_pk(t)?).map_err(TranslateErr::OuterError)?)
+        Bare::new(self.ms.translate_pk(t)?).map_err(TranslateErr::OuterError)
     }
 }
 

src/descriptor/key.rs

@@ -861,8 +861,7 @@ fn parse_xkey_deriv<K: InnerXKey>(
         // step all the vectors of indexes contain a single element. If it did though, one of the
         // vectors contains more than one element.
         // Now transform this list of vectors of steps into distinct derivation paths.
-        .fold(Ok(Vec::new()), |paths, index_list| {
-            let mut paths = paths?;
+        .try_fold(Vec::new(), |mut paths, index_list| {
             let mut index_list = index_list?.into_iter();
             let first_index = index_list
                 .next()
@@ -951,9 +950,7 @@ impl<K: InnerXKey> DescriptorXKey<K> {
         let (compare_fingerprint, compare_path) = match self.origin {
             Some((fingerprint, ref path)) => (
                 fingerprint,
-                path.into_iter()
-                    .chain(self.derivation_path.into_iter())
-                    .collect(),
+                path.into_iter().chain(&self.derivation_path).collect(),
             ),
             None => (
                 self.xkey.xkey_fingerprint(secp),

src/descriptor/mod.rs

@@ -776,7 +776,7 @@ impl Descriptor<DescriptorPublicKey> {
     ///
     /// For multipath descriptors it will return as many descriptors as there is
     /// "parallel" paths. For regular descriptors it will just return itself.
-    #[allow(clippy::blocks_in_if_conditions)]
+    #[allow(clippy::blocks_in_conditions)]
     pub fn into_single_descriptors(self) -> Result<Vec<Descriptor<DescriptorPublicKey>>, Error> {
         // All single-path descriptors contained in this descriptor.
         let mut descriptors = Vec::new();

src/descriptor/tr.rs

@@ -82,11 +82,7 @@ impl<Pk: MiniscriptKey> Eq for Tr<Pk> {}
 
 impl<Pk: MiniscriptKey> PartialOrd for Tr<Pk> {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
-        match self.internal_key.partial_cmp(&other.internal_key) {
-            Some(cmp::Ordering::Equal) => {}
-            ord => return ord,
-        }
-        self.tree.partial_cmp(&other.tree)
+        Some(self.cmp(other))
     }
 }
 
@@ -405,8 +401,7 @@ where
     type Item = (u8, &'a Miniscript<Pk, Tap>);
 
     fn next(&mut self) -> Option<Self::Item> {
-        while !self.stack.is_empty() {
-            let (depth, last) = self.stack.pop().expect("Size checked above");
+        while let Some((depth, last)) = self.stack.pop() {
             match *last {
                 TapTree::Tree(ref l, ref r) => {
                     self.stack.push((depth + 1, r));