Merge rust-bitcoin/rust-miniscript#367: Clear some clippy warnings

7da532763924c9a0d3b5569745182e552ed14ea0 Use semvar-compliant version number (Tobin C. Harding)
17bd217697035fe183c76625f623e4995ae4bdae Use find instead of chaining filter and next (Tobin C. Harding)
b75964cca195bd79c062cc635ba4d67d7dfb6cb7 Use sort_unstable on primitive types (Tobin C. Harding)
769cd6db4cb7c039b4d0ee0c05fb55127d495b58 Do not check for < 0 for usize types (Tobin C. Harding)
289a1a8bda3e5af0bb1b68708c5c811482631fd4 Use flat_map instead of chaining map and flatten (Tobin C. Harding)
90ba69228912def84265883f3edb728f6a0b1c08 Use unwrap_or_else instead of unwrap_or (Tobin C. Harding)
da6e068df151867003ec0768f9fc20c5c684a3a3 Remove the redundant calls to clone on Copy type (Tobin C. Harding)
98d4a063a52f2a882ba0ff7f94113a23ef447f99 Remove unneeded `ref` (Tobin C. Harding)
af2260fae9989558c513cd6034113f9f51bd227a Return block directly (Tobin C. Harding)
54412f137cb97623fb1f935a6c099a028645d520 Simplify duplicate code (Tobin C. Harding)
45fd5f7fc7676bbcfa10f327482bd58b542536ab Use push with character literal (Tobin C. Harding)
ebc4dc9f78ee87bbbc3f8833a4da890c29fdcb9f Use to_string instead of format macro (Tobin C. Harding)
592b4790f3f229b2bcad28238777f6440235d28d Use copied (Tobin C. Harding)
54f23840ae190f4240b3438279320254aa3c4591 Remove redundant clone (Tobin C. Harding)
230cab996721b64a1de8efb04fe6c5c212399d22 Use map instead of and_then (Tobin C. Harding)
bc7be32fab6e4ecf7ba9235013def628ba77a8f4 Remove unnecessary call to String::from (Tobin C. Harding)
35015bf7e702de0c619face925971429c69d3e76 Remove redundant pattern matching (Tobin C. Harding)
ad51d83a9d481e2b0c9b278f4d27625a76c37ea2 Derive Default (Tobin C. Harding)
ea57d6e1bc4b4fa778da347a9d8cf27d039fe32a Use contains instead of manual implementation (Tobin C. Harding)
7b91918a4a37f60348dabd8e7029eeeaef248eef Use is_empty (Tobin C. Harding)
738ff15174f8405c305b843b4118a587018bea0e Remove redundant closures (Tobin C. Harding)
63dee9eb228a08a40a3028ab47647e3adc8c4da4 Use iter instead of into_iter (Tobin C. Harding)
3fdd0f516bd0ff5d26e37c984332036752adeb1a Remove useless conversion call from error return (Tobin C. Harding)
d29d10a95b9357a9bff9abfe73cd9fd5974f95a8 Remove reference from expression and patterns (Tobin C. Harding)
0a1b5e497944da82a5fad08fb67bcd1c1e34992e Do not use & for pattern match arms (Tobin C. Harding)
be1a4ee0af639ba727c93a8b3221c2e41de4e779 Use ok_or_else instead of ok_or (Tobin C. Harding)
8944ca0d4f6cc54ff712e45448f2230ea2432933 Remove explicit lifetimes (Tobin C. Harding)
5647e29606d9503aa7c8180a70827f2d4f14f877 Remove redundant slicing of whole range (Tobin C. Harding)
52f7dce75808b678d11c1c8a0c9a434a714ba19f Use & instead of `ref` (Tobin C. Harding)
81d5ae61375eddcdae7cd5fc97895dac2a0f4d82 Remove explicit return statement (Tobin C. Harding)
03c65871b50581ba7d203b0a77ea09bfcf4f4f49 Remove unneeded explicit reference (Tobin C. Harding)
952af97e2aa3986f1141f7fd0cace331ac943157 Remove unneeded unit return type (Tobin C. Harding)
a1cf3944650e4e3508e78e4bdc0bb80d1e0b1471 Use struct field shorthand (Tobin C. Harding)
e94bf6efb776c234800164451e871fc473fbffa4 Remove redundant import statement (Tobin C. Harding)
77eb4a34803ffd13e3bfd6298fe8a249940ab2f8 Add clippy config file (Tobin C. Harding)

Pull request description:

  Make a start on clearing all the non-contentious clippy warnings.

ACKs for top commit:
  sanket1729:
    ACK 7da532763924c9a0d3b5569745182e552ed14ea0

Tree-SHA512: cb7ad9d8983404a01148a61aa920dfd5657ff2a5fea1ea9d3ff565a1665148e31a693916a253bf8bad274063579d4484dfa738294b0eda4271f0e8fd0a9abbdd

