Transform Jet codec towards object safety

Author: ivanlele

fuzz/fuzz_targets/decode_program.rs

@@ -11,10 +11,10 @@ fn do_test(data: &[u8]) {
     let wit_iter = BitIter::new(core::iter::repeat(0));
     if let Ok(program) = RedeemNode::<Core>::decode(prog_iter, wit_iter) {
         let mut prog_reser = Vec::<u8>::new();
-        let mut wit_reser = std::io::sink();
+        let mut wit_reser = Vec::<u8>::new();
 
-        let mut prog_w = BitWriter::from(&mut prog_reser);
-        let mut wit_w = BitWriter::from(&mut wit_reser);
+        let mut prog_w = BitWriter::from(&mut prog_reser as &mut dyn std::io::Write);
+        let mut wit_w = BitWriter::from(&mut wit_reser as &mut dyn std::io::Write);
         program
             .encode(&mut prog_w, &mut wit_w)
             .expect("encoding to vector");

src/bit_encoding/encode.rs

@@ -154,9 +154,9 @@ impl<N: node::Marker> SharingTracker<EncodeNode<'_, N>> for EncodeSharing<N> {
 /// Encode a Simplicity program to bits, without witness data.
 ///
 /// Returns the number of written bits.
-pub fn encode_program<W: io::Write, N: node::Marker>(
+pub fn encode_program<N: node::Marker>(
     program: &node::Node<N>,
-    w: &mut BitWriter<W>,
+    w: &mut BitWriter<&mut dyn io::Write>,
 ) -> io::Result<usize> {
     let iter = EncodeNode::Node(program).post_order_iter::<EncodeSharing<N>>();
 
@@ -172,9 +172,9 @@ pub fn encode_program<W: io::Write, N: node::Marker>(
 }
 
 /// Encode a node to bits.
-fn encode_node<W: io::Write, N: node::Marker>(
+fn encode_node<N: node::Marker>(
     data: PostOrderIterItem<EncodeNode<N>>,
-    w: &mut BitWriter<W>,
+    w: &mut BitWriter<&mut dyn io::Write>,
 ) -> io::Result<()> {
     // Handle Hidden nodes specially
     let node = match data.node {

src/human_encoding/named_node.rs

@@ -199,7 +199,7 @@ impl<J: Jet> NamedCommitNode<J> {
 
     /// Encode a Simplicity expression to bits without any witness data
     #[deprecated(since = "0.5.0", note = "use Self::encode_without_witness instead")]
-    pub fn encode<W: io::Write>(&self, w: &mut BitWriter<W>) -> io::Result<usize> {
+    pub fn encode(&self, w: &mut BitWriter<&mut dyn io::Write>) -> io::Result<usize> {
         let program_bits = encode::encode_program(self, w)?;
         w.flush_all()?;
         Ok(program_bits)

src/human_encoding/parse/ast.rs

@@ -495,7 +495,7 @@ fn parse_expr<J: Jet + 'static>(p: &mut Parser) -> Result<Expression<J>, ErrorSe
         Some(Token::Jet(ref name)) => {
             let jet_name = name.clone();
             p.advance();
-            let Ok(jet) = J::from_str(&jet_name[4..]) else {
+            let Ok(jet) = J::parse(&jet_name[4..]) else {
                 return Err(ErrorSet::single(position, Error::UnknownJet(jet_name)));
             };
             Ok(Expression {

src/jet/init/bitcoin.rs

@@ -1754,7 +1754,7 @@ impl Jet for Bitcoin {
         TypeName(name)
     }
 
-    fn encode<W: Write>(&self, w: &mut BitWriter<W>) -> std::io::Result<usize> {
+    fn encode(&self, w: &mut BitWriter<&mut dyn Write>) -> std::io::Result<usize> {
         let (n, len) = match self {
             Bitcoin::Verify => (0, 3),
             Bitcoin::Low1 => (8, 6),
@@ -2189,7 +2189,7 @@ impl Jet for Bitcoin {
         w.write_bits_be(n, len)
     }
 
-    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error> {
+    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error> where Self: Sized {
         decode_bits!(bits, {
             0 => {
                 0 => {
@@ -4701,6 +4701,10 @@ impl Jet for Bitcoin {
     fn cost(&self) -> Cost {
         unimplemented!("Unspecified cost of Bitcoin jets")
     }
+
+    fn parse(s: &str) -> Result<Self, crate::Error> where Self: Sized {
+        str::FromStr::from_str(s)
+    }
 }
 
 impl fmt::Display for Bitcoin {

src/jet/init/core.rs

@@ -3357,7 +3357,7 @@ impl Jet for Core {
         TypeName(name)
     }
 
-    fn encode<W: Write>(&self, w: &mut BitWriter<W>) -> std::io::Result<usize> {
+    fn encode(&self, w: &mut BitWriter<&mut dyn Write>) -> std::io::Result<usize> {
         let (n, len) = match self {
             Core::Verify => (0, 2),
             Core::Low1 => (8, 5),
@@ -3732,7 +3732,7 @@ impl Jet for Core {
         w.write_bits_be(n, len)
     }
 
-    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error> {
+    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error> where Self: Sized {
         decode_bits!(bits, {
             0 => {
                 0 => {Core::Verify},
@@ -6385,6 +6385,10 @@ impl Jet for Core {
             Core::XorXor8 => Cost::from_milliweight(86),
         }
     }
+
+    fn parse(s: &str) -> Result<Self, crate::Error> where Self: Sized {
+        str::FromStr::from_str(s)
+    }
 }
 
 impl fmt::Display for Core {

src/jet/init/elements.rs

@@ -4285,7 +4285,7 @@ impl Jet for Elements {
         TypeName(name)
     }
 
-    fn encode<W: Write>(&self, w: &mut BitWriter<W>) -> std::io::Result<usize> {
+    fn encode(&self, w: &mut BitWriter<&mut dyn Write>) -> std::io::Result<usize> {
         let (n, len) = match self {
             Elements::Verify => (0, 3),
             Elements::Low1 => (8, 6),
@@ -4763,7 +4763,7 @@ impl Jet for Elements {
         w.write_bits_be(n, len)
     }
 
-    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error> {
+    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error> where Self: Sized {
         decode_bits!(bits, {
             0 => {
                 0 => {
@@ -7894,6 +7894,10 @@ impl Jet for Elements {
             Elements::XorXor8 => Cost::from_milliweight(98),
         }
     }
+
+    fn parse(s: &str) -> Result<Self, crate::Error> where Self: Sized {
+        str::FromStr::from_str(s)
+    }
 }
 
 impl fmt::Display for Elements {

src/jet/mod.rs

@@ -80,9 +80,7 @@ pub trait JetEnvironment {
 /// Jets may read values from their _environment_.
 ///
 /// Jets are **always** leaves in a Simplicity DAG.
-pub trait Jet:
-    Copy + Eq + Ord + Hash + std::fmt::Debug + std::fmt::Display + std::str::FromStr + 'static
-{
+pub trait Jet: Copy + Eq + Ord + Hash + std::fmt::Debug + std::fmt::Display + 'static {
     /// Return the CMR of the jet.
     fn cmr(&self) -> Cmr;
 
@@ -93,13 +91,18 @@ pub trait Jet:
     fn target_ty(&self) -> TypeName;
 
     /// Encode the jet to bits.
-    fn encode<W: Write>(&self, w: &mut BitWriter<W>) -> std::io::Result<usize>;
+    fn encode(&self, w: &mut BitWriter<&mut dyn Write>) -> std::io::Result<usize>;
 
     /// Decode a jet from bits.
-    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error>;
+    fn decode<I: Iterator<Item = u8>>(bits: &mut BitIter<I>) -> Result<Self, decode::Error>
+    where
+        Self: Sized;
 
     /// Return the cost of the jet.
     fn cost(&self) -> Cost;
+
+    /// Parse a jet from a string.
+    fn parse(s: &str) -> Result<Self, crate::Error>;
 }
 
 #[cfg(test)]

src/node/commit.rs

@@ -283,7 +283,7 @@ impl<J: Jet> CommitNode<J> {
 
     /// Encode a Simplicity expression to bits without any witness data
     #[deprecated(since = "0.5.0", note = "use Self::encode_without_witness instead")]
-    pub fn encode<W: io::Write>(&self, w: &mut BitWriter<W>) -> io::Result<usize> {
+    pub fn encode(&self, w: &mut BitWriter<&mut dyn io::Write>) -> io::Result<usize> {
         let program_bits = encode::encode_program(self, w)?;
         w.flush_all()?;
         Ok(program_bits)

src/node/construct.rs

@@ -258,7 +258,7 @@ impl<'brand, J: Jet> ConstructNode<'brand, J> {
 
     /// Encode a Simplicity expression to bits, with no witness data
     #[deprecated(since = "0.5.0", note = "use Self::encode_without_witness instead")]
-    pub fn encode<W: io::Write>(&self, w: &mut BitWriter<W>) -> io::Result<usize> {
+    pub fn encode(&self, w: &mut BitWriter<&mut dyn io::Write>) -> io::Result<usize> {
         let program_bits = encode::encode_program(self, w)?;
         w.flush_all()?;
         Ok(program_bits)