miniscript: non-recursive Display implementation

This uses the new iterator extensions to implement a `DisplayNode`
wrapper around a `Terminal` which understands that pubkeys, threshold k
values, etc., count as "children" for display purposes.

We can then embed all the alias/wrapper logic in the `as_node` method
and the new `fragment_name` method. The latter is generally useful and
ought to be public; given a fragment, it outputs its name, without
recursing but with consideration of the aliasing rules. Previously this
logic was embedded in the Terminal::condition_fmt method.

The resulting display algorithm is much easier to follow, although it
uses more lines of code (primarily in the form of large repetitive match
statements). cargo bloat shows there is a slight reduction in code size
attributed to the miniscript crate, though a slight increase in the
total code size for an example binary which basically implements the
`string_rtt` test.

I think with some effort we should be able to reduce the code size of
this algorithm. The important thing though is that it's not recursive.

The exact results are as follows (though they have limited use without
my committing the actual example program, which is a little ugly and not
generally useful).

Before:

File .text     Size      Crate Name
0.0%  0.9%   7.3KiB miniscript miniscript::miniscript::astelem::<impl miniscript::expression::FromTree for miniscript::miniscript::decode::Terminal<Pk,Ctx>>::from_tree
0.0%  0.7%   5.8KiB miniscript miniscript::miniscript::types::Type::type_check
0.0%  0.6%   4.4KiB miniscript miniscript::miniscript::types::extra_props::ExtData::threshold
0.0%  0.5%   4.0KiB miniscript <miniscript::Error as core::fmt::Display>::fmt
0.0%  0.5%   4.0KiB miniscript miniscript::miniscript::astelem::<impl miniscript::miniscript::decode::Terminal<Pk,Ctx>>::conditional_fmt
0.0%  0.5%   3.7KiB miniscript miniscript::miniscript::wrap_into_miniscript
0.0%  0.4%   3.0KiB miniscript miniscript::miniscript::types::extra_props::ExtData::or_i
0.0%  0.4%   3.0KiB miniscript <miniscript::miniscript::decode::Terminal<Pk,Ctx> as core::cmp::PartialEq>::eq
0.0%  0.3%   2.8KiB miniscript <miniscript::miniscript::types::Error as core::fmt::Display>::fmt
0.0%  0.3%   2.5KiB miniscript miniscript::expression::Tree::from_slice_delim
0.0%  0.3%   2.4KiB miniscript miniscript::miniscript::types::extra_props::ExtData::type_check
0.0%  0.3%   2.4KiB miniscript alloc::collections::btree::node::BalancingContext<K,V>::bulk_steal_left
0.0%  0.3%   2.2KiB miniscript miniscript::miniscript::split_expression_name
0.0%  0.3%   2.2KiB miniscript <miniscript::Error as core::fmt::Debug>::fmt
0.0%  0.3%   2.1KiB miniscript miniscript::miniscript::types::extra_props::ExtData::and_or
0.0%  0.2%   1.9KiB miniscript miniscript::miniscript::types::extra_props::ExtData::or_b
0.0%  0.2%   1.9KiB miniscript core::slice::sort::merge
0.0%  0.2%   1.8KiB miniscript core::slice::sort::merge
0.0%  0.2%   1.8KiB miniscript core::slice::sort::merge
0.0%  0.2%   1.8KiB miniscript core::slice::sort::merge
0.7% 33.0% 262.1KiB            And 1454 smaller methods. Use -n N to show more.
0.9% 40.7% 323.2KiB            filtered data size, the file size is 34.8MiB

After:

