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.

examples/parse.rs

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

examples/sign_multisig.rs

@@ -17,11 +17,10 @@
 use std::collections::HashMap;
 use std::str::FromStr;
 
-use bitcoin;
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::secp256k1; // secp256k1 re-exported from rust-bitcoin
-use miniscript;
 use miniscript::DescriptorTrait;
+use {bitcoin, miniscript};
 
 fn main() {
     // Avoid repeatedly typing a pretty-common descriptor type

examples/verify_tx.rs

@@ -16,12 +16,11 @@
 
 use std::str::FromStr;
 
-use bitcoin;
 use bitcoin::consensus::Decodable;
 use bitcoin::util::sighash;
 use bitcoin::{secp256k1, TxOut}; // secp256k1 re-exported from rust-bitcoin
-use miniscript;
 use miniscript::interpreter::KeySigPair;
+use {bitcoin, miniscript};
 
 fn main() {
     // tx `f27eba163c38ad3f34971198687a3f1882b7ec818599ffe469a8440d82261c98`

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,14 +18,14 @@
 //! 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 super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::DescriptorTrait;
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};

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 crate::{MiniscriptKey, ToPublicKey};
 

src/descriptor/mod.rs

@@ -23,24 +23,21 @@
 //! these with BIP32 paths, pay-to-contract instructions, etc.
 //!
 
+use std::collections::HashMap;
+use std::fmt;
 use std::ops::Range;
-use std::{collections::HashMap, sync::Arc};
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::str::{self, FromStr};
+use std::sync::Arc;
 
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::util::address::WitnessVersion;
 use bitcoin::{self, secp256k1, Script};
 
 use self::checksum::verify_checksum;
-use crate::expression;
-use crate::miniscript;
 use crate::miniscript::{Legacy, Miniscript, Segwitv0};
 use crate::{
-    BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
-    TranslatePk2,
+    expression, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier,
+    ToPublicKey, TranslatePk, TranslatePk2,
 };
 
 // Directly export from lib.rs, exporting the trait here causes conflicts in this file
@@ -884,10 +881,9 @@ mod tests {
     use super::*;
     use crate::descriptor::key::Wildcard;
     use crate::descriptor::{DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey, SinglePub};
-    use crate::hex_script;
     #[cfg(feature = "compiler")]
     use crate::policy;
-    use crate::{Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+    use crate::{hex_script, Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
 
     type StdDescriptor = Descriptor<PublicKey>;
     const TEST_PK: &'static str =

src/descriptor/pretaproot.rs

@@ -1,11 +1,10 @@
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::fmt;
+use std::str::{self, FromStr};
 
 use bitcoin::{self, Script};
 
-use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
+use super::checksum::verify_checksum;
+use super::{Bare, Pkh, Sh, Wpkh, Wsh};
 use crate::{expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Script descriptor
@@ -242,10 +241,8 @@ pub(crate) mod traits {
     use bitcoin::Script;
 
     use super::PreTaprootDescriptor;
-    use crate::{
-        descriptor::{Pkh, Sh, Wpkh, Wsh},
-        DescriptorTrait, MiniscriptKey, ToPublicKey,
-    };
+    use crate::descriptor::{Pkh, Sh, Wpkh, Wsh};
+    use crate::{DescriptorTrait, MiniscriptKey, ToPublicKey};
 
     /// A general trait for Pre taproot bitcoin descriptor.
     /// Similar to [`DescriptorTrait`], but `explicit_script` and `script_code` methods cannot fail

src/descriptor/segwitv0.rs

@@ -16,14 +16,13 @@
 //! 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 super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::{ScriptContext, ScriptContextError};
 use crate::policy::{semantic, Liftable};

src/descriptor/sh.rs

@@ -18,22 +18,21 @@
 //! 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 super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec, Wpkh, Wsh};
 use crate::expression::{self, FromTree};
 use crate::miniscript::context::ScriptContext;
 use crate::policy::{semantic, Liftable};
-use crate::push_opcode_size;
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    ToPublicKey, TranslatePk,
+    push_opcode_size, Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier,
+    Segwitv0, ToPublicKey, TranslatePk,
 };
 
 /// A Legacy p2sh Descriptor

src/descriptor/sortedmulti.rs

@@ -16,18 +16,19 @@
 //! 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 crate::expression;
-use crate::miniscript::{
-    self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG,
-};
-use crate::policy;
-use crate::script_num_size;
+use crate::miniscript::self;
+use crate::miniscript::context::ScriptContext;
+use crate::miniscript::decode::Terminal;
+use crate::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use crate::{
-    errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
+    errstr, expression, policy, script_num_size, Error, ForEach, ForEachKey, Miniscript,
+    MiniscriptKey, Satisfier, ToPublicKey,
 };
 
 /// Contents of a "sortedmulti" descriptor

src/descriptor/tr.rs

@@ -1,9 +1,9 @@
 // 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::{
@@ -13,15 +13,15 @@ use bitcoin::util::taproot::{
 use bitcoin::{self, secp256k1, Script};
 
 use super::checksum::{desc_checksum, verify_checksum};
-use crate::errstr;
 use crate::expression::{self, FromTree};
 use crate::miniscript::Miniscript;
 use crate::policy::semantic::Policy;
 use crate::policy::Liftable;
 use crate::util::{varint_len, witness_size};
-use crate::Tap;
-use crate::{DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
-use crate::{Error, MiniscriptKey};
+use crate::{
+    errstr, DescriptorTrait, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, Tap,
+    ToPublicKey, TranslatePk,
+};
 
 /// A Taproot Tree representation.
 // Hidden leaves are not yet supported in descriptor spec. Conceptually, it should

src/expression.rs

@@ -17,9 +17,7 @@
 
 use std::str::FromStr;
 
-use crate::errstr;
-use crate::Error;
-use crate::MAX_RECURSION_DEPTH;
+use crate::{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

@@ -19,8 +19,7 @@ use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 
 use super::{stack, BitcoinKey, Error, Stack, TypedHash160};
 use crate::miniscript::context::{NoChecks, ScriptContext};
-use crate::{BareCtx, Legacy, Segwitv0, Tap};
-use crate::{Miniscript, MiniscriptKey};
+use crate::{BareCtx, Legacy, Miniscript, MiniscriptKey, Segwitv0, Tap};
 
 /// Attempts to parse a slice as a Bitcoin public key, checking compressedness
 /// if asked to, but otherwise dropping it

src/interpreter/mod.rs

@@ -30,9 +30,7 @@ use bitcoin::{self, secp256k1, TxOut};
 
 use crate::miniscript::context::NoChecks;
 use crate::miniscript::ScriptContext;
-use crate::Miniscript;
-use crate::Terminal;
-use crate::{Descriptor, ToPublicKey};
+use crate::{Descriptor, Miniscript, Terminal, ToPublicKey};
 
 mod error;
 mod inner;
@@ -1037,9 +1035,7 @@ mod tests {
     use super::inner::ToNoChecks;
     use super::*;
     use crate::miniscript::context::NoChecks;
-    use crate::Miniscript;
-    use crate::MiniscriptKey;
-    use crate::ToPublicKey;
+    use crate::{Miniscript, MiniscriptKey, ToPublicKey};
 
     fn setup_keys_sigs(
         n: usize,

src/lib.rs

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

src/miniscript/analyzable.rs

@@ -20,9 +20,8 @@
 use std::collections::HashSet;
 use std::fmt;
 
-use crate::error;
 use crate::miniscript::iter::PkPkh;
-use crate::{Miniscript, MiniscriptKey, ScriptContext};
+use crate::{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

@@ -27,15 +27,13 @@ use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
 
-use crate::errstr;
-use crate::expression;
 use crate::miniscript::context::SigType;
 use crate::miniscript::types::{self, Property};
 use crate::miniscript::ScriptContext;
-use crate::script_num_size;
 use crate::util::MsKeyBuilder;
 use crate::{
-    Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Terminal, ToPublicKey, TranslatePk,
+    errstr, expression, script_num_size, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey,
+    Terminal, ToPublicKey, TranslatePk,
 };
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {

src/miniscript/context.rs

@@ -25,8 +25,7 @@ use crate::miniscript::limits::{
 };
 use crate::miniscript::types;
 use crate::util::witness_to_scriptsig;
-use crate::Error;
-use crate::{Miniscript, MiniscriptKey, Terminal};
+use crate::{Error, Miniscript, MiniscriptKey, Terminal};
 
 /// Error for Script Context
 #[derive(Clone, PartialEq, Eq, Debug)]

src/miniscript/decode.rs

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