Implement a json-from-wast subcommand (#1460)

* Implement a `wast2json` subcommand

This commit is an implementation of #1395 which brings wabt's
`wast2json` functionality to `wasm-tools`. This is implemented entirely
in the CLI since if using the crate it's already got all the
functionality necessary for this. Additionally this PR attempts to be
pretty close to `wast2json` from wabt in terms of structure and syntax.
The main difference is that wabt fills out the expected return types of
an operation when the operation isn't supposed to return (e.g.
`assert_trap`), but `wasm-tools` won't do that as we don't have that
information so easily available.

This is tested by adding `*.json` files to the `snapshots` directory
with example outputs from all known `*.wast` tests. Everything should be
included except for the `component-model` tests at this time which don't
have support in printing the args/results.

Closes #1395

* Fix tests on wasm

* Fix building just wast2json

* Generate the same test output on Windows

* Rename to `json-from-wast`

* Fix typo

Author: alexcrichton

.github/workflows/main.yml

@@ -157,6 +157,8 @@ jobs:
       - run: cargo check --no-default-features --features metadata
       - run: cargo check --no-default-features --features wit-smith
       - run: cargo check --no-default-features --features addr2line
+      - run: cargo check --no-default-features --features json-from-wast
+      - run: cargo check --no-default-features --features completion
       - run: cargo check --no-default-features -p wit-parser
       - run: cargo check --no-default-features -p wit-parser --features wat
       - run: cargo check --no-default-features -p wit-parser --features serde

Cargo.toml

@@ -166,13 +166,14 @@ default = [
   'wit-smith',
   'addr2line',
   'completion',
+  'json-from-wast',
 ]
 
 # Each subcommand is gated behind a feature and lists the dependencies it needs
 validate = ['dep:wasmparser', 'rayon']
 print = []
 parse = []
-smith = ['wasm-smith', 'arbitrary', 'serde', 'serde_derive', 'serde_json']
+smith = ['wasm-smith', 'arbitrary', 'dep:serde', 'dep:serde_derive', 'dep:serde_json']
 shrink = ['wasm-shrink', 'is_executable']
 mutate = ['wasm-mutate']
 dump = ['dep:wasmparser']
@@ -183,12 +184,13 @@ demangle = ['rustc-demangle', 'cpp_demangle', 'dep:wasmparser', 'wasm-encoder']
 component = [
   'wit-component',
   'wit-parser',
-  'wast',
+  'dep:wast',
   'wasm-encoder',
   'dep:wasmparser',
-  'serde_json',
+  'dep:serde_json',
 ]
-metadata = ['dep:wasmparser', 'wasm-metadata', 'serde_json']
+metadata = ['dep:wasmparser', 'wasm-metadata', 'dep:serde_json']
 wit-smith = ['dep:wit-smith', 'arbitrary']
 addr2line = ['dep:addr2line', 'dep:gimli', 'dep:wasmparser']
 completion = ['dep:clap_complete']
+json-from-wast = ['dep:serde_derive', 'dep:serde_json', 'dep:wast', 'dep:serde']

README.md

@@ -142,6 +142,7 @@ that can be use programmatically as well:
 | `wasm-tools metadata add` |  | Add name or producer metadata to a component or module |
 | `wasm-tools addr2line` |  | Translate wasm offsets to filename/line numbers with DWARF |
 | `wasm-tools completion` |  | Generate shell completion scripts for `wasm-tools` |
+| `wasm-tools json-from-wast` |  | Convert a `*.wast` file into JSON commands |
 
 [wasmparser]: https://crates.io/crates/wasmparser
 [wat]: https://crates.io/crates/wat

crates/wast/src/core/wast.rs

