wasmtime: Initial, partial support for externref

This is enough to get an `externref -> externref` identity function
passing.

However, `externref`s that are dropped by compiled Wasm code are (safely)
leaked. Follow up work will leverage cranelift's stack maps to resolve this
issue.

tests/all/externals.rs

@@ -28,47 +28,27 @@ fn bad_tables() {
 
     // get out of bounds
     let ty = TableType::new(ValType::FuncRef, Limits::new(0, Some(1)));
-    let t = Table::new(
-        &Store::default(),
-        ty.clone(),
-        Val::ExternRef(ExternRef::Null),
-    )
-    .unwrap();
+    let t = Table::new(&Store::default(), ty.clone(), Val::ExternRef(None)).unwrap();
     assert!(t.get(0).is_none());
     assert!(t.get(u32::max_value()).is_none());
 
     // set out of bounds or wrong type
     let ty = TableType::new(ValType::FuncRef, Limits::new(1, Some(1)));
-    let t = Table::new(
-        &Store::default(),
-        ty.clone(),
-        Val::ExternRef(ExternRef::Null),
-    )
-    .unwrap();
+    let t = Table::new(&Store::default(), ty.clone(), Val::ExternRef(None)).unwrap();
     assert!(t.set(0, Val::I32(0)).is_err());
-    assert!(t.set(0, Val::ExternRef(ExternRef::Null)).is_ok());
-    assert!(t.set(1, Val::ExternRef(ExternRef::Null)).is_err());
+    assert!(t.set(0, Val::ExternRef(None)).is_ok());
+    assert!(t.set(1, Val::ExternRef(None)).is_err());
 
     // grow beyond max
     let ty = TableType::new(ValType::FuncRef, Limits::new(1, Some(1)));
-    let t = Table::new(
-        &Store::default(),
-        ty.clone(),
-        Val::ExternRef(ExternRef::Null),
-    )
-    .unwrap();
-    assert!(t.grow(0, Val::ExternRef(ExternRef::Null)).is_ok());
-    assert!(t.grow(1, Val::ExternRef(ExternRef::Null)).is_err());
+    let t = Table::new(&Store::default(), ty.clone(), Val::ExternRef(None)).unwrap();
+    assert!(t.grow(0, Val::ExternRef(None)).is_ok());
+    assert!(t.grow(1, Val::ExternRef(None)).is_err());
     assert_eq!(t.size(), 1);
 
     // grow wrong type
     let ty = TableType::new(ValType::FuncRef, Limits::new(1, Some(2)));
-    let t = Table::new(
-        &Store::default(),
-        ty.clone(),
-        Val::ExternRef(ExternRef::Null),
-    )
-    .unwrap();
+    let t = Table::new(&Store::default(), ty.clone(), Val::ExternRef(None)).unwrap();
     assert!(t.grow(1, Val::I32(0)).is_err());
     assert_eq!(t.size(), 1);
 }
@@ -88,7 +68,7 @@ fn cross_store() -> anyhow::Result<()> {
     let ty = MemoryType::new(Limits::new(1, None));
     let memory = Memory::new(&store2, ty);
     let ty = TableType::new(ValType::FuncRef, Limits::new(1, None));
-    let table = Table::new(&store2, ty, Val::ExternRef(ExternRef::Null))?;
+    let table = Table::new(&store2, ty, Val::ExternRef(None))?;
 
     let need_func = Module::new(&store1, r#"(module (import "" "" (func)))"#)?;
     assert!(Instance::new(&need_func, &[func.into()]).is_err());

tests/all/linker.rs

@@ -56,11 +56,11 @@ fn link_twice_bad() -> Result<()> {
 
     // tables
     let ty = TableType::new(ValType::FuncRef, Limits::new(1, None));
-    let table = Table::new(&store, ty, Val::ExternRef(ExternRef::Null))?;
+    let table = Table::new(&store, ty, Val::ExternRef(None))?;
     linker.define("", "", table.clone())?;
     assert!(linker.define("", "", table.clone()).is_err());
     let ty = TableType::new(ValType::FuncRef, Limits::new(2, None));
-    let table = Table::new(&store, ty, Val::ExternRef(ExternRef::Null))?;
+    let table = Table::new(&store, ty, Val::ExternRef(None))?;
     assert!(linker.define("", "", table.clone()).is_err());
     Ok(())
 }

tests/all/table.rs

@@ -4,9 +4,9 @@ use wasmtime::*;
 fn get_none() {
     let store = Store::default();
     let ty = TableType::new(ValType::FuncRef, Limits::new(1, None));
-    let table = Table::new(&store, ty, Val::ExternRef(ExternRef::Null)).unwrap();
+    let table = Table::new(&store, ty, Val::ExternRef(None)).unwrap();
     match table.get(0) {
-        Some(Val::ExternRef(ExternRef::Null)) => {}
+        Some(Val::ExternRef(None)) => {}
         _ => panic!(),
     }
     assert!(table.get(1).is_none());

tests/all/traps.rs

@@ -341,7 +341,7 @@ fn mismatched_arguments() -> Result<()> {
     );
     assert_eq!(
         func.call(&[Val::F32(0)]).unwrap_err().to_string(),
-        "argument type mismatch",
+        "argument type mismatch: found f32 but expected i32",
     );
     assert_eq!(
         func.call(&[Val::I32(0), Val::I32(1)])

tests/all/use_after_drop.rs

@@ -11,7 +11,7 @@ fn use_func_after_drop() -> Result<()> {
             assert_eq!(closed_over_data, "abcd");
         });
         let ty = TableType::new(ValType::FuncRef, Limits::new(1, None));
-        table = Table::new(&store, ty, Val::ExternRef(ExternRef::Null))?;
+        table = Table::new(&store, ty, Val::ExternRef(None))?;
         table.set(0, func.into())?;
     }
     let func = table.get(0).unwrap().funcref().unwrap().clone();

tests/misc_testsuite/reference-types/externref-id-function.wast

@@ -0,0 +1,8 @@
+(module
+  (func (export "identity") (param externref) (result externref)
+    local.get 0))
+
+(assert_return (invoke "identity" (ref.null extern))
+               (ref.null extern))
+(assert_return (invoke "identity" (ref.extern 1))
+               (ref.extern 1))