fix provenance test regressions

Signed-off-by: Joel Dice <joel.dice@fermyon.com>

Author: dicej

ci/miri-provenance-test.sh

@@ -23,4 +23,4 @@ compile ./tests/all/pulley_provenance_test_async_component.wat
 
 MIRIFLAGS="$MIRIFLAGS -Zmiri-disable-isolation -Zmiri-permissive-provenance" \
   cargo miri test --test all -- \
-    --ignored "$@"
+    --ignored pulley_provenance_test "$@"

tests/all/pulley.rs

@@ -82,6 +82,11 @@ fn provenance_test_config() -> Config {
     config.memory_reservation(1 << 20);
     config.memory_guard_size(0);
     config.signals_based_traps(false);
+    config.async_support(true);
+    config.wasm_component_model_async(true);
+    config.wasm_component_model_async_stackful(true);
+    config.wasm_component_model_async_builtins(true);
+    config.wasm_component_model_error_context(true);
     config
 }
 
@@ -109,9 +114,9 @@ fn provenance_test_config() -> Config {
 /// and instructions. The goal is to kind of do a dry run of interesting
 /// shapes/sizes of what you can do with core wasm and ensure MIRI gives us a
 /// clean bill of health.
-#[test]
+#[tokio::test]
 #[cfg_attr(miri, ignore)]
-fn pulley_provenance_test() -> Result<()> {
+async fn pulley_provenance_test() -> Result<()> {
     let config = provenance_test_config();
     let engine = Engine::new(&config)?;
     let module = if cfg!(miri) {
@@ -132,7 +137,8 @@ fn pulley_provenance_test() -> Result<()> {
         results[2] = Val::I32(3);
         Ok(())
     });
-    let instance = Instance::new(&mut store, &module, &[host_wrap.into(), host_new.into()])?;
+    let instance =
+        Instance::new_async(&mut store, &module, &[host_wrap.into(), host_new.into()]).await?;
 
     for func in [
         "call-wasm",
@@ -145,53 +151,59 @@ fn pulley_provenance_test() -> Result<()> {
         let func = instance
             .get_typed_func::<(), (i32, i32, i32)>(&mut store, func)
             .unwrap();
-        let results = func.call(&mut store, ())?;
+        let results = func.call_async(&mut store, ()).await?;
         assert_eq!(results, (1, 2, 3));
     }
 
     let funcref = instance.get_func(&mut store, "call-wasm").unwrap();
     for func in ["call_ref-wasm", "return_call_ref-wasm"] {
         println!("testing func {func:?}");
         let func = instance.get_typed_func::<Func, (i32, i32, i32)>(&mut store, func)?;
-        let results = func.call(&mut store, funcref)?;
+        let results = func.call_async(&mut store, funcref).await?;
         assert_eq!(results, (1, 2, 3));
     }
 
     let trap = instance
         .get_typed_func::<(), ()>(&mut store, "unreachable")?
-        .call(&mut store, ())
+        .call_async(&mut store, ())
+        .await
         .unwrap_err()
         .downcast::<Trap>()?;
     assert_eq!(trap, Trap::UnreachableCodeReached);
 
     let trap = instance
         .get_typed_func::<(), i32>(&mut store, "divide-by-zero")?
-        .call(&mut store, ())
+        .call_async(&mut store, ())
+        .await
         .unwrap_err()
         .downcast::<Trap>()?;
     assert_eq!(trap, Trap::IntegerDivisionByZero);
 
     instance
         .get_typed_func::<(), ()>(&mut store, "memory-intrinsics")?
-        .call(&mut store, ())?;
+        .call_async(&mut store, ())
+        .await?;
     instance
         .get_typed_func::<(), ()>(&mut store, "table-intrinsics")?
-        .call(&mut store, ())?;
-
-    let funcref = Func::wrap(&mut store, move |mut caller: Caller<'_, ()>| {
-        let func = instance.get_typed_func::<(), (i32, i32, i32)>(&mut caller, "call-wasm")?;
-        func.call(&mut caller, ())
+        .call_async(&mut store, ())
+        .await?;
+
+    let funcref = Func::wrap_async(&mut store, move |mut caller: Caller<'_, ()>, ()| {
+        Box::new(async move {
+            let func = instance.get_typed_func::<(), (i32, i32, i32)>(&mut caller, "call-wasm")?;
+            func.call_async(&mut caller, ()).await
+        })
     });
     let func = instance.get_typed_func::<Func, (i32, i32, i32)>(&mut store, "call_ref-wasm")?;
-    let results = func.call(&mut store, funcref)?;
+    let results = func.call_async(&mut store, funcref).await?;
     assert_eq!(results, (1, 2, 3));
 
     Ok(())
 }
 
-#[test]
+#[tokio::test]
 #[cfg_attr(miri, ignore)]
-fn pulley_provenance_test_components() -> Result<()> {
+async fn pulley_provenance_test_components() -> Result<()> {
     let config = provenance_test_config();
     let engine = Engine::new(&config)?;
     let component = if cfg!(miri) {
@@ -240,7 +252,7 @@ fn pulley_provenance_test_components() -> Result<()> {
         linker
             .root()
             .func_wrap("host-list", |_, (value,): (Vec<String>,)| Ok((value,)))?;
-        let instance = linker.instantiate(&mut store, &component)?;
+        let instance = linker.instantiate_async(&mut store, &component).await?;
 
         let guest_u32 = instance.get_typed_func::<(u32,), (u32,)>(&mut store, "guest-u32")?;
         let guest_enum = instance.get_typed_func::<(E,), (E,)>(&mut store, "guest-enum")?;
@@ -255,45 +267,50 @@ fn pulley_provenance_test_components() -> Result<()> {
         let guest_list =
             instance.get_typed_func::<(&[&str],), (Vec<String>,)>(&mut store, "guest-list")?;
 
-        let (result,) = guest_u32.call(&mut store, (42,))?;
+        let (result,) = guest_u32.call_async(&mut store, (42,)).await?;
         assert_eq!(result, 42);
-        guest_u32.post_return(&mut store)?;
+        guest_u32.post_return_async(&mut store).await?;
 
-        let (result,) = guest_enum.call(&mut store, (E::B,))?;
+        let (result,) = guest_enum.call_async(&mut store, (E::B,)).await?;
         assert_eq!(result, E::B);
-        guest_enum.post_return(&mut store)?;
+        guest_enum.post_return_async(&mut store).await?;
 
-        let (result,) = guest_option.call(&mut store, (None,))?;
+        let (result,) = guest_option.call_async(&mut store, (None,)).await?;
         assert_eq!(result, None);
-        guest_option.post_return(&mut store)?;
-        let (result,) = guest_option.call(&mut store, (Some(200),))?;
+        guest_option.post_return_async(&mut store).await?;
+        let (result,) = guest_option.call_async(&mut store, (Some(200),)).await?;
         assert_eq!(result, Some(200));
-        guest_option.post_return(&mut store)?;
+        guest_option.post_return_async(&mut store).await?;
 
-        let (result,) = guest_result.call(&mut store, (Ok(10),))?;
+        let (result,) = guest_result.call_async(&mut store, (Ok(10),)).await?;
         assert_eq!(result, Ok(10));
-        guest_result.post_return(&mut store)?;
-        let (result,) = guest_result.call(&mut store, (Err(i64::MIN),))?;
+        guest_result.post_return_async(&mut store).await?;
+        let (result,) = guest_result
+            .call_async(&mut store, (Err(i64::MIN),))
+            .await?;
         assert_eq!(result, Err(i64::MIN));
-        guest_result.post_return(&mut store)?;
+        guest_result.post_return_async(&mut store).await?;
 
-        let (result,) = guest_string.call(&mut store, ("",))?;
+        let (result,) = guest_string.call_async(&mut store, ("",)).await?;
         assert_eq!(result, "");
-        guest_string.post_return(&mut store)?;
-        let (result,) = guest_string.call(&mut store, ("hello",))?;
+        guest_string.post_return_async(&mut store).await?;
+        let (result,) = guest_string.call_async(&mut store, ("hello",)).await?;
         assert_eq!(result, "hello");
-        guest_string.post_return(&mut store)?;
+        guest_string.post_return_async(&mut store).await?;
 
-        let (result,) = guest_list.call(&mut store, (&[],))?;
+        let (result,) = guest_list.call_async(&mut store, (&[],)).await?;
         assert!(result.is_empty());
-        guest_list.post_return(&mut store)?;
-        let (result,) = guest_list.call(&mut store, (&["a", "", "b", "c"],))?;
+        guest_list.post_return_async(&mut store).await?;
+        let (result,) = guest_list
+            .call_async(&mut store, (&["a", "", "b", "c"],))
+            .await?;
         assert_eq!(result, ["a", "", "b", "c"]);
-        guest_list.post_return(&mut store)?;
+        guest_list.post_return_async(&mut store).await?;
 
         instance
             .get_typed_func::<(), ()>(&mut store, "resource-intrinsics")?
-            .call(&mut store, ())?;
+            .call_async(&mut store, ())
+            .await?;
     }
     {
         use wasmtime::component::Val;
@@ -323,7 +340,7 @@ fn pulley_provenance_test_components() -> Result<()> {
             results[0] = args[0].clone();
             Ok(())
         })?;
-        let instance = linker.instantiate(&mut store, &component)?;
+        let instance = linker.instantiate_async(&mut store, &component).await?;
 
         let guest_u32 = instance.get_func(&mut store, "guest-u32").unwrap();
         let guest_enum = instance.get_func(&mut store, "guest-enum").unwrap();
@@ -333,53 +350,71 @@ fn pulley_provenance_test_components() -> Result<()> {
         let guest_list = instance.get_func(&mut store, "guest-list").unwrap();
 
         let mut results = [Val::U32(0)];
-        guest_u32.call(&mut store, &[Val::U32(42)], &mut results)?;
+        guest_u32
+            .call_async(&mut store, &[Val::U32(42)], &mut results)
+            .await?;
         assert_eq!(results[0], Val::U32(42));
-        guest_u32.post_return(&mut store)?;
+        guest_u32.post_return_async(&mut store).await?;
 
-        guest_enum.call(&mut store, &[Val::Enum("B".into())], &mut results)?;
+        guest_enum
+            .call_async(&mut store, &[Val::Enum("B".into())], &mut results)
+            .await?;
         assert_eq!(results[0], Val::Enum("B".into()));
-        guest_enum.post_return(&mut store)?;
+        guest_enum.post_return_async(&mut store).await?;
 
-        guest_option.call(&mut store, &[Val::Option(None)], &mut results)?;
+        guest_option
+            .call_async(&mut store, &[Val::Option(None)], &mut results)
+            .await?;
         assert_eq!(results[0], Val::Option(None));
-        guest_option.post_return(&mut store)?;
-        guest_option.call(
-            &mut store,
-            &[Val::Option(Some(Box::new(Val::U8(201))))],
-            &mut results,
-        )?;
+        guest_option.post_return_async(&mut store).await?;
+        guest_option
+            .call_async(
+                &mut store,
+                &[Val::Option(Some(Box::new(Val::U8(201))))],
+                &mut results,
+            )
+            .await?;
         assert_eq!(results[0], Val::Option(Some(Box::new(Val::U8(201)))));
-        guest_option.post_return(&mut store)?;
-
-        guest_result.call(
-            &mut store,
-            &[Val::Result(Ok(Some(Box::new(Val::U16(20)))))],
-            &mut results,
-        )?;
+        guest_option.post_return_async(&mut store).await?;
+
+        guest_result
+            .call_async(
+                &mut store,
+                &[Val::Result(Ok(Some(Box::new(Val::U16(20)))))],
+                &mut results,
+            )
+            .await?;
         assert_eq!(results[0], Val::Result(Ok(Some(Box::new(Val::U16(20))))));
-        guest_result.post_return(&mut store)?;
-        guest_result.call(
-            &mut store,
-            &[Val::Result(Err(Some(Box::new(Val::S64(i64::MAX)))))],
-            &mut results,
-        )?;
+        guest_result.post_return_async(&mut store).await?;
+        guest_result
+            .call_async(
+                &mut store,
+                &[Val::Result(Err(Some(Box::new(Val::S64(i64::MAX)))))],
+                &mut results,
+            )
+            .await?;
         assert_eq!(
             results[0],
             Val::Result(Err(Some(Box::new(Val::S64(i64::MAX)))))
         );
-        guest_result.post_return(&mut store)?;
+        guest_result.post_return_async(&mut store).await?;
 
-        guest_string.call(&mut store, &[Val::String("B".into())], &mut results)?;
+        guest_string
+            .call_async(&mut store, &[Val::String("B".into())], &mut results)
+            .await?;
         assert_eq!(results[0], Val::String("B".into()));
-        guest_string.post_return(&mut store)?;
-        guest_string.call(&mut store, &[Val::String("".into())], &mut results)?;
+        guest_string.post_return_async(&mut store).await?;
+        guest_string
+            .call_async(&mut store, &[Val::String("".into())], &mut results)
+            .await?;
         assert_eq!(results[0], Val::String("".into()));
-        guest_string.post_return(&mut store)?;
+        guest_string.post_return_async(&mut store).await?;
 
-        guest_list.call(&mut store, &[Val::List(Vec::new())], &mut results)?;
+        guest_list
+            .call_async(&mut store, &[Val::List(Vec::new())], &mut results)
+            .await?;
         assert_eq!(results[0], Val::List(Vec::new()));
-        guest_list.post_return(&mut store)?;
+        guest_list.post_return_async(&mut store).await?;
     }
 
     Ok(())
@@ -432,12 +467,7 @@ async fn sleep(duration: std::time::Duration) {
 #[tokio::test]
 #[cfg_attr(miri, ignore)]
 async fn pulley_provenance_test_async_components() -> Result<()> {
-    let mut config = provenance_test_config();
-    config.async_support(true);
-    config.wasm_component_model_async(true);
-    config.wasm_component_model_async_stackful(true);
-    config.wasm_component_model_async_builtins(true);
-    config.wasm_component_model_error_context(true);
+    let config = provenance_test_config();
     let engine = Engine::new(&config)?;
     let component = if cfg!(miri) {
         unsafe {