wip: Run cargo +nightly fmt

Author: tcharding

bitcoind-tests/tests/setup/test_util.rs

@@ -25,8 +25,8 @@ use bitcoin::secp256k1;
 use internals::hex::exts::DisplayHex;
 use miniscript::descriptor::{SinglePub, SinglePubKey};
 use miniscript::{
-    bitcoin, hash256, Descriptor, DescriptorPublicKey, Error, Miniscript, Context,
-    TranslatePk, Translator,
+    bitcoin, hash256, Context, Descriptor, DescriptorPublicKey, Error, Miniscript, TranslatePk,
+    Translator,
 };
 use rand::RngCore;
 use secp256k1::XOnlyPublicKey;

bitcoind-tests/tests/test_desc.rs

@@ -19,7 +19,7 @@ use bitcoin::{
 use bitcoind::bitcoincore_rpc::{json, Client, RpcApi};
 use miniscript::bitcoin::{self, ecdsa, taproot, ScriptBuf};
 use miniscript::psbt::{PsbtExt, PsbtInputExt};
-use miniscript::{Descriptor, Miniscript, Context, ToPublicKey};
+use miniscript::{Context, Descriptor, Miniscript, ToPublicKey};
 mod setup;
 
 use rand::RngCore;

src/descriptor/tr.rs

@@ -19,7 +19,7 @@ use crate::policy::Liftable;
 use crate::prelude::*;
 use crate::util::{varint_len, witness_size};
 use crate::{
-    errstr, Error, ForEachKey, Key, Satisfier, Context, Tap, ToPublicKey, TranslateErr,
+    errstr, Context, Error, ForEachKey, Key, Satisfier, Tap, ToPublicKey, TranslateErr,
     TranslatePk, Translator,
 };
 

src/interpreter/inner.rs

@@ -6,7 +6,7 @@ use bitcoin::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 use bitcoin::Witness;
 
 use super::{stack, BitcoinKey, Error, Stack};
-use crate::miniscript::context::{NoChecks, Context, SigType};
+use crate::miniscript::context::{Context, NoChecks, SigType};
 use crate::prelude::*;
 use crate::{BareCtx, ExtParams, Legacy, Miniscript, Segwitv0, Tap, ToPublicKey, Translator};
 

src/iter/mod.rs

@@ -16,7 +16,7 @@ pub use tree::{
 };
 
 use crate::sync::Arc;
-use crate::{Key, Miniscript, Context, Terminal};
+use crate::{Context, Key, Miniscript, Terminal};
 
 impl<'a, Pk: Key, Ctx: Context> TreeLike for &'a Miniscript<Pk, Ctx> {
     fn as_node(&self) -> Tree<Self> {

src/lib.rs

@@ -142,7 +142,7 @@ use bitcoin::locktime::absolute;
 pub use crate::descriptor::{DefiniteDescriptorKey, Descriptor, DescriptorPublicKey};
 pub use crate::interpreter::Interpreter;
 pub use crate::miniscript::analyzable::{AnalysisError, ExtParams};
-pub use crate::miniscript::context::{BareCtx, Legacy, Context, Segwitv0, SigType, Tap};
+pub use crate::miniscript::context::{BareCtx, Context, Legacy, Segwitv0, SigType, Tap};
 pub use crate::miniscript::decode::Terminal;
 pub use crate::miniscript::satisfy::{Preimage32, Satisfier};
 pub use crate::miniscript::{hash256, Miniscript};

src/miniscript/analyzable.rs

@@ -11,7 +11,7 @@ use core::fmt;
 use std::error;
 
 use crate::prelude::*;
-use crate::{Key, Miniscript, Context, Terminal};
+use crate::{Context, Key, Miniscript, Terminal};
 
 /// Params for parsing miniscripts that either non-sane or non-specified(experimental) in the spec.
 /// Used as a parameter [`Miniscript::from_str_ext`] and [`Miniscript::parse_with_ext`].

src/miniscript/context.rs

@@ -443,17 +443,13 @@ impl Context for Legacy {
         }
     }
 
-    fn check_local_policy_validity<Pk: Key>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ContextError> {
+    fn check_local_policy_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         // Legacy scripts permit upto 1000 stack elements, 520 bytes consensus limits
         // on P2SH size, it is not possible to reach the 1000 elements limit and hence
         // we do not check it.
         match ms.max_satisfaction_size() {
             Err(_e) => Err(ContextError::ImpossibleSatisfaction),
-            Ok(size) if size > MAX_SCRIPTSIG_SIZE => {
-                Err(ContextError::MaxScriptSigSizeExceeded)
-            }
+            Ok(size) if size > MAX_SCRIPTSIG_SIZE => Err(ContextError::MaxScriptSigSizeExceeded),
             _ => Ok(()),
         }
     }
@@ -560,9 +556,7 @@ impl Context for Segwitv0 {
         Ok(())
     }
 
-    fn check_local_policy_validity<Pk: Key>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ContextError> {
+    fn check_local_policy_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         // We don't need to know if this is actually a p2wsh as the standard satisfaction for
         // other Segwitv0 defined programs all require (much) less than 100 elements.
         // The witness script item is accounted for in max_satisfaction_witness_elements().

src/miniscript/decode.rs

@@ -284,9 +284,7 @@ impl<Pk: Key, Ctx: Context> TerminalStack<Pk, Ctx> {
 
 /// Parse a script fragment into an `Miniscript`
 #[allow(unreachable_patterns)]
-pub fn parse<Ctx: Context>(
-    tokens: &mut TokenIter,
-) -> Result<Miniscript<Ctx::Key, Ctx>, Error> {
+pub fn parse<Ctx: Context>(tokens: &mut TokenIter) -> Result<Miniscript<Ctx::Key, Ctx>, Error> {
     let mut non_term = Vec::with_capacity(tokens.len());
     let mut term = TerminalStack(Vec::with_capacity(tokens.len()));
 

src/miniscript/iter.rs

@@ -10,7 +10,7 @@ use core::ops::Deref;
 use sync::Arc;
 
 use super::decode::Terminal;
-use super::{Key, Miniscript, Context};
+use super::{Context, Key, Miniscript};
 use crate::prelude::*;
 
 /// Iterator-related extensions for [Miniscript]