Author: heap-coder

clippy.toml

@@ -0,0 +1 @@
+msrv = "1.41.1"

src/descriptor/bare.rs

@@ -49,7 +49,7 @@ impl<Pk: MiniscriptKey> Bare<Pk> {
     pub fn new(ms: Miniscript<Pk, BareCtx>) -> Result<Self, Error> {
         // do the top-level checks
         BareCtx::top_level_checks(&ms)?;
-        Ok(Self { ms: ms })
+        Ok(Self { ms })
     }
 
     /// get the inner
@@ -111,7 +111,7 @@ where
     <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
 {
     fn from_tree(top: &expression::Tree) -> Result<Self, Error> {
-        let sub = Miniscript::<Pk, BareCtx>::from_tree(&top)?;
+        let sub = Miniscript::<Pk, BareCtx>::from_tree(top)?;
         BareCtx::top_level_checks(&sub)?;
         Bare::new(sub)
     }
@@ -241,7 +241,7 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     /// Create a new Pkh descriptor
     pub fn new(pk: Pk) -> Self {
         // do the top-level checks
-        Self { pk: pk }
+        Self { pk }
     }
 
     /// Get a reference to the inner key

src/descriptor/checksum.rs

@@ -43,10 +43,9 @@ pub fn desc_checksum(desc: &str) -> Result<String, Error> {
     let mut clscount = 0;
 
     for ch in desc.chars() {
-        let pos = INPUT_CHARSET.find(ch).ok_or(Error::BadDescriptor(format!(
-            "Invalid character in checksum: '{}'",
-            ch
-        )))? as u64;
+        let pos = INPUT_CHARSET.find(ch).ok_or_else(|| {
+            Error::BadDescriptor(format!("Invalid character in checksum: '{}'", ch))
+        })? as u64;
         c = poly_mod(c, pos & 31);
         cls = cls * 3 + (pos >> 5);
         clscount += 1;

src/descriptor/key.rs

@@ -73,12 +73,12 @@ pub enum SinglePubKey {
 impl fmt::Display for DescriptorSecretKey {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &DescriptorSecretKey::Single(ref sk) => {
+            DescriptorSecretKey::Single(ref sk) => {
                 maybe_fmt_master_id(f, &sk.origin)?;
                 sk.key.fmt(f)?;
                 Ok(())
             }
-            &DescriptorSecretKey::XPrv(ref xprv) => {
+            DescriptorSecretKey::XPrv(ref xprv) => {
                 maybe_fmt_master_id(f, &xprv.origin)?;
                 xprv.xkey.fmt(f)?;
                 fmt_derivation_path(f, &xprv.derivation_path)?;
@@ -172,9 +172,9 @@ impl DescriptorXKey<bip32::ExtendedPrivKey> {
 
         let xprv = self
             .xkey
-            .derive_priv(&secp, &hardened_path)
+            .derive_priv(secp, &hardened_path)
             .map_err(|_| DescriptorKeyParseError("Unable to derive the hardened steps"))?;
-        let xpub = bip32::ExtendedPubKey::from_priv(&secp, &xprv);
+        let xpub = bip32::ExtendedPubKey::from_priv(secp, &xprv);
 
         let origin = match &self.origin {
             Some((fingerprint, path)) => Some((
@@ -188,7 +188,7 @@ impl DescriptorXKey<bip32::ExtendedPrivKey> {
                 if hardened_path.is_empty() {
                     None
                 } else {
-                    Some((self.xkey.fingerprint(&secp), hardened_path.into()))
+                    Some((self.xkey.fingerprint(secp), hardened_path.into()))
                 }
             }
         };
@@ -562,7 +562,7 @@ impl<K: InnerXKey> DescriptorXKey<K> {
                 DescriptorKeyParseError("Malformed master fingerprint, expected 8 hex chars")
             })?;
             let origin_path = raw_origin
-                .map(|p| bip32::ChildNumber::from_str(p))
+                .map(bip32::ChildNumber::from_str)
                 .collect::<Result<bip32::DerivationPath, bip32::Error>>()
                 .map_err(|_| {
                     DescriptorKeyParseError("Error while parsing master derivation path")
@@ -657,21 +657,20 @@ impl<K: InnerXKey> DescriptorXKey<K> {
     ) -> Option<bip32::DerivationPath> {
         let (fingerprint, path) = keysource;
 
-        let (compare_fingerprint, compare_path) = match &self.origin {
-            &Some((fingerprint, ref path)) => (
+        let (compare_fingerprint, compare_path) = match self.origin {
+            Some((fingerprint, ref path)) => (
                 fingerprint,
                 path.into_iter()
                     .chain(self.derivation_path.into_iter())
                     .collect(),
             ),
-            &None => (
+            None => (
                 self.xkey.xkey_fingerprint(secp),
                 self.derivation_path.into_iter().collect::<Vec<_>>(),
             ),
         };
 
-        let path_excluding_wildcard = if self.wildcard != Wildcard::None && path.as_ref().len() > 0
-        {
+        let path_excluding_wildcard = if self.wildcard != Wildcard::None && !path.is_empty() {
             path.into_iter()
                 .take(path.as_ref().len() - 1)
                 .cloned()

src/descriptor/mod.rs

@@ -712,7 +712,7 @@ impl Descriptor<DescriptorPublicKey> {
                          key_map: &mut KeyMap|
          -> Result<DescriptorPublicKey, DescriptorKeyParseError> {
             let (public_key, secret_key) = match DescriptorSecretKey::from_str(s) {
-                Ok(sk) => (sk.to_public(&secp)?, Some(sk)),
+                Ok(sk) => (sk.to_public(secp)?, Some(sk)),
                 Err(_) => (DescriptorPublicKey::from_str(s)?, None),
             };
 
@@ -774,7 +774,7 @@ impl Descriptor<DescriptorPublicKey> {
         let range = if self.is_deriveable() { range } else { 0..1 };
 
         for i in range {
-            let concrete = self.derived_descriptor(&secp, i)?;
+            let concrete = self.derived_descriptor(secp, i)?;
             if &concrete.script_pubkey() == script_pubkey {
                 return Ok(Some((i, concrete)));
             }

src/descriptor/pretaproot.rs

@@ -259,7 +259,7 @@ pub(crate) mod traits {
         {
             // This expect can technically be avoided if we implement this for types, but
             // having this expect saves lots of LoC because of default implementation
-            <Self as DescriptorTrait<Pk>>::explicit_script(&self)
+            <Self as DescriptorTrait<Pk>>::explicit_script(self)
                 .expect("Pre taproot descriptor have explicit script")
         }
 
@@ -269,7 +269,7 @@ pub(crate) mod traits {
         where
             Pk: ToPublicKey,
         {
-            <Self as DescriptorTrait<Pk>>::script_code(&self)
+            <Self as DescriptorTrait<Pk>>::script_code(self)
                 .expect("Pre taproot descriptor have non-failing script code")
         }
     }

src/descriptor/segwitv0.rs

@@ -140,10 +140,10 @@ where
             let top = &top.args[0];
             if top.name == "sortedmulti" {
                 return Ok(Wsh {
-                    inner: WshInner::SortedMulti(SortedMultiVec::from_tree(&top)?),
+                    inner: WshInner::SortedMulti(SortedMultiVec::from_tree(top)?),
                 });
             }
-            let sub = Miniscript::from_tree(&top)?;
+            let sub = Miniscript::from_tree(top)?;
             Segwitv0::top_level_checks(&sub)?;
             Ok(Wsh {
                 inner: WshInner::Ms(sub),
@@ -313,7 +313,7 @@ where
             WshInner::SortedMulti(ref smv) => WshInner::SortedMulti(smv.translate_pk(&mut fpk)?),
             WshInner::Ms(ref ms) => WshInner::Ms(ms.translate_pk(&mut fpk, &mut fpkh)?),
         };
-        Ok(Wsh { inner: inner })
+        Ok(Wsh { inner })
     }
 }
 
@@ -333,7 +333,7 @@ impl<Pk: MiniscriptKey> Wpkh<Pk> {
                 pk.to_string(),
             )))
         } else {
-            Ok(Self { pk: pk })
+            Ok(Self { pk })
         }
     }
 

src/descriptor/sh.rs

@@ -103,16 +103,16 @@ where
         if top.name == "sh" && top.args.len() == 1 {
             let top = &top.args[0];
             let inner = match top.name {
-                "wsh" => ShInner::Wsh(Wsh::from_tree(&top)?),
-                "wpkh" => ShInner::Wpkh(Wpkh::from_tree(&top)?),
-                "sortedmulti" => ShInner::SortedMulti(SortedMultiVec::from_tree(&top)?),
+                "wsh" => ShInner::Wsh(Wsh::from_tree(top)?),
+                "wpkh" => ShInner::Wpkh(Wpkh::from_tree(top)?),
+                "sortedmulti" => ShInner::SortedMulti(SortedMultiVec::from_tree(top)?),
                 _ => {
-                    let sub = Miniscript::from_tree(&top)?;
+                    let sub = Miniscript::from_tree(top)?;
                     Legacy::top_level_checks(&sub)?;
                     ShInner::Ms(sub)
                 }
             };
-            Ok(Sh { inner: inner })
+            Ok(Sh { inner })
         } else {
             Err(Error::Unexpected(format!(
                 "{}({} args) while parsing sh descriptor",
@@ -439,6 +439,6 @@ where
             ShInner::SortedMulti(ref smv) => ShInner::SortedMulti(smv.translate_pk(&mut fpk)?),
             ShInner::Ms(ref ms) => ShInner::Ms(ms.translate_pk(&mut fpk, &mut fpkh)?),
         };
-        Ok(Sh { inner: inner })
+        Ok(Sh { inner })
     }
 }

src/descriptor/tr.rs

@@ -322,8 +322,8 @@ where
             let (depth, last) = self.stack.pop().expect("Size checked above");
             match &*last {
                 TapTree::Tree(l, r) => {
-                    self.stack.push((depth + 1, &r));
-                    self.stack.push((depth + 1, &l));
+                    self.stack.push((depth + 1, r));
+                    self.stack.push((depth + 1, l));
                 }
                 TapTree::Leaf(ref ms) => return Some((depth, ms)),
             }
@@ -360,12 +360,10 @@ where
                     let right = parse_tr_script_spend(&args[1])?;
                     Ok(TapTree::Tree(Arc::new(left), Arc::new(right)))
                 }
-                _ => {
-                    return Err(Error::Unexpected(
-                        "unknown format for script spending paths while parsing taproot descriptor"
-                            .to_string(),
-                    ));
-                }
+                _ => Err(Error::Unexpected(
+                    "unknown format for script spending paths while parsing taproot descriptor"
+                        .to_string(),
+                )),
             }
         }
 
@@ -386,14 +384,14 @@ where
                     })
                 }
                 2 => {
-                    let ref key = top.args[0];
+                    let key = &top.args[0];
                     if !key.args.is_empty() {
                         return Err(Error::Unexpected(format!(
                             "#{} script associated with `key-path` while parsing taproot descriptor",
                             key.args.len()
                         )));
                     }
-                    let ref tree = top.args[1];
+                    let tree = &top.args[1];
                     let ret = parse_tr_script_spend(tree)?;
                     Ok(Tr {
                         internal_key: expression::terminal(key, Pk::from_str)?,
@@ -460,7 +458,7 @@ fn parse_tr_tree(s: &str) -> Result<expression::Tree, Error> {
         }
     }
 
-    let ret = if s.len() > 3 && &s[..3] == "tr(" && s.as_bytes()[s.len() - 1] == b')' {
+    if s.len() > 3 && &s[..3] == "tr(" && s.as_bytes()[s.len() - 1] == b')' {
         let rest = &s[3..s.len() - 1];
         if !rest.contains(',') {
             let internal_key = expression::Tree {
@@ -497,12 +495,11 @@ fn parse_tr_tree(s: &str) -> Result<expression::Tree, Error> {
         }
     } else {
         Err(Error::Unexpected("invalid taproot descriptor".to_string()))
-    };
-    return ret;
+    }
 }
 
 fn split_once(inp: &str, delim: char) -> Option<(&str, &str)> {
-    let ret = if inp.is_empty() {
+    if inp.is_empty() {
         None
     } else {
         let mut found = inp.len();
@@ -514,12 +511,11 @@ fn split_once(inp: &str, delim: char) -> Option<(&str, &str)> {
         }
         // No comma or trailing comma found
         if found >= inp.len() - 1 {
-            Some((&inp[..], ""))
+            Some((inp, ""))
         } else {
             Some((&inp[..found], &inp[found + 1..]))
         }
-    };
-    return ret;
+    }
 }
 
 impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
@@ -533,7 +529,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
             }
         }
 
-        let pol = lift_helper(&self)?;
+        let pol = lift_helper(self)?;
         Ok(pol.normalized())
     }
 }
@@ -594,15 +590,15 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Tr<Pk> {
         Pk: ToPublicKey,
         S: Satisfier<Pk>,
     {
-        best_tap_spend(&self, satisfier, false /* allow_mall */)
+        best_tap_spend(self, satisfier, false /* allow_mall */)
     }
 
     fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>
     where
         Pk: ToPublicKey,
         S: Satisfier<Pk>,
     {
-        best_tap_spend(&self, satisfier, true /* allow_mall */)
+        best_tap_spend(self, satisfier, true /* allow_mall */)
     }
 
     fn max_satisfaction_weight(&self) -> Result<usize, Error> {

src/expression.rs

@@ -126,7 +126,7 @@ impl<'a> Tree<'a> {
             // String-ending terminal
             Found::Nothing => Ok((
                 Tree {
-                    name: &sl[..],
+                    name: sl,
                     args: vec![],
                 },
                 "",
@@ -195,7 +195,7 @@ impl<'a> Tree<'a> {
 pub fn parse_num(s: &str) -> Result<u32, Error> {
     if s.len() > 1 {
         let ch = s.chars().next().unwrap();
-        if ch < '1' || ch > '9' {
+        if !('1'..='9').contains(&ch) {
             return Err(Error::Unexpected(
                 "Number must start with a digit 1-9".to_string(),
             ));