Hook up folded instructions to fuzzing (#1831)

Extend the `validate_valid_module` fuzzer to print both in folded and
non-folded form to ensure that the output binary is the same when
re-parsed by `wast`.

While here also tweak some APIs and documentation.

Author: alexcrichton

crates/wasmprinter/src/lib.rs

@@ -170,14 +170,16 @@ impl Config {
 
     /// Whether or not to print binary offsets of each item as comments in the
     /// text format whenever a newline is printed.
-    pub fn print_offsets(&mut self, print: bool) {
+    pub fn print_offsets(&mut self, print: bool) -> &mut Self {
         self.print_offsets = print;
+        self
     }
 
     /// Whether or not to print only a "skeleton" which skips function bodies,
     /// data segment contents, element segment contents, etc.
-    pub fn print_skeleton(&mut self, print: bool) {
+    pub fn print_skeleton(&mut self, print: bool) -> &mut Self {
         self.print_skeleton = print;
+        self
     }
 
     /// Assign names to all unnamed items.
@@ -190,13 +192,29 @@ impl Config {
     ///
     /// Note that if the resulting text output is converted back to binary the
     /// resulting `name` custom section will not be the same as before.
-    pub fn name_unnamed(&mut self, enable: bool) {
+    pub fn name_unnamed(&mut self, enable: bool) -> &mut Self {
         self.name_unnamed = enable;
+        self
     }
 
     /// Print instructions in folded form where possible.
-    pub fn fold_instructions(&mut self, enable: bool) {
+    ///
+    /// This will cause printing to favor the s-expression (parenthesized) form
+    /// of WebAssembly instructions. For example this output would be generated
+    /// for a simple `add` function:
+    ///
+    /// ```wasm
+    /// (module
+    ///     (func $foo (param i32 i32) (result i32)
+    ///         (i32.add
+    ///             (local.get 0)
+    ///             (local.get 1))
+    ///     )
+    /// )
+    /// ```
+    pub fn fold_instructions(&mut self, enable: bool) -> &mut Self {
         self.fold_instructions = enable;
+        self
     }
 
     /// Prints a WebAssembly binary into a `String`

fuzz/src/validate_valid_module.rs

@@ -35,38 +35,45 @@ pub fn run(u: &mut Unstructured<'_>) -> Result<()> {
         panic!("Invalid {}: {}", component_or_module, e);
     }
 
-    // After validation make sure that binary-to-text and text-to-binary
-    // transforms all work as well.
+    // Round-trip `wasm_bytes` through text and back to binary.
     let wat_string = wasmprinter::print_bytes(&wasm_bytes).unwrap_or_else(|e| {
         panic!(
             "failed first disassembly of Wasm into wat with `wasmprinter::print_bytes`: {}",
             e
         )
     });
-
     let wasm_bytes = wat::parse_str(&wat_string).unwrap_or_else(|e| {
         panic!(
             "failed to assemble wat into Wasm with `wat::parse_str`: {}",
             e
         )
     });
-    if log::log_enabled!(log::Level::Debug) {
-        log::debug!("Writing roundtripped wasm to `test2.wasm`...");
-        std::fs::write("test2.wasm", &wasm_bytes).unwrap();
-    }
+    crate::log_wasm(&wasm_bytes, &config);
 
-    let wat_string2 = wasmprinter::print_bytes(&wasm_bytes).unwrap_or_else(|e| {
+    let mut wat_string2 = String::new();
+    // Now round-trip the result one more time, but this time with "folded
+    // instructions" (e.g. s-expressions in the text format).
+    wasmprinter::Config::new()
+        .fold_instructions(true)
+        .print(
+            &wasm_bytes,
+            &mut wasmprinter::PrintFmtWrite(&mut wat_string2),
+        )
+        .unwrap_or_else(|e| {
+            panic!(
+                "failed second disassembly of Wasm into wat with `wasmprinter::print_bytes`: {}",
+                e
+            )
+        });
+    let wasm_bytes2 = wat::parse_str(&wat_string2).unwrap_or_else(|e| {
         panic!(
-            "failed second disassembly of Wasm into wat with `wasmprinter::print_bytes`: {}",
+            "failed to assemble wat into Wasm with `wat::parse_str`: {}",
             e
         )
     });
-    if log::log_enabled!(log::Level::Debug) {
-        log::debug!("Writing round tripped text format to `test2.wat`...");
-        std::fs::write("test2.wat", &wat_string2).unwrap();
-    }
+    crate::log_wasm(&wasm_bytes2, &config);
 
-    if wat_string != wat_string2 {
+    if wasm_bytes != wasm_bytes2 {
         panic!("failed to roundtrip valid module");
     }
     Ok(())