remove sketchy LikelyFalse error

examples/psbt_sign_finalize.rs

@@ -7,9 +7,10 @@ use miniscript::bitcoin::consensus::encode::deserialize;
 use miniscript::bitcoin::hashes::hex::FromHex;
 use miniscript::bitcoin::psbt::{self, Psbt};
 use miniscript::bitcoin::sighash::SighashCache;
+//use miniscript::bitcoin::secp256k1; // https://github.com/rust-lang/rust/issues/121684
 use miniscript::bitcoin::{
-    self, secp256k1, transaction, Address, Amount, Network, OutPoint, PrivateKey, Script, Sequence,
-    Transaction, TxIn, TxOut,
+    transaction, Address, Amount, Network, OutPoint, PrivateKey, Script, Sequence, Transaction,
+    TxIn, TxOut,
 };
 use miniscript::psbt::{PsbtExt, PsbtInputExt};
 use miniscript::Descriptor;

examples/sign_multisig.rs

@@ -6,7 +6,7 @@ use std::collections::HashMap;
 use std::str::FromStr;
 
 use bitcoin::blockdata::witness::Witness;
-use bitcoin::{absolute, ecdsa, secp256k1, transaction, Amount, Sequence};
+use bitcoin::{absolute, ecdsa, transaction, Amount, Sequence};
 
 fn main() {
     let mut tx = spending_transaction();

examples/verify_tx.rs

@@ -5,7 +5,7 @@
 use std::str::FromStr;
 
 use miniscript::bitcoin::consensus::Decodable;
-use miniscript::bitcoin::secp256k1::{self, Secp256k1};
+use miniscript::bitcoin::secp256k1::Secp256k1;
 use miniscript::bitcoin::{absolute, sighash, Sequence};
 use miniscript::interpreter::KeySigPair;
 

src/descriptor/key.rs

@@ -1142,7 +1142,7 @@ impl Serialize for DescriptorPublicKey {
 mod test {
     use core::str::FromStr;
 
-    use bitcoin::{bip32, secp256k1};
+    use bitcoin::bip32;
     #[cfg(feature = "serde")]
     use serde_test::{assert_tokens, Token};
 

src/descriptor/mod.rs

@@ -997,25 +997,21 @@ pub(crate) use write_descriptor;
 #[cfg(test)]
 mod tests {
     use core::convert::TryFrom;
-    use core::str::FromStr;
 
     use bitcoin::blockdata::opcodes::all::{OP_CLTV, OP_CSV};
     use bitcoin::blockdata::script::Instruction;
     use bitcoin::blockdata::{opcodes, script};
     use bitcoin::hashes::hex::FromHex;
-    use bitcoin::hashes::{hash160, sha256, Hash};
+    use bitcoin::hashes::Hash;
     use bitcoin::script::PushBytes;
     use bitcoin::sighash::EcdsaSighashType;
-    use bitcoin::{self, bip32, secp256k1, PublicKey, Sequence};
+    use bitcoin::{bip32, PublicKey, Sequence};
 
     use super::checksum::desc_checksum;
-    use super::tr::Tr;
     use super::*;
-    use crate::descriptor::key::Wildcard;
-    use crate::descriptor::{DescriptorPublicKey, DescriptorXKey, SinglePub};
+    use crate::hex_script;
     #[cfg(feature = "compiler")]
     use crate::policy;
-    use crate::{hex_script, Descriptor, Error, Miniscript, Satisfier};
 
     type StdDescriptor = Descriptor<PublicKey>;
     const TEST_PK: &str = "pk(020000000000000000000000000000000000000000000000000000000000000002)";

src/descriptor/tr.rs

@@ -3,11 +3,13 @@
 use core::str::FromStr;
 use core::{cmp, fmt, hash};
 
+#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/121684
+use bitcoin::secp256k1;
 use bitcoin::taproot::{
     LeafVersion, TaprootBuilder, TaprootSpendInfo, TAPROOT_CONTROL_BASE_SIZE,
     TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE,
 };
-use bitcoin::{opcodes, secp256k1, Address, Network, ScriptBuf};
+use bitcoin::{opcodes, Address, Network, ScriptBuf};
 use sync::Arc;
 
 use super::checksum::{self, verify_checksum};

src/interpreter/error.rs

@@ -7,7 +7,9 @@ use std::error;
 
 use bitcoin::hashes::hash160;
 use bitcoin::hex::DisplayHex;
-use bitcoin::{secp256k1, taproot};
+#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/121684
+use bitcoin::secp256k1;
+use bitcoin::taproot;
 
 use super::BitcoinKey;
 use crate::prelude::*;

src/interpreter/inner.rs

@@ -398,12 +398,10 @@ mod tests {
 
     use bitcoin::blockdata::script;
     use bitcoin::hashes::hex::FromHex;
-    use bitcoin::hashes::{hash160, sha256, Hash};
     use bitcoin::script::PushBytes;
-    use bitcoin::{self, ScriptBuf};
+    use bitcoin::ScriptBuf;
 
     use super::*;
-    use crate::miniscript::analyzable::ExtParams;
 
     struct KeyTestData {
         pk_spk: bitcoin::ScriptBuf,

src/interpreter/mod.rs

@@ -1023,15 +1023,11 @@ fn verify_sersig<'txin>(
 #[cfg(test)]
 mod tests {
 
-    use bitcoin;
-    use bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
-    use bitcoin::secp256k1::{self, Secp256k1};
+    use bitcoin::secp256k1::Secp256k1;
 
     use super::inner::ToNoChecks;
     use super::*;
     use crate::miniscript::analyzable::ExtParams;
-    use crate::miniscript::context::NoChecks;
-    use crate::{Miniscript, ToPublicKey};
 
     #[allow(clippy::type_complexity)]
     fn setup_keys_sigs(

src/lib.rs

@@ -442,8 +442,6 @@ pub enum Error {
     MultiAt(String),
     /// Name of a fragment contained `@` but we were not parsing an OR
     AtOutsideOr(String),
-    /// Encountered a `l:0` which is syntactically equal to `u:0` except stupid
-    LikelyFalse,
     /// Encountered a wrapping character that we don't recognize
     UnknownWrapper(char),
     /// Parsed a miniscript and the result was not of type T
@@ -526,7 +524,6 @@ impl fmt::Display for Error {
             Error::MultiColon(ref s) => write!(f, "«{}» has multiple instances of «:»", s),
             Error::MultiAt(ref s) => write!(f, "«{}» has multiple instances of «@»", s),
             Error::AtOutsideOr(ref s) => write!(f, "«{}» contains «@» in non-or() context", s),
-            Error::LikelyFalse => write!(f, "0 is not very likely (use «u:0»)"),
             Error::UnknownWrapper(ch) => write!(f, "unknown wrapper «{}:»", ch),
             Error::NonTopLevel(ref s) => write!(f, "non-T miniscript: {}", s),
             Error::Trailing(ref s) => write!(f, "trailing tokens: {}", s),
@@ -599,7 +596,6 @@ impl error::Error for Error {
             | MultiColon(_)
             | MultiAt(_)
             | AtOutsideOr(_)
-            | LikelyFalse
             | UnknownWrapper(_)
             | NonTopLevel(_)
             | Trailing(_)

src/miniscript/astelem.rs

@@ -412,9 +412,6 @@ impl_from_tree!(
                     )
                 }
                 'l' => {
-                    if ms.node == Terminal::False {
-                        return Err(Error::LikelyFalse);
-                    }
                     unwrapped = Terminal::OrI(
                         Arc::new(Miniscript::from_ast(Terminal::False)?),
                         Arc::new(ms),

src/miniscript/iter.rs

@@ -204,9 +204,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> Iterator for PkIter<'a, Pk, Ctx>
 // dependent libraries for their own tasts based on Miniscript AST
 #[cfg(test)]
 pub mod test {
-    use bitcoin;
     use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
-    use bitcoin::secp256k1;
 
     use super::Miniscript;
     use crate::miniscript::context::Segwitv0;

src/miniscript/mod.rs

@@ -603,7 +603,7 @@ mod tests {
     use bitcoin::hashes::{hash160, sha256, Hash};
     use bitcoin::secp256k1::XOnlyPublicKey;
     use bitcoin::taproot::TapLeafHash;
-    use bitcoin::{self, secp256k1, Sequence};
+    use bitcoin::Sequence;
     use sync::Arc;
 
     use super::{Miniscript, ScriptContext, Segwitv0, Tap};

src/plan.rs

@@ -735,9 +735,7 @@ impl Assets {
 mod test {
     use std::str::FromStr;
 
-    use bitcoin::absolute::LockTime;
     use bitcoin::bip32::Xpub;
-    use bitcoin::Sequence;
 
     use super::*;
     use crate::*;

src/policy/compiler.rs

@@ -5,7 +5,6 @@
 //! Optimizing compiler from concrete policies to Miniscript
 //!
 
-use core::convert::From;
 use core::{cmp, f64, fmt, hash, mem};
 #[cfg(feature = "std")]
 use std::error;
@@ -1152,7 +1151,7 @@ mod tests {
     use core::str::FromStr;
 
     use bitcoin::blockdata::{opcodes, script};
-    use bitcoin::{self, hashes, secp256k1, Sequence};
+    use bitcoin::{hashes, Sequence};
 
     use super::*;
     use crate::miniscript::{Legacy, Segwitv0, Tap};

src/policy/concrete.rs

@@ -1146,8 +1146,6 @@ impl<Pk: MiniscriptKey> TreeLike for Arc<Policy<Pk>> {
 mod compiler_tests {
     use core::str::FromStr;
 
-    use sync::Arc;
-
     use super::*;
 
     #[test]

src/policy/mod.rs

@@ -23,7 +23,9 @@ pub use self::semantic::Policy as Semantic;
 use crate::descriptor::Descriptor;
 use crate::miniscript::{Miniscript, ScriptContext};
 use crate::sync::Arc;
-use crate::{Error, MiniscriptKey, Terminal, Vec};
+#[cfg(all(not(feature = "std"), not(test)))]
+use crate::Vec;
+use crate::{Error, MiniscriptKey, Terminal};
 
 /// Policy entailment algorithm maximum number of terminals allowed.
 const ENTAILMENT_MAX_TERMINALS: usize = 20;
@@ -245,10 +247,9 @@ mod tests {
     #[cfg(feature = "compiler")]
     use crate::descriptor::Tr;
     use crate::miniscript::context::Segwitv0;
-    use crate::miniscript::Miniscript;
     use crate::prelude::*;
     #[cfg(feature = "compiler")]
-    use crate::{descriptor::TapTree, Descriptor, Tap};
+    use crate::{descriptor::TapTree, Tap};
 
     type ConcretePol = Concrete<String>;
     type SemanticPol = Semantic<String>;

src/policy/semantic.rs

@@ -698,8 +698,6 @@ impl<Pk: MiniscriptKey> TreeLike for Arc<Policy<Pk>> {
 
 #[cfg(test)]
 mod tests {
-    use core::str::FromStr;
-
     use bitcoin::PublicKey;
 
     use super::*;

src/psbt/finalizer.rs

@@ -12,7 +12,9 @@ use core::mem;
 
 use bitcoin::hashes::hash160;
 use bitcoin::key::XOnlyPublicKey;
-use bitcoin::secp256k1::{self, Secp256k1};
+#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/121684
+use bitcoin::secp256k1;
+use bitcoin::secp256k1::Secp256k1;
 use bitcoin::sighash::Prevouts;
 use bitcoin::taproot::LeafVersion;
 use bitcoin::{PublicKey, Script, ScriptBuf, TxOut, Witness};

src/psbt/mod.rs

@@ -14,7 +14,9 @@ use std::error;
 
 use bitcoin::hashes::{hash160, sha256d, Hash};
 use bitcoin::psbt::{self, Psbt};
-use bitcoin::secp256k1::{self, Secp256k1, VerifyOnly};
+#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/121684
+use bitcoin::secp256k1;
+use bitcoin::secp256k1::{Secp256k1, VerifyOnly};
 use bitcoin::sighash::{self, SighashCache};
 use bitcoin::taproot::{self, ControlBlock, LeafVersion, TapLeafHash};
 use bitcoin::{absolute, bip32, transaction, Script, ScriptBuf, Sequence};
@@ -1403,7 +1405,7 @@ mod tests {
     use bitcoin::hashes::hex::FromHex;
     use bitcoin::key::XOnlyPublicKey;
     use bitcoin::secp256k1::PublicKey;
-    use bitcoin::{absolute, Amount, OutPoint, TxIn, TxOut};
+    use bitcoin::{Amount, OutPoint, TxIn, TxOut};
 
     use super::*;
     use crate::Miniscript;

src/test_utils.rs

@@ -7,6 +7,7 @@ use std::str::FromStr;
 
 use bitcoin::hashes::{hash160, ripemd160, sha256};
 use bitcoin::key::XOnlyPublicKey;
+#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/121684
 use bitcoin::secp256k1;
 
 use crate::miniscript::context::SigType;