Mass rename anyref to externref (#2142)

Updates a mess of dependencies and tracks the most recent version of the
reference types specification.

crates/externref-xform/tests/all.rs

@@ -0,0 +1,258 @@
+//! A small test framework to execute a test function over all files in a
+//! directory.
+//!
+//! Each file in the directory has its own `CHECK-ALL` annotation indicating the
+//! expected output of the test. That can be automatically updated with
+//! `BLESS=1` in the environment. Otherwise the test are checked against the
+//! listed expectation.
+
+use anyhow::{anyhow, bail, Context, Result};
+use rayon::prelude::*;
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use wast::parser::{Parse, Parser};
+
+fn main() {
+    run("tests".as_ref(), runtest);
+}
+
+fn runtest(test: &Test) -> Result<String> {
+    let wasm = wat::parse_file(&test.file)?;
+    let mut walrus = walrus::Module::from_buffer(&wasm)?;
+    let mut cx = wasm_bindgen_externref_xform::Context::default();
+    cx.prepare(&mut walrus)?;
+    for directive in test.directives.iter() {
+        match &directive.kind {
+            DirectiveKind::Export(name) => {
+                let export = walrus
+                    .exports
+                    .iter()
+                    .find(|e| e.name == *name)
+                    .ok_or_else(|| anyhow!("failed to find export"))?;
+                cx.export_xform(export.id(), &directive.args, directive.ret_externref);
+            }
+            DirectiveKind::Import(module, field) => {
+                let import = walrus
+                    .imports
+                    .iter()
+                    .find(|e| e.module == *module && e.name == *field)
+                    .ok_or_else(|| anyhow!("failed to find export"))?;
+                cx.import_xform(import.id(), &directive.args, directive.ret_externref);
+            }
+            DirectiveKind::Table(idx) => {
+                cx.table_element_xform(*idx, &directive.args, directive.ret_externref);
+            }
+        }
+    }
+    cx.run(&mut walrus)?;
+    walrus::passes::gc::run(&mut walrus);
+    let printed = wasmprinter::print_bytes(&walrus.emit_wasm())?;
+    Ok(printed)
+}
+
+fn run(dir: &Path, run: fn(&Test) -> Result<String>) {
+    let mut tests = Vec::new();
+    find_tests(dir, &mut tests);
+    let filter = std::env::args().nth(1);
+
+    let bless = env::var("BLESS").is_ok();
+    let tests = tests
+        .iter()
+        .filter(|test| {
+            if let Some(filter) = &filter {
+                if let Some(s) = test.file_name().and_then(|s| s.to_str()) {
+                    if !s.contains(filter) {
+                        return false;
+                    }
+                }
+            }
+            true
+        })
+        .collect::<Vec<_>>();
+
+    println!("\nrunning {} tests\n", tests.len());
+
+    let errors = tests
+        .par_iter()
+        .filter_map(|test| run_test(test, bless, run).err())
+        .collect::<Vec<_>>();
+
+    if !errors.is_empty() {
+        for msg in errors.iter() {
+            eprintln!("error: {:?}", msg);
+        }
+
+        panic!("{} tests failed", errors.len())
+    }
+
+    println!("test result: ok. {} passed\n", tests.len());
+}
+
+fn run_test(test: &Path, bless: bool, run: fn(&Test) -> anyhow::Result<String>) -> Result<()> {
+    (|| -> Result<_> {
+        let expected = Test::from_file(test)?;
+        let actual = run(&expected)?;
+        expected.check(&actual, bless)?;
+        Ok(())
+    })()
+    .context(format!("test failed - {}", test.display()))?;
+    Ok(())
+}
+
+fn find_tests(path: &Path, tests: &mut Vec<PathBuf>) {
+    for f in path.read_dir().unwrap() {
+        let f = f.unwrap();
+        if f.file_type().unwrap().is_dir() {
+            find_tests(&f.path(), tests);
+            continue;
+        }
+        match f.path().extension().and_then(|s| s.to_str()) {
+            Some("wat") => {}
+            _ => continue,
+        }
+        tests.push(f.path());
+    }
+}
+
+struct Test {
+    file: PathBuf,
+    directives: Vec<Directive>,
+    assertion: Option<String>,
+}
+
+struct Directive {
+    args: Vec<(usize, bool)>,
+    ret_externref: bool,
+    kind: DirectiveKind,
+}
+
+enum DirectiveKind {
+    Import(String, String),
+    Export(String),
+    Table(u32),
+}
+
+impl Test {
+    fn from_file(path: &Path) -> Result<Test> {
+        let contents = fs::read_to_string(path)?;
+        let mut iter = contents.lines();
+        let mut assertion = None;
+        let mut directives = Vec::new();
+        while let Some(line) = iter.next() {
+            if line.starts_with("(; CHECK-ALL:") {
+                let mut pattern = String::new();
+                while let Some(line) = iter.next() {
+                    if line == ";)" {
+                        break;
+                    }
+                    pattern.push_str(line);
+                    pattern.push_str("\n");
+                }
+                while pattern.ends_with("\n") {
+                    pattern.pop();
+                }
+                if iter.next().is_some() {
+                    bail!("CHECK-ALL must be at the end of the file");
+                }
+                assertion = Some(pattern);
+                continue;
+            }
+
+            if !line.starts_with(";; @xform") {
+                continue;
+            }
+            let directive = &line[9..];
+            let buf = wast::parser::ParseBuffer::new(directive)?;
+            directives.push(wast::parser::parse::<Directive>(&buf)?);
+        }
+        Ok(Test {
+            file: path.to_path_buf(),
+            directives,
+            assertion,
+        })
+    }
+
+    fn check(&self, output: &str, bless: bool) -> Result<()> {
+        if bless {
+            update_output(&self.file, output)
+        } else if let Some(pattern) = &self.assertion {
+            if output == pattern {
+                return Ok(());
+            }
+            bail!(
+                "expected\n    {}\n\nactual\n    {}",
+                pattern.replace("\n", "\n    "),
+                output.replace("\n", "\n    ")
+            );
+        } else {
+            bail!(
+                "no test assertions were found in this file, but you can \
+                 rerun tests with `BLESS=1` to automatically add assertions \
+                 to this file"
+            );
+        }
+    }
+}
+
+fn update_output(path: &Path, output: &str) -> Result<()> {
+    let contents = fs::read_to_string(path)?;
+    let start = contents.find("(; CHECK-ALL:").unwrap_or(contents.len());
+
+    let mut new_output = String::new();
+    for line in output.lines() {
+        new_output.push_str(line);
+        new_output.push_str("\n");
+    }
+    let new = format!(
+        "{}\n\n(; CHECK-ALL:\n{}\n;)\n",
+        contents[..start].trim(),
+        new_output.trim_end()
+    );
+    fs::write(path, new)?;
+    Ok(())
+}
+
+impl<'a> Parse<'a> for Directive {
+    fn parse(parser: Parser<'a>) -> wast::parser::Result<Self> {
+        use wast::kw;
+        wast::custom_keyword!(externref_owned);
+        wast::custom_keyword!(externref_borrowed);
+        wast::custom_keyword!(other);
+
+        let kind = if parser.peek::<kw::import>() {
+            parser.parse::<kw::import>()?;
+            DirectiveKind::Import(parser.parse()?, parser.parse()?)
+        } else if parser.peek::<kw::export>() {
+            parser.parse::<kw::export>()?;
+            DirectiveKind::Export(parser.parse()?)
+        } else {
+            parser.parse::<kw::table>()?;
+            DirectiveKind::Table(parser.parse()?)
+        };
+        let mut args = Vec::new();
+        parser.parens(|p| {
+            let mut i = 0;
+            while !p.is_empty() {
+                if parser.peek::<externref_owned>() {
+                    parser.parse::<externref_owned>()?;
+                    args.push((i, true));
+                } else if parser.peek::<externref_borrowed>() {
+                    parser.parse::<externref_borrowed>()?;
+                    args.push((i, false));
+                } else {
+                    parser.parse::<other>()?;
+                }
+                i += 1;
+            }
+            Ok(())
+        })?;
+
+        let ret_externref = parser.parse::<Option<externref_owned>>()?.is_some();
+        Ok(Directive {
+            args,
+            ret_externref,
+            kind,
+        })
+    }
+}

crates/externref-xform/tests/anyref-param-owned.wat

@@ -0,0 +1,28 @@
+;; @xform export "foo" (externref_owned)
+
+(module
+  (func $foo (export "foo") (param i32))
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param externref)))
+  (func $foo externref shim (type 2) (param externref)
+    (local i32)
+    call $alloc
+    local.tee 1
+    local.get 0
+    table.set 0
+    local.get 1
+    call $foo)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (func $foo (type 1) (param i32))
+  (table (;0;) 32 externref)
+  (export "foo" (func $foo externref shim)))
+;)

