Update to use edition 2018

Use `cargo fix --edition` to update the codebase to edition 2018, the
only changes made are adding `crate::` prefix to use statements.

In addition; do a bunch of manual additions of `crate::`.

Includes `integration_test` crate also.

Cargo.toml

@@ -8,6 +8,7 @@ repository = "https://github.com/rust-bitcoin/rust-miniscript/"
 description = "Miniscript: a subset of Bitcoin Script designed for analysis"
 keywords = [ "crypto", "bitcoin"]
 readme = "README.md"
+edition = "2018"
 
 [features]
 compiler = []

integration_test/src/main.rs

@@ -13,7 +13,7 @@ use bitcoincore_rpc::{Auth, Client, RpcApi};
 mod test_cpp;
 mod test_desc;
 mod test_util;
-use test_util::TestData;
+use crate::test_util::TestData;
 
 struct StdLogger;
 

src/descriptor/bare.rs

@@ -22,11 +22,11 @@ use std::{fmt, str::FromStr};
 
 use bitcoin::{self, blockdata::script, Script};
 
-use expression::{self, FromTree};
-use miniscript::context::ScriptContext;
-use policy::{semantic, Liftable};
-use util::{varint_len, witness_to_scriptsig};
-use {
+use crate::expression::{self, FromTree};
+use crate::miniscript::context::ScriptContext;
+use crate::policy::{semantic, Liftable};
+use crate::util::{varint_len, witness_to_scriptsig};
+use crate::{
     BareCtx, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
     TranslatePk,
 };

src/descriptor/checksum.rs

@@ -5,7 +5,7 @@
 
 use std::iter::FromIterator;
 
-use Error;
+use crate::Error;
 
 const INPUT_CHARSET: &str =  "0123456789()[],'/*abcdefgh@:$%{}IJKLMNOPQRSTUVWXYZ&+-.;<=>?!^_|~ijklmnopqrstuvwxyzABCDEFGH`#\"\\ ";
 const CHECKSUM_CHARSET: &str = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";

src/descriptor/key.rs

@@ -10,7 +10,7 @@ use bitcoin::{
     XOnlyPublicKey, XpubIdentifier,
 };
 
-use {MiniscriptKey, ToPublicKey};
+use crate::{MiniscriptKey, ToPublicKey};
 
 /// The descriptor pubkey, either a single pubkey or an xpub.
 #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]

src/descriptor/mod.rs

@@ -35,10 +35,10 @@ use bitcoin::util::address::WitnessVersion;
 use bitcoin::{self, secp256k1, Script};
 
 use self::checksum::verify_checksum;
-use expression;
-use miniscript;
-use miniscript::{Legacy, Miniscript, Segwitv0};
-use {
+use crate::expression;
+use crate::miniscript;
+use crate::miniscript::{Legacy, Miniscript, Segwitv0};
+use crate::{
     BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
     TranslatePk2,
 };
@@ -870,23 +870,23 @@ mod tests {
     use super::checksum::desc_checksum;
     use super::tr::Tr;
     use super::*;
+    use crate::descriptor::key::Wildcard;
+    use crate::descriptor::{DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey, SinglePub};
+    use crate::hex_script;
+    use crate::{Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
     use bitcoin::blockdata::opcodes::all::{OP_CLTV, OP_CSV};
     use bitcoin::blockdata::script::Instruction;
     use bitcoin::blockdata::{opcodes, script};
     use bitcoin::hashes::hex::{FromHex, ToHex};
     use bitcoin::hashes::{hash160, sha256};
     use bitcoin::util::bip32;
     use bitcoin::{self, secp256k1, EcdsaSighashType, PublicKey};
-    use descriptor::key::Wildcard;
-    use descriptor::{DescriptorPublicKey, DescriptorSecretKey, DescriptorXKey, SinglePub};
-    use hex_script;
     use std::cmp;
     use std::collections::HashMap;
     use std::str::FromStr;
-    use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
 
     #[cfg(feature = "compiler")]
-    use policy;
+    use crate::policy;
 
     type StdDescriptor = Descriptor<PublicKey>;
     const TEST_PK: &'static str =

src/descriptor/pretaproot.rs

@@ -6,7 +6,7 @@ use std::{
 use bitcoin::{self, Script};
 
 use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
-use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
+use crate::{expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -241,7 +241,7 @@ serde_string_impl_pk!(PreTaprootDescriptor, "a pre-taproot script descriptor");
 pub(crate) mod traits {
     use bitcoin::Script;
 
-    use {
+    use crate::{
         descriptor::{Pkh, Sh, Wpkh, Wsh},
         DescriptorTrait, MiniscriptKey, ToPublicKey,
     };

src/descriptor/segwitv0.rs

@@ -20,11 +20,11 @@ use std::{fmt, str::FromStr};
 
 use bitcoin::{self, Script};
 
-use expression::{self, FromTree};
-use miniscript::context::{ScriptContext, ScriptContextError};
-use policy::{semantic, Liftable};
-use util::varint_len;
-use {
+use crate::expression::{self, FromTree};
+use crate::miniscript::context::{ScriptContext, ScriptContextError};
+use crate::policy::{semantic, Liftable};
+use crate::util::varint_len;
+use crate::{
     Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey,
     TranslatePk,
 };

src/descriptor/sh.rs

@@ -22,12 +22,12 @@ use std::{fmt, str::FromStr};
 
 use bitcoin::{self, blockdata::script, 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 {
+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,
 };

src/descriptor/sortedmulti.rs

@@ -20,13 +20,15 @@ use std::{fmt, marker::PhantomData, str::FromStr};
 
 use bitcoin::blockdata::script;
 
-use expression;
-use miniscript::{
+use crate::expression;
+use crate::miniscript::{
     self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG,
 };
-use policy;
-use script_num_size;
-use {errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
+use crate::policy;
+use crate::script_num_size;
+use crate::{
+    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,26 +1,26 @@
 // Tapscript
 
-use policy::semantic::Policy;
-use policy::Liftable;
-use util::{varint_len, witness_size};
-use {DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
+use crate::policy::semantic::Policy;
+use crate::policy::Liftable;
+use crate::util::{varint_len, witness_size};
+use crate::{DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
 
 use super::checksum::{desc_checksum, verify_checksum};
+use crate::errstr;
+use crate::expression::{self, FromTree};
+use crate::miniscript::Miniscript;
+use crate::Tap;
+use crate::{Error, MiniscriptKey};
 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 std::cmp::{self, max};
 use std::hash;
 use std::sync::{Arc, Mutex};
 use std::{fmt, str::FromStr};
-use Tap;
-use {Error, MiniscriptKey};
 
 /// A Taproot Tree representation.
 // Hidden leaves are not yet supported in descriptor spec. Conceptually, it should
@@ -749,7 +749,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ForEachKey;
+    use crate::ForEachKey;
 
     #[test]
     fn test_for_each() {

src/expression.rs

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

src/interpreter/error.rs

@@ -60,7 +60,7 @@ pub enum Error {
     /// Last byte of this signature isn't a standard sighash type
     NonStandardSighash(Vec<u8>),
     /// Miniscript error
-    Miniscript(::Error),
+    Miniscript(crate::Error),
     /// MultiSig requires 1 extra zero element apart from the `k` signatures
     MissingExtraZeroMultiSig,
     /// Script abortion because of incorrect dissatisfaction for multisig.
@@ -173,8 +173,8 @@ impl From<bitcoin::SchnorrSigError> for Error {
 }
 
 #[doc(hidden)]
-impl From<::Error> for Error {
-    fn from(e: ::Error) -> Error {
+impl From<crate::Error> for Error {
+    fn from(e: crate::Error) -> Error {
         Error::Miniscript(e)
     }
 }

src/interpreter/inner.rs

@@ -17,11 +17,11 @@ use bitcoin::blockdata::witness::Witness;
 use bitcoin::hashes::{hash160, sha256, Hash};
 use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 
-use {BareCtx, Legacy, Segwitv0, Tap};
+use crate::{BareCtx, Legacy, Segwitv0, Tap};
 
 use super::{stack, BitcoinKey, Error, Stack, TypedHash160};
-use miniscript::context::{NoChecks, ScriptContext};
-use {Miniscript, MiniscriptKey};
+use crate::miniscript::context::{NoChecks, ScriptContext};
+use crate::{Miniscript, MiniscriptKey};
 
 /// Attempts to parse a slice as a Bitcoin public key, checking compressedness
 /// if asked to, but otherwise dropping it
@@ -58,9 +58,11 @@ fn script_from_stackelem<'a, Ctx: ScriptContext>(
         stack::Element::Push(sl) => {
             Miniscript::parse_insane(&bitcoin::Script::from(sl.to_owned())).map_err(Error::from)
         }
-        stack::Element::Satisfied => Miniscript::from_ast(::Terminal::True).map_err(Error::from),
+        stack::Element::Satisfied => {
+            Miniscript::from_ast(crate::Terminal::True).map_err(Error::from)
+        }
         stack::Element::Dissatisfied => {
-            Miniscript::from_ast(::Terminal::False).map_err(Error::from)
+            Miniscript::from_ast(crate::Terminal::False).map_err(Error::from)
         }
     }
 }

src/interpreter/mod.rs

@@ -25,19 +25,19 @@ use std::borrow::Borrow;
 use std::fmt;
 use std::str::FromStr;
 
+use crate::miniscript::context::NoChecks;
+use crate::miniscript::ScriptContext;
+use crate::Miniscript;
+use crate::Terminal;
+use crate::{Descriptor, ToPublicKey};
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
 use bitcoin::{self, secp256k1, TxOut};
-use miniscript::context::NoChecks;
-use miniscript::ScriptContext;
-use Miniscript;
-use Terminal;
-use {Descriptor, ToPublicKey};
 
 mod error;
 mod inner;
 mod stack;
 
-use MiniscriptKey;
+use crate::MiniscriptKey;
 
 pub use self::error::Error;
 use self::error::PkEvalErrInner;
@@ -444,7 +444,7 @@ impl<'txin> Interpreter<'txin> {
     /// since it cannot distinguish between sorted and unsorted multisigs (and anyway
     /// it can only see the final keys, keyorigin info is lost in serializing to Bitcoin).
     /// x-only keys are translated to [`bitcoin::PublicKey`] with 0x02 prefix.
-    pub fn inferred_descriptor(&self) -> Result<Descriptor<bitcoin::PublicKey>, ::Error> {
+    pub fn inferred_descriptor(&self) -> Result<Descriptor<bitcoin::PublicKey>, crate::Error> {
         Descriptor::from_str(&self.inferred_descriptor_string())
     }
 }
@@ -1032,13 +1032,13 @@ mod tests {
 
     use super::inner::ToNoChecks;
     use super::*;
+    use crate::miniscript::context::NoChecks;
+    use crate::Miniscript;
+    use crate::MiniscriptKey;
+    use crate::ToPublicKey;
     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;
 
     fn setup_keys_sigs(
         n: usize,

src/lib.rs

@@ -122,14 +122,14 @@ use std::{error, fmt, hash, str};
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, sha256, Hash};
 
-pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
-pub use interpreter::Interpreter;
-pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
-pub use miniscript::decode::Terminal;
-pub use miniscript::satisfy::{Preimage32, Satisfier};
-pub use miniscript::Miniscript;
+pub use crate::descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
+pub use crate::interpreter::Interpreter;
+pub use crate::miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
+pub use crate::miniscript::decode::Terminal;
+pub use crate::miniscript::satisfy::{Preimage32, Satisfier};
+pub use crate::miniscript::Miniscript;
 
-pub use descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
+pub use crate::descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
 
 ///Public key trait which can be converted to Hash type
 pub trait MiniscriptKey: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash {
@@ -556,7 +556,7 @@ pub enum Error {
     Secp(bitcoin::secp256k1::Error),
     #[cfg(feature = "compiler")]
     /// Compiler related errors
-    CompilerError(policy::compiler::CompilerError),
+    CompilerError(crate::policy::compiler::CompilerError),
     /// Errors related to policy
     PolicyError(policy::concrete::PolicyError),
     /// Errors related to lifting
@@ -730,8 +730,8 @@ impl fmt::Display for Error {
 
 #[doc(hidden)]
 #[cfg(feature = "compiler")]
-impl From<policy::compiler::CompilerError> for Error {
-    fn from(e: policy::compiler::CompilerError) -> Error {
+impl From<crate::policy::compiler::CompilerError> for Error {
+    fn from(e: crate::policy::compiler::CompilerError) -> Error {
         Error::CompilerError(e)
     }
 }