File .text     Size      Crate Name
0.0%  0.9%   7.3KiB miniscript miniscript::miniscript::astelem::<impl miniscript::expression::FromTree for miniscript::miniscript::decode::Terminal<Pk,Ctx>>::from_tree
0.0%  0.7%   5.8KiB miniscript miniscript::miniscript::types::Type::type_check
0.0%  0.7%   5.7KiB miniscript miniscript::miniscript::display::<impl miniscript::miniscript::decode::Terminal<Pk,Ctx>>::conditional_fmt
0.0%  0.6%   4.4KiB miniscript miniscript::miniscript::types::extra_props::ExtData::threshold
0.0%  0.5%   4.3KiB miniscript <miniscript::miniscript::display::DisplayNode<Pk,Ctx> as miniscript::iter::tree::TreeLike>::as_node
0.0%  0.5%   4.0KiB miniscript <miniscript::Error as core::fmt::Display>::fmt
0.0%  0.5%   3.7KiB miniscript miniscript::miniscript::wrap_into_miniscript
0.0%  0.4%   3.0KiB miniscript miniscript::miniscript::types::extra_props::ExtData::or_i
0.0%  0.3%   2.8KiB miniscript <miniscript::miniscript::types::Error as core::fmt::Display>::fmt
0.0%  0.3%   2.5KiB miniscript miniscript::expression::Tree::from_slice_delim
0.0%  0.3%   2.4KiB miniscript miniscript::miniscript::types::extra_props::ExtData::type_check
0.0%  0.3%   2.4KiB miniscript alloc::collections::btree::node::BalancingContext<K,V>::bulk_steal_left
0.0%  0.3%   2.2KiB miniscript miniscript::miniscript::split_expression_name
0.0%  0.3%   2.2KiB miniscript <miniscript::Error as core::fmt::Debug>::fmt
0.0%  0.3%   2.1KiB miniscript miniscript::miniscript::types::extra_props::ExtData::and_or
0.0%  0.2%   1.9KiB miniscript miniscript::miniscript::types::extra_props::ExtData::or_b
0.0%  0.2%   1.9KiB miniscript core::slice::sort::merge
0.0%  0.2%   1.8KiB miniscript core::slice::sort::merge
0.0%  0.2%   1.8KiB miniscript core::slice::sort::merge
0.0%  0.2%   1.8KiB miniscript core::slice::sort::merge
0.7% 32.2% 256.3KiB            And 1423 smaller methods. Use -n N to show more.
0.9% 40.2% 320.4KiB            filtered data size, the file size is 35.2MiB

Author: apoelstra

src/miniscript/astelem.rs

@@ -7,238 +7,21 @@
 //! encoding in Bitcoin script, as well as a datatype. Full details
 //! are given on the Miniscript website.
 
-use core::fmt;
 use core::str::FromStr;
 
 use bitcoin::hashes::{hash160, Hash};
 use bitcoin::{absolute, opcodes, script};
 use sync::Arc;
 
 use crate::miniscript::context::SigType;
