T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove explicit S type parameters (#5275)

Browse Source 
* Remove explicit `S` type parameters

This commit removes the explicit `S` type parameter on `Func::typed` and
`Instance::get_typed_func`. Historical versions of Rust required that
this be a type parameter but recent rustcs support a mixture of explicit
type parameters and `impl Trait`. This removes, at callsites, a
superfluous `, _` argument which otherwise never needs specification.

* Fix mdbook examples
This commit is contained in:
Alex Crichton
2022-11-15 23:04:26 -06:00
committed by GitHub
parent 8426904129
commit b0939f6626
50 changed files with 223 additions and 238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
tests/all/async_functions.rs
View File

@@ -14,7 +14,7 @@ async fn run_smoke_test(store: &mut Store<()>, func: Func) {
}
async fn run_smoke_typed_test(store: &mut Store<()>, func: Func) {
let func = func.typed::<(), (), _>(&store).unwrap();
let func = func.typed::<(), ()>(&store).unwrap();
func.call_async(&mut *store, ()).await.unwrap();
func.call_async(&mut *store, ()).await.unwrap();
}
@@ -545,8 +545,8 @@ async fn recursive_async() -> Result<()> {
)",
)?;
let i = Instance::new_async(&mut store, &m, &[]).await?;
let overflow = i.get_typed_func::<(), (), _>(&mut store, "overflow")?;
let normal = i.get_typed_func::<(), (), _>(&mut store, "normal")?;
let overflow = i.get_typed_func::<(), ()>(&mut store, "overflow")?;
let normal = i.get_typed_func::<(), ()>(&mut store, "normal")?;
let f2 = Func::wrap0_async(&mut store, move |mut caller| {
Box::new(async move {
// recursive async calls shouldn't immediately stack overflow...
@@ -600,7 +600,7 @@ async fn linker_module_command() -> Result<()> {
linker.module_async(&mut store, "", &module1).await?;
let instance = linker.instantiate_async(&mut store, &module2).await?;
let f = instance.get_typed_func::<(), i32, _>(&mut store, "get")?;
let f = instance.get_typed_func::<(), i32>(&mut store, "get")?;
assert_eq!(f.call_async(&mut store, ()).await?, 0);
assert_eq!(f.call_async(&mut store, ()).await?, 0);
@@ -638,7 +638,7 @@ async fn linker_module_reactor() -> Result<()> {
linker.module_async(&mut store, "", &module1).await?;
let instance = linker.instantiate_async(&mut store, &module2).await?;
let f = instance.get_typed_func::<(), i32, _>(&mut store, "get")?;
let f = instance.get_typed_func::<(), i32>(&mut store, "get")?;
assert_eq!(f.call_async(&mut store, ()).await?, 0);
assert_eq!(f.call_async(&mut store, ()).await?, 1);

18
tests/all/call_hook.rs
View File

@@ -76,7 +76,7 @@ fn call_wrapped_func() -> Result<(), Error> {
assert_eq!(store.data().calls_into_wasm, n);
assert_eq!(store.data().returns_from_wasm, n);
f.typed::<(i32, i64, f32, f64), (), _>(&store)?
f.typed::<(i32, i64, f32, f64), ()>(&store)?
.call(&mut store, (1, 2, 3.0, 4.0))?;
n += 1;
@@ -150,7 +150,7 @@ async fn call_wrapped_async_func() -> Result<(), Error> {
assert_eq!(store.data().calls_into_wasm, 1);
assert_eq!(store.data().returns_from_wasm, 1);
f.typed::<(i32, i64, f32, f64), (), _>(&store)?
f.typed::<(i32, i64, f32, f64), ()>(&store)?
.call_async(&mut store, (1, 2, 3.0, 4.0))
.await?;
@@ -218,7 +218,7 @@ fn call_linked_func() -> Result<(), Error> {
assert_eq!(store.data().calls_into_wasm, 1);
assert_eq!(store.data().returns_from_wasm, 1);
export.typed::<(), (), _>(&store)?.call(&mut store, ())?;
export.typed::<(), ()>(&store)?.call(&mut store, ())?;
assert_eq!(store.data().calls_into_host, 2);
assert_eq!(store.data().returns_from_host, 2);
@@ -290,7 +290,7 @@ async fn call_linked_func_async() -> Result<(), Error> {
assert_eq!(store.data().returns_from_wasm, 1);
export
.typed::<(), (), _>(&store)?
.typed::<(), ()>(&store)?
.call_async(&mut store, ())
.await?;
@@ -362,7 +362,7 @@ fn recursion() -> Result<(), Error> {
.expect("caller exports \"export\"")
.into_func()
.expect("export is a func")
.typed::<i32, (), _>(&caller)
.typed::<i32, ()>(&caller)
.expect("export typing")
.call(&mut caller, n - 1)
.unwrap()
@@ -398,7 +398,7 @@ fn recursion() -> Result<(), Error> {
assert_eq!(store.data().returns_from_wasm, n + 1);
export
.typed::<i32, (), _>(&store)?
.typed::<i32, ()>(&store)?
.call(&mut store, n as i32)?;
assert_eq!(store.data().calls_into_host, 2 * (n + 1));
@@ -445,7 +445,7 @@ fn trapping() -> Result<(), Error> {
.expect("caller exports \"export\"")
.into_func()
.expect("export is a func")
.typed::<(i32, i32), (), _>(&caller)
.typed::<(i32, i32), ()>(&caller)
.expect("export typing")
.call(&mut caller, (action, 0))?;
}
@@ -676,7 +676,7 @@ async fn timeout_async_hook() -> Result<(), Error> {
let inst = linker.instantiate_async(&mut store, &module).await?;
let export = inst
.get_typed_func::<(), (), _>(&mut store, "export")
.get_typed_func::<(), ()>(&mut store, "export")
.expect("export is func");
store.set_epoch_deadline(1);
@@ -743,7 +743,7 @@ async fn drop_suspended_async_hook() -> Result<(), Error> {
let inst = linker.instantiate_async(&mut store, &module).await?;
assert_eq!(*store.data(), 0);
let export = inst
.get_typed_func::<(), (), _>(&mut store, "")
.get_typed_func::<(), ()>(&mut store, "")
.expect("export is func");
// First test that if we drop in the middle of an async hook that everything

6
tests/all/custom_signal_handler.rs
View File

@@ -47,7 +47,7 @@ mod tests {
fn invoke_export(store: &mut Store<()>, instance: Instance, func_name: &str) -> Result<i32> {
let ret = instance
.get_typed_func::<(), i32, _>(&mut *store, func_name)?
.get_typed_func::<(), i32>(&mut *store, func_name)?
.call(store, ())?;
Ok(ret)
}
@@ -175,7 +175,7 @@ mod tests {
// these invoke wasmtime_call_trampoline from callable.rs
{
let read_func = instance.get_typed_func::<(), i32, _>(&mut store, "read")?;
let read_func = instance.get_typed_func::<(), i32>(&mut store, "read")?;
println!("calling read...");
let result = read_func
.call(&mut store, ())
@@ -185,7 +185,7 @@ mod tests {
{
let read_out_of_bounds_func =
instance.get_typed_func::<(), i32, _>(&mut store, "read_out_of_bounds")?;
instance.get_typed_func::<(), i32>(&mut store, "read_out_of_bounds")?;
println!("calling read_out_of_bounds...");
let trap = read_out_of_bounds_func
.call(&mut store, ())

4
tests/all/externals.rs
View File

@@ -133,8 +133,8 @@ fn cross_store() -> anyhow::Result<()> {
.call(&mut store2, &[Some(s2_f.clone()).into()], &mut [])
.is_ok());
let s1_f_t = s1_f.typed::<Option<Func>, (), _>(&store1)?;
let s2_f_t = s2_f.typed::<Option<Func>, (), _>(&store2)?;
let s1_f_t = s1_f.typed::<Option<Func>, ()>(&store1)?;
let s2_f_t = s2_f.typed::<Option<Func>, ()>(&store2)?;
assert!(s1_f_t.call(&mut store1, None).is_ok());
assert!(s2_f_t.call(&mut store2, None).is_ok());

4
tests/all/fuel.rs
View File

@@ -170,9 +170,7 @@ fn host_function_consumes_all() {
});
let instance = Instance::new(&mut store, &module, &[func.into()]).unwrap();
let export = instance
.get_typed_func::<(), (), _>(&mut store, "")
.unwrap();
let export = instance.get_typed_func::<(), ()>(&mut store, "").unwrap();
let trap = export.call(&mut store, ()).unwrap_err();
assert!(
format!("{trap:?}").contains("all fuel consumed"),

116
tests/all/func.rs
View File

@@ -246,40 +246,40 @@ fn trap_import() -> Result<()> {
fn get_from_wrapper() {
let mut store = Store::<()>::default();
let f = Func::wrap(&mut store, || {});
assert!(f.typed::<(), (), _>(&store).is_ok());
assert!(f.typed::<(), i32, _>(&store).is_err());
assert!(f.typed::<(), (), _>(&store).is_ok());
assert!(f.typed::<i32, (), _>(&store).is_err());
assert!(f.typed::<i32, i32, _>(&store).is_err());
assert!(f.typed::<(i32, i32), (), _>(&store).is_err());
assert!(f.typed::<(i32, i32), i32, _>(&store).is_err());
assert!(f.typed::<(), ()>(&store).is_ok());
assert!(f.typed::<(), i32>(&store).is_err());
assert!(f.typed::<(), ()>(&store).is_ok());
assert!(f.typed::<i32, ()>(&store).is_err());
assert!(f.typed::<i32, i32>(&store).is_err());
assert!(f.typed::<(i32, i32), ()>(&store).is_err());
assert!(f.typed::<(i32, i32), i32>(&store).is_err());
let f = Func::wrap(&mut store, || -> i32 { loop {} });
assert!(f.typed::<(), i32, _>(&store).is_ok());
assert!(f.typed::<(), i32>(&store).is_ok());
let f = Func::wrap(&mut store, || -> f32 { loop {} });
assert!(f.typed::<(), f32, _>(&store).is_ok());
assert!(f.typed::<(), f32>(&store).is_ok());
let f = Func::wrap(&mut store, || -> f64 { loop {} });
assert!(f.typed::<(), f64, _>(&store).is_ok());
assert!(f.typed::<(), f64>(&store).is_ok());
let f = Func::wrap(&mut store, || -> Option<ExternRef> { loop {} });
assert!(f.typed::<(), Option<ExternRef>, _>(&store).is_ok());
assert!(f.typed::<(), Option<ExternRef>>(&store).is_ok());
let f = Func::wrap(&mut store, || -> Option<Func> { loop {} });
assert!(f.typed::<(), Option<Func>, _>(&store).is_ok());
assert!(f.typed::<(), Option<Func>>(&store).is_ok());
let f = Func::wrap(&mut store, |_: i32| {});
assert!(f.typed::<i32, (), _>(&store).is_ok());
assert!(f.typed::<i64, (), _>(&store).is_err());
assert!(f.typed::<f32, (), _>(&store).is_err());
assert!(f.typed::<f64, (), _>(&store).is_err());
assert!(f.typed::<i32, ()>(&store).is_ok());
assert!(f.typed::<i64, ()>(&store).is_err());
assert!(f.typed::<f32, ()>(&store).is_err());
assert!(f.typed::<f64, ()>(&store).is_err());
let f = Func::wrap(&mut store, |_: i64| {});
assert!(f.typed::<i64, (), _>(&store).is_ok());
assert!(f.typed::<i64, ()>(&store).is_ok());
let f = Func::wrap(&mut store, |_: f32| {});
assert!(f.typed::<f32, (), _>(&store).is_ok());
assert!(f.typed::<f32, ()>(&store).is_ok());
let f = Func::wrap(&mut store, |_: f64| {});
assert!(f.typed::<f64, (), _>(&store).is_ok());
assert!(f.typed::<f64, ()>(&store).is_ok());
let f = Func::wrap(&mut store, |_: Option<ExternRef>| {});
assert!(f.typed::<Option<ExternRef>, (), _>(&store).is_ok());
assert!(f.typed::<Option<ExternRef>, ()>(&store).is_ok());
let f = Func::wrap(&mut store, |_: Option<Func>| {});
assert!(f.typed::<Option<Func>, (), _>(&store).is_ok());
assert!(f.typed::<Option<Func>, ()>(&store).is_ok());
}
#[test]
@@ -287,16 +287,16 @@ fn get_from_signature() {
let mut store = Store::<()>::default();
let ty = FuncType::new(None, None);
let f = Func::new(&mut store, ty, |_, _, _| panic!());
assert!(f.typed::<(), (), _>(&store).is_ok());
assert!(f.typed::<(), i32, _>(&store).is_err());
assert!(f.typed::<i32, (), _>(&store).is_err());
assert!(f.typed::<(), ()>(&store).is_ok());
assert!(f.typed::<(), i32>(&store).is_err());
assert!(f.typed::<i32, ()>(&store).is_err());
let ty = FuncType::new(Some(ValType::I32), Some(ValType::F64));
let f = Func::new(&mut store, ty, |_, _, _| panic!());
assert!(f.typed::<(), (), _>(&store).is_err());
assert!(f.typed::<(), i32, _>(&store).is_err());
assert!(f.typed::<i32, (), _>(&store).is_err());
assert!(f.typed::<i32, f64, _>(&store).is_ok());
assert!(f.typed::<(), ()>(&store).is_err());
assert!(f.typed::<(), i32>(&store).is_err());
assert!(f.typed::<i32, ()>(&store).is_err());
assert!(f.typed::<i32, f64>(&store).is_ok());
}
#[test]
@@ -316,17 +316,17 @@ fn get_from_module() -> anyhow::Result<()> {
)?;
let instance = Instance::new(&mut store, &module, &[])?;
let f0 = instance.get_func(&mut store, "f0").unwrap();
assert!(f0.typed::<(), (), _>(&store).is_ok());
assert!(f0.typed::<(), i32, _>(&store).is_err());
assert!(f0.typed::<(), ()>(&store).is_ok());
assert!(f0.typed::<(), i32>(&store).is_err());
let f1 = instance.get_func(&mut store, "f1").unwrap();
assert!(f1.typed::<(), (), _>(&store).is_err());
assert!(f1.typed::<i32, (), _>(&store).is_ok());
assert!(f1.typed::<i32, f32, _>(&store).is_err());
assert!(f1.typed::<(), ()>(&store).is_err());
assert!(f1.typed::<i32, ()>(&store).is_ok());
assert!(f1.typed::<i32, f32>(&store).is_err());
let f2 = instance.get_func(&mut store, "f2").unwrap();
assert!(f2.typed::<(), (), _>(&store).is_err());
assert!(f2.typed::<(), i32, _>(&store).is_ok());
assert!(f2.typed::<i32, (), _>(&store).is_err());
assert!(f2.typed::<i32, f32, _>(&store).is_err());
assert!(f2.typed::<(), ()>(&store).is_err());
assert!(f2.typed::<(), i32>(&store).is_ok());
assert!(f2.typed::<i32, ()>(&store).is_err());
assert!(f2.typed::<i32, f32>(&store).is_err());
Ok(())
}
@@ -344,29 +344,29 @@ fn call_wrapped_func() -> Result<()> {
&[Val::I32(1), Val::I64(2), 3.0f32.into(), 4.0f64.into()],
&mut [],
)?;
f.typed::<(i32, i64, f32, f64), (), _>(&store)?
f.typed::<(i32, i64, f32, f64), ()>(&store)?
.call(&mut store, (1, 2, 3.0, 4.0))?;
let mut results = [Val::I32(0)];
let f = Func::wrap(&mut store, || 1i32);
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_i32(), 1);
assert_eq!(f.typed::<(), i32, _>(&store)?.call(&mut store, ())?, 1);
assert_eq!(f.typed::<(), i32>(&store)?.call(&mut store, ())?, 1);
let f = Func::wrap(&mut store, || 2i64);
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_i64(), 2);
assert_eq!(f.typed::<(), i64, _>(&store)?.call(&mut store, ())?, 2);
assert_eq!(f.typed::<(), i64>(&store)?.call(&mut store, ())?, 2);
let f = Func::wrap(&mut store, || 3.0f32);
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_f32(), 3.0);
assert_eq!(f.typed::<(), f32, _>(&store)?.call(&mut store, ())?, 3.0);
assert_eq!(f.typed::<(), f32>(&store)?.call(&mut store, ())?, 3.0);
let f = Func::wrap(&mut store, || 4.0f64);
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_f64(), 4.0);
assert_eq!(f.typed::<(), f64, _>(&store)?.call(&mut store, ())?, 4.0);
assert_eq!(f.typed::<(), f64>(&store)?.call(&mut store, ())?, 4.0);
Ok(())
}
@@ -502,7 +502,7 @@ fn pass_cross_store_arg() -> anyhow::Result<()> {
// And using `.get` followed by a function call also fails with cross-Store
// arguments.
let f = store1_func.typed::<Option<Func>, (), _>(&store1)?;
let f = store1_func.typed::<Option<Func>, ()>(&store1)?;
let result = f.call(&mut store1, Some(store2_func));
assert!(result.is_err());
assert!(result.unwrap_err().to_string().contains("cross-`Store`"));
@@ -572,18 +572,17 @@ fn typed_multiple_results() -> anyhow::Result<()> {
)?;
let instance = Instance::new(&mut store, &module, &[])?;
let f0 = instance.get_func(&mut store, "f0").unwrap();
assert!(f0.typed::<(), (), _>(&store).is_err());
assert!(f0.typed::<(), (i32, f32), _>(&store).is_err());
assert!(f0.typed::<(), i32, _>(&store).is_err());
assert!(f0.typed::<(), ()>(&store).is_err());
assert!(f0.typed::<(), (i32, f32)>(&store).is_err());
assert!(f0.typed::<(), i32>(&store).is_err());
assert_eq!(
f0.typed::<(), (i32, i64), _>(&store)?
.call(&mut store, ())?,
f0.typed::<(), (i32, i64)>(&store)?.call(&mut store, ())?,
(0, 1)
);
let f1 = instance.get_func(&mut store, "f1").unwrap();
assert_eq!(
f1.typed::<(i32, i32, i32), (f32, f64), _>(&store)?
f1.typed::<(i32, i32, i32), (f32, f64)>(&store)?
.call(&mut store, (1, 2, 3))?,
(2., 3.)
);
@@ -610,7 +609,7 @@ fn trap_doesnt_leak() -> anyhow::Result<()> {
drop(&canary1);
bail!("")
});
assert!(f1.typed::<(), (), _>(&store)?.call(&mut store, ()).is_err());
assert!(f1.typed::<(), ()>(&store)?.call(&mut store, ()).is_err());
assert!(f1.call(&mut store, &[], &mut []).is_err());
// test that `Func::new` is correct
@@ -620,7 +619,7 @@ fn trap_doesnt_leak() -> anyhow::Result<()> {
drop(&canary2);
bail!("")
});
assert!(f2.typed::<(), (), _>(&store)?.call(&mut store, ()).is_err());
assert!(f2.typed::<(), ()>(&store)?.call(&mut store, ()).is_err());
assert!(f2.call(&mut store, &[], &mut []).is_err());
// drop everything and ensure dtors are run
@@ -646,7 +645,7 @@ fn wrap_multiple_results() -> anyhow::Result<()> {
{
let f = Func::wrap(&mut *store, move || t);
let mut results = vec![Val::I32(0); f.ty(&store).results().len()];
assert_eq!(f.typed::<(), T, _>(&store)?.call(&mut *store, ())?, t);
assert_eq!(f.typed::<(), T>(&store)?.call(&mut *store, ())?, t);
f.call(&mut *store, &[], &mut results)?;
assert!(t.eq_values(&results));
@@ -654,7 +653,7 @@ fn wrap_multiple_results() -> anyhow::Result<()> {
let instance = Instance::new(&mut *store, &module, &[f.into()])?;
let f = instance.get_func(&mut *store, "foo").unwrap();
assert_eq!(f.typed::<(), T, _>(&store)?.call(&mut *store, ())?, t);
assert_eq!(f.typed::<(), T>(&store)?.call(&mut *store, ())?, t);
f.call(&mut *store, &[], &mut results)?;
assert!(t.eq_values(&results));
Ok(())
@@ -814,7 +813,7 @@ fn trampoline_for_declared_elem() -> anyhow::Result<()> {
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let g = instance.get_typed_func::<(), Option<Func>, _>(&mut store, "g")?;
let g = instance.get_typed_func::<(), Option<Func>>(&mut store, "g")?;
let func = g.call(&mut store, ())?;
func.unwrap().call(&mut store, &[], &mut [])?;
@@ -871,8 +870,7 @@ fn wasm_ty_roundtrip() -> Result<(), anyhow::Error> {
"#,
)?;
let instance = Instance::new(&mut store, &module, &[debug.into()])?;
let foo =
instance.get_typed_func::<(i32, u32, f32, i64, u64, f64), (), _>(&mut store, "foo")?;
let foo = instance.get_typed_func::<(i32, u32, f32, i64, u64, f64), ()>(&mut store, "foo")?;
foo.call(&mut store, (-1, 1, 2.0, -3, 3, 4.0))?;
Ok(())
}
@@ -892,14 +890,14 @@ fn typed_funcs_count_params_correctly_in_error_messages() -> anyhow::Result<()>
let instance = Instance::new(&mut store, &module, &[])?;
// Too few parameters.
match instance.get_typed_func::<(), (), _>(&mut store, "f") {
match instance.get_typed_func::<(), ()>(&mut store, "f") {
Ok(_) => panic!("should be wrong signature"),
Err(e) => {
let msg = format!("{:?}", e);
assert!(dbg!(msg).contains("expected 0 types, found 2"))
}
}
match instance.get_typed_func::<(i32,), (), _>(&mut store, "f") {
match instance.get_typed_func::<(i32,), ()>(&mut store, "f") {
Ok(_) => panic!("should be wrong signature"),
Err(e) => {
let msg = format!("{:?}", e);
@@ -908,7 +906,7 @@ fn typed_funcs_count_params_correctly_in_error_messages() -> anyhow::Result<()>
}
// Too many parameters.
match instance.get_typed_func::<(i32, i32, i32), (), _>(&mut store, "f") {
match instance.get_typed_func::<(i32, i32, i32), ()>(&mut store, "f") {
Ok(_) => panic!("should be wrong signature"),
Err(e) => {
let msg = format!("{:?}", e);

8
tests/all/gc.rs
View File

@@ -285,7 +285,7 @@ fn global_drops_externref() -> anyhow::Result<()> {
"#,
)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run = instance.get_typed_func::<Option<ExternRef>, (), _>(&mut store, "run")?;
let run = instance.get_typed_func::<Option<ExternRef>, ()>(&mut store, "run")?;
let flag = Arc::new(AtomicBool::new(false));
let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
run.call(&mut store, Some(externref))?;
@@ -335,7 +335,7 @@ fn table_drops_externref() -> anyhow::Result<()> {
"#,
)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run = instance.get_typed_func::<Option<ExternRef>, (), _>(&mut store, "run")?;
let run = instance.get_typed_func::<Option<ExternRef>, ()>(&mut store, "run")?;
let flag = Arc::new(AtomicBool::new(false));
let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
run.call(&mut store, Some(externref))?;
@@ -387,7 +387,7 @@ fn gee_i_sure_hope_refcounting_is_atomic() -> anyhow::Result<()> {
)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run = instance.get_typed_func::<Option<ExternRef>, (), _>(&mut store, "run")?;
let run = instance.get_typed_func::<Option<ExternRef>, ()>(&mut store, "run")?;
let flag = Arc::new(AtomicBool::new(false));
let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
@@ -482,7 +482,7 @@ fn no_gc_middle_of_args() -> anyhow::Result<()> {
)?;
let instance = linker.instantiate(&mut store, &module)?;
let func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
func.call(&mut store, ())?;
Ok(())

28
tests/all/host_funcs.rs
View File

@@ -430,7 +430,7 @@ fn call_wasm_many_args() -> Result<()> {
)?;
let typed_run = instance
.get_typed_func::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), (), _>(
.get_typed_func::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>(
&mut store, "run",
)?;
typed_run.call(&mut store, (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))?;
@@ -499,19 +499,19 @@ fn new_from_signature() -> Result<()> {
.unwrap()
.into_func()
.unwrap();
assert!(f.typed::<(), (), _>(&store).is_ok());
assert!(f.typed::<(), i32, _>(&store).is_err());
assert!(f.typed::<i32, (), _>(&store).is_err());
assert!(f.typed::<(), ()>(&store).is_ok());
assert!(f.typed::<(), i32>(&store).is_err());
assert!(f.typed::<i32, ()>(&store).is_err());
let f = linker
.get(&mut store, "", "f2")
.unwrap()
.into_func()
.unwrap();
assert!(f.typed::<(), (), _>(&store).is_err());
assert!(f.typed::<(), i32, _>(&store).is_err());
assert!(f.typed::<i32, (), _>(&store).is_err());
assert!(f.typed::<i32, f64, _>(&store).is_ok());
assert!(f.typed::<(), ()>(&store).is_err());
assert!(f.typed::<(), i32>(&store).is_err());
assert!(f.typed::<i32, ()>(&store).is_err());
assert!(f.typed::<i32, f64>(&store).is_ok());
Ok(())
}
@@ -549,7 +549,7 @@ fn call_wrapped_func() -> Result<()> {
&[Val::I32(1), Val::I64(2), 3.0f32.into(), 4.0f64.into()],
&mut [],
)?;
f.typed::<(i32, i64, f32, f64), (), _>(&store)?
f.typed::<(i32, i64, f32, f64), ()>(&store)?
.call(&mut store, (1, 2, 3.0, 4.0))?;
let f = linker
@@ -559,7 +559,7 @@ fn call_wrapped_func() -> Result<()> {
.unwrap();
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_i32(), 1);
assert_eq!(f.typed::<(), i32, _>(&store)?.call(&mut store, ())?, 1);
assert_eq!(f.typed::<(), i32>(&store)?.call(&mut store, ())?, 1);
let f = linker
.get(&mut store, "", "f3")
@@ -568,7 +568,7 @@ fn call_wrapped_func() -> Result<()> {
.unwrap();
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_i64(), 2);
assert_eq!(f.typed::<(), i64, _>(&store)?.call(&mut store, ())?, 2);
assert_eq!(f.typed::<(), i64>(&store)?.call(&mut store, ())?, 2);
let f = linker
.get(&mut store, "", "f4")
@@ -577,7 +577,7 @@ fn call_wrapped_func() -> Result<()> {
.unwrap();
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_f32(), 3.0);
assert_eq!(f.typed::<(), f32, _>(&store)?.call(&mut store, ())?, 3.0);
assert_eq!(f.typed::<(), f32>(&store)?.call(&mut store, ())?, 3.0);
let f = linker
.get(&mut store, "", "f5")
@@ -586,7 +586,7 @@ fn call_wrapped_func() -> Result<()> {
.unwrap();
f.call(&mut store, &[], &mut results)?;
assert_eq!(results[0].unwrap_f64(), 4.0);
assert_eq!(f.typed::<(), f64, _>(&store)?.call(&mut store, ())?, 4.0);
assert_eq!(f.typed::<(), f64>(&store)?.call(&mut store, ())?, 4.0);
Ok(())
}
@@ -714,7 +714,7 @@ fn wasi_imports() -> Result<()> {
let mut store = Store::new(&engine, WasiCtxBuilder::new().build());
let instance = linker.instantiate(&mut store, &module)?;
let start = instance.get_typed_func::<(), (), _>(&mut store, "_start")?;
let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
let exit = start
.call(&mut store, ())
.unwrap_err()

8
tests/all/iloop.rs
View File

@@ -29,7 +29,7 @@ fn loops_interruptable() -> anyhow::Result<()> {
let mut store = interruptable_store();
let module = Module::new(store.engine(), r#"(func (export "loop") (loop br 0))"#)?;
let instance = Instance::new(&mut store, &module, &[])?;
let iloop = instance.get_typed_func::<(), (), _>(&mut store, "loop")?;
let iloop = instance.get_typed_func::<(), ()>(&mut store, "loop")?;
store.engine().increment_epoch();
let trap = iloop.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
assert_eq!(trap, Trap::Interrupt);
@@ -42,7 +42,7 @@ fn functions_interruptable() -> anyhow::Result<()> {
let module = hugely_recursive_module(store.engine())?;
let func = Func::wrap(&mut store, || {});
let instance = Instance::new(&mut store, &module, &[func.into()])?;
let iloop = instance.get_typed_func::<(), (), _>(&mut store, "loop")?;
let iloop = instance.get_typed_func::<(), ()>(&mut store, "loop")?;
store.engine().increment_epoch();
let trap = iloop.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
assert_eq!(trap, Trap::Interrupt);
@@ -89,7 +89,7 @@ fn loop_interrupt_from_afar() -> anyhow::Result<()> {
// Enter the infinitely looping function and assert that our interrupt
// handle does indeed actually interrupt the function.
let iloop = instance.get_typed_func::<(), (), _>(&mut store, "loop")?;
let iloop = instance.get_typed_func::<(), ()>(&mut store, "loop")?;
let trap = iloop.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
STOP.store(true, SeqCst);
thread.join().unwrap();
@@ -125,7 +125,7 @@ fn function_interrupt_from_afar() -> anyhow::Result<()> {
// Enter the infinitely looping function and assert that our interrupt
// handle does indeed actually interrupt the function.
let iloop = instance.get_typed_func::<(), (), _>(&mut store, "loop")?;
let iloop = instance.get_typed_func::<(), ()>(&mut store, "loop")?;
let trap = iloop.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
STOP.store(true, SeqCst);
thread.join().unwrap();

2
tests/all/import_indexes.rs
View File

@@ -43,7 +43,7 @@ fn same_import_names_still_distinct() -> anyhow::Result<()> {
];
let instance = Instance::new(&mut store, &module, &imports)?;
let func = instance.get_typed_func::<(), i32, _>(&mut store, "foo")?;
let func = instance.get_typed_func::<(), i32>(&mut store, "foo")?;
let result = func.call(&mut store, ())?;
assert_eq!(result, 3);
Ok(())

4
tests/all/instance.rs
View File

@@ -63,8 +63,8 @@ fn linear_memory_limits() -> Result<()> {
let mut store = Store::new(engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let size = instance.get_typed_func::<(), i32, _>(&mut store, "size")?;
let grow = instance.get_typed_func::<(), i32, _>(&mut store, "grow")?;
let size = instance.get_typed_func::<(), i32>(&mut store, "size")?;
let grow = instance.get_typed_func::<(), i32>(&mut store, "grow")?;
assert_eq!(size.call(&mut store, ())?, 65534);
assert_eq!(grow.call(&mut store, ())?, 65534);

10
tests/all/limits.rs
View File

@@ -78,7 +78,7 @@ fn test_limits() -> Result<()> {
store.limiter(|s| s as &mut dyn ResourceLimiter);
let instance = Instance::new(&mut store, &module, &[])?;
let grow = instance.get_func(&mut store, "grow").unwrap();
let grow = grow.typed::<i32, i32, _>(&store).unwrap();
let grow = grow.typed::<i32, i32>(&store).unwrap();
grow.call(&mut store, 3).unwrap();
grow.call(&mut store, 5).unwrap();
@@ -464,7 +464,7 @@ fn test_custom_memory_limiter() -> Result<()> {
assert!(!store.data().limit_exceeded);
// Grow the host "memory" by 384 KiB
let f = instance.get_typed_func::<u32, u32, _>(&mut store, "f")?;
let f = instance.get_typed_func::<u32, u32>(&mut store, "f")?;
assert_eq!(f.call(&mut store, 1 * 0x10000)?, 1);
assert_eq!(f.call(&mut store, 3 * 0x10000)?, 1);
@@ -576,7 +576,7 @@ async fn test_custom_memory_limiter_async() -> Result<()> {
assert!(!store.data().limit_exceeded);
// Grow the host "memory" by 384 KiB
let f = instance.get_typed_func::<u32, u32, _>(&mut store, "f")?;
let f = instance.get_typed_func::<u32, u32>(&mut store, "f")?;
assert_eq!(f.call_async(&mut store, 1 * 0x10000).await?, 1);
assert_eq!(f.call_async(&mut store, 3 * 0x10000).await?, 1);
@@ -965,7 +965,7 @@ fn panic_in_memory_limiter_wasm_stack() {
store.limiter(|s| s as &mut dyn ResourceLimiter);
let instance = linker.instantiate(&mut store, &module).unwrap();
let grow = instance.get_func(&mut store, "grow").unwrap();
let grow = grow.typed::<i32, i32, _>(&store).unwrap();
let grow = grow.typed::<i32, i32>(&store).unwrap();
// Grow the memory, which should panic
grow.call(&mut store, 3).unwrap();
@@ -1032,7 +1032,7 @@ async fn panic_in_async_memory_limiter_wasm_stack() {
store.limiter_async(|s| s as &mut dyn ResourceLimiterAsync);
let instance = linker.instantiate_async(&mut store, &module).await.unwrap();
let grow = instance.get_func(&mut store, "grow").unwrap();
let grow = grow.typed::<i32, i32, _>(&store).unwrap();
let grow = grow.typed::<i32, i32>(&store).unwrap();
// Grow the memory, which should panic
grow.call_async(&mut store, 3).await.unwrap();

6
tests/all/linker.rs
View File

@@ -101,7 +101,7 @@ fn function_interposition() -> Result<()> {
.unwrap()
.into_func()
.unwrap();
let func = func.typed::<(), i32, _>(&store)?;
let func = func.typed::<(), i32>(&store)?;
assert_eq!(func.call(&mut store, ())?, 112);
Ok(())
}
@@ -134,7 +134,7 @@ fn function_interposition_renamed() -> Result<()> {
}
let instance = linker.instantiate(&mut store, &module)?;
let func = instance.get_func(&mut store, "export").unwrap();
let func = func.typed::<(), i32, _>(&store)?;
let func = func.typed::<(), i32>(&store)?;
assert_eq!(func.call(&mut store, ())?, 112);
Ok(())
}
@@ -167,7 +167,7 @@ fn module_interposition() -> Result<()> {
.unwrap()
.into_func()
.unwrap();
let func = func.typed::<(), i32, _>(&store)?;
let func = func.typed::<(), i32>(&store)?;
assert_eq!(func.call(&mut store, ())?, 112);
Ok(())
}

2
tests/all/memory.rs
View File

@@ -346,7 +346,7 @@ fn tiny_static_heap() -> Result<()> {
)?;
let i = Instance::new(&mut store, &module, &[])?;
let f = i.get_typed_func::<(), (), _>(&mut store, "run")?;
let f = i.get_typed_func::<(), ()>(&mut store, "run")?;
f.call(&mut store, ())?;
Ok(())
}

2
tests/all/module.rs
View File

@@ -62,7 +62,7 @@ fn aot_compiles() -> Result<()> {
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let f = instance.get_typed_func::<i32, i32, _>(&mut store, "f")?;
let f = instance.get_typed_func::<i32, i32>(&mut store, "f")?;
assert_eq!(f.call(&mut store, 101)?, 101);
Ok(())

4
tests/all/module_serialize.rs
View File

@@ -51,7 +51,7 @@ fn test_module_serialize_simple() -> Result<()> {
let mut store = Store::default();
let instance = unsafe { deserialize_and_instantiate(&mut store, &buffer)? };
let run = instance.get_typed_func::<(), i32, _>(&mut store, "run")?;
let run = instance.get_typed_func::<(), i32>(&mut store, "run")?;
let result = run.call(&mut store, ())?;
assert_eq!(42, result);
@@ -98,7 +98,7 @@ fn test_deserialize_from_file() -> Result<()> {
fs::write(&path, &buffer)?;
let module = unsafe { Module::deserialize_file(store.engine(), &path)? };
let instance = Instance::new(&mut store, &module, &[])?;
let func = instance.get_typed_func::<(), i32, _>(&mut store, "run")?;
let func = instance.get_typed_func::<(), i32>(&mut store, "run")?;
assert_eq!(func.call(&mut store, ())?, 42);
Ok(())
}

22
tests/all/pooling_allocator.rs
View File

@@ -67,7 +67,7 @@ fn memory_limit() -> Result<()> {
{
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let f = instance.get_typed_func::<(), i32, _>(&mut store, "f")?;
let f = instance.get_typed_func::<(), i32>(&mut store, "f")?;
assert_eq!(f.call(&mut store, ()).expect("function should not trap"), 0);
assert_eq!(f.call(&mut store, ()).expect("function should not trap"), 1);
@@ -149,7 +149,7 @@ fn memory_guard_page_trap() -> Result<()> {
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let m = instance.get_memory(&mut store, "m").unwrap();
let f = instance.get_typed_func::<i32, (), _>(&mut store, "f")?;
let f = instance.get_typed_func::<i32, ()>(&mut store, "f")?;
let trap = f
.call(&mut store, 0)
@@ -273,7 +273,7 @@ fn table_limit() -> Result<()> {
{
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let f = instance.get_typed_func::<(), i32, _>(&mut store, "f")?;
let f = instance.get_typed_func::<(), i32>(&mut store, "f")?;
for i in 0..TABLE_ELEMENTS {
assert_eq!(
@@ -611,7 +611,7 @@ fn switch_image_and_non_image() -> Result<()> {
let assert_zero = || -> Result<()> {
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module1, &[])?;
let func = instance.get_typed_func::<i32, i32, _>(&mut store, "load")?;
let func = instance.get_typed_func::<i32, i32>(&mut store, "load")?;
assert_eq!(func.call(&mut store, 0)?, 0);
Ok(())
};
@@ -719,10 +719,10 @@ fn dynamic_memory_pooling_allocator() -> Result<()> {
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let grow = instance.get_typed_func::<u32, i32, _>(&mut store, "grow")?;
let size = instance.get_typed_func::<(), u32, _>(&mut store, "size")?;
let i32_load = instance.get_typed_func::<u32, i32, _>(&mut store, "i32.load")?;
let i32_store = instance.get_typed_func::<(u32, i32), (), _>(&mut store, "i32.store")?;
let grow = instance.get_typed_func::<u32, i32>(&mut store, "grow")?;
let size = instance.get_typed_func::<(), u32>(&mut store, "size")?;
let i32_load = instance.get_typed_func::<u32, i32>(&mut store, "i32.load")?;
let i32_store = instance.get_typed_func::<(u32, i32), ()>(&mut store, "i32.store")?;
let memory = instance.get_memory(&mut store, "memory").unwrap();
// basic length 1 tests
@@ -757,7 +757,7 @@ fn dynamic_memory_pooling_allocator() -> Result<()> {
// Re-instantiate in another store.
store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let i32_load = instance.get_typed_func::<u32, i32, _>(&mut store, "i32.load")?;
let i32_load = instance.get_typed_func::<u32, i32>(&mut store, "i32.load")?;
let memory = instance.get_memory(&mut store, "memory").unwrap();
// Technically this is out of bounds...
@@ -806,8 +806,8 @@ fn zero_memory_pages_disallows_oob() -> Result<()> {
)?;
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let load32 = instance.get_typed_func::<i32, i32, _>(&mut store, "load")?;
let store32 = instance.get_typed_func::<i32, (), _>(&mut store, "store")?;
let load32 = instance.get_typed_func::<i32, i32>(&mut store, "load")?;
let store32 = instance.get_typed_func::<i32, ()>(&mut store, "store")?;
for i in 0..31 {
assert!(load32.call(&mut store, 1 << i).is_err());
assert!(store32.call(&mut store, 1 << i).is_err());

6
tests/all/relocs.rs
View File

@@ -43,7 +43,7 @@ fn forward_call_works() -> Result<()> {
)?;
let i = Instance::new(&mut store, &module, &[])?;
let foo = i.get_typed_func::<(), i32, _>(&mut store, "foo")?;
let foo = i.get_typed_func::<(), i32>(&mut store, "foo")?;
assert_eq!(foo.call(&mut store, ())?, 4);
Ok(())
}
@@ -64,7 +64,7 @@ fn backwards_call_works() -> Result<()> {
)?;
let i = Instance::new(&mut store, &module, &[])?;
let foo = i.get_typed_func::<(), i32, _>(&mut store, "foo")?;
let foo = i.get_typed_func::<(), i32>(&mut store, "foo")?;
assert_eq!(foo.call(&mut store, ())?, 4);
Ok(())
}
@@ -108,7 +108,7 @@ fn test_many_call_module(mut store: Store<()>) -> Result<()> {
for i in 0..N {
let name = i.to_string();
let func = instance.get_typed_func::<(), (i32, i32), _>(&mut store, &name)?;
let func = instance.get_typed_func::<(), (i32, i32)>(&mut store, &name)?;
let (a, b) = func.call(&mut store, ())?;
assert_eq!(a, i + 1);
assert_eq!(b, i + 2);

2
tests/all/stack_overflow.rs
View File

@@ -24,7 +24,7 @@ fn host_always_has_some_stack() -> anyhow::Result<()> {
)?;
let func = Func::wrap(&mut store, test_host_stack);
let instance = Instance::new(&mut store, &module, &[func.into()])?;
let foo = instance.get_typed_func::<(), (), _>(&mut store, "foo")?;
let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
// Make sure that our function traps and the trap says that the call stack
// has been exhausted.

10
tests/all/threads.rs
View File

@@ -82,10 +82,10 @@ fn test_sharing_of_shared_memory() -> Result<()> {
]
});
let instance1_first_word = instance1
.get_typed_func::<(), i32, _>(&mut store, "first_word")?
.get_typed_func::<(), i32>(&mut store, "first_word")?
.call(&mut store, ())?;
let instance2_first_word = instance2
.get_typed_func::<(), i32, _>(&mut store, "first_word")?
.get_typed_func::<(), i32>(&mut store, "first_word")?
.call(&mut store, ())?;
assert_eq!(shared_memory_first_word, 42);
assert_eq!(instance1_first_word, 42);
@@ -106,7 +106,7 @@ fn test_probe_shared_memory_size() -> Result<()> {
let module = Module::new(&engine, wat)?;
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let size_fn = instance.get_typed_func::<(), i32, _>(&mut store, "size")?;
let size_fn = instance.get_typed_func::<(), i32>(&mut store, "size")?;
let mut shared_memory = instance.get_shared_memory(&mut store, "memory").unwrap();
assert_eq!(size_fn.call(&mut store, ())?, 1);
@@ -185,7 +185,7 @@ fn test_grow_memory_in_multiple_threads() -> Result<()> {
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[shared_memory.into()]).unwrap();
let grow_fn = instance
.get_typed_func::<i32, i32, _>(&mut store, "grow")
.get_typed_func::<i32, i32>(&mut store, "grow")
.unwrap();
let mut thread_local_observed_sizes: Vec<_> = (0..NUM_GROW_OPS / NUM_THREADS)
.map(|_| grow_fn.call(&mut store, 1).unwrap() as u32)
@@ -260,7 +260,7 @@ fn test_memory_size_accessibility() -> Result<()> {
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[probe_memory.into()]).unwrap();
let probe_fn = instance
.get_typed_func::<(), i32, _>(&mut store, "probe_last_available")
.get_typed_func::<(), i32>(&mut store, "probe_last_available")
.unwrap();
while !probe_done.load(Ordering::SeqCst) {
let value = probe_fn.call(&mut store, ()).unwrap() as u32;

46
tests/all/traps.rs
View File

@@ -18,7 +18,7 @@ fn test_trap_return() -> Result<()> {
let hello_func = Func::new(&mut store, hello_type, |_, _, _| bail!("test 123"));
let instance = Instance::new(&mut store, &module, &[hello_func.into()])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
assert!(format!("{e:?}").contains("test 123"));
@@ -48,7 +48,7 @@ fn test_anyhow_error_return() -> Result<()> {
});
let instance = Instance::new(&mut store, &module, &[hello_func.into()])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
assert!(!e.to_string().contains("test 1234"));
@@ -86,7 +86,7 @@ fn test_trap_return_downcast() -> Result<()> {
});
let instance = Instance::new(&mut store, &module, &[hello_func.into()])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func
.call(&mut store, ())
@@ -121,7 +121,7 @@ fn test_trap_trace() -> Result<()> {
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
@@ -196,7 +196,7 @@ fn test_trap_through_host() -> Result<()> {
&module,
&[host_func_a.into(), host_func_b.into()],
)?;
let a = instance.get_typed_func::<(), (), _>(&mut store, "a")?;
let a = instance.get_typed_func::<(), ()>(&mut store, "a")?;
let err = a.call(&mut store, ()).unwrap_err();
let trace = err.downcast_ref::<WasmBacktrace>().unwrap().frames();
assert_eq!(trace.len(), 3);
@@ -222,7 +222,7 @@ fn test_trap_backtrace_disabled() -> Result<()> {
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
assert!(e.downcast_ref::<WasmBacktrace>().is_none());
@@ -245,7 +245,7 @@ fn test_trap_trace_cb() -> Result<()> {
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[fn_func.into()])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
@@ -271,7 +271,7 @@ fn test_trap_stack_overflow() -> Result<()> {
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
@@ -301,7 +301,7 @@ fn trap_display_pretty() -> Result<()> {
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "bar")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "bar")?;
let e = run_func.call(&mut store, ()).unwrap_err();
assert_eq!(
@@ -345,7 +345,7 @@ fn trap_display_multi_module() -> Result<()> {
"#;
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[bar])?;
let bar2 = instance.get_typed_func::<(), (), _>(&mut store, "bar2")?;
let bar2 = instance.get_typed_func::<(), ()>(&mut store, "bar2")?;
let e = bar2.call(&mut store, ()).unwrap_err();
assert_eq!(
@@ -405,12 +405,12 @@ fn rust_panic_import() -> Result<()> {
let func = Func::new(&mut store, sig, |_, _, _| panic!("this is a panic"));
let func2 = Func::wrap(&mut store, || panic!("this is another panic"));
let instance = Instance::new(&mut store, &module, &[func.into(), func2.into()])?;
let func = instance.get_typed_func::<(), (), _>(&mut store, "foo")?;
let func = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
let err =
panic::catch_unwind(AssertUnwindSafe(|| drop(func.call(&mut store, ())))).unwrap_err();
assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
let func = instance.get_typed_func::<(), (), _>(&mut store, "bar")?;
let func = instance.get_typed_func::<(), ()>(&mut store, "bar")?;
let err = panic::catch_unwind(AssertUnwindSafe(|| {
drop(func.call(&mut store, ()));
}))
@@ -468,7 +468,7 @@ fn rust_catch_panic_import() -> Result<()> {
});
let instance = Instance::new(&mut store, &module, &[panic.into(), catch_panic.into()])?;
let run = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let trap = run.call(&mut store, ()).unwrap_err();
let trace = trap.downcast_ref::<WasmBacktrace>().unwrap().frames();
assert_eq!(trace.len(), 1);
@@ -613,7 +613,7 @@ fn present_after_module_drop() -> Result<()> {
let mut store = Store::<()>::default();
let module = Module::new(store.engine(), r#"(func (export "foo") unreachable)"#)?;
let instance = Instance::new(&mut store, &module, &[])?;
let func = instance.get_typed_func::<(), (), _>(&mut store, "foo")?;
let func = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
println!("asserting before we drop modules");
assert_trap(func.call(&mut store, ()).unwrap_err());
@@ -811,13 +811,13 @@ fn multithreaded_traps() -> Result<()> {
let instance = Instance::new(&mut store, &module, &[])?;
assert!(instance
.get_typed_func::<(), (), _>(&mut store, "run")?
.get_typed_func::<(), ()>(&mut store, "run")?
.call(&mut store, ())
.is_err());
let handle = std::thread::spawn(move || {
assert!(instance
.get_typed_func::<(), (), _>(&mut store, "run")
.get_typed_func::<(), ()>(&mut store, "run")
.unwrap()
.call(&mut store, ())
.is_err());
@@ -843,7 +843,7 @@ fn traps_without_address_map() -> Result<()> {
let module = Module::new(store.engine(), wat)?;
let instance = Instance::new(&mut store, &module, &[])?;
let run_func = instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let run_func = instance.get_typed_func::<(), ()>(&mut store, "run")?;
let e = run_func.call(&mut store, ()).unwrap_err();
@@ -891,7 +891,7 @@ fn catch_trap_calling_across_stores() -> Result<()> {
let data = ctx.data_mut();
let func = data
.child_instance
.get_typed_func::<(), (), _>(&mut data.child_store, "trap")
.get_typed_func::<(), ()>(&mut data.child_store, "trap")
.expect("trap function should be exported");
let trap = func.call(&mut data.child_store, ()).unwrap_err();
@@ -935,7 +935,7 @@ fn catch_trap_calling_across_stores() -> Result<()> {
let parent_instance = linker.instantiate(&mut store, &parent_module)?;
let func = parent_instance.get_typed_func::<(), (), _>(&mut store, "run")?;
let func = parent_instance.get_typed_func::<(), ()>(&mut store, "run")?;
func.call(store, ())?;
Ok(())
@@ -994,7 +994,7 @@ async fn async_then_sync_trap() -> Result<()> {
log::info!("Calling `c`...");
let c = sync_instance
.get_typed_func::<(), (), _>(&mut *sync_store, "c")
.get_typed_func::<(), ()>(&mut *sync_store, "c")
.unwrap();
c.call(sync_store, ())?;
Ok(())
@@ -1006,7 +1006,7 @@ async fn async_then_sync_trap() -> Result<()> {
log::info!("Calling `a`...");
let a = async_instance
.get_typed_func::<(), (), _>(&mut async_store, "a")
.get_typed_func::<(), ()>(&mut async_store, "a")
.unwrap();
let trap = a.call_async(&mut async_store, ()).await.unwrap_err();
@@ -1074,7 +1074,7 @@ async fn sync_then_async_trap() -> Result<()> {
log::info!("Calling `c`...");
let c = async_instance
.get_typed_func::<(), (), _>(&mut *async_store, "c")
.get_typed_func::<(), ()>(&mut *async_store, "c")
.unwrap();
tokio::task::block_in_place(|| {
tokio::runtime::Handle::current()
@@ -1087,7 +1087,7 @@ async fn sync_then_async_trap() -> Result<()> {
log::info!("Calling `a`...");
let a = sync_instance
.get_typed_func::<(), (), _>(&mut sync_store, "a")
.get_typed_func::<(), ()>(&mut sync_store, "a")
.unwrap();
let trap = a.call(&mut sync_store, ()).unwrap_err();