Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

14 files changed, 2280 insertions, 0 deletions

diff --git a/js/src/jit-test/etc/wasm/generate-spectests/Cargo.lock b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.lock
new file mode 100644
index 0000000000..fc48ba7a55
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.lock
@@ -0,0 +1,266 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28b2cd92db5cbd74e8e5028f7e27dd7aa3090e89e4f2a197cc7c8dfb69c7063b"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "env_logger"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
+dependencies = [
+ "quick-error",
+]
+
+[[package]]
+name = "leb128"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
+
+[[package]]
+name = "libc"
+version = "0.2.96"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5600b4e6efc5421841a2138a6b082e07fe12f9aaa12783d50e5d13325b26b4fc"
+
+[[package]]
+name = "log"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+
+[[package]]
+name = "serde"
+version = "1.0.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03"
+
+[[package]]
+name = "serde_derive"
+version = "1.0.126"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a1d708c221c5a612956ef9f75b37e454e88d1f7b899fbd3a18d4252012d663"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "wasm-encoder"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4eff853c4f09eec94d76af527eddad4e9de13b11d6286a1ef7134bc30135a2b7"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-generate-spectests"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "env_logger",
+ "log",
+ "regex",
+ "serde",
+ "serde_derive",
+ "toml",
+ "wast2js",
+]
+
+[[package]]
+name = "wast"
+version = "55.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4984d3e1406571f4930ba5cf79bd70f75f41d0e87e17506e0bd19b0e5d085f05"
+dependencies = [
+ "leb128",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder",
+]
+
+[[package]]
+name = "wast2js"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "wast",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/Cargo.toml b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.toml
new file mode 100644
index 0000000000..eb28a53537
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "wasm-generate-spectests"
+version = "0.1.0"
+authors = ["Ryan Hunt <rhunt@eqrion.net>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1"
+serde = "1"
+serde_derive = "1"
+toml = "0.5.6"
+log = "0.4"
+env_logger = "0.7"
+anyhow = "1.0.19"
+wast2js = { path = "./wast2js" }
+
+[workspace]
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/README.md b/js/src/jit-test/etc/wasm/generate-spectests/README.md
new file mode 100644
index 0000000000..4423a31077
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/README.md
@@ -0,0 +1,62 @@
+# generate-spectests
+
+A tool to generate a combined testsuite for the wasm spec and all proposals.
+
+This tool tries to be as robust as possible to deal with upstream breakage, while still generating a minimal testsuite for proposals that don't change many tests.
+
+## Usage
+
+```bash
+# Configure the tests you want
+vim config.toml
+
+# Generate the tests
+# This will create a `repos/` and `tests/` in your working directory
+cargo run
+```
+
+## config.toml
+
+```toml
+# (optional) Text to add to a 'directives.txt' file put in 'js/${repo}/harness'
+harness_directive = ""
+
+# (optional) Text to add to a 'directives.txt' file put in 'js/${repo}'
+directive = ""
+
+# (optional) Tests to include even if they haven't changed with respect to their parent repository
+included_tests = ["test.wast"]
+
+# (optional) Tests to exclude
+excluded_tests = ["test.wast"]
+
+[[repos]]
+# Name of the repository
+name = "sign-extension-ops"
+
+# Url of the repository
+url = "https://github.com/WebAssembly/sign-extension-ops"
+
+# (optional) Name of the repository that is the upstream for this repository.
+# This repository will attempt to merge with this upstream when generating
+# tests. The parent repository must be specified before this repository in the
+# 'config.toml'. If you change this, you must delete the 'repos' directory
+# before generating tests again.
+parent = "spec"
+
+# (optional) Whether to skip merging with upstream, if it exists.
+skip_merge = "false"
+
+# (optional) The commit to checkout when generating tests. If not specified,
+# defaults to the latest 'origin/master'.
+commit = "df34ea92"
+
+# (optional) Text to add to a 'directives.txt' file put in 'js/{$repo}'
+directive = ""
+
+# (optional) Tests to include even if they haven't changed with respect to their parent repository
+included_tests = ["test.wast"]
+
+# (optional) Tests to exclude
+excluded_tests = ["test.wast"]
+```
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml b/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml
new file mode 100644
index 0000000000..7db5f73e43
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/config-lock.toml
@@ -0,0 +1,31 @@
+[[repos]]
+name = 'spec'
+commit = 'b1fbe1a8'
+
+[[repos]]
+name = 'threads'
+commit = '85b562cd'
+
+[[repos]]
+name = 'simd'
+commit = 'a78b98a6'
+
+[[repos]]
+name = 'exception-handling'
+commit = '76419ef8'
+
+[[repos]]
+name = 'memory64'
+commit = '8d8f532d'
+
+[[repos]]
+name = 'function-references'
+commit = 'c4eef9a8'
+
+[[repos]]
+name = 'relaxed-simd'
+commit = 'c4c9ddaf'
+
+[[repos]]
+name = 'extended-const'
+commit = 'dd72ab96'
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/config.toml b/js/src/jit-test/etc/wasm/generate-spectests/config.toml
new file mode 100644
index 0000000000..9341a70ab7
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/config.toml
@@ -0,0 +1,114 @@
+# Standard 'directives.txt' prologues for jit-tests
+harness_directive = "|jit-test| skip-if: true"
+directive = "|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js"
+
+# Failing tests across all testsuites
+excluded_tests = [
+  # false-positive windows-specific failures
+  "align.wast",
+  # bulk-memory-operations/issues/133 (data.wast:161)
+  "data.wast",
+  # memory limits can be encoded with more bytes now
+  "binary.wast",
+  "binary-leb128.wast",
+  # testing that multiple tables fail (imports.wast:309)
+  "imports.wast",
+  # bulk-memory-operations/issues/133 (linking.wast:206)
+  "linking.wast",
+  # bulk-memory-operations/issues/133 (elem.wast:142)
+  "elem.wast",
+  # test harness doesn't acquire global values correctly
+  "exports.wast",
+  # false-positive windows-specific failure
+  "memory_trap.wast",
+  # false-positive error on invalid UTF-8 custom section name (utf8-custom-section-id.wast:6)
+  "utf8-custom-section-id.wast",
+  # invalid table maximum length for web embeddings
+  "table.wast",
+  # fails after a bottom-type has been added to validation
+  "unreached-invalid.wast",
+  # argument is not wasm value
+  "^select.wast",
+]
+
+[[repos]]
+name = "spec"
+url = "https://github.com/WebAssembly/spec"
+excluded_tests = []
+directive = "; test-also=--no-avx; skip-variant-if: --no-avx, !getBuildConfiguration().x86 && !getBuildConfiguration().x64 || getBuildConfiguration().simulator"
+
+[[repos]]
+name = "threads"
+url = "https://github.com/WebAssembly/threads"
+branch = "main"
+parent = "spec"
+excluded_tests = [
+  "atomic.wast",
+  # testing that multi-value isn't implemented (func.wast:492)
+  "func.wast",
+  # testing that multi-value isn't implemented (type.wast:52)
+  "type.wast"
+]
+# Skip in WPT where we can't guard on features being enabled
+skip_wpt = true
+# Skip in jit-test when it's not enabled
+directive = "; skip-if: !wasmThreadsEnabled()"
+
+[[repos]]
+name = "exception-handling"
+url = "https://github.com/WebAssembly/exception-handling"
+branch = "main"
+parent = "spec"
+# Skip in jit-test when it's not enabled
+directive = "; --wasm-exceptions; skip-if: !wasmExceptionsEnabled()"
+excluded_tests = [
+  # This gets included due to divergence between the proposal repo and the
+  # upstream spec, it can be removed when the repo is rebased.
+  "global.wast"
+]
+
+[[repos]]
+name = "memory64"
+url = "https://github.com/mozilla-spidermonkey/memory64"
+branch = "test-cases"
+directive = "; skip-if: !wasmMemory64Enabled()"
+excluded_tests = []
+
+[[repos]]
+name = "function-references"
+url = "https://github.com/WebAssembly/function-references"
+branch = "main"
+parent = "spec"
+directive = "; --wasm-function-references; skip-if: !wasmFunctionReferencesEnabled()"
+excluded_tests = [
+  # return_call_ref not implemented
+  "return_call_ref.wast",
+  # table function elem subtyping
+  "ref_is_null.wast",
+  # cannot expose indexed reference type
+  "ref_null.wast",
+  # parameter subtyping
+  "type-equivalence.wast",
+  # NYI WasmValType.h:259
+  "table-sub.wast",
+  # unrelated
+  "tokens.wast",
+  # irrelevant
+  "simd_lane.wast",
+]
+
+[[repos]]
+name = "relaxed-simd"
+url = "https://github.com/WebAssembly/relaxed-simd"
+branch = "main"
+parent = "spec"
+directive = "; --wasm-relaxed-simd; skip-if: !wasmRelaxedSimdEnabled()"
+excluded_tests = []
+
+[[repos]]
+name = "extended-const"
+url = "https://github.com/WebAssembly/extended-const"
+branch = "main"
+parent = "spec"
+directive = "; --wasm-extended-const; skip-if: !wasmExtendedConstEnabled()"
+excluded_tests = []
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/src/main.rs b/js/src/jit-test/etc/wasm/generate-spectests/src/main.rs
new file mode 100644
index 0000000000..40f27afcc4
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/src/main.rs
@@ -0,0 +1,490 @@
+use std::env;
+use std::ffi::OsStr;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use anyhow::{bail, Result};
+use regex::{RegexSet, RegexSetBuilder};
+use serde_derive::{Deserialize, Serialize};
+use toml;
+use wast2js;
+
+use log::{debug, info, warn};
+
+// Data structures
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Config {
+    #[serde(default)]
+    harness_directive: Option<String>,
+    #[serde(default)]
+    directive: Option<String>,
+    #[serde(default)]
+    included_tests: Vec<String>,
+    #[serde(default)]
+    excluded_tests: Vec<String>,
+    repos: Vec<Repo>,
+}
+
+impl Config {
+    fn find_repo_mut(&mut self, name: &str) -> Option<&mut Repo> {
+        self.repos.iter_mut().find(|x| &x.name == name)
+    }
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Repo {
+    name: String,
+    url: String,
+    #[serde(default)]
+    branch: Option<String>,
+    #[serde(default)]
+    parent: Option<String>,
+    #[serde(default)]
+    directive: Option<String>,
+    #[serde(default)]
+    included_tests: Vec<String>,
+    #[serde(default)]
+    excluded_tests: Vec<String>,
+    #[serde(default)]
+    skip_wast: bool,
+    #[serde(default)]
+    skip_js: bool,
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct Lock {
+    repos: Vec<LockRepo>,
+}
+
+impl Lock {
+    fn find_commit(&self, name: &str) -> Option<&str> {
+        self.repos
+            .iter()
+            .find(|x| &x.name == name)
+            .map(|x| x.commit.as_ref())
+    }
+
+    fn set_commit(&mut self, name: &str, commit: &str) {
+        if let Some(lock) = self.repos.iter_mut().find(|x| &x.name == name) {
+            lock.commit = commit.to_owned();
+        } else {
+            self.repos.push(LockRepo {
+                name: name.to_owned(),
+                commit: commit.to_owned(),
+            });
+        }
+    }
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct LockRepo {
+    name: String,
+    commit: String,
+}
+
+#[derive(Debug)]
+enum Merge {
+    Standalone,
+    Merged,
+    Conflicted,
+}
+
+#[derive(Debug)]
+struct Status {
+    commit_base_hash: String,
+    commit_final_message: String,
+    merged: Merge,
+    built: bool,
+}
+
+// Roll-your-own CLI utilities
+
+fn run(name: &str, args: &[&str]) -> Result<String> {
+    debug!("{} {:?}", name, args);
+    let output = Command::new(name).args(args).output()?;
+    let stdout = String::from_utf8(output.stdout)?.trim().to_owned();
+    let stderr = String::from_utf8(output.stderr)?.trim().to_owned();
+    if !stdout.is_empty() {
+        debug!("{}", stdout);
+    }
+    if !stderr.is_empty() {
+        debug!("{}", stderr);
+    }
+
+    if output.status.success() {
+        Ok(stdout)
+    } else {
+        bail!("{}: {}\n{}", name.to_owned(), stdout, stderr)
+    }
+}
+
+fn change_dir(dir: &str) -> impl Drop {
+    #[must_use]
+    struct Reset {
+        previous: PathBuf,
+    }
+    impl Drop for Reset {
+        fn drop(&mut self) {
+            debug!("cd {}", self.previous.display());
+            env::set_current_dir(&self.previous).unwrap()
+        }
+    }
+
+    let previous = Reset {
+        previous: env::current_dir().unwrap(),
+    };
+    debug!("cd {}", dir);
+    env::set_current_dir(dir).unwrap();
+    previous
+}
+
+fn find(dir: &str) -> Vec<PathBuf> {
+    let mut paths = Vec::new();
+
+    fn find(dir: &str, paths: &mut Vec<PathBuf>) {
+        for entry in fs::read_dir(dir).unwrap().map(|x| x.unwrap()) {
+            let path = entry.path();
+
+            if entry.file_type().unwrap().is_dir() {
+                find(path.to_str().unwrap(), paths);
+            } else {
+                paths.push(path);
+            }
+        }
+    }
+
+    find(dir, &mut paths);
+    paths
+}
+
+fn write_string<P: AsRef<Path>>(path: P, text: &str) -> Result<()> {
+    let path = path.as_ref();
+    if let Some(dir) = path.parent() {
+        let _ = fs::create_dir_all(dir);
+    }
+    fs::write(path, text.as_bytes())?;
+    Ok(())
+}
+
+// The main script
+
+fn main() {
+    env_logger::init();
+
+    // Load the config
+    let mut config: Config =
+        toml::from_str(&fs::read_to_string("config.toml").expect("failed to read config.toml"))
+            .expect("invalid config.toml");
+
+    // Load the lock file, or default to no pinned commits
+    let mut lock: Lock = if Path::new("config-lock.toml").exists() {
+        toml::from_str(
+            &fs::read_to_string("config-lock.toml").expect("failed to read config-lock.toml"),
+        )
+        .expect("invalid config-lock.toml")
+    } else {
+        Lock::default()
+    };
+
+    // Clean old tests and initialize the repo if it doesn't exist
+    let specs_dir = "specs/";
+    clean_and_init_dirs(specs_dir);
+
+    // Generate the tests
+    let mut successes = Vec::new();
+    let mut failures = Vec::new();
+    {
+        // Change to the `specs/` dir where all the work happens
+        let _cd = change_dir(specs_dir);
+        for repo in &config.repos {
+            info!("Processing {:#?}", repo);
+
+            match build_repo(repo, &config, &lock) {
+                Ok(status) => successes.push((repo.name.clone(), status)),
+                Err(err) => failures.push((repo.name.clone(), err)),
+            };
+        }
+    }
+
+    // Abort if we had a failure
+    if !failures.is_empty() {
+        warn!("Failed.");
+        for (name, err) in &failures {
+            warn!("{}: (failure) {:?}", name, err);
+        }
+        std::process::exit(1);
+    }
+
+    // Display successful results
+    info!("Done.");
+    for (name, status) in &successes {
+        let repo = config.find_repo_mut(&name).unwrap();
+        lock.set_commit(&name, &status.commit_base_hash);
+
+        info!(
+            "{}: ({} {}) {}",
+            repo.name,
+            match status.merged {
+                Merge::Standalone => "standalone",
+                Merge::Merged => "merged",
+                Merge::Conflicted => "conflicted",
+            },
+            if status.built { "building" } else { "broken" },
+            status.commit_final_message.trim_end()
+        );
+    }
+
+    // Commit the new lock file
+    write_string("config-lock.toml", &toml::to_string_pretty(&lock).unwrap()).unwrap();
+}
+
+fn clean_and_init_dirs(specs_dir: &str) {
+    if !Path::new(specs_dir).exists() {
+        fs::create_dir(specs_dir).unwrap();
+        run("git", &["-C", specs_dir, "init"]).unwrap();
+    }
+
+    let _ = fs::remove_dir_all("./tests");
+}
+
+fn build_repo(repo: &Repo, config: &Config, lock: &Lock) -> Result<Status> {
+    let remote_name = &repo.name;
+    let remote_url = &repo.url;
+    let remote_branch = repo.branch.as_ref().map(|x| x.as_str()).unwrap_or("master");
+    let branch_upstream = format!("{}/{}", repo.name, remote_branch);
+    let branch_base = repo.name.clone();
+
+    // Initialize our remote and branches if they don't exist
+    let remotes = run("git", &["remote"])?;
+    if !remotes.lines().any(|x| x == repo.name) {
+        run("git", &["remote", "add", remote_name, &remote_url])?;
+        run("git", &["fetch", remote_name])?;
+        run("git", &["branch", &branch_base, &branch_upstream])?;
+    }
+
+    // Set the upstream to the correct branch
+    run(
+        "git",
+        &[
+            "branch",
+            &branch_base,
+            "--set-upstream-to",
+            &branch_upstream,
+        ],
+    )?;
+
+    // Fetch the latest changes for this repo
+    run("git", &["fetch", remote_name])?;
+
+    // Checkout the pinned commit, if any, and get the absolute commit hash
+    let base_treeish = lock.find_commit(&repo.name).unwrap_or(&branch_upstream);
+    run("git", &["checkout", &branch_base])?;
+    run("git", &["reset", base_treeish, "--hard"])?;
+    let commit_base_hash = run("git", &["log", "--pretty=%h", "-n", "1"])?
+        .trim()
+        .to_owned();
+
+    // Try to merge with parent repo, if specified
+    let merged = try_merge_parent(repo, &commit_base_hash)?;
+
+    // Exclude files specified from the config and repo
+    let mut excluded_files = Vec::new();
+    excluded_files.extend_from_slice(&config.excluded_tests);
+    excluded_files.extend_from_slice(&repo.excluded_tests);
+    let exclude = RegexSetBuilder::new(&excluded_files).build().unwrap();
+
+    // Try to build the test suite on this commit. This may fail due to merging
+    // with a parent repo, in which case we will try again in an unmerged state.
+    let mut built = false;
+    match try_build_tests(&exclude) {
+        Ok(()) => built = true,
+        Err(err) => warn!("Failed to build tests: {:?}", err),
+    };
+    // if try_build_tests(&exclude).is_err() {
+    //     if repo.parent.is_some() {
+    //         warn!(
+    //             "Failed to build interpreter. Retrying on unmerged commit ({})",
+    //             &commit_base_hash
+    //         );
+    //         run("git", &["reset", &commit_base_hash, "--hard"])?;
+    //         built = try_build_tests(&exclude).is_ok();
+    //     } else {
+    //         built = false;
+    //     }
+    // }
+    // if !built {
+    //     warn!("Failed to build interpreter, Won't emit js/html");
+    // }
+
+    // Get the final commit message we ended up on
+    let commit_final_message = run("git", &["log", "--oneline", "-n", "1"])?;
+
+    // Compute the source files that changed, and use that to filter the files
+    // we copy over. We can't compare the generated tests, because for a
+    // generated WPT we need to copy both the .js and .html even if only
+    // one of those is different from the master.
+    let tests_changed = find_tests_changed(repo)?;
+    info!("Changed tests: {:#?}", tests_changed);
+
+    // Include the changed tests, specified files, and `harness/` directory
+    let mut included_files = Vec::new();
+    included_files.extend_from_slice(&tests_changed);
+    included_files.extend_from_slice(&config.included_tests);
+    included_files.extend_from_slice(&repo.included_tests);
+    included_files.push("harness/".to_owned());
+    let include = RegexSetBuilder::new(&included_files).build().unwrap();
+
+    // Copy over all the desired test-suites
+    if !repo.skip_wast {
+        copy_tests(repo, "test/core", "../tests", "wast", &include, &exclude);
+    }
+    if built && !repo.skip_js {
+        copy_tests(repo, "js", "../tests", "js", &include, &exclude);
+        copy_directives(repo, config)?;
+    }
+
+    Ok(Status {
+        commit_final_message,
+        commit_base_hash,
+        merged,
+        built,
+    })
+}
+
+fn try_merge_parent(repo: &Repo, commit_base_hash: &str) -> Result<Merge> {
+    if !repo.parent.is_some() {
+        return Ok(Merge::Standalone);
+    }
+    let parent = repo.parent.as_ref().unwrap();
+
+    // Try to merge with the parent branch.
+    let message = format!("Merging {}:{}with {}", repo.name, commit_base_hash, parent);
+    Ok(
+        if !run("git", &["merge", "-q", parent, "-m", &message]).is_ok() {
+            // Ignore merge conflicts in the document directory.
+            if !run("git", &["checkout", "--ours", "document"]).is_ok()
+                || !run("git", &["add", "document"]).is_ok()
+                || !run("git", &["-c", "core.editor=true", "merge", "--continue"]).is_ok()
+            {
+                // Reset to master if we failed
+                warn!(
+                    "Failed to merge {}, falling back to {}.",
+                    repo.name, &commit_base_hash
+                );
+                run("git", &["merge", "--abort"])?;
+                run("git", &["reset", &commit_base_hash, "--hard"])?;
+                Merge::Conflicted
+            } else {
+                Merge::Merged
+            }
+        } else {
+            Merge::Merged
+        },
+    )
+}
+
+fn try_build_tests(exclude: &RegexSet) -> Result<()> {
+    let _ = fs::remove_dir_all("./js");
+    fs::create_dir("./js")?;
+
+    let paths = find("./test/core/");
+    for path in paths {
+        if path.extension() != Some(OsStr::new("wast")) {
+            continue;
+        }
+
+        let stripped_path = path.strip_prefix("./test/core/").unwrap();
+        let stripped_path_str = stripped_path.to_str().unwrap();
+        if exclude.is_match(stripped_path_str) {
+            continue;
+        }
+
+        let source = std::fs::read_to_string(&path)?;
+        let script = wast2js::convert(&path, &source)?;
+
+        std::fs::write(
+            Path::new("./js").join(&path.with_extension("wast.js").file_name().unwrap()),
+            &script,
+        )?;
+    }
+
+    fs::create_dir("./js/harness")?;
+    write_string("./js/harness/harness.js", &wast2js::harness())?;
+
+    Ok(())
+}
+
+fn copy_tests(
+    repo: &Repo,
+    src_dir: &str,
+    dst_dir: &str,
+    test_name: &str,
+    include: &RegexSet,
+    exclude: &RegexSet,
+) {
+    for path in find(src_dir) {
+        let stripped_path = path.strip_prefix(src_dir).unwrap();
+        let stripped_path_str = stripped_path.to_str().unwrap();
+
+        if !include.is_match(stripped_path_str) || exclude.is_match(stripped_path_str) {
+            continue;
+        }
+
+        let out_path = Path::new(dst_dir)
+            .join(test_name)
+            .join(&repo.name)
+            .join(&stripped_path);
+        let out_dir = out_path.parent().unwrap();
+        let _ = fs::create_dir_all(out_dir);
+        fs::copy(path, out_path).unwrap();
+    }
+}
+
+fn copy_directives(repo: &Repo, config: &Config) -> Result<()> {
+    // Write directives files
+    if let Some(harness_directive) = &config.harness_directive {
+        let directives_path = Path::new("../tests/js")
+            .join(&repo.name)
+            .join("harness/directives.txt");
+        write_string(&directives_path, harness_directive)?;
+    }
+    let directives = format!(
+        "{}{}",
+        config.directive.as_ref().map(|x| x.as_str()).unwrap_or(""),
+        repo.directive.as_ref().map(|x| x.as_str()).unwrap_or("")
+    );
+    if !directives.is_empty() {
+        let directives_path = Path::new("../tests/js")
+            .join(&repo.name)
+            .join("directives.txt");
+        write_string(&directives_path, &directives)?;
+    }
+    Ok(())
+}
+
+fn find_tests_changed(repo: &Repo) -> Result<Vec<String>> {
+    let files_changed = if let Some(parent) = repo.parent.as_ref() {
+        run(
+            "git",
+            &["diff", "--name-only", &repo.name, &parent, "test/core"],
+        )?
+        .lines()
+        .map(|x| PathBuf::from(x))
+        .collect()
+    } else {
+        find("test/core")
+    };
+
+    let mut tests_changed = Vec::new();
+    for path in files_changed {
+        if path.extension().map(|x| x.to_str().unwrap()) != Some("wast") {
+            continue;
+        }
+
+        let name = path.file_name().unwrap().to_str().unwrap().to_owned();
+        tests_changed.push(name);
+    }
+    Ok(tests_changed)
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/Cargo.toml b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/Cargo.toml
new file mode 100644
index 0000000000..4329cc10fb
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "wast2js"
+version = "0.1.0"
+authors = ["Ryan Hunt <rhunt@eqrion.net>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.19"
+wast = "55.0.0"
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/README.md b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/README.md
new file mode 100644
index 0000000000..c06210bb04
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/README.md
@@ -0,0 +1,3 @@
+# wast2js
+
+Mozilla specific converter from `.wast` to `.js` for SpiderMonkey jit-tests.
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/convert.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/convert.rs
new file mode 100644
index 0000000000..c6516cb0d0
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/convert.rs
@@ -0,0 +1,672 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use anyhow::{bail, Context as _, Result};
+use std::fmt::Write;
+use std::path::Path;
+use std::str;
+
+use super::out::*;
+
+const HARNESS: &'static str = include_str!("./harness.js");
+const LICENSE: &'static str = include_str!("./license.js");
+
+pub fn harness() -> String {
+    HARNESS.to_string()
+}
+
+pub fn convert<P: AsRef<Path>>(path: P, wast: &str) -> Result<String> {
+    let filename = path.as_ref();
+    let adjust_wast = |mut err: wast::Error| {
+        err.set_path(filename);
+        err.set_text(wast);
+        err
+    };
+
+    let mut lexer = wast::lexer::Lexer::new(wast);
+    // The 'names.wast' spec test has confusable unicode -- disable detection.
+    lexer.allow_confusing_unicode(filename.ends_with("names.wast"));
+    let buf = wast::parser::ParseBuffer::new_with_lexer(lexer).map_err(adjust_wast)?;
+    let ast = wast::parser::parse::<wast::Wast>(&buf).map_err(adjust_wast)?;
+
+    let mut out = String::new();
+
+    writeln!(&mut out, "{}", LICENSE)?;
+    writeln!(&mut out, "// {}", filename.display())?;
+
+    let mut current_instance: Option<usize> = None;
+
+    for directive in ast.directives {
+        let sp = directive.span();
+        let (line, col) = sp.linecol_in(wast);
+        writeln!(&mut out, "")?;
+        convert_directive(
+            directive,
+            &mut current_instance,
+            filename,
+            line,
+            col,
+            wast,
+            &mut out,
+        )
+        .with_context(|| {
+            format!(
+                "failed to convert directive on {}:{}:{}",
+                filename.display(),
+                line + 1,
+                col
+            )
+        })?;
+    }
+
+    Ok(out)
+}
+
+fn convert_directive(
+    directive: wast::WastDirective,
+    current_instance: &mut Option<usize>,
+    filename: &Path,
+    line: usize,
+    col: usize,
+    wast: &str,
+    out: &mut String,
+) -> Result<()> {
+    use wast::WastDirective::*;
+
+    if col == 1 {
+        writeln!(out, "// {}:{}", filename.display(), line + 1)?;
+    } else {
+        writeln!(out, "// {}:{}:{}", filename.display(), line + 1, col)?;
+    }
+    match directive {
+        Wat(wast::QuoteWat::Wat(wast::Wat::Module(module))) => {
+            let next_instance = current_instance.map(|x| x + 1).unwrap_or(0);
+            let module_text = module_to_js_string(&module, wast)?;
+
+            writeln!(
+                out,
+                "let ${} = instantiate(`{}`);",
+                next_instance, module_text
+            )?;
+            if let Some(id) = module.id {
+                writeln!(
+                    out,
+                    "register(${}, {});",
+                    next_instance,
+                    format!("`{}`", escape_template_string(id.name()))
+                )?;
+            }
+
+            *current_instance = Some(next_instance);
+        }
+        Wat(_) => {
+            write!(out, "// unsupported quote wat")?;
+        }
+        Register {
+            span: _,
+            name,
+            module,
+        } => {
+            let instanceish = module
+                .map(|x| format!("`{}`", escape_template_string(x.name())))
+                .unwrap_or_else(|| format!("${}", current_instance.unwrap()));
+
+            writeln!(
+                out,
+                "register({}, `{}`);",
+                instanceish,
+                escape_template_string(name)
+            )?;
+        }
+        Invoke(i) => {
+            let invoke_node = invoke_to_js(current_instance, i)?;
+            writeln!(out, "{};", invoke_node.output(0))?;
+        }
+        AssertReturn {
+            span: _,
+            exec,
+            results,
+        } => {
+            let exec_node = execute_to_js(current_instance, exec, wast)?;
+            let expected_node = to_js_value_array(&results, assert_expression_to_js_value)?;
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_return".to_string(),
+                    exec: exec_node,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertTrap {
+            span: _,
+            exec,
+            message,
+        } => {
+            let exec_node = execute_to_js(current_instance, exec, wast)?;
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_trap".to_string(),
+                    exec: exec_node,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertExhaustion {
+            span: _,
+            call,
+            message,
+        } => {
+            let exec_node = invoke_to_js(current_instance, call)?;
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_exhaustion".to_string(),
+                    exec: exec_node,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertInvalid {
+            span: _,
+            module,
+            message,
+        } => {
+            let text = match module {
+                wast::QuoteWat::Wat(wast::Wat::Module(m)) => module_to_js_string(&m, wast)?,
+                wast::QuoteWat::QuoteModule(_, source) => quote_module_to_js_string(source)?,
+                other => bail!("unsupported {:?} in assert_invalid", other),
+            };
+            let exec = Box::new(JSNode::Raw(format!("instantiate(`{}`)", text)));
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_invalid".to_string(),
+                    exec: exec,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertMalformed {
+            module,
+            span: _,
+            message,
+        } => {
+            let text = match module {
+                wast::QuoteWat::Wat(wast::Wat::Module(m)) => module_to_js_string(&m, wast)?,
+                wast::QuoteWat::QuoteModule(_, source) => quote_module_to_js_string(source)?,
+                other => bail!("unsupported {:?} in assert_malformed", other),
+            };
+            let exec = Box::new(JSNode::Raw(format!("instantiate(`{}`)", text)));
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_malformed".to_string(),
+                    exec: exec,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertUnlinkable {
+            span: _,
+            module,
+            message,
+        } => {
+            let text = match module {
+                wast::Wat::Module(module) => module_to_js_string(&module, wast)?,
+                other => bail!("unsupported {:?} in assert_unlinkable", other),
+            };
+            let exec = Box::new(JSNode::Raw(format!("instantiate(`{}`)", text)));
+            let expected_node = Box::new(JSNode::Raw(format!(
+                "`{}`",
+                escape_template_string(message)
+            )));
+            writeln!(
+                out,
+                "{};",
+                JSNode::Assert {
+                    name: "assert_unlinkable".to_string(),
+                    exec: exec,
+                    expected: expected_node,
+                }
+                .output(0),
+            )?;
+        }
+        AssertException { span: _, exec } => {
+            // This assert doesn't have a second parameter, so we don't bother
+            // formatting it using an Assert node.
+            let exec_node = execute_to_js(current_instance, exec, wast)?;
+            writeln!(out, "assert_exception(() => {});", exec_node.output(0))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn escape_template_string(text: &str) -> String {
+    let mut escaped = String::new();
+    for c in text.chars() {
+        match c {
+            '$' => escaped.push_str("$$"),
+            '\\' => escaped.push_str("\\\\"),
+            '`' => escaped.push_str("\\`"),
+            c if c.is_ascii_control() && c != '\n' && c != '\t' => {
+                escaped.push_str(&format!("\\x{:02x}", c as u32))
+            }
+            c if !c.is_ascii() => escaped.push_str(&c.escape_unicode().to_string()),
+            c => escaped.push(c),
+        }
+    }
+    escaped
+}
+
+fn span_to_offset(span: wast::token::Span, text: &str) -> Result<usize> {
+    let (span_line, span_col) = span.linecol_in(text);
+    let mut cur = 0;
+    // Use split_terminator instead of lines so that if there is a `\r`,
+    // it is included in the offset calculation. The `+1` values below
+    // account for the `\n`.
+    for (i, line) in text.split_terminator('\n').enumerate() {
+        if span_line == i {
+            assert!(span_col < line.len());
+            return Ok(cur + span_col);
+        }
+        cur += line.len() + 1;
+    }
+    bail!("invalid line/col");
+}
+
+fn closed_module(module: &str) -> Result<&str> {
+    enum State {
+        Module,
+        QStr,
+        EscapeQStr,
+    }
+
+    let mut i = 0;
+    let mut level = 1;
+    let mut state = State::Module;
+
+    let mut chars = module.chars();
+    while level != 0 {
+        let next = match chars.next() {
+            Some(next) => next,
+            None => bail!("was unable to close module"),
+        };
+        match state {
+            State::Module => match next {
+                '(' => level += 1,
+                ')' => level -= 1,
+                '"' => state = State::QStr,
+                _ => {}
+            },
+            State::QStr => match next {
+                '"' => state = State::Module,
+                '\\' => state = State::EscapeQStr,
+                _ => {}
+            },
+            State::EscapeQStr => match next {
+                _ => state = State::QStr,
+            },
+        }
+        i += next.len_utf8();
+    }
+    return Ok(&module[0..i]);
+}
+
+fn module_to_js_string(module: &wast::core::Module, wast: &str) -> Result<String> {
+    let offset = span_to_offset(module.span, wast)?;
+    let opened_module = &wast[offset..];
+    if !opened_module.starts_with("module") {
+        return Ok(escape_template_string(opened_module));
+    }
+    Ok(escape_template_string(&format!(
+        "({}",
+        closed_module(opened_module)?
+    )))
+}
+
+fn quote_module_to_js_string(quotes: Vec<(wast::token::Span, &[u8])>) -> Result<String> {
+    let mut text = String::new();
+    for (_, src) in quotes {
+        text.push_str(str::from_utf8(src)?);
+        text.push_str(" ");
+    }
+    let escaped = escape_template_string(&text);
+    Ok(escaped)
+}
+
+fn invoke_to_js(current_instance: &Option<usize>, i: wast::WastInvoke) -> Result<Box<JSNode>> {
+    let instanceish = i
+        .module
+        .map(|x| format!("`{}`", escape_template_string(x.name())))
+        .unwrap_or_else(|| format!("${}", current_instance.unwrap()));
+    let body = to_js_value_array(&i.args, arg_to_js_value)?;
+
+    Ok(Box::new(JSNode::Invoke {
+        instance: instanceish,
+        name: escape_template_string(i.name),
+        body: body,
+    }))
+}
+
+fn execute_to_js(
+    current_instance: &Option<usize>,
+    exec: wast::WastExecute,
+    wast: &str,
+) -> Result<Box<JSNode>> {
+    match exec {
+        wast::WastExecute::Invoke(invoke) => invoke_to_js(current_instance, invoke),
+        wast::WastExecute::Wat(module) => {
+            let text = match module {
+                wast::Wat::Module(module) => module_to_js_string(&module, wast)?,
+                other => bail!("unsupported {:?} at execute_to_js", other),
+            };
+            Ok(Box::new(JSNode::Raw(format!("instantiate(`{}`)", text))))
+        }
+        wast::WastExecute::Get { module, global } => {
+            let instanceish = module
+                .map(|x| format!("`{}`", escape_template_string(x.name())))
+                .unwrap_or_else(|| format!("${}", current_instance.unwrap()));
+            Ok(Box::new(JSNode::Raw(format!(
+                "get({}, `{}`)",
+                instanceish, global
+            ))))
+        }
+    }
+}
+
+fn to_js_value_array<T, F: Fn(&T) -> Result<String>>(vals: &[T], func: F) -> Result<Box<JSNode>> {
+    let mut value_nodes: Vec<Box<JSNode>> = vec![];
+    for val in vals {
+        let converted_value = (func)(val)?;
+        value_nodes.push(Box::new(JSNode::Raw(converted_value)));
+    }
+
+    Ok(Box::new(JSNode::Array(value_nodes)))
+}
+
+fn to_js_value_array_string<T, F: Fn(&T) -> Result<String>>(vals: &[T], func: F) -> Result<String> {
+    let array = to_js_value_array(vals, func)?;
+    Ok(array.output(NOWRAP))
+}
+
+fn f32_needs_bits(a: f32) -> bool {
+    if a.is_infinite() {
+        return false;
+    }
+    return a.is_nan()
+        || ((a as f64) as f32).to_bits() != a.to_bits()
+        || (format!("{:.}", a).parse::<f64>().unwrap() as f32).to_bits() != a.to_bits();
+}
+
+fn f64_needs_bits(a: f64) -> bool {
+    return a.is_nan();
+}
+
+fn f32x4_needs_bits(a: &[wast::token::Float32; 4]) -> bool {
+    a.iter().any(|x| {
+        let as_f32 = f32::from_bits(x.bits);
+        f32_needs_bits(as_f32)
+    })
+}
+
+fn f64x2_needs_bits(a: &[wast::token::Float64; 2]) -> bool {
+    a.iter().any(|x| {
+        let as_f64 = f64::from_bits(x.bits);
+        f64_needs_bits(as_f64)
+    })
+}
+
+fn f32_to_js_value(val: f32) -> String {
+    if val == f32::INFINITY {
+        format!("Infinity")
+    } else if val == f32::NEG_INFINITY {
+        format!("-Infinity")
+    } else if val.is_sign_negative() && val == 0f32 {
+        format!("-0")
+    } else {
+        format!("{:.}", val)
+    }
+}
+
+fn f64_to_js_value(val: f64) -> String {
+    if val == f64::INFINITY {
+        format!("Infinity")
+    } else if val == f64::NEG_INFINITY {
+        format!("-Infinity")
+    } else if val.is_sign_negative() && val == 0f64 {
+        format!("-0")
+    } else {
+        format!("{:.}", val)
+    }
+}
+
+fn float32_to_js_value(val: &wast::token::Float32) -> String {
+    let as_f32 = f32::from_bits(val.bits);
+    if f32_needs_bits(as_f32) {
+        format!(
+            "bytes(\"f32\", {})",
+            to_js_value_array_string(&val.bits.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))
+                .unwrap(),
+        )
+    } else {
+        format!("value(\"f32\", {})", f32_to_js_value(as_f32))
+    }
+}
+
+fn float64_to_js_value(val: &wast::token::Float64) -> String {
+    let as_f64 = f64::from_bits(val.bits);
+    if f64_needs_bits(as_f64) {
+        format!(
+            "bytes(\"f64\", {})",
+            to_js_value_array_string(&val.bits.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))
+                .unwrap(),
+        )
+    } else {
+        format!("value(\"f64\", {})", f64_to_js_value(as_f64))
+    }
+}
+
+fn f32_pattern_to_js_value(pattern: &wast::core::NanPattern<wast::token::Float32>) -> String {
+    use wast::core::NanPattern::*;
+    match pattern {
+        CanonicalNan => format!("`canonical_nan`"),
+        ArithmeticNan => format!("`arithmetic_nan`"),
+        Value(x) => float32_to_js_value(x),
+    }
+}
+
+fn f64_pattern_to_js_value(pattern: &wast::core::NanPattern<wast::token::Float64>) -> String {
+    use wast::core::NanPattern::*;
+    match pattern {
+        CanonicalNan => format!("`canonical_nan`"),
+        ArithmeticNan => format!("`arithmetic_nan`"),
+        Value(x) => float64_to_js_value(x),
+    }
+}
+
+fn return_value_to_js_value(v: &wast::core::WastRetCore<'_>) -> Result<String> {
+    use wast::core::WastRetCore::*;
+    Ok(match v {
+        I32(x) => format!("value(\"i32\", {})", x),
+        I64(x) => format!("value(\"i64\", {}n)", x),
+        F32(x) => f32_pattern_to_js_value(x),
+        F64(x) => f64_pattern_to_js_value(x),
+        RefNull(x) => match x {
+            Some(wast::core::HeapType::Func) => format!("value('anyfunc', null)"),
+            Some(wast::core::HeapType::Extern) => format!("value('externref', null)"),
+            other => bail!(
+                "couldn't convert ref.null {:?} to a js assertion value",
+                other
+            ),
+        },
+        RefExtern(x) => format!("value('externref', externref({}))", x),
+        V128(x) => {
+            use wast::core::V128Pattern::*;
+            match x {
+                I8x16(elements) => format!(
+                    "i8x16({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I16x8(elements) => format!(
+                    "i16x8({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I32x4(elements) => format!(
+                    "i32x4({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I64x2(elements) => format!(
+                    "i64x2({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}n", x)))?,
+                ),
+                F32x4(elements) => {
+                    let elements: Vec<String> = elements
+                        .iter()
+                        .map(|x| f32_pattern_to_js_value(x))
+                        .collect();
+                    let elements = strings_to_raws(elements);
+                    JSNode::Call {
+                        name: "new F32x4Pattern".to_string(),
+                        args: elements,
+                    }
+                    .output(0)
+                }
+                F64x2(elements) => {
+                    let elements: Vec<String> = elements
+                        .iter()
+                        .map(|x| f64_pattern_to_js_value(x))
+                        .collect();
+                    let elements = strings_to_raws(elements);
+                    JSNode::Call {
+                        name: "new F64x2Pattern".to_string(),
+                        args: elements,
+                    }
+                    .output(0)
+                }
+            }
+        }
+        Either(v) => {
+            let args = v
+                .iter()
+                .map(|v| return_value_to_js_value(v).unwrap())
+                .collect();
+            let args = strings_to_raws(args);
+            JSNode::Call {
+                name: "either".to_string(),
+                args: args,
+            }
+            .output(0)
+        }
+        other => bail!("couldn't convert Core({:?}) to a js assertion value", other),
+    })
+}
+
+fn assert_expression_to_js_value(v: &wast::WastRet<'_>) -> Result<String> {
+    use wast::WastRet::*;
+
+    Ok(match &v {
+        Core(x) => return_value_to_js_value(x)?,
+        other => bail!("couldn't convert {:?} to a js assertion value", other),
+    })
+}
+
+fn arg_to_js_value(v: &wast::WastArg<'_>) -> Result<String> {
+    use wast::core::WastArgCore::*;
+    use wast::WastArg::Core;
+
+    Ok(match &v {
+        Core(I32(x)) => format!("{}", *x),
+        Core(I64(x)) => format!("{}n", *x),
+        Core(F32(x)) => float32_to_js_value(x),
+        Core(F64(x)) => float64_to_js_value(x),
+        Core(V128(x)) => {
+            use wast::core::V128Const::*;
+            match x {
+                I8x16(elements) => format!(
+                    "i8x16({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I16x8(elements) => format!(
+                    "i16x8({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I32x4(elements) => format!(
+                    "i32x4({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}", x)))?,
+                ),
+                I64x2(elements) => format!(
+                    "i64x2({})",
+                    to_js_value_array_string(elements, |x| Ok(format!("0x{:x}n", x)))?,
+                ),
+                F32x4(elements) => {
+                    if f32x4_needs_bits(elements) {
+                        let bytes =
+                            to_js_value_array(&x.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))?;
+                        format!("bytes('v128', {})", bytes.output(0))
+                    } else {
+                        let vals = to_js_value_array(elements, |x| {
+                            Ok(f32_to_js_value(f32::from_bits(x.bits)))
+                        })?;
+                        format!("f32x4({})", vals.output(0))
+                    }
+                }
+                F64x2(elements) => {
+                    if f64x2_needs_bits(elements) {
+                        let bytes =
+                            to_js_value_array(&x.to_le_bytes(), |x| Ok(format!("0x{:x}", x)))?;
+                        format!("bytes('v128', {})", bytes.output(0))
+                    } else {
+                        let vals = to_js_value_array(elements, |x| {
+                            Ok(f64_to_js_value(f64::from_bits(x.bits)))
+                        })?;
+                        format!("f64x2({})", vals.output(0))
+                    }
+                }
+            }
+        }
+        Core(RefNull(_)) => format!("null"),
+        Core(RefExtern(x)) => format!("externref({})", x),
+        other => bail!("couldn't convert {:?} to a js value", other),
+    })
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/harness.js b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: console.log.bind(console),
+  print_i32_f32: console.log.bind(console),
+  print_f64_f64: console.log.bind(console),
+  print_f32: console.log.bind(console),
+  print_f64: console.log.bind(console),
+  global_i32: 666,
+  global_i64: 666n,
+  global_f32: 666,
+  global_f64: 666,
+  table: new WebAssembly.Table({
+    initial: 10,
+    maximum: 20,
+    element: "anyfunc",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/lib.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/lib.rs
new file mode 100644
index 0000000000..b62bcbfaea
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/lib.rs
@@ -0,0 +1,18 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+mod convert;
+mod out;
+pub use convert::*;
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/license.js b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/license.js
new file mode 100644
index 0000000000..12d51bd702
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/license.js
@@ -0,0 +1,14 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/main.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/main.rs
new file mode 100644
index 0000000000..d5d1118e7e
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/main.rs
@@ -0,0 +1,40 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use anyhow::{Context as _, Result};
+use std::env;
+use std::path::Path;
+
+mod convert;
+mod out;
+
+fn main() -> Result<()> {
+    let files = env::args().collect::<Vec<String>>();
+    for path in &files[1..] {
+        let source =
+            std::fs::read_to_string(path).with_context(|| format!("failed to read `{}`", path))?;
+
+        let mut full_script = String::new();
+        full_script.push_str(&convert::harness());
+        full_script.push_str(&convert::convert(path, &source)?);
+
+        std::fs::write(
+            Path::new(path).with_extension("js").file_name().unwrap(),
+            &full_script,
+        )?;
+    }
+
+    Ok(())
+}
diff --git a/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/out.rs b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/out.rs
new file mode 100644
index 0000000000..1d47365f19
--- /dev/null
+++ b/js/src/jit-test/etc/wasm/generate-spectests/wast2js/src/out.rs
@@ -0,0 +1,180 @@
+/* Copyright 2022 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/// This module has a bare-bones "syntax tree" that helps us output more readable JS code in our
+/// tests. This is a lot cheaper and faster than running a full JS formatter on the generated code.
+/// The tree only has node types for things that matter to formatting; most things in the output
+/// use the Raw type, which is just a plain old string.
+
+pub const LINE_WIDTH: usize = 80; // the default line width to try to meet (will not be met perfectly)
+pub const NOWRAP: usize = 1000; // use for line_remaining when you don't want to wrap text
+
+pub enum JSNode {
+    Assert {
+        name: String,
+        exec: Box<JSNode>,
+        expected: Box<JSNode>,
+    },
+    Invoke {
+        instance: String,
+        name: String,
+        body: Box<JSNode>,
+    },
+    Call {
+        name: String,
+        args: Vec<Box<JSNode>>,
+    },
+    Array(Vec<Box<JSNode>>),
+    Raw(String),
+}
+
+impl JSNode {
+    /// Converts a node to JavaScript code. line_remaining is the number of characters remaining on
+    /// the line, used for line-wrapping purposes; if zero, the default LINE_WIDTH will be used.
+    pub fn output(&self, line_remaining: usize) -> String {
+        let line_remaining = if line_remaining == 0 {
+            LINE_WIDTH
+        } else {
+            line_remaining
+        };
+        match self {
+            Self::Assert {
+                name,
+                exec,
+                expected,
+            } => {
+                if self.len() > line_remaining {
+                    format!(
+                        "{}(\n{}\n)",
+                        name,
+                        indent(format!(
+                            "() => {},\n{},",
+                            exec.output(line_remaining - 8),
+                            expected.output(line_remaining - 2),
+                        )),
+                    )
+                } else {
+                    format!(
+                        "{}(() => {}, {})",
+                        name,
+                        exec.output(NOWRAP),
+                        expected.output(NOWRAP),
+                    )
+                }
+            }
+            Self::Invoke {
+                instance,
+                name,
+                body,
+            } => {
+                let body_string =
+                    body.output(line_remaining - "invoke".len() - instance.len() - name.len());
+                format!("invoke({}, `{}`, {})", instance, name, body_string)
+            }
+            Self::Call { name, args } => {
+                if self.len() > line_remaining {
+                    let arg_strings: Vec<String> = args
+                        .iter()
+                        .map(|arg| arg.output(line_remaining - 2))
+                        .collect();
+                    format!("{}(\n{},\n)", name, indent(arg_strings.join(",\n")))
+                } else {
+                    let arg_strings: Vec<String> =
+                        args.iter().map(|arg| arg.output(NOWRAP)).collect();
+                    format!("{}({})", name, arg_strings.join(", "))
+                }
+            }
+            Self::Array(values) => {
+                if self.len() > line_remaining {
+                    let value_strings = output_nodes(&values, 70);
+                    format!("[\n{},\n]", indent(value_strings.join(",\n")))
+                } else {
+                    let value_strings = output_nodes(&values, 80);
+                    format!("[{}]", value_strings.join(", "))
+                }
+            }
+            Self::Raw(val) => val.to_string(),
+        }
+    }
+
+    /// A rough estimate of the string length of the node. Used as a heuristic to know when we
+    /// should wrap text.
+    fn len(&self) -> usize {
+        match self {
+            Self::Assert {
+                name,
+                exec,
+                expected,
+            } => name.len() + exec.len() + expected.len(),
+            Self::Invoke {
+                instance,
+                name,
+                body,
+            } => instance.len() + name.len() + body.len(),
+            Self::Call { name, args } => {
+                let mut args_len: usize = 0;
+                for node in args {
+                    args_len += node.len() + ", ".len();
+                }
+                name.len() + args_len
+            }
+            Self::Array(nodes) => {
+                let mut content_len: usize = 0;
+                for node in nodes {
+                    content_len += node.len() + ", ".len();
+                }
+                content_len
+            }
+            Self::Raw(s) => s.len(),
+        }
+    }
+}
+
+pub fn output_nodes(nodes: &Vec<Box<JSNode>>, line_width_per_node: usize) -> Vec<String> {
+    nodes
+        .iter()
+        .map(|node| node.output(line_width_per_node))
+        .collect()
+}
+
+pub fn strings_to_raws(strs: Vec<String>) -> Vec<Box<JSNode>> {
+    let mut res: Vec<Box<JSNode>> = vec![];
+    for s in strs {
+        res.push(Box::new(JSNode::Raw(s)));
+    }
+    res
+}
+
+fn indent(s: String) -> String {
+    let mut result = String::new();
+    let mut do_indent = true;
+    for (i, line) in s.lines().enumerate() {
+        if i > 0 {
+            result.push('\n');
+        }
+        if line.chars().any(|c| !c.is_whitespace()) {
+            if do_indent {
+                result.push_str("  ");
+            }
+            result.push_str(line);
+
+            // An odd number of backticks in the line means we are entering or exiting a raw string.
+            if line.matches("`").count() % 2 == 1 {
+                do_indent = !do_indent
+            }
+        }
+    }
+    result
+}