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.
rust-bitcoin · May 10, 2022 · 2034c17 · 2034c17
1 parent 618017d
commit 2034c17
Show file tree

Hide file tree

Showing 30 changed files with 95 additions and 142 deletions.
diff --git a/examples/parse.rs b/examples/parse.rs
@@ -16,7 +16,8 @@
 
 use std::str::FromStr;
 
-use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
+use miniscript::descriptor::DescriptorType;
+use miniscript::{Descriptor, DescriptorTrait};
 
 fn main() {
     let desc = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(

diff --git a/rustfmt.toml b/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

diff --git a/src/descriptor/bare.rs b/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};

diff --git a/src/descriptor/key.rs b/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};
 

diff --git a/src/descriptor/mod.rs b/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
@@ -874,10 +871,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 =

diff --git a/src/descriptor/pretaproot.rs b/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

diff --git a/src/descriptor/segwitv0.rs b/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};

diff --git a/src/descriptor/sh.rs b/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

diff --git a/src/descriptor/sortedmulti.rs b/src/descriptor/sortedmulti.rs
@@ -16,18 +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 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::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, miniscript, policy, script_num_size, Error, ForEach, ForEachKey,
+    Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
 };
 
 /// Contents of a "sortedmulti" descriptor

diff --git a/src/descriptor/tr.rs b/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

diff --git a/src/expression.rs b/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`

diff --git a/src/interpreter/error.rs b/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};
 

diff --git a/src/interpreter/inner.rs b/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

diff --git a/src/interpreter/mod.rs b/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,

diff --git a/src/lib.rs b/src/lib.rs
@@ -119,7 +119,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};

diff --git a/src/miniscript/analyzable.rs b/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

diff --git a/src/miniscript/astelem.rs b/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> {

diff --git a/src/miniscript/context.rs b/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)]

diff --git a/src/miniscript/decode.rs b/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

diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs
@@ -51,8 +51,7 @@ pub use crate::miniscript::context::ScriptContext;
 use crate::miniscript::decode::Terminal;
 use crate::miniscript::types::extra_props::ExtData;
 use crate::miniscript::types::Type;
-use crate::MiniscriptKey;
-use crate::{expression, Error, ForEach, ForEachKey, ToPublicKey, TranslatePk};
+use crate::{expression, Error, ForEach, ForEachKey, MiniscriptKey, ToPublicKey, TranslatePk};
 
 #[cfg(test)]
 mod ms_tests;
@@ -479,15 +478,14 @@ mod tests {
     use bitcoin::util::taproot::TapLeafHash;
     use bitcoin::{self, secp256k1};
 
-    use super::{Miniscript, ScriptContext};
-    use super::{Segwitv0, Tap};
-    use crate::hex_script;
+    use super::{Miniscript, ScriptContext, Segwitv0, Tap};
     use crate::miniscript::types::{self, ExtData, Property, Type};
     use crate::miniscript::Terminal;
     use crate::policy::Liftable;
-    use crate::TranslatePk2;
-    use crate::{DummyKey, DummyKeyHash, MiniscriptKey, TranslatePk, TranslatePk1};
-    use crate::{Satisfier, ToPublicKey};
+    use crate::{
+        hex_script, DummyKey, DummyKeyHash, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
+        TranslatePk1, TranslatePk2,
+    };
 
     type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;
     type Tapscript = Miniscript<bitcoin::secp256k1::XOnlyPublicKey, Tap>;