Migrate execution to dynamic dispatch

fuzz/fuzz_lib/program.rs

@@ -49,8 +49,8 @@ impl Extractor<'_> {
         &mut self,
         ctx: &types::Context<'brand>,
         force_control: Option<ProgramControl>,
-    ) -> Option<Arc<ConstructNode<'brand, Core>>> {
-        type ArcNode<'brand> = Arc<ConstructNode<'brand, Core>>;
+    ) -> Option<Arc<ConstructNode<'brand>>> {
+        type ArcNode<'brand> = Arc<ConstructNode<'brand>>;
 
         let mut stack: Vec<ArcNode> = vec![];
 
@@ -165,7 +165,7 @@ impl Extractor<'_> {
                     _ => {
                         let extra_bits = usize::from(control >> 6);
                         let idx = (extra_bits << 8) + usize::from(self.extract_u8()?);
-                        stack.push(ArcNode::jet(ctx, Core::ALL[idx % Core::ALL.len()]));
+                        stack.push(ArcNode::jet(ctx, &Core::ALL[idx % Core::ALL.len()]));
                     }
                 }
             }

fuzz/fuzz_targets/c_rust_merkle.rs

@@ -36,7 +36,7 @@ fn do_test(data: &[u8]) {
 
     let prog_iter = BitIter::from(program);
     let wit_iter = BitIter::from(witness);
-    let rust_result = RedeemNode::<Elements>::decode(prog_iter, wit_iter);
+    let rust_result = RedeemNode::decode::<_, _, Elements>(prog_iter, wit_iter);
 
     match (c_result, rust_result) {
         (Ok(_), Err(e)) => panic!("C accepted code that Rust rejected: {}", e),

fuzz/fuzz_targets/decode_program.rs

@@ -9,7 +9,7 @@ fn do_test(data: &[u8]) {
 
     let prog_iter = BitIter::new(data.iter().cloned());
     let wit_iter = BitIter::new(core::iter::repeat(0));
-    if let Ok(program) = RedeemNode::<Core>::decode(prog_iter, wit_iter) {
+    if let Ok(program) = RedeemNode::decode::<_, _, Core>(prog_iter, wit_iter) {
         let mut prog_reser = Vec::<u8>::new();
         let mut wit_reser = Vec::<u8>::new();
 

fuzz/fuzz_targets/parse_human.rs

@@ -12,9 +12,9 @@ fn do_test(data: &[u8]) {
         Err(_) => return,
     };
 
-    if let Ok(program) = Forest::<Elements>::parse(s) {
+    if let Ok(program) = Forest::parse::<Elements>(s) {
         let reserialize = program.string_serialize();
-        let round_trip = Forest::<Elements>::parse(&reserialize).unwrap();
+        let round_trip = Forest::parse::<Elements>(&reserialize).unwrap();
         assert_eq!(program, round_trip);
     }
 }

fuzz/fuzz_targets/regression_286.rs

@@ -32,7 +32,7 @@ fn do_test(data: &[u8]) {
         let prog = finalized.encode_to_vec();
         //println!("{}", simplicity::bitcoin::hex::DisplayHex::as_hex(&prog));
         let prog = BitIter::from(prog);
-        let decode = CommitNode::<Core>::decode(prog).unwrap();
+        let decode = CommitNode::decode::<_, Core>(prog).unwrap();
         assert_eq!(
             finalized, decode,
             "Constructed committed LHS; encoded and decoded to get RHS",

simpcli/src/main.rs

@@ -75,9 +75,9 @@ impl Command {
     }
 }
 
-fn parse_file(name: &str) -> Result<Forest<DefaultJet>, String> {
+fn parse_file(name: &str) -> Result<Forest, String> {
     let s = fs::read_to_string(name).map_err(|e| format!("failed to read file {}: {}", name, e))?;
-    match Forest::parse(&s) {
+    match Forest::parse::<DefaultJet>(&s) {
         Ok(prog) => Ok(prog),
         Err(mut errs) => {
             errs.add_context(std::sync::Arc::from(s));
@@ -154,16 +154,16 @@ fn main() -> Result<(), String> {
             let v = simplicity::base64::Engine::decode(&STANDARD, first_arg.as_bytes())
                 .map_err(|e| format!("failed to parse base64: {}", e))?;
             let iter = BitIter::from(v.into_iter());
-            let commit =
-                CommitNode::decode(iter).map_err(|e| format!("failed to decode program: {}", e))?;
-            let prog = Forest::<DefaultJet>::from_program(commit);
+            let commit = CommitNode::decode::<_, DefaultJet>(iter)
+                .map_err(|e| format!("failed to decode program: {}", e))?;
+            let prog = Forest::from_program(commit);
             println!("{}", prog.string_serialize());
         }
         Command::Graph => {
             let v = simplicity::base64::Engine::decode(&STANDARD, first_arg.as_bytes())
                 .map_err(|e| format!("failed to parse base64: {}", e))?;
             let iter = BitIter::from(v.into_iter());
-            let commit = CommitNode::<DefaultJet>::decode(iter)
+            let commit = CommitNode::decode::<_, DefaultJet>(iter)
                 .map_err(|e| format!("failed to decode program: {}", e))?;
             println!("{}", commit.display_as_dot());
         }

src/analysis.rs

@@ -370,7 +370,7 @@ impl NodeBounds {
     }
 
     /// Node bounds for an arbitrary jet node
-    pub fn jet<J: Jet>(jet: J) -> NodeBounds {
+    pub fn jet(jet: &dyn Jet) -> NodeBounds {
         NodeBounds {
             extra_cells: 0,
             extra_frames: 0,

src/bit_encoding/bitwriter.rs

@@ -115,7 +115,6 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::jet::Core;
     use crate::node::CoreConstructible;
     use crate::types;
     use crate::ConstructNode;
@@ -124,7 +123,7 @@ mod tests {
     #[test]
     fn vec() {
         types::Context::with_context(|ctx| {
-            let program = Arc::<ConstructNode<Core>>::unit(&ctx);
+            let program = Arc::<ConstructNode>::unit(&ctx);
             let _ = write_to_vec(|w| program.encode_without_witness(w));
         })
     }

src/bit_encoding/decode.rs

@@ -21,7 +21,7 @@ use std::{cmp, error, fmt};
 
 use super::bititer::{u2, DecodeNaturalError};
 
-type ArcNode<'brand, J> = Arc<ConstructNode<'brand, J>>;
+type ArcNode<'brand> = Arc<ConstructNode<'brand>>;
 
 /// Decoding error
 #[non_exhaustive]
@@ -104,7 +104,7 @@ impl error::Error for Error {
 }
 
 #[derive(Debug)]
-enum DecodeNode<J: Jet> {
+enum DecodeNode {
     Iden,
     Unit,
     InjL(usize),
@@ -119,14 +119,14 @@ enum DecodeNode<J: Jet> {
     Witness,
     Fail(FailEntropy),
     Hidden(Cmr),
-    Jet(J),
+    Jet(Box<dyn Jet>),
     Word(Word),
 }
 
-impl<J: Jet> DagLike for (usize, &'_ [DecodeNode<J>]) {
-    type Node = DecodeNode<J>;
+impl DagLike for (usize, &'_ [DecodeNode]) {
+    type Node = DecodeNode;
 
-    fn data(&self) -> &DecodeNode<J> {
+    fn data(&self) -> &DecodeNode {
         &self.1[self.0]
     }
 
@@ -156,14 +156,14 @@ impl<J: Jet> DagLike for (usize, &'_ [DecodeNode<J>]) {
 pub fn decode_expression<'brand, I: Iterator<Item = u8>, J: Jet>(
     ctx: &types::Context<'brand>,
     bits: &mut BitIter<I>,
-) -> Result<ArcNode<'brand, J>, Error> {
-    enum Converted<'brand, J: Jet> {
-        Node(ArcNode<'brand, J>),
+) -> Result<ArcNode<'brand>, Error> {
+    enum Converted<'brand> {
+        Node(ArcNode<'brand>),
         Hidden(Cmr),
     }
     use Converted::{Hidden, Node};
-    impl<'brand, J: Jet> Converted<'brand, J> {
-        fn get(&self) -> Result<&ArcNode<'brand, J>, Error> {
+    impl<'brand> Converted<'brand> {
+        fn get(&self) -> Result<&ArcNode<'brand>, Error> {
             match self {
                 Node(arc) => Ok(arc),
                 Hidden(_) => Err(Error::HiddenNode),
@@ -176,57 +176,57 @@ pub fn decode_expression<'brand, I: Iterator<Item = u8>, J: Jet>(
 
     let mut nodes = Vec::with_capacity(cmp::min(len, 10_000));
     for _ in 0..len {
-        let new_node = decode_node(bits, nodes.len())?;
+        let new_node = decode_node::<I, J>(bits, nodes.len())?;
         nodes.push(new_node);
     }
 
     // It is a sharing violation for any hidden node to be repeated. Track them in this set.
     let mut hidden_set = HashSet::<Cmr>::new();
     // Convert the DecodeNode structure into a CommitNode structure
-    let mut converted = Vec::<Converted<J>>::with_capacity(len);
+    let mut converted = Vec::<Converted>::with_capacity(len);
     for data in (nodes.len() - 1, &nodes[..]).post_order_iter::<InternalSharing>() {
         // Check canonical order as we go
         if data.index != data.node.0 {
             return Err(Error::NotInCanonicalOrder);
         }
 
-        let new = match nodes[data.node.0] {
+        let new = match &nodes[data.node.0] {
             DecodeNode::Unit => Node(ArcNode::unit(ctx)),
             DecodeNode::Iden => Node(ArcNode::iden(ctx)),
-            DecodeNode::InjL(i) => Node(ArcNode::injl(converted[i].get()?)),
-            DecodeNode::InjR(i) => Node(ArcNode::injr(converted[i].get()?)),
-            DecodeNode::Take(i) => Node(ArcNode::take(converted[i].get()?)),
-            DecodeNode::Drop(i) => Node(ArcNode::drop_(converted[i].get()?)),
+            DecodeNode::InjL(i) => Node(ArcNode::injl(converted[*i].get()?)),
+            DecodeNode::InjR(i) => Node(ArcNode::injr(converted[*i].get()?)),
+            DecodeNode::Take(i) => Node(ArcNode::take(converted[*i].get()?)),
+            DecodeNode::Drop(i) => Node(ArcNode::drop_(converted[*i].get()?)),
             DecodeNode::Comp(i, j) => {
-                Node(ArcNode::comp(converted[i].get()?, converted[j].get()?)?)
+                Node(ArcNode::comp(converted[*i].get()?, converted[*j].get()?)?)
             }
             DecodeNode::Case(i, j) => {
                 // Case is a special case, since it uniquely is allowed to have hidden
                 // children (but only one!) in which case it becomes an assertion.
-                match (&converted[i], &converted[j]) {
+                match (&converted[*i], &converted[*j]) {
                     (Node(left), Node(right)) => Node(ArcNode::case(left, right)?),
                     (Node(left), Hidden(cmr)) => Node(ArcNode::assertl(left, *cmr)?),
                     (Hidden(cmr), Node(right)) => Node(ArcNode::assertr(*cmr, right)?),
                     (Hidden(_), Hidden(_)) => return Err(Error::BothChildrenHidden),
                 }
             }
             DecodeNode::Pair(i, j) => {
-                Node(ArcNode::pair(converted[i].get()?, converted[j].get()?)?)
+                Node(ArcNode::pair(converted[*i].get()?, converted[*j].get()?)?)
             }
-            DecodeNode::Disconnect1(i) => Node(ArcNode::disconnect(converted[i].get()?, &None)?),
+            DecodeNode::Disconnect1(i) => Node(ArcNode::disconnect(converted[*i].get()?, &None)?),
             DecodeNode::Disconnect(i, j) => Node(ArcNode::disconnect(
-                converted[i].get()?,
-                &Some(Arc::clone(converted[j].get()?)),
+                converted[*i].get()?,
+                &Some(Arc::clone(converted[*j].get()?)),
             )?),
             DecodeNode::Witness => Node(ArcNode::witness(ctx, None)),
-            DecodeNode::Fail(entropy) => Node(ArcNode::fail(ctx, entropy)),
+            DecodeNode::Fail(entropy) => Node(ArcNode::fail(ctx, *entropy)),
             DecodeNode::Hidden(cmr) => {
-                if !hidden_set.insert(cmr) {
+                if !hidden_set.insert(*cmr) {
                     return Err(Error::SharingNotMaximal);
                 }
-                Hidden(cmr)
+                Hidden(*cmr)
             }
-            DecodeNode::Jet(j) => Node(ArcNode::jet(ctx, j)),
+            DecodeNode::Jet(j) => Node(ArcNode::jet(ctx, j.as_ref())),
             DecodeNode::Word(ref w) => Node(ArcNode::const_word(ctx, w.shallow_clone())),
         };
         converted.push(new);
@@ -240,12 +240,12 @@ pub fn decode_expression<'brand, I: Iterator<Item = u8>, J: Jet>(
 fn decode_node<I: Iterator<Item = u8>, J: Jet>(
     bits: &mut BitIter<I>,
     index: usize,
-) -> Result<DecodeNode<J>, Error> {
+) -> Result<DecodeNode, Error> {
     // First bit: 1 for jets/words, 0 for normal combinators
     if bits.read_bit()? {
         // Second bit: 1 for jets, 0 for words
         if bits.read_bit()? {
-            J::decode(bits).map(|jet| DecodeNode::Jet(jet))
+            J::decode(bits).map(|jet| DecodeNode::Jet(Box::new(jet)))
         } else {
             let n = bits.read_natural(Some(32))?;
             let word = Word::from_bits(bits, n - 1)?;
@@ -321,10 +321,10 @@ mod tests {
         });
         // ...but NOT as a CommitNode
         let iter = BitIter::from(&justjet[..]);
-        CommitNode::<Core>::decode(iter).unwrap_err();
+        CommitNode::decode::<_, Core>(iter).unwrap_err();
         // ...or as a RedeemNode
         let iter = BitIter::from(&justjet[..]);
-        RedeemNode::<Core>::decode(iter, BitIter::from(&[][..])).unwrap_err();
+        RedeemNode::decode::<_, _, Core>(iter, BitIter::from(&[][..])).unwrap_err();
     }
 
     #[test]

src/bit_encoding/encode.rs

@@ -8,7 +8,6 @@
 //! to read it visually the way you can with Bitcoin Script.
 
 use crate::dag::{Dag, DagLike, PostOrderIterItem, SharingTracker};
-use crate::jet::Jet;
 use crate::node::{self, Disconnectable};
 use crate::{BitWriter, Cmr, Value};
 

src/bit_machine/limits.rs

@@ -93,9 +93,7 @@ impl LimitError {
     }
 
     /// Helper function to check every value and sum for being within bounds.
-    pub(super) fn check_program<J: crate::jet::Jet>(
-        program: &crate::RedeemNode<J>,
-    ) -> Result<(), Self> {
+    pub(super) fn check_program(program: &crate::RedeemNode) -> Result<(), Self> {
         let source_ty_width = program.arrow().source.bit_width();
         let target_ty_width = program.arrow().target.bit_width();
         let bounds = program.bounds();