Merge rust-bitcoin/rust-miniscript#498: Fix a load of non-controversial clippy warnings

6b6f8082a568a8cc61528a3447272e9aa8e846f1 Use any combinator (Tobin C. Harding)
6088c2586c6cbcfb5e105a73b48cf42a93fd88fa Use {} instead of explicit return (Tobin C. Harding)
06c9617a8ebf70b6b47d31481304eceb0550171b Remove unnecessary cast (Tobin C. Harding)
eb38507b59e4397d738496e1688b1fd959b2f1ef Do not use bool in assert_eq macro (Tobin C. Harding)
3c46e4c04cb19bf2b23762979693ee1f4a7e8288 Use expect_err (Tobin C. Harding)
9c377b25864c16632633b4d444e430ae6994839a Remove useless use of format (Tobin C. Harding)
bf44938756466f4a9468555ae08802d5d068fc43 Remove unneeded calls to clone (Tobin C. Harding)
227a3a92b4fb7e7d9dbd19f832f16b851a3b560e Remove identical if blocks (Tobin C. Harding)
45091a8e617d8109bf00e8de969433f8e4e090aa Remove unneeded explicit lifetimes (Tobin C. Harding)
2e70cd0a8b3304fb95a3e98b5ea0eac36a860ab3 Do not manually convert bool to integer (Tobin C. Harding)
c4ab53e92387ed219751f126843ebf9dc9bc770c Use &str not &String (Tobin C. Harding)
b81f08c699153f40d18dbdb64b1f16f4caa02656 Return result of function call (Tobin C. Harding)
fc37f414af3c0983ee85943fa89f2b6094e38371 Use unwrap_or_default (Tobin C. Harding)
f0820cef0c3627e56601ac3758679a52e969db75 Remove redundant explicit references (Tobin C. Harding)
64c6e51da577d68b2c1088629edd041410bc7167 Fix pattern matching ref/deref (Tobin C. Harding)
a9238551d7307e4a5bf9703ddc43ea473c740872 Do not use redundant closures (Tobin C. Harding)
4ab7e7abe66f7f5b5dda59bced35fe4ff3e2853e Use terse struct construction form (Tobin C. Harding)
9d1a98440f6021fc7fa142f39e10b155377d8905 Remove 'static from &str (Tobin C. Harding)
b9df24c2120789e7d6536f7b83ba521563c461e4 Clear block can be collapsed warnings (Tobin C. Harding)

Pull request description:

  I've attempted to only do the easy, and non-controversial ones in this PR. Each warning is a separate patch (except `clone` warnings). `rustfmt` run on each patch.

ACKs for top commit:
  sanket1729:
    ACK 6b6f8082a568a8cc61528a3447272e9aa8e846f1
  apoelstra:
    ACK 6b6f8082a568a8cc61528a3447272e9aa8e846f1

Tree-SHA512: 1289ee2950107bf4cd0d8a09d91dd2c2ed98defcd4d9bffdd506ea144e1df07df5c18e485ae5745b878cf8d32b131764c8953bbc784193369d8dd7e6b8ca6ad8

Author: heap-coder

src/descriptor/key.rs