crates/externref-xform/tests/anyref-param.wat

@@ -0,0 +1,37 @@
+;; @xform export "foo" (externref_borrowed)
+
+(module
+  (func $foo (export "foo") (param i32))
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (param i32)))
+  (type (;1;) (func (param externref)))
+  (func $foo externref shim (type 1) (param externref)
+    (local i32)
+    global.get 0
+    i32.const 1
+    i32.sub
+    local.tee 1
+    global.set 0
+    local.get 1
+    local.get 0
+    table.set 0
+    local.get 1
+    call $foo
+    local.get 1
+    ref.nullextern
+    table.set 0
+    local.get 1
+    i32.const 1
+    i32.add
+    global.set 0)
+  (func $foo (type 0) (param i32))
+  (table (;0;) 32 externref)
+  (global (;0;) (mut i32) (i32.const 32))
+  (export "foo" (func $foo externref shim)))
+;)

crates/externref-xform/tests/clone-ref-intrinsic.wat

@@ -0,0 +1,48 @@
+;; @xform export "foo" (externref_owned) externref_owned
+
+(module
+  (import "__wbindgen_placeholder__" "__wbindgen_object_clone_ref"
+    (func $clone (param i32) (result i32)))
+  (func $foo (export "foo") (param i32) (result i32)
+    local.get 0
+    call $clone)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param i32) (result i32)))
+  (type (;3;) (func (param externref) (result externref)))
+  (func $foo externref shim (type 3) (param externref) (result externref)
+    (local i32)
+    call $alloc
+    local.tee 1
+    local.get 0
+    table.set 0
+    local.get 1
+    call $foo
+    local.tee 1
+    table.get 0
+    local.get 1
+    call $dealloc)
+  (func $__wbindgen_object_clone_ref (type 2) (param i32) (result i32)
+    (local i32)
+    call $alloc
+    local.tee 1
+    local.get 0
+    table.get 0
+    table.set 0
+    local.get 1)
+  (func $foo (type 2) (param i32) (result i32)
+    local.get 0
+    call $__wbindgen_object_clone_ref)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (func $dealloc (type 1) (param i32))
+  (table (;0;) 32 externref)
+  (export "foo" (func $foo externref shim)))
+;)