-use crate::miniscript::{types, ScriptContext};
+use crate::miniscript::ScriptContext;
 use crate::prelude::*;
 use crate::util::MsKeyBuilder;
 use crate::{
     expression, AbsLockTime, Error, FromStrKey, Miniscript, MiniscriptKey, RelLockTime, Terminal,
     ToPublicKey,
 };
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
-    /// Internal helper function for displaying wrapper types; returns
-    /// a character to display before the `:` as well as a reference
-    /// to the wrapped type to allow easy recursion
-    fn wrap_char(&self) -> Option<(char, &Arc<Miniscript<Pk, Ctx>>)> {
-        match *self {
-            Terminal::Alt(ref sub) => Some(('a', sub)),
-            Terminal::Swap(ref sub) => Some(('s', sub)),
-            Terminal::Check(ref sub) => Some(('c', sub)),
-            Terminal::DupIf(ref sub) => Some(('d', sub)),
-            Terminal::Verify(ref sub) => Some(('v', sub)),
-            Terminal::NonZero(ref sub) => Some(('j', sub)),
-            Terminal::ZeroNotEqual(ref sub) => Some(('n', sub)),
-            Terminal::AndV(ref sub, ref r) if r.node == Terminal::True => Some(('t', sub)),
-            Terminal::OrI(ref sub, ref r) if r.node == Terminal::False => Some(('u', sub)),
-            Terminal::OrI(ref l, ref sub) if l.node == Terminal::False => Some(('l', sub)),
-            _ => None,
-        }
-    }
-
-    fn conditional_fmt(&self, f: &mut fmt::Formatter, is_debug: bool) -> fmt::Result {
-        match *self {
-            Terminal::PkK(ref pk) => fmt_1(f, "pk_k(", pk, is_debug),
-            Terminal::PkH(ref pk) => fmt_1(f, "pk_h(", pk, is_debug),
-            Terminal::RawPkH(ref pkh) => fmt_1(f, "expr_raw_pk_h(", pkh, is_debug),
-            Terminal::After(ref t) => fmt_1(f, "after(", t, is_debug),
-            Terminal::Older(ref t) => fmt_1(f, "older(", t, is_debug),
-            Terminal::Sha256(ref h) => fmt_1(f, "sha256(", h, is_debug),
-            Terminal::Hash256(ref h) => fmt_1(f, "hash256(", h, is_debug),
-            Terminal::Ripemd160(ref h) => fmt_1(f, "ripemd160(", h, is_debug),
-            Terminal::Hash160(ref h) => fmt_1(f, "hash160(", h, is_debug),
-            Terminal::True => f.write_str("1"),
-            Terminal::False => f.write_str("0"),
-            Terminal::AndV(ref l, ref r) if r.node != Terminal::True => {
-                fmt_2(f, "and_v(", l, r, is_debug)
-            }
-            Terminal::AndB(ref l, ref r) => fmt_2(f, "and_b(", l, r, is_debug),
-            Terminal::AndOr(ref a, ref b, ref c) => {
-                if c.node == Terminal::False {
-                    fmt_2(f, "and_b(", a, b, is_debug)
-                } else {
-                    f.write_str("andor(")?;
-                    conditional_fmt(f, a, is_debug)?;
-                    f.write_str(",")?;
-                    conditional_fmt(f, b, is_debug)?;
-                    f.write_str(",")?;
-                    conditional_fmt(f, c, is_debug)?;
-                    f.write_str(")")
-                }
-            }
-            Terminal::OrB(ref l, ref r) => fmt_2(f, "or_b(", l, r, is_debug),
-            Terminal::OrD(ref l, ref r) => fmt_2(f, "or_d(", l, r, is_debug),
-            Terminal::OrC(ref l, ref r) => fmt_2(f, "or_c(", l, r, is_debug),
-            Terminal::OrI(ref l, ref r)
-                if l.node != Terminal::False && r.node != Terminal::False =>
-            {
-                fmt_2(f, "or_i(", l, r, is_debug)
-            }
-            Terminal::Thresh(ref thresh) => {
-                if is_debug {
-                    fmt::Debug::fmt(&thresh.debug("thresh", true), f)
-                } else {
-                    fmt::Display::fmt(&thresh.display("thresh", true), f)
-                }
-            }
-            Terminal::Multi(ref thresh) => {
-                if is_debug {
-                    fmt::Debug::fmt(&thresh.debug("multi", true), f)
-                } else {
-                    fmt::Display::fmt(&thresh.display("multi", true), f)
-                }
-            }
-            Terminal::MultiA(ref thresh) => {
-                if is_debug {
-                    fmt::Debug::fmt(&thresh.debug("multi_a", true), f)
-                } else {
-                    fmt::Display::fmt(&thresh.display("multi_a", true), f)
-                }
-            }
-            // wrappers
-            _ => {
-                if let Some((ch, sub)) = self.wrap_char() {
-                    if ch == 'c' {
-                        if let Terminal::PkK(ref pk) = sub.node {
-                            // alias: pk(K) = c:pk_k(K)
-                            return fmt_1(f, "pk(", pk, is_debug);
-                        } else if let Terminal::RawPkH(ref pkh) = sub.node {
-                            // `RawPkH` is currently unsupported in the descriptor spec
-                            // alias: pkh(K) = c:pk_h(K)
-                            // We temporarily display there using raw_pkh, but these descriptors
-                            // are not defined in the spec yet. These are prefixed with `expr`
-                            // in the descriptor string.
-                            // We do not support parsing these descriptors yet.
-                            return fmt_1(f, "expr_raw_pkh(", pkh, is_debug);
-                        } else if let Terminal::PkH(ref pk) = sub.node {
-                            // alias: pkh(K) = c:pk_h(K)
-                            return fmt_1(f, "pkh(", pk, is_debug);
-                        }
-                    }
-
-                    fmt::Write::write_char(f, ch)?;
-                    match sub.node.wrap_char() {
-                        None => {
-                            f.write_str(":")?;
-                        }
-                        // Add a ':' wrapper if there are other wrappers apart from c:pk_k()
-                        // tvc:pk_k() -> tv:pk()
-                        Some(('c', ms)) => match ms.node {
-                            Terminal::PkK(_) | Terminal::PkH(_) | Terminal::RawPkH(_) => {
-                                f.write_str(":")?;
-                            }
-                            _ => {}
-                        },
-                        _ => {}
-                    };
-                    if is_debug {
-                        write!(f, "{:?}", sub)
-                    } else {
-                        write!(f, "{}", sub)
-                    }
-                } else {
-                    unreachable!();
-                }
-            }
-        }
-    }
-}
-
-fn fmt_1<D: fmt::Debug + fmt::Display>(
-    f: &mut fmt::Formatter,
-    name: &str,
-    a: &D,
-    is_debug: bool,
-) -> fmt::Result {
-    f.write_str(name)?;
-    conditional_fmt(f, a, is_debug)?;
-    f.write_str(")")
-}
-fn fmt_2<D: fmt::Debug + fmt::Display>(
-    f: &mut fmt::Formatter,
-    name: &str,
-    a: &D,
-    b: &D,
-    is_debug: bool,
-) -> fmt::Result {
-    f.write_str(name)?;
-    conditional_fmt(f, a, is_debug)?;
-    f.write_str(",")?;
-    conditional_fmt(f, b, is_debug)?;
-    f.write_str(")")
-}
-fn conditional_fmt<D: fmt::Debug + fmt::Display>(
-    f: &mut fmt::Formatter,
-    data: &D,
-    is_debug: bool,
-) -> fmt::Result {
-    if is_debug {
-        fmt::Debug::fmt(data, f)
-    } else {
-        fmt::Display::fmt(data, f)
-    }
-}
-
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fn fmt_type_map(f: &mut fmt::Formatter<'_>, type_map: types::Type) -> fmt::Result {
-            f.write_str(match type_map.corr.base {
-                types::Base::B => "B",
-                types::Base::K => "K",
-                types::Base::V => "V",
-                types::Base::W => "W",
-            })?;
-            f.write_str("/")?;
-            f.write_str(match type_map.corr.input {
-                types::Input::Zero => "z",
-                types::Input::One => "o",
-                types::Input::OneNonZero => "on",
-                types::Input::Any => "",
-                types::Input::AnyNonZero => "n",
-            })?;
-            if type_map.corr.dissatisfiable {
-                f.write_str("d")?;
-            }
-            if type_map.corr.unit {
-                f.write_str("u")?;
-            }
-            f.write_str(match type_map.mall.dissat {
-                types::Dissat::None => "f",
-                types::Dissat::Unique => "e",
-                types::Dissat::Unknown => "",
-            })?;
-            if type_map.mall.safe {
-                f.write_str("s")?;
-            }
-            if type_map.mall.non_malleable {
-                f.write_str("m")?;
-            }
-            Ok(())
-        }
-
-        f.write_str("[")?;
-        if let Ok(type_map) = types::Type::type_check(self) {
-            fmt_type_map(f, type_map)?;
-        } else {
-            f.write_str("TYPECHECK FAILED")?;
-        }
-        f.write_str("]")?;
-
-        self.conditional_fmt(f, true)
-    }
-}
-
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.conditional_fmt(f, false) }
-}
-
 impl<Pk: FromStrKey, Ctx: ScriptContext> crate::expression::FromTree for Arc<Terminal<Pk, Ctx>> {
     fn from_tree(top: &expression::Tree) -> Result<Arc<Terminal<Pk, Ctx>>, Error> {
         Ok(Arc::new(expression::FromTree::from_tree(top)?))