Merge #535: clippy fixes

34f77df cargo fmt (Andrew Poelstra)
9ad1495 fix ci for serde breakage (Andrew Poelstra)
80a2057 increase 'serde' version to 1.0.103, the earliest version that actually works (Andrew Poelstra)
4c6d78d clippy: remove unused into_iter (Andrew Poelstra)
456aa21 clippy: remove unused return statements (Andrew Poelstra)
caa3368 clippy: add Default impl for checksum engine (Andrew Poelstra)
a455c91 clippy: get rid of &Pattern(ref field) reference stuff (Andrew Poelstra)

Pull request description:

  Also check minimum dependency versions.

ACKs for top commit:
  sanket1729:
    ACK 34f77df

Tree-SHA512: 35563598047f1f90768a7e092e69ca2c68d4b35c1f20c19393746262bb3476e2f2ea1ffbdf3b3d524c4e11da5dbb4779769cfdc5e5909c7d92c22dc3972adc1d

Author: sanket1729

Cargo.toml

@@ -27,7 +27,7 @@ bitcoin = { version = "0.29.1", default-features = false }
 hashbrown = { version = "0.11", optional = true }
 
 # Do NOT use this as a feature! Use the `serde` feature instead.
-actual-serde = { package = "serde", version = "1.0", optional = true }
+actual-serde = { package = "serde", version = "1.0.103", optional = true }
 
 [dev-dependencies]
 serde_test = "1.0.147"
@@ -65,4 +65,4 @@ required-features = ["compiler","std"]
 
 [[example]]
 name = "psbt_sign_finalize"
-required-features = ["std", "base64"]
+required-features = ["std", "base64"]

contrib/test.sh

@@ -17,11 +17,13 @@ fi
 # Pin dependencies required to build with Rust 1.41.1
 if cargo --version | grep "1\.41\.0"; then
     cargo update -p once_cell --precise 1.13.1
+    cargo update -p serde --precise 1.0.156
 fi
 
 # Pin dependencies required to build with Rust 1.47.0
 if cargo --version | grep "1\.47\.0"; then
     cargo update -p once_cell --precise 1.13.1
+    cargo update -p serde --precise 1.0.156
 fi
 
 # Fuzz if told to

src/descriptor/checksum.rs

@@ -79,6 +79,12 @@ pub struct Engine {
     clscount: u64,
 }
 
+impl Default for Engine {
+    fn default() -> Engine {
+        Engine::new()
+    }
+}
+
 impl Engine {
     /// Construct an engine with no input
     pub fn new() -> Self {

src/descriptor/key.rs

@@ -855,7 +855,6 @@ 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.
-        .into_iter()
         .fold(Ok(Vec::new()), |paths, index_list| {
             let mut paths = paths?;
             let mut index_list = index_list?.into_iter();

src/descriptor/tr.rs

@@ -468,20 +468,18 @@ impl_from_tree!(
                     let ret = Self::parse_tr_script_spend(tree)?;
                     Tr::new(expression::terminal(key, Pk::from_str)?, Some(ret))
                 }
-                _ => {
-                    return Err(Error::Unexpected(format!(
-                        "{}[#{} args] while parsing taproot descriptor",
-                        top.name,
-                        top.args.len()
-                    )));
-                }
+                _ => Err(Error::Unexpected(format!(
+                    "{}[#{} args] while parsing taproot descriptor",
+                    top.name,
+                    top.args.len()
+                ))),
             }
         } else {
-            return Err(Error::Unexpected(format!(
+            Err(Error::Unexpected(format!(
                 "{}[#{} args] while parsing taproot descriptor",
                 top.name,
                 top.args.len()
-            )));
+            )))
         }
     }
 );

src/miniscript/iter.rs