crates/externref-xform/tests/drop-ref-intrinsic.wat

@@ -0,0 +1,35 @@
+;; @xform export "foo" (externref_owned)
+
+(module
+  (import "__wbindgen_placeholder__" "__wbindgen_object_drop_ref"
+    (func $drop (param i32)))
+  (func $foo (export "foo") (param i32)
+    local.get 0
+    call $drop)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param externref)))
+  (func $foo externref shim (type 2) (param externref)
+    (local i32)
+    call $alloc
+    local.tee 1
+    local.get 0
+    table.set 0
+    local.get 1
+    call $foo)
+  (func $foo (type 1) (param i32)
+    local.get 0
+    call $dealloc)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (func $dealloc (type 1) (param i32))
+  (table (;0;) 32 externref)
+  (export "foo" (func $foo externref shim)))
+;)

crates/externref-xform/tests/import-anyref-owned.wat

@@ -0,0 +1,31 @@
+;; @xform import "" "a" (externref_owned)
+
+(module
+  (import "" "a" (func $a (param i32)))
+  (func (export "foo")
+    i32.const 0
+    call $a)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param externref)))
+  (import "" "a" (func $a (type 2)))
+  (func $a externref shim (type 1) (param i32)
+    local.get 0
+    table.get 0
+    local.get 0
+    call $dealloc
+    call $a)
+  (func (;2;) (type 0)
+    i32.const 0
+    call $a externref shim)
+  (func $dealloc (type 1) (param i32))
+  (table (;0;) 32 externref)
+  (export "foo" (func 2)))
+;)

