clippy: non-reference stuff

As in other PRs, the meaningful changes here are: 'A'..'Z' becoming 'A'..='Z',
and the partial_cmp replacements.

Author: apoelstra

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

@@ -2,9 +2,9 @@ use std::collections::BTreeMap;
 use std::str::FromStr;
 
 use bitcoin::consensus::serialize;
+use bitcoin::hashes::hex::ToHex as _;
 use bitcoin::util::sighash::SighashCache;
 use bitcoin::{PackedLockTime, PrivateKey};
-use bitcoin::hashes::hex::ToHex as _;
 use miniscript::bitcoin::consensus::encode::deserialize;
 use miniscript::bitcoin::hashes::hex::FromHex;
 use miniscript::bitcoin::util::psbt;
@@ -97,10 +97,12 @@ fn main() {
 
     let (outpoint, witness_utxo) = get_vout(&depo_tx, bridge_descriptor.script_pubkey());
 
-    let mut txin = TxIn::default();
-    txin.previous_output = outpoint;
+    let txin = TxIn {
+        previous_output: outpoint,
 
-    txin.sequence = Sequence::from_height(26); //Sequence::MAX; //
+        sequence: Sequence::from_height(26),
+        ..TxIn::default()
+    };
     psbt.unsigned_tx.input.push(txin);
 
     psbt.unsigned_tx.output.push(TxOut {
@@ -147,13 +149,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::EcdsaSig {
-            sig: sig1,
-            hash_ty: hash_ty,
-        },
-    );
+    psbt.inputs[0]
+        .partial_sigs
+        .insert(pk1, bitcoin::EcdsaSig { sig: sig1, hash_ty });
 
     println!("{:#?}", psbt);
 

examples/taproot.rs

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

examples/verify_tx.rs

@@ -59,15 +59,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);
         }
     }
 
@@ -84,12 +81,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/key.rs

@@ -665,9 +665,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),
@@ -784,11 +782,9 @@ impl FromStr for DefiniteDescriptorKey {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let inner = DescriptorPublicKey::from_str(s)?;
-        Ok(
-            DefiniteDescriptorKey::new(inner).ok_or(DescriptorKeyParseError(
-                "cannot parse key with a wilcard as a DerivedDescriptorKey",
-            ))?,
-        )
+        DefiniteDescriptorKey::new(inner).ok_or(DescriptorKeyParseError(
+            "cannot parse key with a wilcard as a DerivedDescriptorKey",
+        ))
     }
 }
 
@@ -948,17 +944,17 @@ mod test {
         let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/2").unwrap();
         assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
         assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'/2");
-        assert_eq!(public_key.has_wildcard(), false);
+        assert!(!public_key.has_wildcard());
 
         let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/*").unwrap();
         assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
         assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'");
-        assert_eq!(public_key.has_wildcard(), true);
+        assert!(public_key.has_wildcard());
 
         let public_key = DescriptorPublicKey::from_str("[abcdef00/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/*h").unwrap();
         assert_eq!(public_key.master_fingerprint().to_string(), "abcdef00");
         assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'");
-        assert_eq!(public_key.has_wildcard(), true);
+        assert!(public_key.has_wildcard());
     }
 
     #[test]
@@ -970,7 +966,7 @@ mod test {
         assert_eq!(public_key.to_string(), "[2cbe2a6d/0'/1']tpubDBrgjcxBxnXyL575sHdkpKohWu5qHKoQ7TJXKNrYznh5fVEGBv89hA8ENW7A8MFVpFUSvgLqc4Nj1WZcpePX6rrxviVtPowvMuGF5rdT2Vi/2");
         assert_eq!(public_key.master_fingerprint().to_string(), "2cbe2a6d");
         assert_eq!(public_key.full_derivation_path().to_string(), "m/0'/1'/2");
-        assert_eq!(public_key.has_wildcard(), false);
+        assert!(!public_key.has_wildcard());
 
         let secret_key = DescriptorSecretKey::from_str("tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/0'/1'/2'").unwrap();
         let public_key = secret_key.to_public(&secp).unwrap();

src/descriptor/mod.rs

@@ -856,8 +856,7 @@ mod tests {
     use crate::{hex_script, Descriptor, DummyKey, Error, Miniscript, Satisfier};
 
     type StdDescriptor = Descriptor<PublicKey>;
-    const TEST_PK: &'static str =
-        "pk(020000000000000000000000000000000000000000000000000000000000000002)";
+    const TEST_PK: &str = "pk(020000000000000000000000000000000000000000000000000000000000000002)";
 
     impl cmp::PartialEq for DescriptorSecretKey {
         fn eq(&self, other: &Self) -> bool {

src/descriptor/sortedmulti.rs

@@ -112,11 +112,11 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
 }
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for SortedMultiVec<Pk, Ctx> {
-    fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool
+    fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool
     where
         Pk: 'a,
     {
-        self.pks.iter().all(|key| pred(key))
+        self.pks.iter().all(pred)
     }
 }
 
@@ -258,11 +258,11 @@ mod tests {
 
         let mut pks = Vec::new();
         for _ in 0..over {
-            pks.push(pk.clone());
+            pks.push(pk);
         }
 
         let res: Result<SortedMultiVec<PublicKey, Legacy>, Error> = SortedMultiVec::new(0, pks);
-        let error = res.err().expect("constructor should err");
+        let error = res.expect_err("constructor should err");
 
         match error {
             Error::BadDescriptor(_) => {} // ok

src/descriptor/tr.rs

@@ -81,11 +81,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))
     }
 }
 
@@ -352,9 +348,8 @@ 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");
-            match &*last {
+        while let Some((depth, last)) = self.stack.pop() {
+            match last {
                 TapTree::Tree(l, r) => {
                     self.stack.push((depth + 1, r));
                     self.stack.push((depth + 1, l));

src/interpreter/inner.rs

@@ -344,22 +344,20 @@ pub(super) fn from_txdata<'txin>(
             None => Err(Error::UnexpectedStackEnd),
         }
     // ** bare script **
+    } else if wit_stack.is_empty() {
+        // Bare script parsed in BareCtx
+        let miniscript = Miniscript::<bitcoin::PublicKey, BareCtx>::parse_with_ext(
+            spk,
+            &ExtParams::allow_all(),
+        )?;
+        let miniscript = miniscript.to_no_checks_ms();
+        Ok((
+            Inner::Script(miniscript, ScriptType::Bare),
+            ssig_stack,
+            Some(spk.clone()),
+        ))
     } else {
-        if wit_stack.is_empty() {
-            // Bare script parsed in BareCtx
-            let miniscript = Miniscript::<bitcoin::PublicKey, BareCtx>::parse_with_ext(
-                spk,
-                &ExtParams::allow_all(),
-            )?;
-            let miniscript = miniscript.to_no_checks_ms();
-            Ok((
-                Inner::Script(miniscript, ScriptType::Bare),
-                ssig_stack,
-                Some(spk.clone()),
-            ))
-        } else {
-            Err(Error::NonEmptyWitness)
-        }
+        Err(Error::NonEmptyWitness)
     }
 }