@@ -151,7 +151,7 @@ impl Peek for WastRetCore<'_> {
 }
 
 /// Either a NaN pattern (`nan:canonical`, `nan:arithmetic`) or a value of type `T`.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 #[allow(missing_docs)]
 pub enum NanPattern<T> {
     CanonicalNan,

crates/wast/src/wast.rs

@@ -113,8 +113,7 @@ impl WastDirective<'_> {
     /// Returns the location in the source that this directive was defined at
     pub fn span(&self) -> Span {
         match self {
-            WastDirective::Wat(QuoteWat::Wat(Wat::Module(m))) => m.span,
-            WastDirective::Wat(QuoteWat::Wat(Wat::Component(c))) => c.span,
+            WastDirective::Wat(QuoteWat::Wat(w)) => w.span(),
             WastDirective::Wat(QuoteWat::QuoteModule(span, _)) => *span,
             WastDirective::Wat(QuoteWat::QuoteComponent(span, _)) => *span,
             WastDirective::AssertMalformed { span, .. }
@@ -219,11 +218,23 @@ pub enum WastExecute<'a> {
     Invoke(WastInvoke<'a>),
     Wat(Wat<'a>),
     Get {
+        span: Span,
         module: Option<Id<'a>>,
         global: &'a str,
     },
 }
 
+impl<'a> WastExecute<'a> {
+    /// Returns the first span for this execute statement.
+    pub fn span(&self) -> Span {
+        match self {
+            WastExecute::Invoke(i) => i.span,
+            WastExecute::Wat(i) => i.span(),
+            WastExecute::Get { span, .. } => *span,
+        }
+    }
+}
+
 impl<'a> Parse<'a> for WastExecute<'a> {
     fn parse(parser: Parser<'a>) -> Result<Self> {
         let mut l = parser.lookahead1();
@@ -232,8 +243,9 @@ impl<'a> Parse<'a> for WastExecute<'a> {
         } else if l.peek::<kw::module>()? || l.peek::<kw::component>()? {
             Ok(WastExecute::Wat(parse_wat(parser)?))
         } else if l.peek::<kw::get>()? {
-            parser.parse::<kw::get>()?;
+            let span = parser.parse::<kw::get>()?.0;
             Ok(WastExecute::Get {
+                span,
                 module: parser.parse()?,
                 global: parser.parse()?,
             })
@@ -296,28 +308,47 @@ impl QuoteWat<'_> {
     /// Encodes this module to bytes, either by encoding the module directly or
     /// parsing the contents and then encoding it.
     pub fn encode(&mut self) -> Result<Vec<u8>, Error> {
+        match self.to_test()? {
+            QuoteWatTest::Binary(bytes) => Ok(bytes),
+            QuoteWatTest::Text(text) => {
+                let text = std::str::from_utf8(&text).map_err(|_| {
+                    let span = self.span();
+                    Error::new(span, "malformed UTF-8 encoding".to_string())
+                })?;
+                let buf = ParseBuffer::new(&text)?;
+                let mut wat = parser::parse::<Wat<'_>>(&buf)?;
+                wat.encode()
+            }
+        }
+    }
+
+    /// Converts this to either a `QuoteWatTest::Binary` or
+    /// `QuoteWatTest::Text` depending on what it is internally.
+    pub fn to_test(&mut self) -> Result<QuoteWatTest, Error> {
         let (source, prefix) = match self {
-            QuoteWat::Wat(m) => return m.encode(),
+            QuoteWat::Wat(m) => return m.encode().map(QuoteWatTest::Binary),
             QuoteWat::QuoteModule(_, source) => (source, None),
             QuoteWat::QuoteComponent(_, source) => (source, Some("(component")),
         };
-        let mut ret = String::new();
-        for (span, src) in source {
-            match std::str::from_utf8(src) {
-                Ok(s) => ret.push_str(s),
-                Err(_) => {
-                    return Err(Error::new(*span, "malformed UTF-8 encoding".to_string()));
-                }
-            }
-            ret.push(' ');
+        let mut ret = Vec::new();
+        for (_, src) in source {
+            ret.extend_from_slice(src);
+            ret.push(b' ');
         }
         if let Some(prefix) = prefix {
-            ret.insert_str(0, prefix);
-            ret.push(')');
+            ret.splice(0..0, prefix.as_bytes().iter().copied());
+            ret.push(b')');
+        }
+        Ok(QuoteWatTest::Text(ret))
+    }
+
+    /// Returns the defining span of this module.
+    pub fn span(&self) -> Span {
+        match self {
+            QuoteWat::Wat(w) => w.span(),
+            QuoteWat::QuoteModule(span, _) => *span,
+            QuoteWat::QuoteComponent(span, _) => *span,
         }
-        let buf = ParseBuffer::new(&ret)?;
-        let mut wat = parser::parse::<Wat<'_>>(&buf)?;
-        wat.encode()
     }
 }
 
@@ -345,6 +376,14 @@ impl<'a> Parse<'a> for QuoteWat<'a> {
     }
 }
 
+/// Returned from [`QuoteWat::to_test`].
+#[allow(missing_docs)]
+#[derive(Debug)]
+pub enum QuoteWatTest {
+    Binary(Vec<u8>),
+    Text(Vec<u8>),
+}
+
 #[derive(Debug)]
 #[allow(missing_docs)]
 pub enum WastArg<'a> {

crates/wast/src/wat.rs

@@ -32,6 +32,14 @@ impl Wat<'_> {
             Wat::Component(c) => c.encode(),
         }
     }
+
+    /// Returns the defining span of this file.
+    pub fn span(&self) -> Span {
+        match self {
+            Wat::Module(m) => m.span,
+            Wat::Component(c) => c.span,
+        }
+    }
 }
 
 impl<'a> Parse<'a> for Wat<'a> {