crates/externref-xform/tests/import-anyref-ret.wat

@@ -0,0 +1,32 @@
+;; @xform import "" "a" () externref_owned
+
+(module
+  (import "" "a" (func $a (result i32)))
+  (func (export "foo") (result i32)
+    call $a)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (result externref)))
+  (import "" "a" (func $a (type 1)))
+  (func $a externref shim (type 0) (result i32)
+    (local i32 externref)
+    call $a
+    local.set 1
+    call $alloc
+    local.tee 0
+    local.get 1
+    table.set 0
+    local.get 0)
+  (func (;2;) (type 0) (result i32)
+    call $a externref shim)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (table (;0;) 32 externref)
+  (export "foo" (func 2)))
+;)

crates/externref-xform/tests/import-anyref.wat

@@ -0,0 +1,28 @@
+;; @xform import "" "a" (externref_borrowed)
+
+(module
+  (import "" "a" (func $a (param i32)))
+  (func (export "foo")
+    i32.const 0
+    call $a)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param externref)))
+  (import "" "a" (func $a (type 2)))
+  (func $a externref shim (type 1) (param i32)
+    local.get 0
+    table.get 0
+    call $a)
+  (func (;2;) (type 0)
+    i32.const 0
+    call $a externref shim)
+  (table (;0;) 32 externref)
+  (export "foo" (func 2)))
+;)

crates/externref-xform/tests/mixed-export.wat

@@ -0,0 +1,48 @@
+;; @xform export "a" (other externref_borrowed other externref_owned other)
+
+(module
+  (func $a (export "a") (param f32 i32 i64 i32 i32))
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param f32 i32 i64 i32 i32)))
+  (type (;2;) (func (param f32 externref i64 externref i32)))
+  (func $a externref shim (type 2) (param f32 externref i64 externref i32)
+    (local i32 i32)
+    global.get 0
+    i32.const 1
+    i32.sub
+    local.tee 5
+    global.set 0
+    local.get 0
+    local.get 5
+    local.get 1
+    table.set 0
+    local.get 5
+    local.get 2
+    call $alloc
+    local.tee 6
+    local.get 3
+    table.set 0
+    local.get 6
+    local.get 4
+    call $a
+    local.get 5
+    ref.nullextern
+    table.set 0
+    local.get 5
+    i32.const 1
+    i32.add
+    global.set 0)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (func $a (type 1) (param f32 i32 i64 i32 i32))
+  (table (;0;) 32 externref)
+  (global (;0;) (mut i32) (i32.const 32))
+  (export "a" (func $a externref shim)))
+;)

crates/externref-xform/tests/mixed.wat

@@ -0,0 +1,45 @@
+;; @xform import "" "a" (other externref_borrowed other externref_owned other)
+
+(module
+  (import "" "a" (func $a (param f32 i32 i64 i32 i32)))
+  (func (export "foo")
+    f32.const 1
+    i32.const 2
+    i64.const 3
+    i32.const 4
+    i32.const 5
+    call $a)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param f32 i32 i64 i32 i32)))
+  (type (;3;) (func (param f32 externref i64 externref i32)))
+  (import "" "a" (func $a (type 3)))
+  (func $a externref shim (type 2) (param f32 i32 i64 i32 i32)
+    local.get 0
+    local.get 1
+    table.get 0
+    local.get 2
+    local.get 3
+    table.get 0
+    local.get 3
+    call $dealloc
+    local.get 4
+    call $a)
+  (func (;2;) (type 0)
+    f32.const 0x1p+0 (;=1;)
+    i32.const 2
+    i64.const 3
+    i32.const 4
+    i32.const 5
+    call $a externref shim)
+  (func $dealloc (type 1) (param i32))
+  (table (;0;) 32 externref)
+  (export "foo" (func 2)))
+;)