@@ -63,30 +63,30 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// Returns child node with given index, if any
     pub fn get_nth_child(&self, n: usize) -> Option<&Miniscript<Pk, Ctx>> {
         match (n, &self.node) {
-            (0, &Terminal::Alt(ref node))
-            | (0, &Terminal::Swap(ref node))
-            | (0, &Terminal::Check(ref node))
-            | (0, &Terminal::DupIf(ref node))
-            | (0, &Terminal::Verify(ref node))
-            | (0, &Terminal::NonZero(ref node))
-            | (0, &Terminal::ZeroNotEqual(ref node))
-            | (0, &Terminal::AndV(ref node, _))
-            | (0, &Terminal::AndB(ref node, _))
-            | (0, &Terminal::OrB(ref node, _))
-            | (0, &Terminal::OrD(ref node, _))
-            | (0, &Terminal::OrC(ref node, _))
-            | (0, &Terminal::OrI(ref node, _))
-            | (1, &Terminal::AndV(_, ref node))
-            | (1, &Terminal::AndB(_, ref node))
-            | (1, &Terminal::OrB(_, ref node))
-            | (1, &Terminal::OrD(_, ref node))
-            | (1, &Terminal::OrC(_, ref node))
-            | (1, &Terminal::OrI(_, ref node))
-            | (0, &Terminal::AndOr(ref node, _, _))
-            | (1, &Terminal::AndOr(_, ref node, _))
-            | (2, &Terminal::AndOr(_, _, ref node)) => Some(node),
-
-            (n, &Terminal::Thresh(_, ref node_vec)) => node_vec.get(n).map(|x| &**x),
+            (0, Terminal::Alt(node))
+            | (0, Terminal::Swap(node))
+            | (0, Terminal::Check(node))
+            | (0, Terminal::DupIf(node))
+            | (0, Terminal::Verify(node))
+            | (0, Terminal::NonZero(node))
+            | (0, Terminal::ZeroNotEqual(node))
+            | (0, Terminal::AndV(node, _))
+            | (0, Terminal::AndB(node, _))
+            | (0, Terminal::OrB(node, _))
+            | (0, Terminal::OrD(node, _))
+            | (0, Terminal::OrC(node, _))
+            | (0, Terminal::OrI(node, _))
+            | (1, Terminal::AndV(_, node))
+            | (1, Terminal::AndB(_, node))
+            | (1, Terminal::OrB(_, node))
+            | (1, Terminal::OrD(_, node))
+            | (1, Terminal::OrC(_, node))
+            | (1, Terminal::OrI(_, node))
+            | (0, Terminal::AndOr(node, _, _))
+            | (1, Terminal::AndOr(_, node, _))
+            | (2, Terminal::AndOr(_, _, node)) => Some(node),
+
+            (n, Terminal::Thresh(_, node_vec)) => node_vec.get(n).map(|x| &**x),
 
             _ => None,
         }

src/miniscript/satisfy.rs

@@ -537,17 +537,17 @@ impl PartialOrd for Witness {
 impl Ord for Witness {
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         match (self, other) {
-            (&Witness::Stack(ref v1), &Witness::Stack(ref v2)) => {
+            (Witness::Stack(v1), Witness::Stack(v2)) => {
                 let w1 = witness_size(v1);
                 let w2 = witness_size(v2);
                 w1.cmp(&w2)
             }
-            (&Witness::Stack(_), _) => cmp::Ordering::Less,
-            (_, &Witness::Stack(_)) => cmp::Ordering::Greater,
-            (&Witness::Impossible, &Witness::Unavailable) => cmp::Ordering::Less,
-            (&Witness::Unavailable, &Witness::Impossible) => cmp::Ordering::Greater,
-            (&Witness::Impossible, &Witness::Impossible) => cmp::Ordering::Equal,
-            (&Witness::Unavailable, &Witness::Unavailable) => cmp::Ordering::Equal,
+            (Witness::Stack(_), _) => cmp::Ordering::Less,
+            (_, Witness::Stack(_)) => cmp::Ordering::Greater,
+            (Witness::Impossible, Witness::Unavailable) => cmp::Ordering::Less,
+            (Witness::Unavailable, Witness::Impossible) => cmp::Ordering::Greater,
+            (Witness::Impossible, Witness::Impossible) => cmp::Ordering::Equal,
+            (Witness::Unavailable, Witness::Unavailable) => cmp::Ordering::Equal,
         }
     }
 }
@@ -751,7 +751,7 @@ impl Satisfaction {
                 // This can only be the case when we have PkH without the corresponding
                 // Pubkey.
                 (_, &Witness::Unavailable) | (_, &Witness::Impossible) => i64::MIN,
-                (&Witness::Stack(ref s), &Witness::Stack(ref d)) => {
+                (Witness::Stack(s), Witness::Stack(d)) => {
                     witness_size(s) as i64 - witness_size(d) as i64
                 }
             };
@@ -869,7 +869,7 @@ impl Satisfaction {
                 (&Witness::Unavailable, _) | (&Witness::Impossible, _) => i64::MAX,
                 // This is only possible when one of the branches has PkH
                 (_, &Witness::Unavailable) | (_, &Witness::Impossible) => i64::MIN,
-                (&Witness::Stack(ref s), &Witness::Stack(ref d)) => {
+                (Witness::Stack(s), Witness::Stack(d)) => {
                     witness_size(s) as i64 - witness_size(d) as i64
                 }
             }

src/policy/concrete.rs

@@ -764,7 +764,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
             )),
             Policy::Or(ref subs) => Ok(Policy::Or(
                 subs.iter()
-                    .map(|&(ref prob, ref sub)| Ok((*prob, sub._translate_pk(t)?)))
+                    .map(|(prob, sub)| Ok((*prob, sub._translate_pk(t)?)))
                     .collect::<Result<Vec<(usize, Policy<Q>)>, E>>()?,
             )),
         }
@@ -894,9 +894,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 TimelockInfo::combine_threshold(subs.len(), iter)
             }
             Policy::Or(ref subs) => {
-                let iter = subs
-                    .iter()
-                    .map(|&(ref _p, ref sub)| sub.check_timelocks_helper());
+                let iter = subs.iter().map(|(_p, sub)| sub.check_timelocks_helper());
                 TimelockInfo::combine_threshold(1, iter)
             }
         }
@@ -925,7 +923,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     Err(PolicyError::NonBinaryArgOr)
                 } else {
                     subs.iter()
-                        .map(|&(ref _prob, ref sub)| sub.is_valid())
+                        .map(|(_prob, sub)| sub.is_valid())
                         .collect::<Result<Vec<()>, PolicyError>>()?;
                     Ok(())
                 }
@@ -1002,7 +1000,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
             Policy::Or(ref subs) => {
                 let (all_safe, atleast_one_safe, all_non_mall) = subs
                     .iter()
-                    .map(|&(_, ref sub)| sub.is_safe_nonmalleable())
+                    .map(|(_, sub)| sub.is_safe_nonmalleable())
                     .fold((true, false, true), |acc, x| {
                         (acc.0 && x.0, acc.1 || x.0, acc.2 && x.1)
                     });

src/policy/mod.rs

@@ -204,7 +204,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
             }
             Concrete::Or(ref subs) => {
                 let semantic_subs: Result<_, Error> =
-                    subs.iter().map(|&(ref _p, ref sub)| sub.lift()).collect();
+                    subs.iter().map(|(_p, sub)| sub.lift()).collect();
                 Semantic::Threshold(1, semantic_subs?)
             }
             Concrete::Threshold(k, ref subs) => {