Merge #567: Eliminate a bunch of recursion

67e91b9 miniscript: eliminate recursion in substitute_raw_pkh (Andrew Poelstra)
d858ffc miniscript: remove recursion from script_size (Andrew Poelstra)
8c32a19 miniscript: eliminate recursion from TranslatePk (Andrew Poelstra)
2930938 miniscript: eliminate recursion in for_each_key (Andrew Poelstra)
3c0ff73 iter: add module, copied in large from rust-simplicity (Andrew Poelstra)

Pull request description:

  This introduces a new `iter` module with facilities for iterating over tree structures, and uses it to eliminate a bunch of recursion.

  There's a lot more "obvious" work after this, so I figured I'd PR this now for review and then do followup ones if it's accepted.

  Then there's some less obvious work around getting rid of the recursion in `Expression::from_str` and tightening up the memory allocation/locality there, and some even less obvious work in improving memory allocation/locality in `Miniscript`. But even if those later stages don't work out, this is a step in the right direction because it eliminates a bunch of stack overflow vectors, and reduces the amount of code.

ACKs for top commit:
  sanket1729:
    reACK 67e91b9

Tree-SHA512: 30038e2e185f9ff5a87d32508a03db61f7de9997900ce381df3974f5dc1818402a2b444808907f5d849f7ca2f9812dd0c2f578a4fbad56ef2cd01b9382a60d70

Author: sanket1729

src/interpreter/inner.rs

@@ -380,7 +380,7 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::PublicKey, Ctx> {
             translate_hash_clone!(bitcoin::PublicKey, BitcoinKey, ());
         }
 
-        self.real_translate_pk(&mut TranslateFullPk)
+        self.translate_pk_ctx(&mut TranslateFullPk)
             .expect("Translation should succeed")
     }
 }
@@ -397,7 +397,7 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::key::XOnlyPublicKey,
 
             translate_hash_clone!(bitcoin::key::XOnlyPublicKey, BitcoinKey, ());
         }
-        self.real_translate_pk(&mut TranslateXOnlyPk)
+        self.translate_pk_ctx(&mut TranslateXOnlyPk)
             .expect("Translation should succeed")
     }
 }

src/iter/mod.rs

@@ -0,0 +1,93 @@
+// Written in 2023 by Andrew Poelstra <[email protected]>
+// SPDX-License-Identifier: CC0-1.0
+
+//! Abstract Tree Iteration
+//!
+//! This module provides functionality to treat Miniscript objects abstractly
+//! as trees, iterating over them in various orders. The iterators in this
+//! module can be used to avoid explicitly recursive algorithms.
+//!
+
+mod tree;
+
+pub use tree::{
+    PostOrderIter, PostOrderIterItem, PreOrderIter, PreOrderIterItem, Tree, TreeLike,
+    VerbosePreOrderIter,
+};
+
+use crate::sync::Arc;
+use crate::{Miniscript, MiniscriptKey, ScriptContext, Terminal};
+
+impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Miniscript<Pk, Ctx> {
+    fn as_node(&self) -> Tree<Self> {
+        match self.node {
+            Terminal::PkK(..)
+            | Terminal::PkH(..)
+            | Terminal::RawPkH(..)
+            | Terminal::After(..)
+            | Terminal::Older(..)
+            | Terminal::Sha256(..)
+            | Terminal::Hash256(..)
+            | Terminal::Ripemd160(..)
+            | Terminal::Hash160(..)
+            | Terminal::True
+            | Terminal::False
+            | Terminal::Multi(..)
+            | Terminal::MultiA(..) => Tree::Nullary,
+            Terminal::Alt(ref sub)
+            | Terminal::Swap(ref sub)
+            | Terminal::Check(ref sub)
+            | Terminal::DupIf(ref sub)
+            | Terminal::Verify(ref sub)
+            | Terminal::NonZero(ref sub)
+            | Terminal::ZeroNotEqual(ref sub) => Tree::Unary(sub),
+            Terminal::AndV(ref left, ref right)
+            | Terminal::AndB(ref left, ref right)
+            | Terminal::OrB(ref left, ref right)
+            | Terminal::OrD(ref left, ref right)
+            | Terminal::OrC(ref left, ref right)
+            | Terminal::OrI(ref left, ref right) => Tree::Binary(left, right),
+            Terminal::AndOr(ref a, ref b, ref c) => Tree::Nary(Arc::from([a.as_ref(), b, c])),
+            Terminal::Thresh(_, ref subs) => Tree::Nary(subs.iter().map(Arc::as_ref).collect()),
+        }
+    }
+}
+
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for Arc<Miniscript<Pk, Ctx>> {
+    fn as_node(&self) -> Tree<Self> {
+        match self.node {
+            Terminal::PkK(..)
+            | Terminal::PkH(..)
+            | Terminal::RawPkH(..)
+            | Terminal::After(..)
+            | Terminal::Older(..)
+            | Terminal::Sha256(..)
+            | Terminal::Hash256(..)
+            | Terminal::Ripemd160(..)
+            | Terminal::Hash160(..)
+            | Terminal::True
+            | Terminal::False
+            | Terminal::Multi(..)
+            | Terminal::MultiA(..) => Tree::Nullary,
+            Terminal::Alt(ref sub)
+            | Terminal::Swap(ref sub)
+            | Terminal::Check(ref sub)
+            | Terminal::DupIf(ref sub)
+            | Terminal::Verify(ref sub)
+            | Terminal::NonZero(ref sub)
+            | Terminal::ZeroNotEqual(ref sub) => Tree::Unary(Arc::clone(sub)),
+            Terminal::AndV(ref left, ref right)
+            | Terminal::AndB(ref left, ref right)
+            | Terminal::OrB(ref left, ref right)
+            | Terminal::OrD(ref left, ref right)
+            | Terminal::OrC(ref left, ref right)
+            | Terminal::OrI(ref left, ref right) => {
+                Tree::Binary(Arc::clone(left), Arc::clone(right))
+            }
+            Terminal::AndOr(ref a, ref b, ref c) => {
+                Tree::Nary(Arc::from([Arc::clone(a), Arc::clone(b), Arc::clone(c)]))
+            }
+            Terminal::Thresh(_, ref subs) => Tree::Nary(subs.iter().map(Arc::clone).collect()),
+        }
+    }
+}