Configure imports_granularity

Configure `imports_granularity = "Module"`.

The benefit of this option is that it increases uniformity in the code
base over the default "Preserve" and also, from my personal experience,
it tends to reduce the noise in diffs from adding/removing imports.

Author: tcharding

examples/parse.rs

@@ -19,7 +19,8 @@ extern crate miniscript;
 
 use std::str::FromStr;
 
-use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
+use miniscript::descriptor::DescriptorType;
+use miniscript::{Descriptor, DescriptorTrait};
 
 fn main() {
     let my_descriptor = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(

rustfmt.toml

@@ -27,7 +27,7 @@ fn_single_line = false
 where_single_line = false
 imports_indent = "Block"
 imports_layout = "Mixed"
-imports_granularity = "Preserve"
+imports_granularity = "Module"     # Default "Preserve"
 group_imports = "StdExternalCrate" # Default "Preserve"
 reorder_imports = true
 reorder_modules = true

src/descriptor/bare.rs

@@ -18,9 +18,11 @@
 //! Also includes pk, and pkh descriptors
 //!
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
-use bitcoin::{self, blockdata::script, Script};
+use bitcoin::blockdata::script;
+use bitcoin::{self, Script};
 use expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
@@ -30,10 +32,8 @@ use {
     TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::DescriptorTrait;
 
 /// Create a Bare Descriptor. That is descriptor that is
 /// not wrapped in sh or wsh. This covers the Pk descriptor

src/descriptor/key.rs

@@ -1,14 +1,11 @@
-use std::{error, fmt, str::FromStr};
-
-use bitcoin::{
-    self,
-    hashes::Hash,
-    hashes::{hex::FromHex, HashEngine},
-    secp256k1,
-    secp256k1::{Secp256k1, Signing},
-    util::bip32,
-    XOnlyPublicKey, XpubIdentifier,
-};
+use std::str::FromStr;
+use std::{error, fmt};
+
+use bitcoin::hashes::hex::FromHex;
+use bitcoin::hashes::{Hash, HashEngine};
+use bitcoin::secp256k1::{Secp256k1, Signing};
+use bitcoin::util::bip32;
+use bitcoin::{self, secp256k1, XOnlyPublicKey, XpubIdentifier};
 use {MiniscriptKey, ToPublicKey};
 
 /// Single public key without any origin or range information

src/descriptor/mod.rs

@@ -23,20 +23,17 @@
 //! these with BIP32 paths, pay-to-contract instructions, etc.
 //!
 
-use std::{collections::HashMap, sync::Arc};
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::collections::HashMap;
+use std::fmt;
+use std::str::{self, FromStr};
+use std::sync::Arc;
 
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::{self, secp256k1, Script};
-use expression;
-use miniscript;
 use miniscript::{Legacy, Miniscript, Segwitv0};
 use {
-    BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
-    TranslatePk2,
+    expression, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier,
+    ToPublicKey, TranslatePk, TranslatePk2,
 };
 
 use self::checksum::verify_checksum;
@@ -839,10 +836,9 @@ mod tests {
     use descriptor::{
         DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePub, DescriptorXKey,
     };
-    use hex_script;
     #[cfg(feature = "compiler")]
     use policy;
-    use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+    use {hex_script, Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
 
     use super::checksum::desc_checksum;
     use super::tr::Tr;

src/descriptor/pretaproot.rs

@@ -1,12 +1,11 @@
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::fmt;
+use std::str::{self, FromStr};
 
 use bitcoin::{self, Script};
 use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
-use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
+use super::checksum::verify_checksum;
+use super::{Bare, Pkh, Sh, Wpkh, Wsh};
 
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -240,10 +239,8 @@ serde_string_impl_pk!(PreTaprootDescriptor, "a pre-taproot script descriptor");
 // Have the trait in a separate module to avoid conflicts
 pub(crate) mod traits {
     use bitcoin::Script;
-    use {
-        descriptor::{Pkh, Sh, Wpkh, Wsh},
-        DescriptorTrait, MiniscriptKey, ToPublicKey,
-    };
+    use descriptor::{Pkh, Sh, Wpkh, Wsh};
+    use {DescriptorTrait, MiniscriptKey, ToPublicKey};
 
     use super::PreTaprootDescriptor;
 

src/descriptor/segwitv0.rs

@@ -16,7 +16,8 @@
 //! Implementation of Segwit Descriptors. Contains the implementation
 //! of wsh, wpkh and sortedmulti inside wsh.
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
 use bitcoin::{self, Script};
 use expression::{self, FromTree};
@@ -28,10 +29,8 @@ use {
     TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec};
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct Wsh<Pk: MiniscriptKey> {

src/descriptor/sh.rs

@@ -18,23 +18,22 @@
 //! sh(miniscript), and sh(wpkh)
 //!
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
-use bitcoin::{self, blockdata::script, Script};
+use bitcoin::blockdata::script;
+use bitcoin::{self, Script};
 use expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
-use push_opcode_size;
 use util::{varint_len, witness_to_scriptsig};
 use {
-    Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    ToPublicKey, TranslatePk,
+    push_opcode_size, Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier,
+    Segwitv0, ToPublicKey, TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec, Wpkh, Wsh};
 
 /// A Legacy p2sh Descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]

src/descriptor/sortedmulti.rs

@@ -16,16 +16,18 @@
 //! Implementation of sorted multi primitive for descriptors
 //!
 
-use std::{fmt, marker::PhantomData, str::FromStr};
+use std::fmt;
+use std::marker::PhantomData;
+use std::str::FromStr;
 
 use bitcoin::blockdata::script;
-use expression;
-use miniscript::{
-    self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG,
+use miniscript::context::ScriptContext;
+use miniscript::decode::Terminal;
+use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
+use {
+    errstr, expression, miniscript, policy, script_num_size, Error, ForEach, ForEachKey,
+    Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
 };
-use policy;
-use script_num_size;
-use {errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Contents of a "sortedmulti" descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

src/descriptor/tr.rs

@@ -1,25 +1,25 @@
 // Tapscript
 
 use std::cmp::{self, max};
-use std::hash;
+use std::str::FromStr;
 use std::sync::{Arc, Mutex};
-use std::{fmt, str::FromStr};
+use std::{fmt, hash};
 
 use bitcoin::blockdata::opcodes;
 use bitcoin::util::taproot::{
     LeafVersion, TaprootBuilder, TaprootBuilderError, TaprootSpendInfo, TAPROOT_CONTROL_BASE_SIZE,
     TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE,
 };
 use bitcoin::{self, secp256k1, Script};
-use errstr;
 use expression::{self, FromTree};
 use miniscript::Miniscript;
 use policy::semantic::Policy;
 use policy::Liftable;
 use util::{varint_len, witness_size};
-use Tap;
-use {DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
-use {Error, MiniscriptKey};
+use {
+    errstr, DescriptorTrait, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, Tap,
+    ToPublicKey, TranslatePk,
+};
 
 use super::checksum::{desc_checksum, verify_checksum};
 

src/expression.rs

@@ -17,9 +17,7 @@
 
 use std::str::FromStr;
 
-use errstr;
-use Error;
-use MAX_RECURSION_DEPTH;
+use {errstr, Error, MAX_RECURSION_DEPTH};
 
 #[derive(Debug)]
 /// A token of the form `x(...)` or `x`

src/interpreter/error.rs

@@ -14,7 +14,8 @@
 
 use std::{error, fmt};
 
-use bitcoin::hashes::{hash160, hex::ToHex};
+use bitcoin::hashes::hash160;
+use bitcoin::hashes::hex::ToHex;
 use bitcoin::util::taproot;
 use bitcoin::{self, secp256k1};
 

src/interpreter/inner.rs

@@ -12,13 +12,11 @@
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
 
-use bitcoin;
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::hashes::{hash160, sha256, Hash};
 use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 use miniscript::context::{NoChecks, ScriptContext};
-use {BareCtx, Legacy, Segwitv0, Tap};
-use {Miniscript, MiniscriptKey};
+use {bitcoin, BareCtx, Legacy, Miniscript, MiniscriptKey, Segwitv0, Tap};
 
 use super::{stack, BitcoinKey, Error, Stack, TypedHash160};
 

src/interpreter/mod.rs

@@ -29,9 +29,7 @@ use bitcoin::util::{sighash, taproot};
 use bitcoin::{self, secp256k1, TxOut};
 use miniscript::context::NoChecks;
 use miniscript::ScriptContext;
-use Miniscript;
-use Terminal;
-use {Descriptor, ToPublicKey};
+use {Descriptor, Miniscript, Terminal, ToPublicKey};
 
 mod error;
 mod inner;
@@ -1030,13 +1028,10 @@ fn verify_sersig<'txin>(
 #[cfg(test)]
 mod tests {
 
-    use bitcoin;
     use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
     use bitcoin::secp256k1::{self, Secp256k1};
     use miniscript::context::NoChecks;
-    use Miniscript;
-    use MiniscriptKey;
-    use ToPublicKey;
+    use {bitcoin, Miniscript, MiniscriptKey, ToPublicKey};
 
     use super::inner::ToNoChecks;
     use super::*;

src/lib.rs

@@ -121,7 +121,8 @@ use std::{error, fmt, hash, str};
 
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, sha256, Hash};
-pub use descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
+pub use descriptor::pretaproot::traits::PreTaprootDescriptorTrait;
+pub use descriptor::pretaproot::PreTaprootDescriptor;
 pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 pub use interpreter::Interpreter;
 pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};

src/miniscript/analyzable.rs

@@ -20,9 +20,8 @@
 use std::collections::HashSet;
 use std::fmt;
 
-use error;
 use miniscript::iter::PkPkh;
-use {Miniscript, MiniscriptKey, ScriptContext};
+use {error, Miniscript, MiniscriptKey, ScriptContext};
 /// Possible reasons Miniscript guarantees can fail
 /// We currently mark Miniscript as Non-Analyzable if
 /// 1. It is unsafe(does not require a digital signature to spend it)

src/miniscript/astelem.rs

@@ -26,14 +26,14 @@ use std::{fmt, str};
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
-use errstr;
-use expression;
 use miniscript::context::SigType;
 use miniscript::types::{self, Property};
 use miniscript::ScriptContext;
-use script_num_size;
 use util::MsKeyBuilder;
-use {Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Terminal, ToPublicKey, TranslatePk};
+use {
+    errstr, expression, script_num_size, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey,
+    Terminal, ToPublicKey, TranslatePk,
+};
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
     /// Internal helper function for displaying wrapper types; returns

src/miniscript/context.rs

@@ -14,7 +14,6 @@
 
 use std::{fmt, hash};
 
-use bitcoin;
 use bitcoin::blockdata::constants::MAX_BLOCK_WEIGHT;
 use miniscript::limits::{
     MAX_OPS_PER_SCRIPT, MAX_PUBKEYS_PER_MULTISIG, MAX_SCRIPTSIG_SIZE, MAX_SCRIPT_ELEMENT_SIZE,
@@ -23,8 +22,7 @@ use miniscript::limits::{
 };
 use miniscript::types;
 use util::witness_to_scriptsig;
-use Error;
-use {Miniscript, MiniscriptKey, Terminal};
+use {bitcoin, Error, Miniscript, MiniscriptKey, Terminal};
 
 use super::decode::ParseableKey;
 

src/miniscript/decode.rs

@@ -26,13 +26,9 @@ use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
 use miniscript::lex::{Token as Tk, TokenIter};
 use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use miniscript::types::extra_props::ExtData;
-use miniscript::types::Property;
-use miniscript::types::Type;
+use miniscript::types::{Property, Type};
 use miniscript::ScriptContext;
-use Error;
-use MiniscriptKey;
-use ToPublicKey;
-use {bitcoin, Miniscript};
+use {bitcoin, Error, Miniscript, MiniscriptKey, ToPublicKey};
 
 fn return_none<T>(_: usize) -> Option<T> {
     None