Remove unneeded explicit reference

tcharding · tcharding · commit 03c65871b505 · 2022-05-10T12:00:45.000+10:00
Clippy emits a bunch of warnings of the form

  warning: this expression borrows a reference (`&amp;Self`) that is
  immediately dereferenced by the compiler

As suggested, remove the unneeded explicit reference.
diff --git a/src/descriptor/bare.rs b/src/descriptor/bare.rs
@@ -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)
     }
diff --git a/src/descriptor/key.rs b/src/descriptor/key.rs
@@ -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()))
                 }
             }
         };
diff --git a/src/descriptor/mod.rs b/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)));
             }
diff --git a/src/descriptor/pretaproot.rs b/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")
         }
     }
diff --git a/src/descriptor/segwitv0.rs b/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),
diff --git a/src/descriptor/sh.rs b/src/descriptor/sh.rs
@@ -103,11 +103,11 @@ 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)
                 }
diff --git a/src/descriptor/tr.rs b/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)),
             }
@@ -533,7 +533,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
             }
         }
 
-        let pol = lift_helper(&self)?;
+        let pol = lift_helper(self)?;
         Ok(pol.normalized())
     }
 }
@@ -594,15 +594,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> {
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
@@ -254,13 +254,13 @@ impl<'txin> Interpreter<'txin> {
                 let script_pubkey = self.script_code.as_ref().expect("Legacy have script code");
                 let sighash = if self.is_legacy() {
                     let sighash_u32 = ecdsa_sig.hash_ty.to_u32();
-                    cache.legacy_signature_hash(input_idx, &script_pubkey, sighash_u32)
+                    cache.legacy_signature_hash(input_idx, script_pubkey, sighash_u32)
                 } else if self.is_segwit_v0() {
                     let amt = match get_prevout(prevouts, input_idx) {
                         Some(txout) => txout.borrow().value,
                         None => return false,
                     };
-                    cache.segwit_signature_hash(input_idx, &script_pubkey, amt, ecdsa_sig.hash_ty)
+                    cache.segwit_signature_hash(input_idx, script_pubkey, amt, ecdsa_sig.hash_ty)
                 } else {
                     // taproot(or future) signatures in segwitv0 context
                     return false;
@@ -280,7 +280,7 @@ impl<'txin> Interpreter<'txin> {
                         of script code for script spend",
                     );
                     let leaf_hash = taproot::TapLeafHash::from_script(
-                        &tap_script,
+                        tap_script,
                         taproot::LeafVersion::TapScript,
                     );
                     cache.taproot_script_spend_signature_hash(
@@ -296,7 +296,7 @@ impl<'txin> Interpreter<'txin> {
                 let msg =
                     sighash_msg.map(|hash| secp256k1::Message::from_slice(&hash).expect("32 byte"));
                 let success =
-                    msg.map(|msg| secp.verify_schnorr(&schnorr_sig.sig, &msg, &xpk).is_ok());
+                    msg.map(|msg| secp.verify_schnorr(&schnorr_sig.sig, &msg, xpk).is_ok());
                 success.unwrap_or(false) // unwrap_or_default checks for errors, while success would have checksig results
             }
         }
@@ -975,7 +975,7 @@ where
         //Pk based descriptor
         if let Some(pk) = self.public_key {
             if let Some(stack::Element::Push(sig)) = self.stack.pop() {
-                if let Ok(key_sig) = verify_sersig(&mut self.verify_sig, &pk, &sig) {
+                if let Ok(key_sig) = verify_sersig(&mut self.verify_sig, pk, sig) {
                     //Signature check successful, set public_key to None to
                     //terminate the next() function in the subsequent call
                     self.public_key = None;
diff --git a/src/miniscript/analyzable.rs b/src/miniscript/analyzable.rs
@@ -83,7 +83,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     // It maybe possible to return a detail error type containing why the miniscript
     // failed. But doing so may require returning a collection of errors
     pub fn within_resource_limits(&self) -> bool {
-        match Ctx::check_local_validity(&self) {
+        match Ctx::check_local_validity(self) {
             Ok(_) => true,
             Err(_) => false,
         }
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
@@ -659,7 +659,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             Terminal::PkH(ref hash) => builder
                 .push_opcode(opcodes::all::OP_DUP)
                 .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&Pk::hash_to_hash160(&hash)[..])
+                .push_slice(&Pk::hash_to_hash160(hash)[..])
                 .push_opcode(opcodes::all::OP_EQUALVERIFY),
             Terminal::After(t) => builder
                 .push_int(t as i64)
diff --git a/src/miniscript/lex.rs b/src/miniscript/lex.rs
@@ -226,10 +226,10 @@ pub fn lex<'s>(script: &'s script::Script) -> Result<Vec<Token<'s>>, Error> {
             }
             script::Instruction::PushBytes(bytes) => {
                 match bytes.len() {
-                    20 => ret.push(Token::Hash20(&bytes)),
-                    32 => ret.push(Token::Bytes32(&bytes)),
-                    33 => ret.push(Token::Bytes33(&bytes)),
-                    65 => ret.push(Token::Bytes65(&bytes)),
+                    20 => ret.push(Token::Hash20(bytes)),
+                    32 => ret.push(Token::Bytes32(bytes)),
+                    33 => ret.push(Token::Bytes33(bytes)),
+                    65 => ret.push(Token::Bytes65(bytes)),
                     _ => {
                         match script::read_scriptint(bytes) {
                             Ok(v) if v >= 0 => {
diff --git a/src/psbt/finalizer.rs b/src/psbt/finalizer.rs
@@ -106,7 +106,7 @@ pub(super) fn get_scriptpubkey(psbt: &Psbt, index: usize) -> Result<&Script, Inp
 pub(super) fn get_utxo(psbt: &Psbt, index: usize) -> Result<&bitcoin::TxOut, InputError> {
     let inp = &psbt.inputs[index];
     let utxo = if let Some(ref witness_utxo) = inp.witness_utxo {
-        &witness_utxo
+        witness_utxo
     } else if let Some(ref non_witness_utxo) = inp.non_witness_utxo {
         let vout = psbt.unsigned_tx.input[index].previous_output.vout;
         &non_witness_utxo.output[vout as usize]
@@ -278,7 +278,7 @@ pub fn interpreter_check<C: secp256k1::Verification>(
     psbt: &Psbt,
     secp: &Secp256k1<C>,
 ) -> Result<(), Error> {
-    let utxos = prevouts(&psbt)?;
+    let utxos = prevouts(psbt)?;
     let utxos = &Prevouts::All(&utxos);
     for (index, input) in psbt.inputs.iter().enumerate() {
         let empty_script_sig = Script::new();
@@ -290,7 +290,7 @@ pub fn interpreter_check<C: secp256k1::Verification>(
             .map(|wit_slice| Witness::from_vec(wit_slice.to_vec())) // TODO: Update rust-bitcoin psbt API to use witness
             .unwrap_or(empty_witness);
 
-        interpreter_inp_check(psbt, secp, index, utxos, &witness, &script_sig)?;
+        interpreter_inp_check(psbt, secp, index, utxos, &witness, script_sig)?;
     }
     Ok(())
 }
@@ -313,9 +313,9 @@ fn interpreter_inp_check<C: secp256k1::Verification, T: Borrow<TxOut>>(
         let cltv = psbt.unsigned_tx.lock_time;
         let csv = psbt.unsigned_tx.input[index].sequence;
         let interpreter =
-            interpreter::Interpreter::from_txdata(spk, &script_sig, &witness, cltv, csv)
+            interpreter::Interpreter::from_txdata(spk, script_sig, witness, cltv, csv)
                 .map_err(|e| Error::InputError(InputError::Interpreter(e), index))?;
-        let iter = interpreter.iter(secp, &psbt.unsigned_tx, index, &utxos);
+        let iter = interpreter.iter(secp, &psbt.unsigned_tx, index, utxos);
         if let Some(error) = iter.filter_map(Result::err).next() {
             return Err(Error::InputError(InputError::Interpreter(error), index));
         };
@@ -373,7 +373,7 @@ fn finalize_input_helper<C: secp256k1::Verification>(
 ) -> Result<(Witness, Script), super::Error> {
     let (witness, script_sig) = {
         let spk = get_scriptpubkey(psbt, index).map_err(|e| Error::InputError(e, index))?;
-        let sat = PsbtInputSatisfier::new(&psbt, index);
+        let sat = PsbtInputSatisfier::new(psbt, index);
 
         if spk.is_v1_p2tr() {
             // Deal with tr case separately, unfortunately we cannot infer the full descriptor for Tr
@@ -382,10 +382,10 @@ fn finalize_input_helper<C: secp256k1::Verification>(
             (wit, Script::new())
         } else {
             // Get a descriptor for this input.
-            let desc = get_descriptor(&psbt, index).map_err(|e| Error::InputError(e, index))?;
+            let desc = get_descriptor(psbt, index).map_err(|e| Error::InputError(e, index))?;
 
             //generate the satisfaction witness and scriptsig
-            let sat = PsbtInputSatisfier::new(&psbt, index);
+            let sat = PsbtInputSatisfier::new(psbt, index);
             if !allow_mall {
                 desc.get_satisfaction(sat)
             } else {
@@ -396,7 +396,7 @@ fn finalize_input_helper<C: secp256k1::Verification>(
     };
 
     let witness = bitcoin::Witness::from_vec(witness);
-    let utxos = prevouts(&psbt)?;
+    let utxos = prevouts(psbt)?;
     let utxos = &Prevouts::All(&utxos);
     interpreter_inp_check(psbt, secp, index, utxos, &witness, &script_sig)?;
 
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs
@@ -363,7 +363,7 @@ impl<'psbt, Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for PsbtInputSatisfie
 fn try_vec_as_preimage32(vec: &Vec<u8>) -> Option<Preimage32> {
     if vec.len() == 32 {
         let mut arr = [0u8; 32];
-        arr.copy_from_slice(&vec);
+        arr.copy_from_slice(vec);
         Some(arr)
     } else {
         None
@@ -763,7 +763,7 @@ impl PsbtExt for Psbt {
         };
 
         let (_, spk_check_passed) =
-            update_input_with_descriptor_helper(input, &desc, Some(expected_spk))
+            update_input_with_descriptor_helper(input, desc, Some(expected_spk))
                 .map_err(UtxoUpdateError::DerivationError)?;
 
         if !spk_check_passed {
@@ -831,7 +831,7 @@ impl PsbtExt for Psbt {
                     .unwrap_or(false);
             if inp_spk.is_v0_p2wpkh() || inp_spk.is_v0_p2wsh() || is_nested_wpkh || is_nested_wsh {
                 let msg = if inp_spk.is_v0_p2wpkh() {
-                    let script_code = script_code_wpkh(&inp_spk);
+                    let script_code = script_code_wpkh(inp_spk);
                     cache.segwit_signature_hash(idx, &script_code, amt, hash_ty)?
                 } else if is_nested_wpkh {
                     let script_code = script_code_wpkh(
@@ -852,7 +852,7 @@ impl PsbtExt for Psbt {
             } else {
                 // legacy sighash case
                 let script_code = if inp_spk.is_p2sh() {
-                    &inp.redeem_script
+                    inp.redeem_script
                         .as_ref()
                         .ok_or(SighashError::MissingRedeemScript)?
                 } else {

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ where`
`111`	`111`	`<<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,`
`112`	`112`	`{`
`113`	`113`	`fn from_tree(top: &expression::Tree) -> Result<Self, Error> {`
`114`		`- let sub = Miniscript::<Pk, BareCtx>::from_tree(&top)?;`
	`114`	`+ let sub = Miniscript::<Pk, BareCtx>::from_tree(top)?;`
`115`	`115`	`BareCtx::top_level_checks(&sub)?;`
`116`	`116`	`Bare::new(sub)`
`117`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -259,7 +259,7 @@ pub(crate) mod traits {`
`259`	`259`	`{`
`260`	`260`	`// This expect can technically be avoided if we implement this for types, but`
`261`	`261`	`// having this expect saves lots of LoC because of default implementation`
`262`		`- <Self as DescriptorTrait<Pk>>::explicit_script(&self)`
	`262`	`+ <Self as DescriptorTrait<Pk>>::explicit_script(self)`
`263`	`263`	`.expect("Pre taproot descriptor have explicit script")`
`264`	`264`	`}`
`265`	`265`
`@@ -269,7 +269,7 @@ pub(crate) mod traits {`
`269`	`269`	`where`
`270`	`270`	`Pk: ToPublicKey,`
`271`	`271`	`{`
`272`		`- <Self as DescriptorTrait<Pk>>::script_code(&self)`
	`272`	`+ <Self as DescriptorTrait<Pk>>::script_code(self)`
`273`	`273`	`.expect("Pre taproot descriptor have non-failing script code")`
`274`	`274`	`}`
`275`	`275`	`}`
Original file line number	Diff line number	Diff line change
`@@ -322,8 +322,8 @@ where`
`322`	`322`	`let (depth, last) = self.stack.pop().expect("Size checked above");`
`323`	`323`	`match &*last {`
`324`	`324`	`TapTree::Tree(l, r) => {`
`325`		`- self.stack.push((depth + 1, &r));`
`326`		`- self.stack.push((depth + 1, &l));`
	`325`	`+ self.stack.push((depth + 1, r));`
	`326`	`+ self.stack.push((depth + 1, l));`
`327`	`327`	`}`
`328`	`328`	`TapTree::Leaf(ref ms) => return Some((depth, ms)),`
`329`	`329`	`}`
`@@ -533,7 +533,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {`
`533`	`533`	`}`
`534`	`534`	`}`
`535`	`535`
`536`		`- let pol = lift_helper(&self)?;`
	`536`	`+ let pol = lift_helper(self)?;`
`537`	`537`	`Ok(pol.normalized())`
`538`	`538`	`}`
`539`	`539`	`}`
`@@ -594,15 +594,15 @@ impl<Pk: MiniscriptKey> DescriptorTrait<Pk> for Tr<Pk> {`
`594`	`594`	`Pk: ToPublicKey,`
`595`	`595`	`S: Satisfier<Pk>,`
`596`	`596`	`{`
`597`		`- best_tap_spend(&self, satisfier, false /* allow_mall */)`
	`597`	`+ best_tap_spend(self, satisfier, false /* allow_mall */)`
`598`	`598`	`}`
`599`	`599`
`600`	`600`	`fn get_satisfaction_mall<S>(&self, satisfier: S) -> Result<(Vec<Vec<u8>>, Script), Error>`
`601`	`601`	`where`
`602`	`602`	`Pk: ToPublicKey,`
`603`	`603`	`S: Satisfier<Pk>,`
`604`	`604`	`{`
`605`		`- best_tap_spend(&self, satisfier, true /* allow_mall */)`
	`605`	`+ best_tap_spend(self, satisfier, true /* allow_mall */)`
`606`	`606`	`}`
`607`	`607`
`608`	`608`	`fn max_satisfaction_weight(&self) -> Result<usize, Error> {`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {`
`83`	`83`	`// It maybe possible to return a detail error type containing why the miniscript`
`84`	`84`	`// failed. But doing so may require returning a collection of errors`
`85`	`85`	`pub fn within_resource_limits(&self) -> bool {`
`86`		`- match Ctx::check_local_validity(&self) {`
	`86`	`+ match Ctx::check_local_validity(self) {`
`87`	`87`	`Ok(_) => true,`
`88`	`88`	`Err(_) => false,`
`89`	`89`	`}`