crates/externref-xform/tests/ret-anyref.wat

@@ -0,0 +1,29 @@
+;; @xform export "foo" () externref_owned
+
+(module
+  (func $foo (export "foo") (result i32)
+    i32.const 0)
+
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (result externref)))
+  (type (;2;) (func (param i32)))
+  (func $foo externref shim (type 1) (result externref)
+    (local i32)
+    call $foo
+    local.tee 0
+    table.get 0
+    local.get 0
+    call $dealloc)
+  (func $foo (type 0) (result i32)
+    i32.const 0)
+  (func $dealloc (type 2) (param i32))
+  (table (;0;) 32 externref)
+  (export "foo" (func $foo externref shim)))
+;)

crates/externref-xform/tests/table-grow-intrinsic.wat

@@ -0,0 +1,37 @@
+;; @xform export "foo" (externref_owned)
+
+(module
+  (import "__wbindgen_externref_xform__" "__wbindgen_externref_table_grow"
+    (func $grow (param i32) (result i32)))
+  (func $foo (export "foo") (param i32)
+    i32.const 0
+    call $grow
+    drop)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param externref)))
+  (func $foo externref shim (type 2) (param externref)
+    (local i32)
+    call $alloc
+    local.tee 1
+    local.get 0
+    table.set 0
+    local.get 1
+    call $foo)
+  (func $foo (type 1) (param i32)
+    ref.nullextern
+    i32.const 0
+    table.grow 0
+    drop)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (table (;0;) 32 externref)
+  (export "foo" (func $foo externref shim)))
+;)

crates/externref-xform/tests/table-set-null-intrinsic.wat

@@ -0,0 +1,35 @@
+;; @xform export "foo" (externref_owned)
+
+(module
+  (import "__wbindgen_externref_xform__" "__wbindgen_externref_table_set_null"
+    (func $set-null (param i32)))
+  (func $foo (export "foo") (param i32)
+    local.get 0
+    call $set-null)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param externref)))
+  (func $foo externref shim (type 2) (param externref)
+    (local i32)
+    call $alloc
+    local.tee 1
+    local.get 0
+    table.set 0
+    local.get 1
+    call $foo)
+  (func $foo (type 1) (param i32)
+    local.get 0
+    ref.nullextern
+    table.set 0)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (table (;0;) 32 externref)
+  (export "foo" (func $foo externref shim)))
+;)

crates/externref-xform/tests/table.wat

@@ -0,0 +1,33 @@
+;; @xform table 0 (externref_owned)
+
+(module
+  (func $foo (param i32))
+  (table (export "func") 0 funcref)
+  (elem (i32.const 0) 0)
+  (func $alloc (export "__externref_table_alloc") (result i32)
+    i32.const 0)
+  (func $dealloc (export "__externref_table_dealloc") (param i32))
+)
+
+(; CHECK-ALL:
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (func (param i32)))
+  (type (;2;) (func (param externref)))
+  (func $closure0 externref shim (type 2) (param externref)
+    (local i32)
+    call $alloc
+    local.tee 1
+    local.get 0
+    table.set 1
+    local.get 1
+    call $foo)
+  (func $alloc (type 0) (result i32)
+    i32.const 0)
+  (func $foo (type 1) (param i32))
+  (table (;0;) 2 funcref)
+  (table (;1;) 32 externref)
+  (export "func" (table 0))
+  (elem (;0;) (i32.const 0) func $foo)
+  (elem (;1;) (i32.const 1) func $closure0 externref shim))
+;)