Add test for consuming interface types inputs

This commit adds a test suite for consuming interface types modules as
input and producing a JS polyfill output. The tests are relatively
simple today and don't exercise a ton of functionality, but they should
hopefully cover the breadth of at least some basics of what wasm
interface types supports today.

A few small fixes were applied along the way, such as:

* Don't require modules to have a stack pointer

* Allow passing `*.wat`, `*.wit`, or `*.wasm` files as input to
  `wasm-bindgen` instead of always requiring `*.wasm`.

Author: alexcrichton

crates/cli-support/Cargo.toml

@@ -12,17 +12,19 @@ Shared support for the wasm-bindgen-cli package, an internal dependency
 edition = '2018'
 
 [dependencies]
-base64 = "0.9"
 anyhow = "1.0"
+base64 = "0.9"
 log = "0.4"
 rustc-demangle = "0.1.13"
 serde_json = "1.0"
 tempfile = "3.0"
 walrus = "0.14.0"
 wasm-bindgen-anyref-xform = { path = '../anyref-xform', version = '=0.2.55' }
-wasm-bindgen-shared = { path = "../shared", version = '=0.2.55' }
 wasm-bindgen-multi-value-xform = { path = '../multi-value-xform', version = '=0.2.55' }
+wasm-bindgen-shared = { path = "../shared", version = '=0.2.55' }
 wasm-bindgen-threads-xform = { path = '../threads-xform', version = '=0.2.55' }
 wasm-bindgen-wasm-conventions = { path = '../wasm-conventions', version = '=0.2.55' }
 wasm-bindgen-wasm-interpreter = { path = "../wasm-interpreter", version = '=0.2.55' }
+wit-text = "0.1.1"
 wit-walrus = "0.1.0"
+wit-validator = "0.1.0"

crates/cli-support/src/lib.rs