@@ -138,7 +138,7 @@ impl fmt::Display for DescriptorSecretKey {
             DescriptorSecretKey::MultiXPrv(ref xprv) => {
                 maybe_fmt_master_id(f, &xprv.origin)?;
                 xprv.xkey.fmt(f)?;
-                fmt_derivation_paths(f, &xprv.derivation_paths.paths())?;
+                fmt_derivation_paths(f, xprv.derivation_paths.paths())?;
                 match xprv.wildcard {
                     Wildcard::None => {}
                     Wildcard::Unhardened => write!(f, "/*")?,
@@ -302,7 +302,7 @@ impl fmt::Display for DescriptorPublicKey {
             DescriptorPublicKey::MultiXPub(ref xpub) => {
                 maybe_fmt_master_id(f, &xpub.origin)?;
                 xpub.xkey.fmt(f)?;
-                fmt_derivation_paths(f, &xpub.derivation_paths.paths())?;
+                fmt_derivation_paths(f, xpub.derivation_paths.paths())?;
                 match xpub.wildcard {
                     Wildcard::None => {}
                     Wildcard::Unhardened => write!(f, "/*")?,
@@ -453,10 +453,7 @@ impl FromStr for DescriptorPublicKey {
                 Ok(DescriptorPublicKey::XPub(DescriptorXKey {
                     origin,
                     xkey: xpub,
-                    derivation_path: derivation_paths
-                        .into_iter()
-                        .next()
-                        .unwrap_or_else(|| bip32::DerivationPath::default()),
+                    derivation_path: derivation_paths.into_iter().next().unwrap_or_default(),
                     wildcard,
                 }))
             }
@@ -716,10 +713,7 @@ impl FromStr for DescriptorSecretKey {
                 Ok(DescriptorSecretKey::XPrv(DescriptorXKey {
                     origin,
                     xkey: xpriv,
-                    derivation_path: derivation_paths
-                        .into_iter()
-                        .next()
-                        .unwrap_or_else(|| bip32::DerivationPath::default()),
+                    derivation_path: derivation_paths.into_iter().next().unwrap_or_default(),
                     wildcard,
                 }))
             }
@@ -1078,11 +1072,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",
+        ))
     }
 }
 
@@ -1253,23 +1245,23 @@ mod test {
             public_key.full_derivation_path().unwrap().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().unwrap().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().unwrap().to_string(),
             "m/0'/1'"
         );
-        assert_eq!(public_key.has_wildcard(), true);
+        assert!(public_key.has_wildcard());
     }
 
     #[test]
@@ -1284,7 +1276,7 @@ mod test {
             public_key.full_derivation_path().unwrap().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

@@ -584,7 +584,7 @@ impl Descriptor<DescriptorPublicKey> {
         secp: &secp256k1::Secp256k1<C>,
         index: u32,
     ) -> Result<Descriptor<bitcoin::PublicKey>, ConversionError> {
-        self.at_derivation_index(index)?.derived_descriptor(&secp)
+        self.at_derivation_index(index)?.derived_descriptor(secp)
     }
 
     /// Parse a descriptor that may contain secret keys
@@ -596,7 +596,7 @@ impl Descriptor<DescriptorPublicKey> {
         s: &str,
     ) -> Result<(Descriptor<DescriptorPublicKey>, KeyMap), Error> {
         fn parse_key<C: secp256k1::Signing>(
-            s: &String,
+            s: &str,
             key_map: &mut KeyMap,
             secp: &secp256k1::Secp256k1<C>,
         ) -> Result<DescriptorPublicKey, Error> {
@@ -865,7 +865,7 @@ impl Descriptor<DefiniteDescriptorKey> {
                 &mut self,
                 pk: &DefiniteDescriptorKey,
             ) -> Result<bitcoin::PublicKey, ConversionError> {
-                pk.derive_public_key(&self.0)
+                pk.derive_public_key(self.0)
             }
 
             translate_hash_clone!(DefiniteDescriptorKey, bitcoin::PublicKey, ConversionError);
@@ -964,11 +964,10 @@ 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)";
 
     fn roundtrip_descriptor(s: &str) {
-        let desc = Descriptor::<DummyKey>::from_str(&s).unwrap();
+        let desc = Descriptor::<DummyKey>::from_str(s).unwrap();
         let output = desc.to_string();
         let normalize_aliases = s.replace("c:pk_k(", "pk(").replace("c:pk_h(", "pkh(");
         assert_eq!(
@@ -1031,9 +1030,9 @@ mod tests {
 
     #[test]
     pub fn script_pubkey() {
-        let bare = StdDescriptor::from_str(&format!(
-            "multi(1,020000000000000000000000000000000000000000000000000000000000000002)"
-        ))
+        let bare = StdDescriptor::from_str(
+            "multi(1,020000000000000000000000000000000000000000000000000000000000000002)",
+        )
         .unwrap();
         assert_eq!(
             bare.script_pubkey(),
@@ -1233,7 +1232,7 @@ mod tests {
             sequence: Sequence::from_height(100),
             witness: Witness::default(),
         };
-        let bare = Descriptor::new_bare(ms.clone()).unwrap();
+        let bare = Descriptor::new_bare(ms).unwrap();
 
         bare.satisfy(&mut txin, &satisfier).expect("satisfaction");
         assert_eq!(
@@ -1757,8 +1756,8 @@ mod tests {
             "sh(multi(2,[00000000/111'/222]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL,xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y/0))##tjq09x4t"
         );
 
-        Descriptor::parse_descriptor(&secp, "sh(multi(2,[00000000/111'/222]xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc,xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L/0))#ggrsrxfy").expect("Valid descriptor with checksum");
-        Descriptor::parse_descriptor(&secp, "sh(multi(2,[00000000/111'/222]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL,xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y/0))#tjg09x5t").expect("Valid descriptor with checksum");
+        Descriptor::parse_descriptor(secp, "sh(multi(2,[00000000/111'/222]xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc,xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L/0))#ggrsrxfy").expect("Valid descriptor with checksum");
+        Descriptor::parse_descriptor(secp, "sh(multi(2,[00000000/111'/222]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL,xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y/0))#tjg09x5t").expect("Valid descriptor with checksum");
     }
 
     #[test]
@@ -1788,7 +1787,7 @@ pk(03f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8))";
         let secp = &secp256k1::Secp256k1::signing_only();
         let descriptor_str = "wpkh(xprv9s21ZrQH143K4CTb63EaMxja1YiTnSEWKMbn23uoEnAzxjdUJRQkazCAtzxGm4LSoTSVTptoV9RbchnKPW9HxKtZumdyxyikZFDLhogJ5Uj/44'/0'/0'/0/*)#v20xlvm9";
         let (descriptor, keymap) =
-            Descriptor::<DescriptorPublicKey>::parse_descriptor(&secp, descriptor_str).unwrap();
+            Descriptor::<DescriptorPublicKey>::parse_descriptor(secp, descriptor_str).unwrap();
 
         let expected = "wpkh([a12b02f4/44'/0'/0']xpub6BzhLAQUDcBUfHRQHZxDF2AbcJqp4Kaeq6bzJpXrjrWuK26ymTFwkEFbxPra2bJ7yeZKbDjfDeFwxe93JMqpo5SsPJH6dZdvV9kMzJkAZ69/0/*)#u37l7u8u";
         assert_eq!(expected, descriptor.to_string());

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

@@ -354,8 +354,8 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         while !self.stack.is_empty() {
             let (depth, last) = self.stack.pop().expect("Size checked above");
-            match &*last {
-                TapTree::Tree(l, r) => {
+            match *last {
+                TapTree::Tree(ref l, ref r) => {
                     self.stack.push((depth + 1, r));
                     self.stack.push((depth + 1, l));
                 }

src/interpreter/inner.rs

@@ -107,6 +107,7 @@ pub(super) enum Inner {
 /// Parses an `Inner` and appropriate `Stack` from completed transaction data,
 /// as well as the script that should be used as a scriptCode in a sighash
 /// Tr outputs don't have script code and return None.
+#[allow(clippy::collapsible_else_if)]
 pub(super) fn from_txdata<'txin>(
     spk: &bitcoin::Script,
     script_sig: &'txin bitcoin::Script,
@@ -819,7 +820,7 @@ mod tests {
             from_txdata(&spk, &script_sig, &empty_wit).expect("parse txdata");
         assert_eq!(inner, Inner::Script(miniscript, ScriptType::Sh));
         assert_eq!(stack, Stack::from(vec![]));
-        assert_eq!(script_code, Some(redeem_script.clone()));
+        assert_eq!(script_code, Some(redeem_script));
 
         // nonempty witness
         let wit = Witness::from_vec(vec![vec![]]);

src/interpreter/mod.rs

@@ -1143,10 +1143,10 @@ mod tests {
         ) -> Iter<'elem, 'txin> {
             Iter {
                 verify_sig: verify_fn,
-                stack: stack,
+                stack,
                 public_key: None,
                 state: vec![NodeEvaluationState {
-                    node: &ms,
+                    node: ms,
                     n_evaluated: 0,
                     n_satisfied: 0,
                 }],
@@ -1163,7 +1163,7 @@ mod tests {
         let after = no_checks_ms(&format!("after({})", 1000));
         let older = no_checks_ms(&format!("older({})", 1000));
         //Hashes
-        let preimage = [0xab as u8; 32];
+        let preimage = [0xab; 32];
         let sha256_hash = sha256::Hash::hash(&preimage);
         let sha256 = no_checks_ms(&format!("sha256({})", sha256_hash));
         let hash256_hash = hash256::Hash::hash(&preimage);
@@ -1235,7 +1235,7 @@ mod tests {
             sah256_satisfied.unwrap(),
             vec![SatisfiedConstraint::HashLock {
                 hash: HashLockType::Sha256(sha256_hash),
-                preimage: preimage,
+                preimage,
             }]
         );
 
@@ -1247,7 +1247,7 @@ mod tests {
             sha256d_satisfied.unwrap(),
             vec![SatisfiedConstraint::HashLock {
                 hash: HashLockType::Hash256(hash256_hash),
-                preimage: preimage,
+                preimage,
             }]
         );
 
@@ -1259,7 +1259,7 @@ mod tests {
             hash160_satisfied.unwrap(),
             vec![SatisfiedConstraint::HashLock {
                 hash: HashLockType::Hash160(hash160_hash),
-                preimage: preimage,
+                preimage,
             }]
         );
 
@@ -1271,7 +1271,7 @@ mod tests {
             ripemd160_satisfied.unwrap(),
             vec![SatisfiedConstraint::HashLock {
                 hash: HashLockType::Ripemd160(ripemd160_hash),
-                preimage: preimage
+                preimage,
             }]
         );
 
@@ -1319,7 +1319,7 @@ mod tests {
                 },
                 SatisfiedConstraint::HashLock {
                     hash: HashLockType::Sha256(sha256_hash),
-                    preimage: preimage,
+                    preimage,
                 }
             ]
         );
@@ -1344,7 +1344,7 @@ mod tests {
                 },
                 SatisfiedConstraint::HashLock {
                     hash: HashLockType::Sha256(sha256_hash),
-                    preimage: preimage,
+                    preimage,
                 }
             ]
         );
@@ -1383,7 +1383,7 @@ mod tests {
             or_b_satisfied.unwrap(),
             vec![SatisfiedConstraint::HashLock {
                 hash: HashLockType::Sha256(sha256_hash),
-                preimage: preimage,
+                preimage,
             }]
         );
 

src/miniscript/astelem.rs

@@ -113,9 +113,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                     && c.real_for_each_key(pred)
             }
             Terminal::Thresh(_, ref subs) => subs.iter().all(|sub| sub.real_for_each_key(pred)),
-            Terminal::Multi(_, ref keys) | Terminal::MultiA(_, ref keys) => {
-                keys.iter().all(|key| pred(key))
-            }
+            Terminal::Multi(_, ref keys) | Terminal::MultiA(_, ref keys) => keys.iter().all(pred),
         }
     }
 
@@ -131,10 +129,10 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             Terminal::RawPkH(ref p) => Terminal::RawPkH(*p),
             Terminal::After(n) => Terminal::After(n),
             Terminal::Older(n) => Terminal::Older(n),
-            Terminal::Sha256(ref x) => Terminal::Sha256(t.sha256(&x)?),
-            Terminal::Hash256(ref x) => Terminal::Hash256(t.hash256(&x)?),
-            Terminal::Ripemd160(ref x) => Terminal::Ripemd160(t.ripemd160(&x)?),
-            Terminal::Hash160(ref x) => Terminal::Hash160(t.hash160(&x)?),
+            Terminal::Sha256(ref x) => Terminal::Sha256(t.sha256(x)?),
+            Terminal::Hash256(ref x) => Terminal::Hash256(t.hash256(x)?),
+            Terminal::Ripemd160(ref x) => Terminal::Ripemd160(t.ripemd160(x)?),
+            Terminal::Hash160(ref x) => Terminal::Hash160(t.hash160(x)?),
             Terminal::True => Terminal::True,
             Terminal::False => Terminal::False,
             Terminal::Alt(ref sub) => Terminal::Alt(Arc::new(sub.real_translate_pk(t)?)),
@@ -624,7 +622,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             Terminal::RawPkH(ref hash) => builder
                 .push_opcode(opcodes::all::OP_DUP)
                 .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&hash)
+                .push_slice(hash)
                 .push_opcode(opcodes::all::OP_EQUALVERIFY),
             Terminal::After(t) => builder
                 .push_int(t.to_u32().into())
@@ -637,28 +635,28 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 .push_int(32)
                 .push_opcode(opcodes::all::OP_EQUALVERIFY)
                 .push_opcode(opcodes::all::OP_SHA256)
-                .push_slice(&Pk::to_sha256(&h))
+                .push_slice(&Pk::to_sha256(h))
                 .push_opcode(opcodes::all::OP_EQUAL),
             Terminal::Hash256(ref h) => builder
                 .push_opcode(opcodes::all::OP_SIZE)
                 .push_int(32)
                 .push_opcode(opcodes::all::OP_EQUALVERIFY)
                 .push_opcode(opcodes::all::OP_HASH256)
-                .push_slice(&Pk::to_hash256(&h))
+                .push_slice(&Pk::to_hash256(h))
                 .push_opcode(opcodes::all::OP_EQUAL),
             Terminal::Ripemd160(ref h) => builder
                 .push_opcode(opcodes::all::OP_SIZE)
                 .push_int(32)
                 .push_opcode(opcodes::all::OP_EQUALVERIFY)
                 .push_opcode(opcodes::all::OP_RIPEMD160)
-                .push_slice(&Pk::to_ripemd160(&h))
+                .push_slice(&Pk::to_ripemd160(h))
                 .push_opcode(opcodes::all::OP_EQUAL),
             Terminal::Hash160(ref h) => builder
                 .push_opcode(opcodes::all::OP_SIZE)
                 .push_int(32)
                 .push_opcode(opcodes::all::OP_EQUALVERIFY)
                 .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&Pk::to_hash160(&h))
+                .push_slice(&Pk::to_hash160(h))
                 .push_opcode(opcodes::all::OP_EQUAL),
             Terminal::True => builder.push_opcode(opcodes::OP_TRUE),
             Terminal::False => builder.push_opcode(opcodes::OP_FALSE),
@@ -777,7 +775,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             Terminal::Check(ref sub) => sub.node.script_size() + 1,
             Terminal::DupIf(ref sub) => sub.node.script_size() + 3,
             Terminal::Verify(ref sub) => {
-                sub.node.script_size() + if sub.ext.has_free_verify { 0 } else { 1 }
+                sub.node.script_size() + usize::from(!sub.ext.has_free_verify)
             }
             Terminal::NonZero(ref sub) => sub.node.script_size() + 4,
             Terminal::ZeroNotEqual(ref sub) => sub.node.script_size() + 1,