Merge #367: Clear some clippy warnings

7da5327 Use semvar-compliant version number (Tobin C. Harding)
17bd217 Use find instead of chaining filter and next (Tobin C. Harding)
b75964c Use sort_unstable on primitive types (Tobin C. Harding)
769cd6d Do not check for < 0 for usize types (Tobin C. Harding)
289a1a8 Use flat_map instead of chaining map and flatten (Tobin C. Harding)
90ba692 Use unwrap_or_else instead of unwrap_or (Tobin C. Harding)
da6e068 Remove the redundant calls to clone on Copy type (Tobin C. Harding)
98d4a06 Remove unneeded `ref` (Tobin C. Harding)
af2260f Return block directly (Tobin C. Harding)
54412f1 Simplify duplicate code (Tobin C. Harding)
45fd5f7 Use push with character literal (Tobin C. Harding)
ebc4dc9 Use to_string instead of format macro (Tobin C. Harding)
592b479 Use copied (Tobin C. Harding)
54f2384 Remove redundant clone (Tobin C. Harding)
230cab9 Use map instead of and_then (Tobin C. Harding)
bc7be32 Remove unnecessary call to String::from (Tobin C. Harding)
35015bf Remove redundant pattern matching (Tobin C. Harding)
ad51d83 Derive Default (Tobin C. Harding)
ea57d6e Use contains instead of manual implementation (Tobin C. Harding)
7b91918 Use is_empty (Tobin C. Harding)
738ff15 Remove redundant closures (Tobin C. Harding)
63dee9e Use iter instead of into_iter (Tobin C. Harding)
3fdd0f5 Remove useless conversion call from error return (Tobin C. Harding)
d29d10a Remove reference from expression and patterns (Tobin C. Harding)
0a1b5e4 Do not use & for pattern match arms (Tobin C. Harding)
be1a4ee Use ok_or_else instead of ok_or (Tobin C. Harding)
8944ca0 Remove explicit lifetimes (Tobin C. Harding)
5647e29 Remove redundant slicing of whole range (Tobin C. Harding)
52f7dce Use & instead of `ref` (Tobin C. Harding)
81d5ae6 Remove explicit return statement (Tobin C. Harding)
03c6587 Remove unneeded explicit reference (Tobin C. Harding)
952af97 Remove unneeded unit return type (Tobin C. Harding)
a1cf394 Use struct field shorthand (Tobin C. Harding)
e94bf6e Remove redundant import statement (Tobin C. Harding)
77eb4a3 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 7da5327

Tree-SHA512: cb7ad9d8983404a01148a61aa920dfd5657ff2a5fea1ea9d3ff565a1665148e31a693916a253bf8bad274063579d4484dfa738294b0eda4271f0e8fd0a9abbdd

Author: sanket1729

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(),
             ));