Remove custom translation framework from wasm-mutate (#1796)

* Treat inputs uniformly in `mutate` fuzzer

Don't use cargo features to reinterpret inputs to ensure that test cases
can reproduce more easily when toggling features.

* Remove a panic in wasm-mutate

Let this fall through to the "unimplemented opcodes" section below
instead of panicking.

* Remove usage of `Translator` from peephole pass

Only used in a minor capacity, easy to transfer over.

* Share the `ReencodeResult` type in wasm-mutate

* Refactor `Elements` in `wasm-encoder`

* Add another hook in `Reencode` to process just elements
* Change the internal slices to `Cow` instead of `&[T]` to be a bit more
  flexible in terms of ownership

* Migrate const expression mutator to wasm-mutate

Mostly just updating various bits and pieces here and there.

* Remove translation framework of wasm-mutate

Now no-longer-needed.

* Reject `TryTable` in `wasm-mutate`

Returns a first-class error instead of creating an invalid module.

* Fix another panic in wasm-mutate

Fall back on empty type info instead of panicking to get the error to
crop up elsewhere for unsupported instructions.

* Fix test on historical rust

* More test fixes for older rust

Author: alexcrichton

crates/wasm-encoder/src/core/code.rs

@@ -3736,7 +3736,7 @@ impl Encode for Catch {
 /// A constant expression.
 ///
 /// Usable in contexts such as offsets or initializers.
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct ConstExpr {
     bytes: Vec<u8>,
 }

crates/wasm-encoder/src/core/elements.rs

@@ -1,4 +1,5 @@
 use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
+use std::borrow::Cow;
 
 /// An encoder for the element section.
 ///
@@ -7,6 +8,7 @@ use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
 /// # Example
 ///
 /// ```
+/// use std::borrow::Cow;
 /// use wasm_encoder::{
 ///     Elements, ElementSection, Module, TableSection, TableType,
 ///     RefType, ConstExpr
@@ -24,9 +26,9 @@ use crate::{encode_section, ConstExpr, Encode, RefType, Section, SectionId};
 /// let mut elements = ElementSection::new();
 /// let table_index = 0;
 /// let offset = ConstExpr::i32_const(42);
-/// let functions = Elements::Functions(&[
+/// let functions = Elements::Functions(Cow::Borrowed(&[
 ///     // Function indices...
-/// ]);
+/// ]));
 /// elements.active(Some(table_index), &offset, functions);
 ///
 /// let mut module = Module::new();
@@ -43,12 +45,12 @@ pub struct ElementSection {
 }
 
 /// A sequence of elements in a segment in the element section.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub enum Elements<'a> {
     /// A sequences of references to functions by their indices.
-    Functions(&'a [u32]),
+    Functions(Cow<'a, [u32]>),
     /// A sequence of reference expressions.
-    Expressions(RefType, &'a [ConstExpr]),
+    Expressions(RefType, Cow<'a, [ConstExpr]>),
 }
 
 /// An element segment's mode.
@@ -151,7 +153,7 @@ impl ElementSection {
                     ty.encode(&mut self.bytes);
                 }
                 e.len().encode(&mut self.bytes);
-                for expr in e {
+                for expr in e.iter() {
                     expr.encode(&mut self.bytes);
                 }
             }

crates/wasm-encoder/src/reencode.rs

@@ -304,6 +304,13 @@ pub trait Reencode {
         utils::parse_element(self, elements, element)
     }
 
+    fn element_items<'a>(
+        &mut self,
+        items: wasmparser::ElementItems<'a>,
+    ) -> Result<crate::Elements<'a>, Error<Self::Error>> {
+        utils::element_items(self, items)
+    }
+
     /// Parses the input `section` given from the `wasmparser` crate and adds
     /// all the exports to the `exports` section.
     fn parse_export_section(
@@ -1390,24 +1397,7 @@ pub mod utils {
         elements: &mut crate::ElementSection,
         element: wasmparser::Element<'_>,
     ) -> Result<(), Error<T::Error>> {
-        let mut funcs;
-        let mut exprs;
-        let elems = match element.items {
-            wasmparser::ElementItems::Functions(f) => {
-                funcs = Vec::new();
-                for func in f {
-                    funcs.push(reencoder.function_index(func?));
-                }
-                crate::Elements::Functions(&funcs)
-            }
-            wasmparser::ElementItems::Expressions(ty, e) => {
-                exprs = Vec::new();
-                for expr in e {
-                    exprs.push(reencoder.const_expr(expr?)?);
-                }
-                crate::Elements::Expressions(reencoder.ref_type(ty)?, &exprs)
-            }
-        };
+        let elems = reencoder.element_items(element.items)?;
         match element.kind {
             wasmparser::ElementKind::Active {
                 table_index,
@@ -1436,6 +1426,28 @@ pub mod utils {
         Ok(())
     }
 
+    pub fn element_items<'a, T: ?Sized + Reencode>(
+        reencoder: &mut T,
+        items: wasmparser::ElementItems<'a>,
+    ) -> Result<crate::Elements<'a>, Error<T::Error>> {
+        Ok(match items {
+            wasmparser::ElementItems::Functions(f) => {
+                let mut funcs = Vec::new();
+                for func in f {
+                    funcs.push(reencoder.function_index(func?));
+                }
+                crate::Elements::Functions(funcs.into())
+            }
+            wasmparser::ElementItems::Expressions(ty, e) => {
+                let mut exprs = Vec::new();
+                for expr in e {
+                    exprs.push(reencoder.const_expr(expr?)?);
+                }
+                crate::Elements::Expressions(reencoder.ref_type(ty)?, exprs.into())
+            }
+        })
+    }
+
     pub fn table_index<T: ?Sized + Reencode>(_reencoder: &mut T, table: u32) -> u32 {
         table
     }

crates/wasm-mutate/src/error.rs

@@ -101,3 +101,6 @@ pub enum ErrorKind {
 
 /// A `Result` type that is either `Ok(T)` or `Err(wasm_mutate::Error)`.
 pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+/// A `Result` type for use with `wasm_encoder::reencode`
+pub type ReencodeResult<T, E = Error> = Result<T, wasm_encoder::reencode::Error<E>>;

crates/wasm-mutate/src/mutators.rs

@@ -39,7 +39,6 @@ pub mod start;
 
 mod translate;
 pub use self::translate::Item;
-use self::translate::{DefaultTranslator, Translator};
 
 use std::borrow::Cow;
 

crates/wasm-mutate/src/mutators/codemotion/ir.rs

@@ -2,6 +2,7 @@
 use crate::{
     module::map_block_type,
     mutators::{codemotion::ir::parse_context::ParseContext, OperatorAndByteOffset},
+    Error,
 };
 use std::ops::Range;
 use wasm_encoder::{Function, Instruction};
@@ -287,6 +288,7 @@ impl AstBuilder {
                     parse_context.push_state();
                     parse_context.push_frame(State::Loop, Some(*blockty), idx);
                 }
+                Operator::TryTable { .. } => return Err(Error::no_mutations_applicable()),
                 Operator::End => {
                     if !parse_context.current_code_is_empty() {
                         parse_context.push_current_code_as_node();

crates/wasm-mutate/src/mutators/codemotion/loop_unrolling.rs

@@ -70,13 +70,10 @@ impl LoopUnrollWriter {
                 newfunc.instruction(&Instruction::Block(map_block_type(*ty)?));
                 for (idx, (op, _)) in chunk.iter().enumerate() {
                     match op {
-                        Operator::Block { .. } => {
-                            current_depth += 1;
-                        }
-                        Operator::Loop { .. } => {
-                            current_depth += 1;
-                        }
-                        Operator::If { .. } => {
+                        Operator::Block { .. }
+                        | Operator::Loop { .. }
+                        | Operator::If { .. }
+                        | Operator::TryTable { .. } => {
                             current_depth += 1;
                         }
                         Operator::End { .. } => {