@@ -264,8 +264,10 @@ impl Bindgen {
                 (mem::replace(m, blank_module), &name[..])
             }
             Input::Path(ref path) => {
-                let contents = fs::read(&path)
+                let wasm = wit_text::parse_file(&path)
                     .with_context(|| format!("failed to read `{}`", path.display()))?;
+                wit_validator::validate(&wasm)
+                    .with_context(|| format!("failed to validate `{}`", path.display()))?;
                 let module = walrus::ModuleConfig::new()
                     // Skip validation of the module as LLVM's output is
                     // generally already well-formed and so we won't gain much
@@ -278,7 +280,7 @@ impl Bindgen {
                     .generate_name_section(!self.remove_name_section)
                     .generate_producers_section(!self.remove_producers_section)
                     .on_parse(wit_walrus::on_parse)
-                    .parse(&contents)
+                    .parse(&wasm)
                     .context("failed to parse input file as wasm")?;
                 let stem = match &self.out_name {
                     Some(name) => &name,

crates/cli-support/src/wit/mod.rs

@@ -92,8 +92,8 @@ pub fn process(
 
 impl<'a> Context<'a> {
     fn init(&mut self) -> Result<(), Error> {
-        let stack_pointer = wasm_bindgen_wasm_conventions::get_shadow_stack_pointer(self.module)?;
-        self.aux.shadow_stack_pointer = Some(stack_pointer);
+        self.aux.shadow_stack_pointer =
+            wasm_bindgen_wasm_conventions::get_shadow_stack_pointer(self.module);
 
         // Make a map from string name to ids of all exports
         for export in self.module.exports.iter() {

crates/cli/Cargo.toml

@@ -36,12 +36,17 @@ rayon = "1.0"
 tempfile = "3.0"
 walrus = "0.14"
 wit-printer = "0.1"
+wit-text = "0.1"
 wit-validator = "0.1"
 wit-walrus = "0.1"
 
 [[test]]
 name = "reference"
 harness = false
 
+[[test]]
+name = "interface-types"
+harness = false
+
 [features]
 vendored-openssl = ['openssl/vendored']

crates/cli/tests/interface-types.rs

@@ -0,0 +1,85 @@
+use anyhow::{bail, Result};
+use assert_cmd::prelude::*;
+use rayon::prelude::*;
+use std::env;
+use std::path::Path;
+use std::process::Command;
+
+fn main() -> Result<()> {
+    let filter = env::args().nth(1);
+
+    let mut tests = Vec::new();
+    let dir = env::current_dir()?.join("tests/interface-types");
+    for entry in dir.read_dir()? {
+        let path = entry?.path();
+        if path.extension().and_then(|s| s.to_str()) != Some("wit") {
+            continue;
+        }
+        if let Some(filter) = &filter {
+            if !path.display().to_string().contains(filter) {
+                continue;
+            }
+        }
+        tests.push(path);
+    }
+    tests.sort();
+
+    let errs = tests
+        .par_iter()
+        .filter_map(|t| runtest(t).err().map(|e| (t, e)))
+        .collect::<Vec<_>>();
+
+    if errs.len() == 0 {
+        println!("{} tests passed", tests.len());
+        return Ok(());
+    }
+    eprintln!("failed tests:\n");
+    for (test, err) in errs {
+        eprintln!("{} failure\n{}", test.display(), tab(&format!("{:?}", err)));
+    }
+    bail!("tests failed");
+}
+
+fn runtest(test: &Path) -> Result<()> {
+    let js = test.with_extension("js");
+    let td = tempfile::TempDir::new()?;
+
+    let mut bindgen = Command::cargo_bin("wasm-bindgen")?;
+    bindgen
+        .arg("--out-dir")
+        .arg(td.path())
+        .arg(test)
+        .arg("--out-name=wasm")
+        .arg("--nodejs")
+        .arg("--no-typescript");
+    exec(&mut bindgen)?;
+
+    exec(Command::new("node")
+        .arg("--experimental-wasm-anyref")
+        .arg("--experimental-wasm-mv")
+        .arg(&js).env("NODE_PATH", td.path()))?;
+
+    Ok(())
+}
+
+fn exec(cmd: &mut Command) -> Result<()> {
+    let output = cmd.output()?;
+    if output.status.success() {
+        return Ok(());
+    }
+    let mut err = format!("command failed {:?}", cmd);
+    err.push_str(&format!("\nstatus: {}", output.status));
+    err.push_str(&format!(
+        "\nstderr:\n{}",
+        tab(&String::from_utf8_lossy(&output.stderr))
+    ));
+    err.push_str(&format!(
+        "\nstdout:\n{}",
+        tab(&String::from_utf8_lossy(&output.stdout))
+    ));
+    bail!("{}", err);
+}
+
+fn tab(s: &str) -> String {
+    format!("    {}", s.replace("\n", "\n    "))
+}

crates/cli/tests/interface-types/anyref.js

@@ -0,0 +1,16 @@
+const assert = require('assert');
+const wasm = require('wasm');
+
+const obj = {};
+assert.strictEqual(wasm.foo(obj), obj);
+
+wasm.store('x');
+assert.strictEqual(wasm.load(), 'x');
+
+const obj2 = {};
+wasm.store(obj2);
+assert.strictEqual(wasm.load(), obj2);
+assert.strictEqual(wasm.load(), obj2);
+
+wasm.store(undefined);
+assert.strictEqual(wasm.load(), undefined);

crates/cli/tests/interface-types/anyref.wit

@@ -0,0 +1,26 @@
+(module
+  (func $foo (param anyref) (result anyref)
+    local.get 0)
+
+  (func $store (param anyref)
+    i32.const 0
+    local.get 0
+    table.set 0)
+
+  (func $load (result anyref)
+    i32.const 0
+    table.get 0)
+
+  (table 1 anyref)
+
+  (@interface func (export "foo") (param anyref) (result anyref)
+    arg.get 0
+    call-core $foo)
+
+  (@interface func (export "store") (param anyref)
+    arg.get 0
+    call-core $store)
+
+  (@interface func (export "load") (result anyref)
+    call-core $load)
+)

crates/cli/tests/interface-types/defer-call.js

@@ -0,0 +1,5 @@
+const wasm = require('wasm');
+const assert = require('assert');
+
+assert.strictEqual(wasm.foo(), 0);
+assert.strictEqual(wasm.get(), 1);

crates/cli/tests/interface-types/defer-call.wit

@@ -0,0 +1,21 @@
+(module
+  (global $ctr (mut i32) (i32.const 0))
+
+  (func $increment
+    global.get $ctr
+    i32.const 1
+    i32.add
+    global.set $ctr)
+
+  (func $get (result i32)
+    global.get $ctr)
+
+  (@interface func (export "foo") (result s32)
+    defer-call-core $increment
+    call-core $get
+    i32-to-s32)
+
+  (@interface func (export "get") (result s32)
+    call-core $get
+    i32-to-s32)
+)

crates/cli/tests/interface-types/empty.js

@@ -0,0 +1,2 @@
+const m = require('wasm');
+