A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Add a new fuzzer focused on component-model-async events (#12119)
Alex Crichtonfee9be219e30
diff --git a/Cargo.lock b/Cargo.lockindex c8bfcd637c..b79bd18164 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3640,10 +3640,13 @@ version = "0.0.0"dependencies = ["anyhow","base64",+ "env_logger 0.11.5","flate2","futures","libc",+ "log","once_cell",+ "pin-project-lite","sha2","url","wasi-nn",@@ -4721,6 +4724,7 @@ dependencies = ["backtrace","env_logger 0.11.5","futures",+ "indexmap 2.11.4","log","mutatis","rand 0.8.5",@@ -4730,7 +4734,9 @@ dependencies = ["smallvec","target-lexicon","tempfile",+ "test-programs-artifacts","v8",+ "wasm-compose","wasm-encoder","wasm-mutate","wasm-smith",@@ -4741,6 +4747,7 @@ dependencies = ["wasmtime","wasmtime-cli-flags","wasmtime-test-util",+ "wasmtime-wasi","wasmtime-wast","wat",]diff --git a/Cargo.toml b/Cargo.tomlindex bd9ceb5caa..c3dc9d9fce 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -427,6 +427,7 @@ tokio-util = "0.7.16"arbtest = "0.3.2"rayon = "1.5.3"regex = "1.9.1"+pin-project-lite = "0.2.14"# =============================================================================#diff --git a/crates/component-macro/tests/expanded/char.rs b/crates/component-macro/tests/expanded/char.rsindex 62978b4019..c17404c9df 100644--- a/crates/component-macro/tests/expanded/char.rs+++ b/crates/component-macro/tests/expanded/char.rs@@ -253,6 +253,7 @@ pub mod exports {pub mod chars {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {take_char: wasmtime::component::Func,return_char: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/char_async.rs b/crates/component-macro/tests/expanded/char_async.rsindex 00d0be6d90..203b118db4 100644--- a/crates/component-macro/tests/expanded/char_async.rs+++ b/crates/component-macro/tests/expanded/char_async.rs@@ -267,6 +267,7 @@ pub mod exports {pub mod chars {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {take_char: wasmtime::component::Func,return_char: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/char_concurrent.rs b/crates/component-macro/tests/expanded/char_concurrent.rsindex 1d11f95afa..a22cd8e218 100644--- a/crates/component-macro/tests/expanded/char_concurrent.rs+++ b/crates/component-macro/tests/expanded/char_concurrent.rs@@ -246,6 +246,7 @@ pub mod exports {pub mod chars {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {take_char: wasmtime::component::Func,return_char: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/char_tracing_async.rs b/crates/component-macro/tests/expanded/char_tracing_async.rsindex 01ad8a97d4..0314bf0e20 100644--- a/crates/component-macro/tests/expanded/char_tracing_async.rs+++ b/crates/component-macro/tests/expanded/char_tracing_async.rs@@ -296,6 +296,7 @@ pub mod exports {pub mod chars {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {take_char: wasmtime::component::Func,return_char: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/conventions.rs b/crates/component-macro/tests/expanded/conventions.rsindex 6e8dc054ab..6e52b654da 100644--- a/crates/component-macro/tests/expanded/conventions.rs+++ b/crates/component-macro/tests/expanded/conventions.rs@@ -453,6 +453,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {kebab_case: wasmtime::component::Func,foo: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/conventions_async.rs b/crates/component-macro/tests/expanded/conventions_async.rsindex 8c43e152d1..918136e41a 100644--- a/crates/component-macro/tests/expanded/conventions_async.rs+++ b/crates/component-macro/tests/expanded/conventions_async.rs@@ -511,6 +511,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {kebab_case: wasmtime::component::Func,foo: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/conventions_concurrent.rs b/crates/component-macro/tests/expanded/conventions_concurrent.rsindex 1cf2470695..a61d3326f4 100644--- a/crates/component-macro/tests/expanded/conventions_concurrent.rs+++ b/crates/component-macro/tests/expanded/conventions_concurrent.rs@@ -459,6 +459,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {kebab_case: wasmtime::component::Func,foo: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/conventions_tracing_async.rs b/crates/component-macro/tests/expanded/conventions_tracing_async.rsindex 5f2dcaf078..3a8238c1fa 100644--- a/crates/component-macro/tests/expanded/conventions_tracing_async.rs+++ b/crates/component-macro/tests/expanded/conventions_tracing_async.rs@@ -671,6 +671,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {kebab_case: wasmtime::component::Func,foo: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/flags.rs b/crates/component-macro/tests/expanded/flags.rsindex c45bdb6279..0a348636b6 100644--- a/crates/component-macro/tests/expanded/flags.rs+++ b/crates/component-macro/tests/expanded/flags.rs@@ -590,6 +590,7 @@ pub mod exports {4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {roundtrip_flag1: wasmtime::component::Func,roundtrip_flag2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/flags_async.rs b/crates/component-macro/tests/expanded/flags_async.rsindex 7f4374215e..f5aef11f2e 100644--- a/crates/component-macro/tests/expanded/flags_async.rs+++ b/crates/component-macro/tests/expanded/flags_async.rs@@ -646,6 +646,7 @@ pub mod exports {4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {roundtrip_flag1: wasmtime::component::Func,roundtrip_flag2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/flags_concurrent.rs b/crates/component-macro/tests/expanded/flags_concurrent.rsindex 9e0575692a..2368bf5c40 100644--- a/crates/component-macro/tests/expanded/flags_concurrent.rs+++ b/crates/component-macro/tests/expanded/flags_concurrent.rs@@ -585,6 +585,7 @@ pub mod exports {4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {roundtrip_flag1: wasmtime::component::Func,roundtrip_flag2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/flags_tracing_async.rs b/crates/component-macro/tests/expanded/flags_tracing_async.rsindex 7030fcf65e..6f140e753c 100644--- a/crates/component-macro/tests/expanded/flags_tracing_async.rs+++ b/crates/component-macro/tests/expanded/flags_tracing_async.rs@@ -758,6 +758,7 @@ pub mod exports {4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {roundtrip_flag1: wasmtime::component::Func,roundtrip_flag2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/floats.rs b/crates/component-macro/tests/expanded/floats.rsindex 98a56f77ba..94e34f2f23 100644--- a/crates/component-macro/tests/expanded/floats.rs+++ b/crates/component-macro/tests/expanded/floats.rs@@ -272,6 +272,7 @@ pub mod exports {pub mod floats {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f32_param: wasmtime::component::Func,f64_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/floats_async.rs b/crates/component-macro/tests/expanded/floats_async.rsindex 52f43ee0c3..be44742453 100644--- a/crates/component-macro/tests/expanded/floats_async.rs+++ b/crates/component-macro/tests/expanded/floats_async.rs@@ -300,6 +300,7 @@ pub mod exports {pub mod floats {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f32_param: wasmtime::component::Func,f64_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/floats_concurrent.rs b/crates/component-macro/tests/expanded/floats_concurrent.rsindex 7b81ae6d4f..f28ef61743 100644--- a/crates/component-macro/tests/expanded/floats_concurrent.rs+++ b/crates/component-macro/tests/expanded/floats_concurrent.rs@@ -273,6 +273,7 @@ pub mod exports {pub mod floats {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f32_param: wasmtime::component::Func,f64_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/floats_tracing_async.rs b/crates/component-macro/tests/expanded/floats_tracing_async.rsindex e830d4ae59..654d38cb24 100644--- a/crates/component-macro/tests/expanded/floats_tracing_async.rs+++ b/crates/component-macro/tests/expanded/floats_tracing_async.rs@@ -358,6 +358,7 @@ pub mod exports {pub mod floats {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f32_param: wasmtime::component::Func,f64_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/integers.rs b/crates/component-macro/tests/expanded/integers.rsindex 00550dada7..d8b002493e 100644--- a/crates/component-macro/tests/expanded/integers.rs+++ b/crates/component-macro/tests/expanded/integers.rs@@ -482,6 +482,7 @@ pub mod exports {pub mod integers {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a1: wasmtime::component::Func,a2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/integers_async.rs b/crates/component-macro/tests/expanded/integers_async.rsindex db511f4b77..68f1477360 100644--- a/crates/component-macro/tests/expanded/integers_async.rs+++ b/crates/component-macro/tests/expanded/integers_async.rs@@ -571,6 +571,7 @@ pub mod exports {pub mod integers {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a1: wasmtime::component::Func,a2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/integers_concurrent.rs b/crates/component-macro/tests/expanded/integers_concurrent.rsindex 947b85ad3f..98e0a04f3d 100644--- a/crates/component-macro/tests/expanded/integers_concurrent.rs+++ b/crates/component-macro/tests/expanded/integers_concurrent.rs@@ -492,6 +492,7 @@ pub mod exports {pub mod integers {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a1: wasmtime::component::Func,a2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/integers_tracing_async.rs b/crates/component-macro/tests/expanded/integers_tracing_async.rsindex e74b1ead83..a2976eb15e 100644--- a/crates/component-macro/tests/expanded/integers_tracing_async.rs+++ b/crates/component-macro/tests/expanded/integers_tracing_async.rs@@ -836,6 +836,7 @@ pub mod exports {pub mod integers {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a1: wasmtime::component::Func,a2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/lists.rs b/crates/component-macro/tests/expanded/lists.rsindex 508bbab6c7..294b2a7e74 100644--- a/crates/component-macro/tests/expanded/lists.rs+++ b/crates/component-macro/tests/expanded/lists.rs@@ -1158,6 +1158,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {list_u8_param: wasmtime::component::Func,list_u16_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/lists_async.rs b/crates/component-macro/tests/expanded/lists_async.rsindex ce393e867c..4c3292e783 100644--- a/crates/component-macro/tests/expanded/lists_async.rs+++ b/crates/component-macro/tests/expanded/lists_async.rs@@ -1324,6 +1324,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {list_u8_param: wasmtime::component::Func,list_u16_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/lists_concurrent.rs b/crates/component-macro/tests/expanded/lists_concurrent.rsindex fbbadef3ce..9291504fae 100644--- a/crates/component-macro/tests/expanded/lists_concurrent.rs+++ b/crates/component-macro/tests/expanded/lists_concurrent.rs@@ -1127,6 +1127,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {list_u8_param: wasmtime::component::Func,list_u16_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/lists_tracing_async.rs b/crates/component-macro/tests/expanded/lists_tracing_async.rsindex 485434acbb..cf47e764cf 100644--- a/crates/component-macro/tests/expanded/lists_tracing_async.rs+++ b/crates/component-macro/tests/expanded/lists_tracing_async.rs@@ -1755,6 +1755,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {list_u8_param: wasmtime::component::Func,list_u16_param: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/many-arguments.rs b/crates/component-macro/tests/expanded/many-arguments.rsindex b686d0838a..c934894ec5 100644--- a/crates/component-macro/tests/expanded/many-arguments.rs+++ b/crates/component-macro/tests/expanded/many-arguments.rs@@ -526,6 +526,7 @@ pub mod exports {4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {many_args: wasmtime::component::Func,big_argument: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/many-arguments_async.rs b/crates/component-macro/tests/expanded/many-arguments_async.rsindex 05ca37301e..bdb7301eb0 100644--- a/crates/component-macro/tests/expanded/many-arguments_async.rs+++ b/crates/component-macro/tests/expanded/many-arguments_async.rs@@ -540,6 +540,7 @@ pub mod exports {4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {many_args: wasmtime::component::Func,big_argument: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/many-arguments_concurrent.rs b/crates/component-macro/tests/expanded/many-arguments_concurrent.rsindex a36f4defe8..3a35627bf5 100644--- a/crates/component-macro/tests/expanded/many-arguments_concurrent.rs+++ b/crates/component-macro/tests/expanded/many-arguments_concurrent.rs@@ -487,6 +487,7 @@ pub mod exports {4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {many_args: wasmtime::component::Func,big_argument: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/many-arguments_tracing_async.rs b/crates/component-macro/tests/expanded/many-arguments_tracing_async.rsindex 106c4784cb..1fe25868ca 100644--- a/crates/component-macro/tests/expanded/many-arguments_tracing_async.rs+++ b/crates/component-macro/tests/expanded/many-arguments_tracing_async.rs@@ -583,6 +583,7 @@ pub mod exports {4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {many_args: wasmtime::component::Func,big_argument: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/multiversion.rs b/crates/component-macro/tests/expanded/multiversion.rsindex 90622deb90..3d5192e1c0 100644--- a/crates/component-macro/tests/expanded/multiversion.rs+++ b/crates/component-macro/tests/expanded/multiversion.rs@@ -285,6 +285,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}@@ -364,6 +365,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/multiversion_async.rs b/crates/component-macro/tests/expanded/multiversion_async.rsindex 9fb0b0b247..03fe15c242 100644--- a/crates/component-macro/tests/expanded/multiversion_async.rs+++ b/crates/component-macro/tests/expanded/multiversion_async.rs@@ -289,6 +289,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}@@ -371,6 +372,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/multiversion_concurrent.rs b/crates/component-macro/tests/expanded/multiversion_concurrent.rsindex 3fb25d163b..0b3529e92c 100644--- a/crates/component-macro/tests/expanded/multiversion_concurrent.rs+++ b/crates/component-macro/tests/expanded/multiversion_concurrent.rs@@ -277,6 +277,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}@@ -359,6 +360,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/multiversion_tracing_async.rs b/crates/component-macro/tests/expanded/multiversion_tracing_async.rsindex e2ce390bf0..bab3788cde 100644--- a/crates/component-macro/tests/expanded/multiversion_tracing_async.rs+++ b/crates/component-macro/tests/expanded/multiversion_tracing_async.rs@@ -315,6 +315,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}@@ -408,6 +409,7 @@ pub mod exports {pub mod a {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {x: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/records.rs b/crates/component-macro/tests/expanded/records.rsindex 95a917474c..4462a77430 100644--- a/crates/component-macro/tests/expanded/records.rs+++ b/crates/component-macro/tests/expanded/records.rs@@ -713,6 +713,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {tuple_arg: wasmtime::component::Func,tuple_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/records_async.rs b/crates/component-macro/tests/expanded/records_async.rsindex ff0a1c48c0..bd51cda2fb 100644--- a/crates/component-macro/tests/expanded/records_async.rs+++ b/crates/component-macro/tests/expanded/records_async.rs@@ -791,6 +791,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {tuple_arg: wasmtime::component::Func,tuple_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/records_concurrent.rs b/crates/component-macro/tests/expanded/records_concurrent.rsindex c2476be09f..8839ca3f53 100644--- a/crates/component-macro/tests/expanded/records_concurrent.rs+++ b/crates/component-macro/tests/expanded/records_concurrent.rs@@ -724,6 +724,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {tuple_arg: wasmtime::component::Func,tuple_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/records_tracing_async.rs b/crates/component-macro/tests/expanded/records_tracing_async.rsindex 7f67a75f4f..b5c3d75c9a 100644--- a/crates/component-macro/tests/expanded/records_tracing_async.rs+++ b/crates/component-macro/tests/expanded/records_tracing_async.rs@@ -952,6 +952,7 @@ pub mod exports {>::ALIGN32);};+ #[derive(Clone)]pub struct Guest {tuple_arg: wasmtime::component::Func,tuple_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/resources-export.rs b/crates/component-macro/tests/expanded/resources-export.rsindex d3e66b2bef..cc34bbf437 100644--- a/crates/component-macro/tests/expanded/resources-export.rs+++ b/crates/component-macro/tests/expanded/resources-export.rs@@ -297,6 +297,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -442,6 +443,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -594,6 +596,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,}@@ -686,6 +689,7 @@ pub mod exports {pub struct GuestB<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_b_constructor: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/resources-export_async.rs b/crates/component-macro/tests/expanded/resources-export_async.rsindex db25ccc4b7..a7f9a84648 100644--- a/crates/component-macro/tests/expanded/resources-export_async.rs+++ b/crates/component-macro/tests/expanded/resources-export_async.rs@@ -302,6 +302,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -462,6 +463,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -629,6 +631,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,}@@ -726,6 +729,7 @@ pub mod exports {pub struct GuestB<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_b_constructor: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/resources-export_concurrent.rs b/crates/component-macro/tests/expanded/resources-export_concurrent.rsindex 24e7a27007..a08a729331 100644--- a/crates/component-macro/tests/expanded/resources-export_concurrent.rs+++ b/crates/component-macro/tests/expanded/resources-export_concurrent.rs@@ -294,6 +294,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -450,6 +451,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -615,6 +617,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,}@@ -710,6 +713,7 @@ pub mod exports {pub struct GuestB<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_b_constructor: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/resources-export_tracing_async.rs b/crates/component-macro/tests/expanded/resources-export_tracing_async.rsindex 2bdaf403ca..49ad4526ce 100644--- a/crates/component-macro/tests/expanded/resources-export_tracing_async.rs+++ b/crates/component-macro/tests/expanded/resources-export_tracing_async.rs@@ -302,6 +302,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -489,6 +490,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,static_a_static_a: wasmtime::component::Func,@@ -685,6 +687,7 @@ pub mod exports {pub struct GuestA<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_a_constructor: wasmtime::component::Func,}@@ -791,6 +794,7 @@ pub mod exports {pub struct GuestB<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {constructor_b_constructor: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/resources-import.rs b/crates/component-macro/tests/expanded/resources-import.rsindex ab424a8073..ff7fce1d5f 100644--- a/crates/component-macro/tests/expanded/resources-import.rs+++ b/crates/component-macro/tests/expanded/resources-import.rs@@ -1137,6 +1137,7 @@ pub mod exports {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};pub type Foo = super::super::super::super::foo::foo::transitive_interface_with_resource::Foo;+ #[derive(Clone)]pub struct Guest {handle: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/resources-import_async.rs b/crates/component-macro/tests/expanded/resources-import_async.rsindex dfddc60eac..3ea8ce555c 100644--- a/crates/component-macro/tests/expanded/resources-import_async.rs+++ b/crates/component-macro/tests/expanded/resources-import_async.rs@@ -1324,6 +1324,7 @@ pub mod exports {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};pub type Foo = super::super::super::super::foo::foo::transitive_interface_with_resource::Foo;+ #[derive(Clone)]pub struct Guest {handle: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/resources-import_concurrent.rs b/crates/component-macro/tests/expanded/resources-import_concurrent.rsindex 9d7d77656a..4c40a6aa51 100644--- a/crates/component-macro/tests/expanded/resources-import_concurrent.rs+++ b/crates/component-macro/tests/expanded/resources-import_concurrent.rs@@ -1107,6 +1107,7 @@ pub mod exports {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};pub type Foo = super::super::super::super::foo::foo::transitive_interface_with_resource::Foo;+ #[derive(Clone)]pub struct Guest {handle: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/resources-import_tracing_async.rs b/crates/component-macro/tests/expanded/resources-import_tracing_async.rsindex 071458dfe6..1556124d3c 100644--- a/crates/component-macro/tests/expanded/resources-import_tracing_async.rs+++ b/crates/component-macro/tests/expanded/resources-import_tracing_async.rs@@ -1741,6 +1741,7 @@ pub mod exports {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};pub type Foo = super::super::super::super::foo::foo::transitive_interface_with_resource::Foo;+ #[derive(Clone)]pub struct Guest {handle: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/share-types.rs b/crates/component-macro/tests/expanded/share-types.rsindex 622ac4bd10..a71fac51f1 100644--- a/crates/component-macro/tests/expanded/share-types.rs+++ b/crates/component-macro/tests/expanded/share-types.rs@@ -315,6 +315,7 @@ pub mod exports {assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {handle_request: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/share-types_async.rs b/crates/component-macro/tests/expanded/share-types_async.rsindex ad1e2ec494..f972dd9f87 100644--- a/crates/component-macro/tests/expanded/share-types_async.rs+++ b/crates/component-macro/tests/expanded/share-types_async.rs@@ -323,6 +323,7 @@ pub mod exports {assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {handle_request: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/share-types_concurrent.rs b/crates/component-macro/tests/expanded/share-types_concurrent.rsindex ba588a021c..663eb83db1 100644--- a/crates/component-macro/tests/expanded/share-types_concurrent.rs+++ b/crates/component-macro/tests/expanded/share-types_concurrent.rs@@ -312,6 +312,7 @@ pub mod exports {assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {handle_request: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/share-types_tracing_async.rs b/crates/component-macro/tests/expanded/share-types_tracing_async.rsindex 8f5d127702..0f6f82cecb 100644--- a/crates/component-macro/tests/expanded/share-types_tracing_async.rs+++ b/crates/component-macro/tests/expanded/share-types_tracing_async.rs@@ -339,6 +339,7 @@ pub mod exports {assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {handle_request: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/simple-functions.rs b/crates/component-macro/tests/expanded/simple-functions.rsindex 8c5abab81b..141b83ca37 100644--- a/crates/component-macro/tests/expanded/simple-functions.rs+++ b/crates/component-macro/tests/expanded/simple-functions.rs@@ -302,6 +302,7 @@ pub mod exports {pub mod simple {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f1: wasmtime::component::Func,f2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/simple-functions_async.rs b/crates/component-macro/tests/expanded/simple-functions_async.rsindex 2cd17461eb..974577688f 100644--- a/crates/component-macro/tests/expanded/simple-functions_async.rs+++ b/crates/component-macro/tests/expanded/simple-functions_async.rs@@ -342,6 +342,7 @@ pub mod exports {pub mod simple {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f1: wasmtime::component::Func,f2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/simple-functions_concurrent.rs b/crates/component-macro/tests/expanded/simple-functions_concurrent.rsindex f33e5ca356..a7d02c9ea4 100644--- a/crates/component-macro/tests/expanded/simple-functions_concurrent.rs+++ b/crates/component-macro/tests/expanded/simple-functions_concurrent.rs@@ -310,6 +310,7 @@ pub mod exports {pub mod simple {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f1: wasmtime::component::Func,f2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/simple-functions_tracing_async.rs b/crates/component-macro/tests/expanded/simple-functions_tracing_async.rsindex ca16fdd8ca..b2c7c618bc 100644--- a/crates/component-macro/tests/expanded/simple-functions_tracing_async.rs+++ b/crates/component-macro/tests/expanded/simple-functions_tracing_async.rs@@ -430,6 +430,7 @@ pub mod exports {pub mod simple {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {f1: wasmtime::component::Func,f2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/simple-lists.rs b/crates/component-macro/tests/expanded/simple-lists.rsindex 3e8d2d7f3d..044e325cea 100644--- a/crates/component-macro/tests/expanded/simple-lists.rs+++ b/crates/component-macro/tests/expanded/simple-lists.rs@@ -327,6 +327,7 @@ pub mod exports {pub mod simple_lists {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {simple_list1: wasmtime::component::Func,simple_list2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/simple-lists_async.rs b/crates/component-macro/tests/expanded/simple-lists_async.rsindex 18b7f05aa7..06afa4710a 100644--- a/crates/component-macro/tests/expanded/simple-lists_async.rs+++ b/crates/component-macro/tests/expanded/simple-lists_async.rs@@ -351,6 +351,7 @@ pub mod exports {pub mod simple_lists {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {simple_list1: wasmtime::component::Func,simple_list2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/simple-lists_concurrent.rs b/crates/component-macro/tests/expanded/simple-lists_concurrent.rsindex b4cb1c593d..a0ac716713 100644--- a/crates/component-macro/tests/expanded/simple-lists_concurrent.rs+++ b/crates/component-macro/tests/expanded/simple-lists_concurrent.rs@@ -310,6 +310,7 @@ pub mod exports {pub mod simple_lists {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {simple_list1: wasmtime::component::Func,simple_list2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/simple-lists_tracing_async.rs b/crates/component-macro/tests/expanded/simple-lists_tracing_async.rsindex c7837ff962..15f519a6cc 100644--- a/crates/component-macro/tests/expanded/simple-lists_tracing_async.rs+++ b/crates/component-macro/tests/expanded/simple-lists_tracing_async.rs@@ -412,6 +412,7 @@ pub mod exports {pub mod simple_lists {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {simple_list1: wasmtime::component::Func,simple_list2: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/small-anonymous.rs b/crates/component-macro/tests/expanded/small-anonymous.rsindex 281f73a2e9..9b6cf457e8 100644--- a/crates/component-macro/tests/expanded/small-anonymous.rs+++ b/crates/component-macro/tests/expanded/small-anonymous.rs@@ -338,6 +338,7 @@ pub mod exports {1 == < Error as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {option_test: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/small-anonymous_async.rs b/crates/component-macro/tests/expanded/small-anonymous_async.rsindex c733e00f1e..bd0df2997c 100644--- a/crates/component-macro/tests/expanded/small-anonymous_async.rs+++ b/crates/component-macro/tests/expanded/small-anonymous_async.rs@@ -350,6 +350,7 @@ pub mod exports {1 == < Error as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {option_test: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/small-anonymous_concurrent.rs b/crates/component-macro/tests/expanded/small-anonymous_concurrent.rsindex 8b58de4bef..a14c649b96 100644--- a/crates/component-macro/tests/expanded/small-anonymous_concurrent.rs+++ b/crates/component-macro/tests/expanded/small-anonymous_concurrent.rs@@ -335,6 +335,7 @@ pub mod exports {1 == < Error as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {option_test: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/small-anonymous_tracing_async.rs b/crates/component-macro/tests/expanded/small-anonymous_tracing_async.rsindex 6d772136fd..a0e22a4b26 100644--- a/crates/component-macro/tests/expanded/small-anonymous_tracing_async.rs+++ b/crates/component-macro/tests/expanded/small-anonymous_tracing_async.rs@@ -363,6 +363,7 @@ pub mod exports {1 == < Error as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {option_test: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/smoke-export.rs b/crates/component-macro/tests/expanded/smoke-export.rsindex d3811adfd2..5659486b29 100644--- a/crates/component-macro/tests/expanded/smoke-export.rs+++ b/crates/component-macro/tests/expanded/smoke-export.rs@@ -178,6 +178,7 @@ pub mod exports {pub mod the_name {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {y: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/smoke-export_async.rs b/crates/component-macro/tests/expanded/smoke-export_async.rsindex 14b21f578d..f7838fe51e 100644--- a/crates/component-macro/tests/expanded/smoke-export_async.rs+++ b/crates/component-macro/tests/expanded/smoke-export_async.rs@@ -178,6 +178,7 @@ pub mod exports {pub mod the_name {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {y: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/smoke-export_concurrent.rs b/crates/component-macro/tests/expanded/smoke-export_concurrent.rsindex 5970138a93..03a04b2de7 100644--- a/crates/component-macro/tests/expanded/smoke-export_concurrent.rs+++ b/crates/component-macro/tests/expanded/smoke-export_concurrent.rs@@ -178,6 +178,7 @@ pub mod exports {pub mod the_name {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {y: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/smoke-export_tracing_async.rs b/crates/component-macro/tests/expanded/smoke-export_tracing_async.rsindex 57d38d6fe1..d40a07a0a8 100644--- a/crates/component-macro/tests/expanded/smoke-export_tracing_async.rs+++ b/crates/component-macro/tests/expanded/smoke-export_tracing_async.rs@@ -178,6 +178,7 @@ pub mod exports {pub mod the_name {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {y: wasmtime::component::Func,}diff --git a/crates/component-macro/tests/expanded/strings.rs b/crates/component-macro/tests/expanded/strings.rsindex 1075c2e8b0..744f839aa4 100644--- a/crates/component-macro/tests/expanded/strings.rs+++ b/crates/component-macro/tests/expanded/strings.rs@@ -280,6 +280,7 @@ pub mod exports {pub mod strings {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a: wasmtime::component::Func,b: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/strings_async.rs b/crates/component-macro/tests/expanded/strings_async.rsindex 7bb903dcef..c3bca170bc 100644--- a/crates/component-macro/tests/expanded/strings_async.rs+++ b/crates/component-macro/tests/expanded/strings_async.rs@@ -304,6 +304,7 @@ pub mod exports {pub mod strings {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a: wasmtime::component::Func,b: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/strings_concurrent.rs b/crates/component-macro/tests/expanded/strings_concurrent.rsindex b4f942988f..acf72fecc4 100644--- a/crates/component-macro/tests/expanded/strings_concurrent.rs+++ b/crates/component-macro/tests/expanded/strings_concurrent.rs@@ -277,6 +277,7 @@ pub mod exports {pub mod strings {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a: wasmtime::component::Func,b: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/strings_tracing_async.rs b/crates/component-macro/tests/expanded/strings_tracing_async.rsindex ff93e28993..4d63ddcf38 100644--- a/crates/component-macro/tests/expanded/strings_tracing_async.rs+++ b/crates/component-macro/tests/expanded/strings_tracing_async.rs@@ -349,6 +349,7 @@ pub mod exports {pub mod strings {#[allow(unused_imports)]use wasmtime::component::__internal::{anyhow, Box};+ #[derive(Clone)]pub struct Guest {a: wasmtime::component::Func,b: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/variants.rs b/crates/component-macro/tests/expanded/variants.rsindex faf367221f..80895a1746 100644--- a/crates/component-macro/tests/expanded/variants.rs+++ b/crates/component-macro/tests/expanded/variants.rs@@ -1245,6 +1245,7 @@ pub mod exports {4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {e1_arg: wasmtime::component::Func,e1_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/variants_async.rs b/crates/component-macro/tests/expanded/variants_async.rsindex c8cd1a062d..c4e4958b80 100644--- a/crates/component-macro/tests/expanded/variants_async.rs+++ b/crates/component-macro/tests/expanded/variants_async.rs@@ -1376,6 +1376,7 @@ pub mod exports {4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {e1_arg: wasmtime::component::Func,e1_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/variants_concurrent.rs b/crates/component-macro/tests/expanded/variants_concurrent.rsindex 6ff18d8c22..38f483c9e0 100644--- a/crates/component-macro/tests/expanded/variants_concurrent.rs+++ b/crates/component-macro/tests/expanded/variants_concurrent.rs@@ -1230,6 +1230,7 @@ pub mod exports {4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {e1_arg: wasmtime::component::Func,e1_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/variants_tracing_async.rs b/crates/component-macro/tests/expanded/variants_tracing_async.rsindex f62145fbda..32677bd123 100644--- a/crates/component-macro/tests/expanded/variants_tracing_async.rs+++ b/crates/component-macro/tests/expanded/variants_tracing_async.rs@@ -1674,6 +1674,7 @@ pub mod exports {4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32);};+ #[derive(Clone)]pub struct Guest {e1_arg: wasmtime::component::Func,e1_result: wasmtime::component::Func,diff --git a/crates/component-macro/tests/expanded/wat.rs b/crates/component-macro/tests/expanded/wat.rsindex 6586292522..007df70962 100644--- a/crates/component-macro/tests/expanded/wat.rs+++ b/crates/component-macro/tests/expanded/wat.rs@@ -188,6 +188,7 @@ pub mod exports {pub struct GuestThisNameIsDuplicated<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {}#[derive(Clone)]pub struct GuestIndices {}diff --git a/crates/component-macro/tests/expanded/wat_async.rs b/crates/component-macro/tests/expanded/wat_async.rsindex 6586292522..007df70962 100644--- a/crates/component-macro/tests/expanded/wat_async.rs+++ b/crates/component-macro/tests/expanded/wat_async.rs@@ -188,6 +188,7 @@ pub mod exports {pub struct GuestThisNameIsDuplicated<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {}#[derive(Clone)]pub struct GuestIndices {}diff --git a/crates/component-macro/tests/expanded/wat_concurrent.rs b/crates/component-macro/tests/expanded/wat_concurrent.rsindex 6586292522..007df70962 100644--- a/crates/component-macro/tests/expanded/wat_concurrent.rs+++ b/crates/component-macro/tests/expanded/wat_concurrent.rs@@ -188,6 +188,7 @@ pub mod exports {pub struct GuestThisNameIsDuplicated<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {}#[derive(Clone)]pub struct GuestIndices {}diff --git a/crates/component-macro/tests/expanded/wat_tracing_async.rs b/crates/component-macro/tests/expanded/wat_tracing_async.rsindex 6586292522..007df70962 100644--- a/crates/component-macro/tests/expanded/wat_tracing_async.rs+++ b/crates/component-macro/tests/expanded/wat_tracing_async.rs@@ -188,6 +188,7 @@ pub mod exports {pub struct GuestThisNameIsDuplicated<'a> {funcs: &'a Guest,}+ #[derive(Clone)]pub struct Guest {}#[derive(Clone)]pub struct GuestIndices {}diff --git a/crates/fuzzing/Cargo.toml b/crates/fuzzing/Cargo.tomlindex 84ca8b8ac6..f60ec3aa21 100644--- a/crates/fuzzing/Cargo.toml+++ b/crates/fuzzing/Cargo.toml@@ -32,12 +32,16 @@ wasmtime = { workspace = true, features = ['default', 'winch'] }wasm-encoder = { workspace = true }wasm-smith = { workspace = true, features = ['serde'] }wasm-mutate = { workspace = true }+wasm-compose = { workspace = true }wasm-spec-interpreter = { path = "./wasm-spec-interpreter", optional = true }wasmi = { version = "0.51.1", default-features = false, features = ["std", "simd"] }-futures = { workspace = true }+futures = { workspace = true, features = ['async-await'] }wasmtime-test-util = { workspace = true, features = ['wast', 'component-fuzz', 'component'] }serde_json = { workspace = true }serde = { workspace = true }+test-programs-artifacts = { workspace = true }+wasmtime-wasi = { workspace = true }+indexmap = { workspace = true }[dependencies.wasmtime-cli-flags]workspace = truediff --git a/crates/fuzzing/src/generators.rs b/crates/fuzzing/src/generators.rsindex bbfff51aa2..1f04f07792 100644--- a/crates/fuzzing/src/generators.rs+++ b/crates/fuzzing/src/generators.rs@@ -11,6 +11,7 @@pub mod api;mod async_config;mod codegen_settings;+pub mod component_async;mod config;pub mod gc_ops;mod instance_allocation_strategy;diff --git a/crates/fuzzing/src/generators/component_async.rs b/crates/fuzzing/src/generators/component_async.rsnew file mode 100644index 0000000000..a7dc1ac213--- /dev/null+++ b/crates/fuzzing/src/generators/component_async.rs@@ -0,0 +1,1020 @@+//! For a high-level overview of this fuzz target see `fuzz_async.rs`++#![expect(missing_docs, reason = "macro-generated code")]++use arbitrary::{Arbitrary, Unstructured};+use indexmap::{IndexMap, IndexSet};++wasmtime::component::bindgen!({+ world: "fuzz-async",+ imports: {+ "wasmtime-fuzz:fuzz/types.get-commands": store,+ },+ exports: { default: async | store },+});++use wasmtime_fuzz::fuzz::types::{+ Command, FuturePayload, StreamReadPayload, StreamReadyPayload, StreamWritePayload,+};++const SOFT_MAX_COMMANDS: usize = 100;+const MAX_STREAM_COUNT: u32 = 10;++/// Structure used for the "component async" fuzzer.+///+/// This encapsulates a list of commands for the fuzzer to run. Note that the+/// commands are not 100% arbitrary but instead they're generated similar to+/// wasm instructions where only some sequences of instructions are valid. The+/// rest of this module is dedicated to the generation of these commands.+#[derive(Debug)]+pub struct ComponentAsync {+ /// A sequence of commands to run, tagged with a scope that they're run+ /// within.+ pub commands: Vec<(Scope, Command)>,+}++/// The possible "scopes" that async commands run within.+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]+pub enum Scope {+ /// The outermost layer of the host, which controls invocations of the+ /// guests.+ HostCaller,++ /// The first layer of the guest, or the raw exports from the root of the+ /// component.+ ///+ /// This imports functions from the `GuestCallee`.+ GuestCaller,++ /// The second layer of the guest which imports the host functions directly.+ ///+ /// This is then in turn imported by the `GuestCaller`.+ GuestCallee,++ /// The innermost layer of the host which provides imported functions to the+ /// `GuestCallee`.+ HostCallee,+}++impl Scope {+ const ALL: &[Scope; 4] = &[+ Scope::HostCaller,+ Scope::GuestCaller,+ Scope::GuestCallee,+ Scope::HostCallee,+ ];+ const CALLERS: &[Scope; 3] = &[Scope::HostCaller, Scope::GuestCaller, Scope::GuestCallee];++ fn callee(&self) -> Option<Scope> {+ match self {+ Scope::HostCaller => Some(Scope::GuestCaller),+ Scope::GuestCaller => Some(Scope::GuestCallee),+ Scope::GuestCallee => Some(Scope::HostCallee),+ Scope::HostCallee => None,+ }+ }++ fn caller(&self) -> Option<Scope> {+ match self {+ Scope::HostCaller => None,+ Scope::GuestCaller => Some(Scope::HostCaller),+ Scope::GuestCallee => Some(Scope::GuestCaller),+ Scope::HostCallee => Some(Scope::GuestCallee),+ }+ }++ fn is_host(&self) -> bool {+ match self {+ Scope::HostCaller | Scope::HostCallee => true,+ Scope::GuestCaller | Scope::GuestCallee => false,+ }+ }+}++impl Arbitrary<'_> for ComponentAsync {+ fn arbitrary(u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {+ let mut state = State::default();+ let mut ret = Vec::new();++ // While there's more unstructured data, and our list of commands isn't+ // too long, generate some new commands per-component.+ while !u.is_empty() && ret.len() < SOFT_MAX_COMMANDS {+ state.generate(u, false, &mut ret)?;+ }++ // Optionally, if specified, finish up all async operations.+ if u.arbitrary()? {+ while !state.is_empty() {+ state.generate(u, true, &mut ret)?;+ }+ }++ Ok(ComponentAsync { commands: ret })+ }+}++#[derive(Default)]+struct State {+ next_id: u32,++ /// List of scopes that have an active and pending call to the+ /// `async-pending` function.+ async_pending: Vec<(Scope, u32)>,++ /// Deferred work that can happen at any time, for example asserting the+ /// result of some previous operation.+ deferred: Vec<(Scope, Command)>,++ /// State associated with futures/streams and their handles within.+ futures: HandleStates<(), u32>,+ streams: HandleStates<StreamRead, StreamWrite>,+}++#[derive(Default)]+struct HandleStates<R, W> {+ readers: HalfStates<R>,+ writers: HalfStates<W>,+}++impl<R, W> HandleStates<R, W> {+ fn is_empty(&self) -> bool {+ self.readers.is_empty() && self.writers.is_empty()+ }+}++/// State management for "half" of a future/stream read/write pair.+///+/// This tracks all the various states of all handles in the system to be able+/// to select amongst them an arbitrary operation to perform. This structure's+/// sets are primarily manipulated through helper methods to ensure that the set+/// metadata all stays in sync.+#[derive(Default)]+struct HalfStates<T> {+ /// All known handles of this type, where they're located, etc.+ handles: IndexMap<u32, (Scope, HalfState, Transferrable)>,++ /// All handles which can currently be dropped. Handles can't be dropped if+ /// they're in use, for example.+ droppable: IndexSet<u32>,++ /// All handles which can be read/written from (depending on handle type).+ /// Handles where both pairs are in the same component can't be+ /// read/written to for example.+ ready: IndexSet<u32>,++ /// All handles which can be transferred somewhere else.+ ///+ /// Some examples of non-transferrable handles are:+ ///+ /// * writers+ /// * handles with an outstanding read+ /// * host-based handles that have been used at least once (FIXME #12090)+ transferrable: IndexSet<u32>,++ /// Handles currently being read/written to.+ ///+ /// Also includes state about the operation, such as whether it's been+ /// dropped on the other side.+ in_use: IndexMap<u32, (T, OpState)>,++ /// Handles with a pending operation which can be cancelled.+ cancellable: IndexSet<u32>,+}++enum HalfState {+ Idle,+ InUse,+}++#[derive(Copy, Clone, PartialEq, Debug)]+enum Transferrable {+ Yes,+ No,+}++#[derive(Copy, Clone, PartialEq, Debug)]+enum Cancellable {+ Yes,+ No,+}++#[derive(Copy, Clone, PartialEq, Debug)]+enum OpState {+ Pending,+ Dropped,+}++#[derive(Default, Copy, Clone)]+struct StreamRead {+ count: u32,+}++#[derive(Default, Copy, Clone)]+struct StreamWrite {+ item: u32,+ count: u32,+}++impl<T> HalfStates<T> {+ fn is_empty(&self) -> bool {+ self.handles.is_empty()+ }++ /// Adds a new handle `id` to this set.+ fn insert(&mut self, id: u32, scope: Scope, transferrable: Transferrable) {+ let prev = self+ .handles+ .insert(id, (scope, HalfState::Idle, transferrable));+ assert!(prev.is_none());+ assert!(self.droppable.insert(id));+ if transferrable == Transferrable::Yes {+ self.transferrable.insert(id);+ }+ }++ /// Removes the handle `id` for closing.+ fn remove(&mut self, id: u32) -> Scope {+ let (scope, state, transferrable) = self.handles.swap_remove(&id).unwrap();+ assert!(matches!(state, HalfState::Idle));+ self.droppable.swap_remove(&id);+ self.ready.swap_remove(&id);+ if transferrable == Transferrable::Yes {+ assert!(self.transferrable.swap_remove(&id));+ }+ scope+ }++ /// Locks `id` in whatever scope it's currently in for the rest of its+ /// lifetime, preventing its transfer. This is used as a workaround for+ /// #12090.+ fn lock_in_place(&mut self, id: u32) {+ let (_scope, state, transferrable) = self.handles.get_mut(&id).unwrap();+ assert!(matches!(state, HalfState::Idle));+ if matches!(transferrable, Transferrable::Yes) {+ assert!(self.transferrable.swap_remove(&id));+ *transferrable = Transferrable::No;+ }+ }++ /// Starts an operation on the handle `id`.+ fn start(&mut self, id: u32, cancellable: Cancellable, payload: T) {+ let (_scope, state, transferrable) = self.handles.get_mut(&id).unwrap();+ assert!(matches!(state, HalfState::Idle));+ assert!(self.ready.swap_remove(&id));+ self.droppable.swap_remove(&id);+ *state = HalfState::InUse;+ let prev = self.in_use.insert(id, (payload, OpState::Pending));+ assert!(prev.is_none());+ if *transferrable == Transferrable::Yes {+ assert!(self.transferrable.swap_remove(&id));+ }+ if cancellable == Cancellable::Yes {+ assert!(self.cancellable.insert(id));+ }+ }++ /// Completes an operation on `id`, returning the state it was started with+ /// along with whether it was dropped.+ fn stop(&mut self, id: u32) -> (T, OpState) {+ let (_scope, state, transferrable) = self.handles.get_mut(&id).unwrap();+ assert!(matches!(state, HalfState::InUse));+ *state = HalfState::Idle;+ let dropped = self.in_use.swap_remove(&id).unwrap();+ self.cancellable.swap_remove(&id);+ if *transferrable == Transferrable::Yes {+ assert!(self.transferrable.insert(id));+ }+ assert!(self.droppable.insert(id));+ if dropped.1 != OpState::Dropped {+ assert!(self.ready.insert(id));+ } else {+ self.lock_in_place(id);+ }+ dropped+ }++ /// Updates to `OpState::Dropped` for an operation-in-progress.+ fn set_in_use_state_dropped(&mut self, id: u32) {+ let (_, prev) = self.in_use.get_mut(&id).unwrap();+ assert_eq!(*prev, OpState::Pending);+ *prev = OpState::Dropped;++ // This operation is now "cancellable" meaning that at any point in the+ // future it can be resolved since the other end was dropped.+ self.cancellable.insert(id);+ }+}++impl State {+ fn is_empty(&self) -> bool {+ let State {+ next_id: _,+ async_pending,+ deferred,+ futures,+ streams,+ } = self;+ async_pending.is_empty() && deferred.is_empty() && futures.is_empty() && streams.is_empty()+ }++ fn generate(+ &mut self,+ u: &mut Unstructured<'_>,+ finish: bool,+ commands: &mut Vec<(Scope, Command)>,+ ) -> arbitrary::Result<()> {+ let mut choices = Vec::new();++ // If we're not finishing up then have the possibility of+ // immediately-ready sync/async calls and such sort of miscellaneous+ // work.+ if !finish {+ choices.push(Choice::SyncReadyCall);+ choices.push(Choice::AsyncReadyCall);+ choices.push(Choice::FutureNew);+ choices.push(Choice::StreamNew);+ }++ // If we're not finishing up, and if we don't have too much pending+ // work, then possibly make some more pending work.+ if !finish && self.async_pending.len() < 20 {+ choices.push(Choice::AsyncPendingCall);+ }++ // If there's pending work, possibly resolve something.+ if self.async_pending.len() > 0 {+ choices.push(Choice::AsyncPendingResolve);+ }++ // If something has been deferred to later, possibly add that command+ // into the stream.+ if self.deferred.len() > 0 {+ choices.push(Choice::Deferred);+ }++ // Wrap up work with futures by dropping handles, writing, cancelling,+ // etc.+ if self.futures.readers.droppable.len() > 0 {+ choices.push(Choice::FutureDropReadable);+ }+ if self.futures.writers.droppable.len() > 0 {+ choices.push(Choice::FutureDropWritable);+ }+ if self.futures.writers.cancellable.len() > 0 {+ choices.push(Choice::FutureCancelWrite);+ }+ if self.futures.readers.cancellable.len() > 0 {+ choices.push(Choice::FutureCancelRead);+ }+ // If more work is allowed kick of reads/transfers.+ if !finish {+ if self.futures.writers.ready.len() > 0 {+ choices.push(Choice::FutureWrite);+ }+ if self.futures.readers.ready.len() > 0 {+ choices.push(Choice::FutureRead);+ }+ if self.futures.readers.transferrable.len() > 0 {+ choices.push(Choice::FutureReaderTransfer);+ }+ }++ // Streams can be dropped at any time and their pending operations can+ // be ceased at any time.+ if self.streams.readers.droppable.len() > 0 {+ choices.push(Choice::StreamDropReadable);+ }+ if self.streams.writers.droppable.len() > 0 {+ choices.push(Choice::StreamDropWritable);+ }+ if self.streams.readers.cancellable.len() > 0 {+ choices.push(Choice::StreamEndRead);+ }+ if self.streams.writers.cancellable.len() > 0 {+ choices.push(Choice::StreamEndWrite);+ }+ // If more work is allowed then streams can be moved around and new+ // reads/writes may be started.+ if !finish {+ if self.streams.readers.transferrable.len() > 0 {+ choices.push(Choice::StreamReaderTransfer);+ }+ if self.streams.readers.ready.len() > 0 {+ choices.push(Choice::StreamRead);+ }+ if self.streams.writers.ready.len() > 0 {+ choices.push(Choice::StreamWrite);+ }+ }++ #[derive(Debug)]+ enum Choice {+ SyncReadyCall,+ AsyncReadyCall,+ AsyncPendingCall,+ AsyncPendingResolve,+ Deferred,++ FutureNew,+ FutureReaderTransfer,+ FutureRead,+ FutureWrite,+ FutureCancelRead,+ FutureCancelWrite,+ FutureDropReadable,+ FutureDropWritable,++ StreamNew,+ StreamReaderTransfer,+ StreamDropReadable,+ StreamDropWritable,+ StreamRead,+ StreamWrite,+ StreamEndRead,+ StreamEndWrite,+ }++ match u.choose(&choices)? {+ Choice::SyncReadyCall => {+ let caller = *u.choose(Scope::CALLERS)?;+ commands.push((caller, Command::SyncReadyCall));+ }+ Choice::AsyncReadyCall => {+ let caller = *u.choose(Scope::CALLERS)?;+ commands.push((caller, Command::AsyncReadyCall));+ }++ Choice::AsyncPendingCall => {+ let caller = *u.choose(Scope::CALLERS)?;+ let id = self.next_id();+ self.async_pending.push((caller, id));+ commands.push((caller, Command::AsyncPendingImportCall(id)));+ }++ Choice::AsyncPendingResolve => {+ let index = u.int_in_range(0..=self.async_pending.len() - 1)?;+ let (caller, id) = self.async_pending.swap_remove(index);+ let callee = caller.callee().unwrap();++ // FIXME(#11833) the host can't cancel calls at this time, so+ // they can only be completed. Everything else though is+ // guest-initiated which means that the call can be either+ // completed or cancelled.+ let complete = caller == Scope::HostCaller || u.arbitrary()?;++ if complete {+ commands.push((callee, Command::AsyncPendingExportComplete(id)));+ self.deferred+ .push((caller, Command::AsyncPendingImportAssertReady(id)));+ } else {+ commands.push((caller, Command::AsyncPendingImportCancel(id)));+ self.deferred+ .push((callee, Command::AsyncPendingExportAssertCancelled(id)));+ }+ }++ Choice::Deferred => {+ let index = u.int_in_range(0..=self.deferred.len() - 1)?;+ let (scope, cmd) = self.deferred.swap_remove(index);+ commands.push((scope, cmd));+ }++ Choice::FutureNew => {+ let scope = *u.choose(Scope::ALL)?;+ let id = self.next_id();+ commands.push((scope, Command::FutureNew(id)));+ self.futures.readers.insert(id, scope, Transferrable::Yes);+ self.futures.writers.insert(id, scope, Transferrable::No);++ // Future writers cannot be dropped without writing.+ assert!(self.futures.writers.droppable.swap_remove(&id));+ }+ Choice::FutureReaderTransfer => {+ let set = &mut self.futures.readers.transferrable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = &mut self.futures.readers.handles[&id].0;++ enum Action {+ CallerTake(Scope),+ GiveCallee(Scope),+ }++ let action = match (scope.caller(), scope.callee()) {+ (Some(caller), None) => Action::CallerTake(caller),+ (None, Some(callee)) => Action::GiveCallee(callee),+ (Some(caller), Some(callee)) => {+ if u.arbitrary()? {+ Action::CallerTake(caller)+ } else {+ Action::GiveCallee(callee)+ }+ }+ (None, None) => unreachable!(),+ };+ match action {+ Action::CallerTake(caller) => {+ commands.push((caller, Command::FutureTake(id)));+ *scope = caller;+ }+ Action::GiveCallee(callee) => {+ commands.push((*scope, Command::FutureGive(id)));+ *scope = callee;+ }+ }++ // See what scope the reader/writer half are in. Allow+ // operations if they're in different scopes, but disallow+ // operations if they're in the same scope.+ let reader_scope = Some(*scope);+ let writer_scope = self.futures.writers.handles.get(&id).map(|p| p.0);+ if reader_scope == writer_scope {+ self.futures.readers.ready.swap_remove(&id);+ self.futures.writers.ready.swap_remove(&id);+ } else {+ self.futures.readers.ready.insert(id);+ if writer_scope.is_some() && !self.futures.writers.in_use.contains_key(&id) {+ self.futures.writers.ready.insert(id);+ }+ }+ }+ Choice::FutureRead => {+ let set = &self.futures.readers.ready;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.futures.readers.handles[&id].0;++ if let Some((item, _)) = self.futures.writers.in_use.get(&id) {+ // If the future has an active write, then this should+ // complete with that write. The write is then resolved and+ // the future reader/writer are both gone.+ let item = *item;+ commands.push((+ scope,+ Command::FutureReadReady(FuturePayload { future: id, item }),+ ));+ let write_scope = self.futures.writers.handles[&id].0;+ commands.push((write_scope, Command::FutureWriteAssertComplete(id)));++ self.futures.writers.stop(id);+ self.futures.readers.remove(id);+ self.futures.writers.remove(id);+ } else {+ // If the write-end is idle, then this should be a pending+ // future read.+ //+ // FIXME(#12090) host reads cannot be cancelled+ let cancellable = if scope.is_host() {+ Cancellable::No+ } else {+ Cancellable::Yes+ };+ self.futures.readers.start(id, cancellable, ());+ commands.push((scope, Command::FutureReadPending(id)));+ }+ }+ Choice::FutureWrite => {+ let set = &self.futures.writers.ready;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.futures.writers.handles[&id].0;+ let item = self.next_id();+ let payload = FuturePayload { future: id, item };++ if !self.futures.readers.handles.contains_key(&id) {+ // If the reader is gone then this write should complete+ // immediately with "dropped" and furthermore the writer+ // should now be removed.+ commands.push((scope, Command::FutureWriteDropped(id)));+ self.futures.writers.remove(id);+ } else if self.futures.readers.in_use.contains_key(&id) {+ // If the reader is in-progress then this should complete+ // the read/write pair. The reader/writer are both removed+ // as a result.+ commands.push((scope, Command::FutureWriteReady(payload)));+ let read_scope = self.futures.readers.handles[&id].0;+ commands.push((read_scope, Command::FutureReadAssertComplete(payload)));+ self.futures.readers.stop(id);+ self.futures.readers.remove(id);+ self.futures.writers.remove(id);+ } else {+ // If the read-end is idle, then this should be a pending+ // future read.+ self.futures.writers.start(id, Cancellable::Yes, item);+ commands.push((scope, Command::FutureWritePending(payload)));+ }+ }+ Choice::FutureCancelWrite => {+ let set = &self.futures.writers.cancellable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.futures.writers.handles[&id].0;++ let (_write, state) = self.futures.writers.stop(id);+ match state {+ OpState::Pending => {+ commands.push((scope, Command::FutureCancelWrite(id)));+ assert!(self.futures.writers.droppable.swap_remove(&id));+ }+ OpState::Dropped => {+ commands.push((scope, Command::FutureWriteAssertDropped(id)));+ self.futures.writers.remove(id);+ }+ }+ }+ Choice::FutureCancelRead => {+ let set = &self.futures.readers.cancellable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.futures.readers.handles[&id].0;++ let (_read, state) = self.futures.readers.stop(id);+ match state {+ OpState::Pending => {+ commands.push((scope, Command::FutureCancelRead(id)));+ }+ // Writers cannot be dropped with futures, so this is not+ // reachable.+ OpState::Dropped => unreachable!(),+ }+ }+ Choice::FutureDropReadable => {+ let set = &self.futures.readers.droppable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.futures.readers.remove(id);+ commands.push((scope, Command::FutureDropReadable(id)));++ // If the writer is active then its write is now destined to+ // finish with "dropped", and otherwise the writer is also now+ // droppable since the reader handle is gone.+ if self.futures.writers.in_use.contains_key(&id) {+ self.futures.writers.set_in_use_state_dropped(id);+ } else {+ assert!(self.futures.writers.droppable.insert(id));+ }+ }+ Choice::FutureDropWritable => {+ let set = &self.futures.writers.droppable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.futures.writers.remove(id);++ // Writers can't actually be dropped prior to writing so fake+ // a write by writing a value and asserting that the result is+ // "dropped".+ commands.push((scope, Command::FutureWriteDropped(id)));++ assert!(!self.futures.readers.handles.contains_key(&id));+ }++ Choice::StreamNew => {+ let scope = *u.choose(Scope::ALL)?;+ let id = self.next_id();+ commands.push((scope, Command::StreamNew(id)));+ self.streams.readers.insert(id, scope, Transferrable::Yes);+ self.streams.writers.insert(id, scope, Transferrable::No);+ }+ Choice::StreamReaderTransfer => {+ let set = &mut self.streams.readers.transferrable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = &mut self.streams.readers.handles[&id].0;++ enum Action {+ CallerTake(Scope),+ GiveCallee(Scope),+ }++ let action = match (scope.caller(), scope.callee()) {+ (Some(caller), None) => Action::CallerTake(caller),+ (None, Some(callee)) => Action::GiveCallee(callee),+ (Some(caller), Some(callee)) => {+ if u.arbitrary()? {+ Action::CallerTake(caller)+ } else {+ Action::GiveCallee(callee)+ }+ }+ (None, None) => unreachable!(),+ };+ match action {+ Action::CallerTake(caller) => {+ commands.push((caller, Command::StreamTake(id)));+ *scope = caller;+ }+ Action::GiveCallee(callee) => {+ commands.push((*scope, Command::StreamGive(id)));+ *scope = callee;+ }+ }++ // See what scope the reader/writer half are in. Allow+ // operations if they're in different scopes, but disallow+ // operations if they're in the same scope.+ //+ // Note that host<->host reads/writes for streams aren't fuzzed+ // at this time so that's also explicitly disallowed.+ let reader_scope = Some(*scope);+ let writer_scope = self.streams.writers.handles.get(&id).map(|p| p.0);+ if reader_scope == writer_scope+ || reader_scope.is_some_and(|s| s.is_host())+ == writer_scope.is_some_and(|s| s.is_host())+ {+ self.streams.readers.ready.swap_remove(&id);+ self.streams.writers.ready.swap_remove(&id);+ } else {+ self.streams.readers.ready.insert(id);+ if writer_scope.is_some() && !self.streams.writers.in_use.contains_key(&id) {+ self.streams.writers.ready.insert(id);+ }+ }+ }+ Choice::StreamDropReadable => {+ let set = &self.streams.readers.droppable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.streams.readers.remove(id);+ commands.push((scope, Command::StreamDropReadable(id)));++ if self.streams.writers.in_use.contains_key(&id) {+ self.streams.writers.set_in_use_state_dropped(id);+ }+ }+ Choice::StreamDropWritable => {+ let set = &self.streams.writers.droppable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.streams.writers.remove(id);+ commands.push((scope, Command::StreamDropWritable(id)));++ if self.streams.readers.in_use.contains_key(&id) {+ self.streams.readers.set_in_use_state_dropped(id);+ }+ }+ Choice::StreamRead => {+ let set = &self.streams.readers.ready;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.streams.readers.handles[&id].0;+ let count = u.int_in_range(0..=MAX_STREAM_COUNT)?;++ // FIXME(#12090)+ if scope.is_host() {+ self.streams.readers.lock_in_place(id);+ }++ if !self.streams.writers.handles.contains_key(&id) {+ // If the write handle is dropped, then this should+ // immediately report as such.+ commands.push((+ scope,+ Command::StreamReadDropped(StreamReadPayload { stream: id, count }),+ ));+ // Can't read from this stream again, so it's not ready,+ // and then we also can't lift/lower it any more so it's+ // locked in place.+ assert!(self.streams.readers.ready.swap_remove(&id));+ self.streams.readers.lock_in_place(id);+ } else if self.streams.writers.in_use.contains_key(&id) {+ // If the write handle is active then this read should+ // complete immediately.+ let write_count = self.streams.writers.in_use[&id].0.count;+ let write_scope = self.streams.writers.handles[&id].0;+ let min = count.min(write_count);++ match (count, write_count) {+ // Two zero-length operations rendezvousing will leave+ // the reader blocked but the writer should wake up. A+ // nonzero-length read and a 0-length write performs+ // the same way too.+ (0, 0) | (1.., 0) => {+ self.streams+ .readers+ .start(id, Cancellable::Yes, StreamRead { count });+ commands.push((+ scope,+ Command::StreamReadPending(StreamReadPayload { stream: id, count }),+ ));+ self.streams.writers.stop(id);+ commands.push((+ write_scope,+ Command::StreamWriteAssertComplete(StreamReadPayload {+ stream: id,+ count: min,+ }),+ ));+ }++ // A zero-length read with a nonzero-length-write+ // should wake up just the reader and do nothing to the+ // writer.+ (0, 1..) => {+ commands.push((+ scope,+ Command::StreamReadReady(StreamReadyPayload {+ stream: id,+ item: 0,+ ready_count: min,+ op_count: count,+ }),+ ));+ }++ // With two nonzero lengths both operations should complete.+ (1.., 1..) => {+ let (write, _) = self.streams.writers.stop(id);+ commands.push((+ scope,+ Command::StreamReadReady(StreamReadyPayload {+ stream: id,+ item: write.item,+ ready_count: min,+ op_count: count,+ }),+ ));+ commands.push((+ write_scope,+ Command::StreamWriteAssertComplete(StreamReadPayload {+ stream: id,+ count: min,+ }),+ ));+ }+ }+ } else {+ // If the write handle is not active then this should be in+ // a pending state now.+ self.streams+ .readers+ .start(id, Cancellable::Yes, StreamRead { count });+ commands.push((+ scope,+ Command::StreamReadPending(StreamReadPayload { stream: id, count }),+ ));+ }+ }+ Choice::StreamWrite => {+ let set = &self.streams.writers.ready;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.streams.writers.handles[&id].0;+ let item = self.next_id();+ let count = u.int_in_range(0..=MAX_STREAM_COUNT)?;++ // FIXME(#12090)+ if scope.is_host() {+ self.streams.writers.lock_in_place(id);+ }++ if !self.streams.readers.handles.contains_key(&id) {+ // If the read handle is dropped, then this should+ // immediately report as such.+ commands.push((+ scope,+ Command::StreamWriteDropped(StreamWritePayload {+ stream: id,+ item,+ count,+ }),+ ));+ // Cannot write ever again to this handle so remove it from+ // the writable set.+ assert!(self.streams.writers.ready.swap_remove(&id));+ } else if self.streams.readers.in_use.contains_key(&id) {+ // If the read handle is active then this write should+ // complete immediately.+ let read_count = self.streams.readers.in_use[&id].0.count;+ let read_scope = self.streams.readers.handles[&id].0;+ let min = count.min(read_count);++ match (read_count, count) {+ // A zero-length write, no matter what the read half is+ // pending as, is always ready and doesn't affect the+ // reader.+ (_, 0) => {+ commands.push((+ scope,+ Command::StreamWriteReady(StreamReadyPayload {+ stream: id,+ item,+ op_count: count,+ ready_count: min,+ }),+ ));+ }++ // With a zero-length read and a nonzero-length write+ // the writer is blocked but the reader is unblocked.+ (0, 1..) => {+ self.streams.writers.start(+ id,+ Cancellable::Yes,+ StreamWrite { item, count },+ );+ commands.push((+ scope,+ Command::StreamWritePending(StreamWritePayload {+ stream: id,+ item,+ count,+ }),+ ));+ self.streams.readers.stop(id);+ commands.push((+ read_scope,+ Command::StreamReadAssertComplete(StreamWritePayload {+ stream: id,+ item,+ count: min,+ }),+ ));+ }++ // Nonzero sizes means that the write immediately+ // finishes and the read is also now ready to complete.+ (1.., 1..) => {+ commands.push((+ scope,+ Command::StreamWriteReady(StreamReadyPayload {+ stream: id,+ item,+ op_count: count,+ ready_count: min,+ }),+ ));+ self.streams.readers.stop(id);+ commands.push((+ read_scope,+ Command::StreamReadAssertComplete(StreamWritePayload {+ stream: id,+ item,+ count: min,+ }),+ ));+ }+ }+ } else {+ // If the read handle is not active then this should be in+ // a pending state now.+ self.streams+ .writers+ .start(id, Cancellable::Yes, StreamWrite { item, count });+ commands.push((+ scope,+ Command::StreamWritePending(StreamWritePayload {+ stream: id,+ item,+ count,+ }),+ ));+ }+ }+ Choice::StreamEndRead => {+ let set = &self.streams.readers.cancellable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.streams.readers.handles[&id].0;++ let (_read, state) = self.streams.readers.stop(id);+ match state {+ OpState::Pending => {+ commands.push((scope, Command::StreamCancelRead(id)));+ }+ OpState::Dropped => {+ commands.push((scope, Command::StreamReadAssertDropped(id)));+ }+ }+ }+ Choice::StreamEndWrite => {+ let set = &self.streams.writers.cancellable;+ let i = u.int_in_range(0..=set.len() - 1)?;+ let id = *set.get_index(i).unwrap();+ let scope = self.streams.writers.handles[&id].0;++ let (_write, state) = self.streams.writers.stop(id);+ match state {+ OpState::Pending => {+ commands.push((scope, Command::StreamCancelWrite(id)));+ }+ OpState::Dropped => {+ commands.push((+ scope,+ Command::StreamWriteAssertDropped(StreamReadPayload {+ stream: id,+ count: 0,+ }),+ ));+ }+ }+ }+ }+ Ok(())+ }++ fn next_id(&mut self) -> u32 {+ let id = self.next_id;+ self.next_id += 1;+ id+ }+}diff --git a/crates/fuzzing/src/lib.rs b/crates/fuzzing/src/lib.rsindex 9c25b4dde8..bb538d8f2d 100644--- a/crates/fuzzing/src/lib.rs+++ b/crates/fuzzing/src/lib.rs@@ -2,6 +2,7 @@#![deny(missing_docs)]+use std::pin::Pin;use std::task::{Context, Poll, Waker};pub use wasm_mutate;@@ -33,15 +34,54 @@ pub fn init_fuzzing() {});}+/// One time start up initialization for fuzzing:+///+/// * Enables `env_logger`.+///+/// * Restricts `rayon` to a single thread in its thread pool, for more+/// deterministic executions.+///+/// If a fuzz target is taking raw input bytes from the fuzzer, it is fine to+/// call this function in the fuzz target's oracle or in the fuzz target+/// itself. However, if the fuzz target takes an `Arbitrary` type, and the+/// `Arbitrary` implementation is not derived and does interesting things, then+/// the `Arbitrary` implementation should call this function, since it runs+/// before the fuzz target itself.+pub fn misc_init() {+ init_fuzzing();+ oracles::component_async::init();+}+fn block_on<F: Future>(future: F) -> F::Output {+ const MAX_POLLS: u32 = 100_000;+let mut f = Box::pin(future);let mut cx = Context::from_waker(Waker::noop());- loop {+ for _ in 0..MAX_POLLS {match f.as_mut().poll(&mut cx) {- Poll::Ready(val) => break val,+ Poll::Ready(val) => return val,Poll::Pending => {}}}++ panic!("future didn't become ready")+}++/// Helper future to yield N times before resolving.+struct YieldN(u32);++impl Future for YieldN {+ type Output = ();++ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {+ if self.0 == 0 {+ Poll::Ready(())+ } else {+ self.0 -= 1;+ cx.waker().wake_by_ref();+ Poll::Pending+ }+ }}#[cfg(test)]diff --git a/crates/fuzzing/src/oracles.rs b/crates/fuzzing/src/oracles.rsindex fa9df31778..255c4e9325 100644--- a/crates/fuzzing/src/oracles.rs+++ b/crates/fuzzing/src/oracles.rs@@ -11,6 +11,7 @@//! panicking.pub mod component_api;+pub mod component_async;#[cfg(feature = "fuzz-spec-interpreter")]pub mod diff_spec;pub mod diff_wasmi;@@ -22,10 +23,10 @@ mod stacks;use self::diff_wasmtime::WasmtimeInstance;use self::engine::{DiffEngine, DiffInstance};-use crate::block_on;use crate::generators::GcOps;use crate::generators::{self, CompilerStrategy, DiffValue, DiffValueType};use crate::single_module_fuzzer::KnownValid;+use crate::{YieldN, block_on};use arbitrary::Arbitrary;pub use stacks::check_stacks;use std::future::Future;@@ -1206,23 +1207,6 @@ pub fn call_async(wasm: &[u8], config: &generators::Config, mut poll_amts: &[u32}}- /// Helper future to yield N times before resolving.- struct YieldN(u32);-- impl Future for YieldN {- type Output = ();-- fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {- if self.0 == 0 {- Poll::Ready(())- } else {- self.0 -= 1;- cx.waker().wake_by_ref();- Poll::Pending- }- }- }-/// Helper future for applying a timeout to `future` up to either when `end`/// is the current time or `polls` polls happen.///diff --git a/crates/fuzzing/src/oracles/component_async.rs b/crates/fuzzing/src/oracles/component_async.rsnew file mode 100644index 0000000000..196d34080c--- /dev/null+++ b/crates/fuzzing/src/oracles/component_async.rs@@ -0,0 +1,1479 @@+//! For a high-level overview of this fuzz target see `fuzz_async.rs`++use crate::block_on;+use crate::generators::component_async::exports::wasmtime_fuzz::fuzz::async_test::Guest;+use crate::generators::component_async::wasmtime_fuzz::fuzz::async_test::{self, Command};+use crate::generators::component_async::wasmtime_fuzz::fuzz::types;+use crate::generators::component_async::{ComponentAsync, FuzzAsyncPre, Scope};+use futures::channel::oneshot;+use std::collections::{HashMap, HashSet};+use std::mem;+use std::pin::Pin;+use std::sync::{Arc, OnceLock, Weak};+use std::task::{Context, Poll, Waker};+use std::time::Instant;+use wasmtime::component::{+ Access, Accessor, AccessorTask, Component, Destination, FutureConsumer, FutureProducer,+ FutureReader, HasSelf, Linker, ResourceTable, Source, StreamConsumer, StreamProducer,+ StreamReader, StreamResult, VecBuffer,+};+use wasmtime::{AsContextMut, Config, Engine, Result, Store, StoreContextMut};+use wasmtime_wasi::{WasiCtx, WasiCtxView, WasiView};++static STATE: OnceLock<(Engine, FuzzAsyncPre<Data>)> = OnceLock::new();++/// Initializes state for future fuzz runs.+///+/// This will create an `Engine` to run this fuzzer within and it will+/// additionally precompile the component that will be used for fuzzing.+///+/// There are a few points of note about this:+///+/// * The `misc` fuzzer is manually instrumented with this function as the init+/// hook to ensure this runs before any other fuzzing.+///+/// * Compilation of the component takes quite some time with+/// fuzzing-instrumented Cranelift. To assist with local development this+/// implements a cache which is serialized/deserialized via an env var.+pub fn init() {+ crate::init_fuzzing();++ STATE.get_or_init(|| {+ let mut config = Config::new();+ config.wasm_component_model_async(true);+ config.async_support(true);+ let engine = Engine::new(&config).unwrap();+ let component = compile(&engine);+ let mut linker = Linker::new(&engine);+ wasmtime_wasi::p2::add_to_linker_async(&mut linker).unwrap();+ async_test::add_to_linker::<_, HasSelf<Data>>(&mut linker, |d| d).unwrap();+ types::add_to_linker::<_, HasSelf<Data>>(&mut linker, |d| d).unwrap();++ let pre = linker.instantiate_pre(&component).unwrap();+ let pre = FuzzAsyncPre::new(pre).unwrap();++ (engine, pre)+ });++ fn compile(engine: &Engine) -> Component {+ let wasm = test_programs_artifacts::FUZZ_ASYNC_COMPONENT;+ let cwasm_cache = std::env::var("COMPONENT_ASYNC_CWASM_CACHE").ok();+ if let Some(path) = &cwasm_cache+ && let Ok(cwasm_mtime) = std::fs::metadata(&path).and_then(|m| m.modified())+ && let Ok(wasm_mtime) = std::fs::metadata(wasm).and_then(|m| m.modified())+ && cwasm_mtime > wasm_mtime+ {+ log::debug!("Using cached component async cwasm at {path}");+ unsafe {+ return Component::deserialize_file(engine, path).unwrap();+ }+ }++ let composition = {+ let mut config = wasm_compose::config::Config::default();+ let tempdir = tempfile::TempDir::new().unwrap();+ let path = tempdir.path().join("fuzz-async.wasm");+ std::fs::copy(wasm, &path).unwrap();+ config.definitions.push(path.clone());++ wasm_compose::composer::ComponentComposer::new(&path, &config)+ .compose()+ .unwrap()+ };+ let start = Instant::now();+ let component = Component::new(&engine, &composition).unwrap();+ if let Some(path) = cwasm_cache {+ log::debug!("Caching component async cwasm to {path}");+ std::fs::write(path, &component.serialize().unwrap()).unwrap();+ } else if start.elapsed() > std::time::Duration::from_secs(1) {+ eprintln!(+ "+!!!!!!!!!!!!!!!!!!!!!!!!!!++Component compilation is slow, try setting `COMPONENT_ASYNC_CWASM_CACHE=path` to+cache compilation results++!!!!!!!!!!!!!!!!!!!!!!!!!!+"+ );+ }+ return component;+ }+}++#[derive(Default)]+struct Data {+ ctx: WasiCtx,+ table: ResourceTable,+ wakers: HashMap<Scope, Waker>,+ commands: Vec<(Scope, Command)>,++ guest_caller_stream: Option<StreamReader<Command>>,+ guest_callee_stream: Option<StreamReader<Command>>,++ host_pending_async_calls: HashMap<u32, oneshot::Sender<()>>,+ host_pending_async_calls_cancelled: HashSet<u32>,+ guest_pending_async_calls_ready: HashSet<u32>,++ // State of futures/streams. Note that while #12091 is unresolved an+ // `Arc`/`Weak` combo is used to detect when wasmtime drops futures/streams+ // and the various halves we're interacting with using traits.+ host_futures: HashMap<u32, FutureReader<u32>>,+ host_future_producers: HashMap<u32, (HostFutureProducerState, Weak<()>)>,+ host_future_consumers: HashMap<u32, (HostFutureConsumerState, Weak<()>)>,+ host_streams: HashMap<u32, StreamReader<u32>>,+ host_stream_producers: HashMap<u32, (HostStreamProducerState, Weak<()>)>,+ host_stream_consumers: HashMap<u32, (HostStreamConsumerState, Weak<()>)>,+}++impl WasiView for Data {+ fn ctx(&mut self) -> WasiCtxView<'_> {+ WasiCtxView {+ ctx: &mut self.ctx,+ table: &mut self.table,+ }+ }+}++impl async_test::HostWithStore for HasSelf<Data> {+ async fn async_ready<T>(_store: &Accessor<T, Self>) {}++ async fn async_pending<T>(store: &Accessor<T, Self>, id: u32) {+ let (tx, rx) = oneshot::channel();+ store.with(|mut s| s.get().host_pending_async_calls.insert(id, tx));+ let record = RecordCancelOnDrop { store, id };+ rx.await.unwrap();+ mem::forget(record);++ struct RecordCancelOnDrop<'a, T: 'static> {+ store: &'a Accessor<T, HasSelf<Data>>,+ id: u32,+ }++ impl<T> Drop for RecordCancelOnDrop<'_, T> {+ fn drop(&mut self) {+ self.store.with(|mut s| {+ s.get().host_pending_async_calls_cancelled.insert(self.id);+ });+ }+ }+ }++ async fn init<T>(_store: &Accessor<T, Self>, _scope: types::Scope) {}+}++impl async_test::Host for Data {+ fn sync_ready(&mut self) {}++ fn future_take(&mut self, id: u32) -> FutureReader<u32> {+ self.host_futures.remove(&id).unwrap()+ }++ fn future_receive(&mut self, id: u32, future: FutureReader<u32>) {+ let prev = self.host_futures.insert(id, future);+ assert!(prev.is_none());+ }++ fn stream_take(&mut self, id: u32) -> StreamReader<u32> {+ self.host_streams.remove(&id).unwrap()+ }++ fn stream_receive(&mut self, id: u32, stream: StreamReader<u32>) {+ let prev = self.host_streams.insert(id, stream);+ assert!(prev.is_none());+ }+}++impl types::HostWithStore for HasSelf<Data> {+ fn get_commands<T>(+ mut store: Access<'_, T, Self>,+ scope: types::Scope,+ ) -> StreamReader<Command> {+ let data = store.get();+ match scope {+ types::Scope::Caller => data.guest_caller_stream.take().unwrap(),+ types::Scope::Callee => data.guest_callee_stream.take().unwrap(),+ }+ }+}++impl types::Host for Data {}++/// Executes the `input` provided, assuming that `init` has been previously+/// executed.+pub fn run(mut input: ComponentAsync) {+ log::debug!("Running component async fuzz test with\n{input:?}");++ // Commands are executed in the order that they're listed in the input, but+ // to make it easier on the `StreamProducer` implementation below they're+ // popped off the back. To ensure that they're all delivered in the right+ // order reverse the list to ensure the correct order is maintained.+ input.commands.reverse();++ let (engine, pre) = STATE.get().unwrap();+ let mut store = Store::new(+ engine,+ Data {+ ctx: WasiCtx::builder().inherit_stdio().inherit_env().build(),+ commands: input.commands,+ ..Data::default()+ },+ );++ let guest_caller_stream = StreamReader::new(&mut store, SharedStream(Scope::GuestCaller));+ let guest_callee_stream = StreamReader::new(&mut store, SharedStream(Scope::GuestCallee));+ store.data_mut().guest_caller_stream = Some(guest_caller_stream);+ store.data_mut().guest_callee_stream = Some(guest_callee_stream);+ block_on(async {+ let instance = pre.instantiate_async(&mut store).await.unwrap();+ let test = instance.wasmtime_fuzz_fuzz_async_test();++ let mut host_caller = SharedStream(Scope::HostCaller);+ let mut host_callee = SharedStream(Scope::HostCallee);+ store+ .run_concurrent(async |store| {+ // Kick off stream reads in the guest. This function will return+ // but the tasks in the guest will keep running after they+ // return to process stream items.+ test.call_init(store, types::Scope::Caller).await.unwrap();++ // Simultaneously process commands from both host streams. These+ // will return once the entire command queue is exhausted.+ futures::join!(+ async {+ while let Some(cmd) = host_caller.next(store).await {+ host_caller_cmd(&test, store, cmd).await;+ }+ },+ async {+ while let Some(cmd) = host_callee.next(store).await {+ host_callee_cmd(store, cmd).await;+ }+ },+ );++ // Note that there may still be pending async work in the guest+ // (or host). It's intentional that it's not cleaned up here to+ // help test situations where async work is all abruptly+ // cancelled by just being dropped in the host.+ })+ .await+ .unwrap();+ });+}++/// See documentation in `fuzz_async.rs` for what's going on here.+async fn test_property<F>(store: &Accessor<Data>, mut f: F) -> bool+where+ F: FnMut(&mut Data) -> bool,+{+ for _ in 0..1000 {+ let ready = store.with(|mut s| f(s.get()));+ if ready {+ return true;+ }++ crate::YieldN(1).await;+ }++ return false;+}++async fn await_property<F>(store: &Accessor<Data>, desc: &str, f: F)+where+ F: FnMut(&mut Data) -> bool,+{+ assert!(+ test_property(store, f).await,+ "timed out waiting for {desc}",+ );+}++async fn host_caller_cmd(test: &Guest, store: &Accessor<Data>, cmd: Command) {+ match cmd {+ Command::Ack => {}+ Command::SyncReadyCall => test.call_sync_ready(store).await.unwrap(),+ Command::AsyncReadyCall => test.call_async_ready(store).await.unwrap(),+ Command::AsyncPendingExportComplete(_i) => todo!(),+ Command::AsyncPendingExportAssertCancelled(_i) => todo!(),+ Command::AsyncPendingImportCall(i) => {+ struct RunPendingImport {+ test: Guest,+ i: u32,+ }++ store.spawn(RunPendingImport {+ test: test.clone(),+ i,+ });++ impl AccessorTask<Data> for RunPendingImport {+ async fn run(self, store: &Accessor<Data>) -> Result<()> {+ self.test.call_async_pending(store, self.i).await?;+ store.with(|mut s| {+ s.get().guest_pending_async_calls_ready.insert(self.i);+ });+ Ok(())+ }+ }+ }+ Command::AsyncPendingImportCancel(_i) => todo!(),+ Command::AsyncPendingImportAssertReady(i) => {+ assert!(+ test_property(store, |s| s.guest_pending_async_calls_ready.remove(&i)).await,+ "expected async_pending import {i} to be ready",+ );+ }++ Command::FutureTake(i) => {+ let future = test.call_future_take(store, i).await.unwrap();+ store.with(|mut s| {+ let prev = s.get().host_futures.insert(i, future);+ assert!(prev.is_none());+ });+ }+ Command::FutureGive(i) => {+ let future = store.with(|mut s| s.get().host_futures.remove(&i).unwrap());+ test.call_future_receive(store, i, future).await.unwrap();+ }+ Command::StreamTake(i) => {+ let stream = test.call_stream_take(store, i).await.unwrap();+ store.with(|mut s| {+ let prev = s.get().host_streams.insert(i, stream);+ assert!(prev.is_none());+ });+ }+ Command::StreamGive(i) => {+ let stream = store.with(|mut s| s.get().host_streams.remove(&i).unwrap());+ test.call_stream_receive(store, i, stream).await.unwrap();+ }++ other => future_or_stream_cmd(store, other).await,+ }+}++async fn host_callee_cmd(store: &Accessor<Data>, cmd: Command) {+ match cmd {+ Command::Ack => {}+ Command::SyncReadyCall => todo!(),+ Command::AsyncReadyCall => todo!(),+ Command::AsyncPendingExportComplete(i) => store.with(|mut s| {+ s.get()+ .host_pending_async_calls+ .remove(&i)+ .unwrap()+ .send(())+ .unwrap();+ }),+ Command::AsyncPendingExportAssertCancelled(i) => {+ assert!(+ test_property(store, |s| s.host_pending_async_calls_cancelled.remove(&i)).await,+ "expected async_pending export {i} to be cancelled",+ );+ }+ Command::AsyncPendingImportCall(_i) => todo!(),+ Command::AsyncPendingImportCancel(_i) => todo!(),+ Command::AsyncPendingImportAssertReady(_i) => todo!(),++ other => future_or_stream_cmd(store, other).await,+ }+}++async fn future_or_stream_cmd(store: &Accessor<Data>, cmd: Command) {+ match cmd {+ // These commands should be handled above+ Command::Ack+ | Command::SyncReadyCall+ | Command::AsyncReadyCall+ | Command::AsyncPendingExportComplete(_)+ | Command::AsyncPendingExportAssertCancelled(_)+ | Command::AsyncPendingImportCall(_)+ | Command::AsyncPendingImportCancel(_)+ | Command::FutureTake(_)+ | Command::FutureGive(_)+ | Command::StreamTake(_)+ | Command::StreamGive(_)+ | Command::AsyncPendingImportAssertReady(_) => unreachable!(),++ Command::FutureNew(id) => {+ store.with(|mut s| {+ let arc = Arc::new(());+ let weak = Arc::downgrade(&arc);+ let future = FutureReader::new(&mut s, HostFutureProducer(id, arc));+ let data = s.get();+ let prev = data.host_futures.insert(id, future);+ assert!(prev.is_none());+ let prev = data+ .host_future_producers+ .insert(id, (HostFutureProducerState::Idle, weak));+ assert!(prev.is_none());+ });+ }+ Command::FutureDropReadable(id) => {+ store.with(|mut s| match s.get().host_futures.remove(&id) {+ Some(mut future) => future.close(&mut s),+ None => {+ let (mut state, _weak) = s.get().host_future_consumers.remove(&id).unwrap();+ state.wake_by_ref();+ }+ })+ }+ Command::FutureWriteReady(payload) => {+ await_property(store, "future write should be waiting", |s| {+ matches!(+ s.host_future_producers.get(&payload.future),+ Some((HostFutureProducerState::Waiting(_), _))+ )+ })+ .await;+ store.with(|mut s| {+ let state = s+ .get()+ .host_future_producers+ .get_mut(&payload.future)+ .unwrap();+ match state {+ (HostFutureProducerState::Waiting(waker), _) => {+ waker.wake_by_ref();+ state.0 = HostFutureProducerState::Writing(payload.item);+ }+ (state, _) => panic!("future not waiting: {state:?}"),+ }+ })+ }+ Command::FutureWritePending(payload) => store.with(|mut s| {+ let state = s+ .get()+ .host_future_producers+ .get_mut(&payload.future)+ .unwrap();+ match state {+ (HostFutureProducerState::Idle, _) => {+ state.0 = HostFutureProducerState::Writing(payload.item);+ }+ _ => panic!("future not idle"),+ }+ }),+ Command::FutureWriteDropped(id) => store.with(|mut s| {+ let (state, weak) = s.get().host_future_producers.remove(&id).unwrap();+ assert!(matches!(state, HostFutureProducerState::Idle));+ assert!(weak.upgrade().is_none());+ }),+ Command::FutureReadReady(payload) => {+ let id = payload.future;+ store.with(|mut s| {+ let arc = Arc::new(());+ let weak = Arc::downgrade(&arc);+ let data = s.get();+ let future = data.host_futures.remove(&id).unwrap();+ let prev = data+ .host_future_consumers+ .insert(id, (HostFutureConsumerState::Consuming, weak));+ assert!(prev.is_none());+ future.pipe(&mut s, HostFutureConsumer(id, arc));+ });++ await_property(store, "future should be present", |s| {+ matches!(+ s.host_future_consumers[&id],+ (HostFutureConsumerState::Complete(_), _)+ )+ })+ .await;++ store.with(|mut s| {+ let (state, _) = s.get().host_future_consumers.remove(&id).unwrap();+ match state {+ HostFutureConsumerState::Complete(i) => assert_eq!(i, payload.item),+ _ => panic!("future not complete"),+ }+ });+ }+ Command::FutureReadPending(id) => {+ ensure_future_reading(store, id);+ store.with(|mut s| {+ let (state, _) = s.get().host_future_consumers.get_mut(&id).unwrap();+ state.wake_by_ref();+ assert!(+ matches!(state, HostFutureConsumerState::Idle),+ "bad state: {state:?}",+ );+ *state = HostFutureConsumerState::Consuming;+ })+ }+ Command::FutureCancelWrite(id) => store.with(|mut s| {+ let (state, _) = s.get().host_future_producers.get_mut(&id).unwrap();+ assert!(matches!(state, HostFutureProducerState::Writing(_)));+ *state = HostFutureProducerState::Idle;+ }),+ Command::FutureCancelRead(id) => store.with(|mut s| {+ let (state, _) = s.get().host_future_consumers.get_mut(&id).unwrap();+ assert!(matches!(state, HostFutureConsumerState::Consuming));+ *state = HostFutureConsumerState::Idle;+ }),+ Command::FutureReadAssertComplete(payload) => {+ await_property(store, "future read should be complete", |s| {+ matches!(+ s.host_future_consumers.get(&payload.future),+ Some((HostFutureConsumerState::Complete(_), _))+ )+ })+ .await;+ store.with(|mut s| {+ let (state, _) = s+ .get()+ .host_future_consumers+ .remove(&payload.future)+ .unwrap();+ match state {+ HostFutureConsumerState::Complete(i) => assert_eq!(i, payload.item),+ _ => panic!("future not complete"),+ }+ })+ }+ Command::FutureWriteAssertComplete(id) => store.with(|mut s| {+ let (state, weak) = s.get().host_future_producers.remove(&id).unwrap();+ assert!(matches!(state, HostFutureProducerState::Complete));+ assert!(weak.upgrade().is_none());+ }),+ Command::FutureWriteAssertDropped(id) => store.with(|mut s| {+ let (state, weak) = s.get().host_future_producers.remove(&id).unwrap();+ assert!(matches!(state, HostFutureProducerState::Writing(_)));+ assert!(weak.upgrade().is_none());+ }),++ Command::StreamNew(id) => {+ store.with(|mut s| {+ let arc = Arc::new(());+ let weak = Arc::downgrade(&arc);+ let stream = StreamReader::new(&mut s, HostStreamProducer(id, arc));+ let data = s.get();+ let prev = data.host_streams.insert(id, stream);+ assert!(prev.is_none());+ let prev = data+ .host_stream_producers+ .insert(id, (HostStreamProducerState::idle(), weak));+ assert!(prev.is_none());+ });+ }+ Command::StreamDropReadable(id) => {+ store.with(|mut s| match s.get().host_streams.remove(&id) {+ Some(mut stream) => {+ stream.close(&mut s);+ }+ None => {+ let (mut state, _weak) = s.get().host_stream_consumers.remove(&id).unwrap();+ state.wake_by_ref();+ }+ })+ }+ Command::StreamDropWritable(id) => store.with(|mut s| {+ let (mut state, _weak) = s.get().host_stream_producers.remove(&id).unwrap();+ state.wake_by_ref();+ }),+ Command::StreamWriteReady(payload) => {+ let id = payload.stream;+ store.with(|mut s| {+ let (state, _) = s.get().host_stream_producers.get_mut(&id).unwrap();+ state.wake_by_ref();+ match state.kind {+ HostStreamProducerStateKind::Idle => {+ state.kind = HostStreamProducerStateKind::Writing(stream_payload(+ payload.item,+ payload.op_count,+ ));+ }+ _ => panic!("stream not idle: {state:?}"),+ }+ });+ await_property(store, "stream should complete a write", |s| {+ matches!(+ s.host_stream_producers[&id].0.kind,+ HostStreamProducerStateKind::Wrote(_),+ )+ })+ .await;+ store.with(|mut s| {+ let (state, _) = s.get().host_stream_producers.get_mut(&id).unwrap();+ match state.kind {+ HostStreamProducerStateKind::Wrote(amt) => {+ assert_eq!(amt, payload.ready_count);+ state.kind = HostStreamProducerStateKind::Idle;+ }+ _ => panic!("stream not idle: {state:?}"),+ }+ });+ }+ Command::StreamReadReady(payload) => {+ let id = payload.stream;+ ensure_stream_reading(store, id);+ store.with(|mut s| {+ let (state, _) = s.get().host_stream_consumers.get_mut(&id).unwrap();+ state.wake_by_ref();+ state.kind = HostStreamConsumerStateKind::Consuming(payload.op_count);+ });+ await_property(store, "stream should complete a read", |s| {+ matches!(+ s.host_stream_consumers[&id].0.kind,+ HostStreamConsumerStateKind::Consumed(_),+ )+ })+ .await;++ store.with(|mut s| {+ let (state, _) = s.get().host_stream_consumers.get_mut(&id).unwrap();+ match &state.kind {+ HostStreamConsumerStateKind::Consumed(last_read) => {+ assert_eq!(+ *last_read,+ stream_payload(payload.item, payload.ready_count)+ );+ state.kind = HostStreamConsumerStateKind::Idle;+ }+ _ => panic!("future not complete"),+ }+ });+ }+ Command::StreamWritePending(payload) => store.with(|mut s| {+ let (state, _) = s+ .get()+ .host_stream_producers+ .get_mut(&payload.stream)+ .unwrap();+ state.wake_by_ref();+ match state.kind {+ HostStreamProducerStateKind::Idle => {+ state.kind = HostStreamProducerStateKind::Writing(stream_payload(+ payload.item,+ payload.count,+ ));+ }+ _ => panic!("stream not idle {:?}", state.kind),+ }+ }),+ Command::StreamReadPending(payload) => {+ ensure_stream_reading(store, payload.stream);+ store.with(|mut s| {+ let (state, _) = s+ .get()+ .host_stream_consumers+ .get_mut(&payload.stream)+ .unwrap();+ state.wake_by_ref();+ assert!(matches!(state.kind, HostStreamConsumerStateKind::Idle));+ state.kind = HostStreamConsumerStateKind::Consuming(payload.count);+ })+ }+ Command::StreamWriteDropped(payload) => store.with(|mut s| {+ let (state, weak) = s+ .get()+ .host_stream_producers+ .get_mut(&payload.stream)+ .unwrap();+ assert!(matches!(state.kind, HostStreamProducerStateKind::Idle));+ assert!(weak.upgrade().is_none());+ }),+ Command::StreamReadDropped(payload) => {+ ensure_stream_reading(store, payload.stream);+ await_property(store, "stream read should get dropped", |s| {+ let weak = &s.host_stream_consumers[&payload.stream].1;+ weak.upgrade().is_none()+ })+ .await;+ store.with(|mut s| {+ let (state, weak) = s+ .get()+ .host_stream_consumers+ .get_mut(&payload.stream)+ .unwrap();+ assert!(matches!(state.kind, HostStreamConsumerStateKind::Idle));+ assert!(weak.upgrade().is_none());+ })+ }+ Command::StreamCancelWrite(id) => store.with(|mut s| {+ let (state, _) = s.get().host_stream_producers.get_mut(&id).unwrap();+ assert!(+ matches!(state.kind, HostStreamProducerStateKind::Writing(_)),+ "invalid state {state:?}",+ );+ state.kind = HostStreamProducerStateKind::Idle;+ state.wake_by_ref();+ }),+ Command::StreamCancelRead(id) => store.with(|mut s| {+ let (state, _) = s.get().host_stream_consumers.get_mut(&id).unwrap();+ assert!(matches!(+ state.kind,+ HostStreamConsumerStateKind::Consuming(_)+ ));+ state.kind = HostStreamConsumerStateKind::Idle;+ }),+ Command::StreamReadAssertComplete(payload) => store.with(|mut s| {+ let (state, _) = s+ .get()+ .host_stream_consumers+ .get_mut(&payload.stream)+ .unwrap();+ match &state.kind {+ HostStreamConsumerStateKind::Consumed(last_read) => {+ assert_eq!(*last_read, stream_payload(payload.item, payload.count));+ state.kind = HostStreamConsumerStateKind::Idle;+ }+ _ => panic!("stream not complete"),+ }+ }),+ Command::StreamWriteAssertComplete(payload) => store.with(|mut s| {+ let (state, _) = s+ .get()+ .host_stream_producers+ .get_mut(&payload.stream)+ .unwrap();+ match state.kind {+ HostStreamProducerStateKind::Wrote(amt) => {+ assert_eq!(amt, payload.count);+ state.kind = HostStreamProducerStateKind::Idle;+ }+ _ => panic!("stream not complete: {:?}", state.kind),+ }+ }),+ Command::StreamWriteAssertDropped(payload) => {+ await_property(store, "stream write should be dropped", |s| {+ let weak = &s.host_stream_producers[&payload.stream].1;+ weak.upgrade().is_none()+ })+ .await;+ store.with(|mut s| {+ let (state, weak) = s+ .get()+ .host_stream_producers+ .get_mut(&payload.stream)+ .unwrap();+ assert!(matches!(+ state.kind,+ HostStreamProducerStateKind::Writing(_)+ ));+ assert!(weak.upgrade().is_none());+ })+ }+ Command::StreamReadAssertDropped(id) => {+ await_property(store, "stream read should be dropped", |s| {+ let weak = &s.host_stream_consumers[&id].1;+ weak.upgrade().is_none()+ })+ .await;+ store.with(|mut s| {+ let (state, weak) = s.get().host_stream_consumers.get_mut(&id).unwrap();+ assert!(matches!(+ state.kind,+ HostStreamConsumerStateKind::Consuming(_),+ ));+ assert!(weak.upgrade().is_none());+ })+ }+ }+}++fn stream_payload(item: u32, count: u32) -> Vec<u32> {+ (item..item + count).collect()+}++fn ensure_future_reading(store: &Accessor<Data>, id: u32) {+ store.with(|mut s| {+ let data = s.get();+ if !data.host_futures.contains_key(&id) {+ return;+ }+ log::debug!("future consume: start {id}");+ let arc = Arc::new(());+ let weak = Arc::downgrade(&arc);+ let data = s.get();+ let future = data.host_futures.remove(&id).unwrap();+ let prev = data+ .host_future_consumers+ .insert(id, (HostFutureConsumerState::Idle, weak));+ assert!(prev.is_none());+ future.pipe(&mut s, HostFutureConsumer(id, arc));+ });+}++fn ensure_stream_reading(store: &Accessor<Data>, id: u32) {+ store.with(|mut s| {+ let data = s.get();+ if !data.host_streams.contains_key(&id) {+ return;+ }+ log::debug!("stream consume: start {id}");+ let arc = Arc::new(());+ let weak = Arc::downgrade(&arc);+ let prev = data.host_stream_consumers.insert(+ id,+ (+ HostStreamConsumerState {+ kind: HostStreamConsumerStateKind::Idle,+ waker: None,+ },+ weak,+ ),+ );+ assert!(prev.is_none());+ let stream = data.host_streams.remove(&id).unwrap();+ stream.pipe(&mut s, HostStreamConsumer(id, arc));+ });+}++struct HostFutureConsumer(u32, #[expect(dead_code, reason = "drop-tracking")] Arc<()>);++/// Note that this is only created once a read is actually initiated on a+/// future. It's also not possible to cancel a host-based read on a future,+/// hence why this is simpler than the `HostFutureProducerState` state below.+#[derive(Debug)]+enum HostFutureConsumerState {+ Idle,+ Waiting(Waker),+ Consuming,+ Complete(u32),+}++impl HostFutureConsumerState {+ fn wake_by_ref(&mut self) {+ if let HostFutureConsumerState::Waiting(waker) = &self {+ waker.wake_by_ref();+ *self = HostFutureConsumerState::Idle;+ }+ }+}++impl FutureConsumer<Data> for HostFutureConsumer {+ type Item = u32;++ fn poll_consume(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ mut store: StoreContextMut<'_, Data>,+ mut source: Source<'_, Self::Item>,+ finish: bool,+ ) -> Poll<Result<()>> {+ let state = match store.data_mut().host_future_consumers.get_mut(&self.0) {+ Some(state) => state,+ None => {+ log::debug!("consume: closed {}", self.0);+ return Poll::Ready(Ok(()));+ }+ };+ match state.0 {+ HostFutureConsumerState::Idle | HostFutureConsumerState::Waiting(_) => {+ if finish {+ log::debug!("consume: cancel {}", self.0);+ state.0 = HostFutureConsumerState::Idle;+ Poll::Ready(Ok(()))+ } else {+ log::debug!("consume: wait {}", self.0);+ state.0 = HostFutureConsumerState::Waiting(cx.waker().clone());+ Poll::Pending+ }+ }+ HostFutureConsumerState::Consuming => {+ log::debug!("consume: done {}", self.0);+ let mut item = None;+ source.read(&mut store, &mut item).unwrap();+ store+ .data_mut()+ .host_future_consumers+ .get_mut(&self.0)+ .unwrap()+ .0 = HostFutureConsumerState::Complete(item.unwrap());+ Poll::Ready(Ok(()))+ }+ HostFutureConsumerState::Complete(_) => unreachable!(),+ }+ }+}++struct HostFutureProducer(u32, #[expect(dead_code, reason = "drop-tracking")] Arc<()>);++#[derive(Debug)]+enum HostFutureProducerState {+ Idle,+ Waiting(Waker),+ Writing(u32),+ Complete,+}++impl FutureProducer<Data> for HostFutureProducer {+ type Item = u32;++ fn poll_produce(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ mut store: StoreContextMut<'_, Data>,+ finish: bool,+ ) -> Poll<Result<Option<Self::Item>>> {+ let state = store+ .data_mut()+ .host_future_producers+ .get_mut(&self.0)+ .unwrap();+ match state.0 {+ HostFutureProducerState::Idle | HostFutureProducerState::Waiting(_) => {+ if finish {+ log::debug!("produce: cancel {}", self.0);+ state.0 = HostFutureProducerState::Idle;+ Poll::Ready(Ok(None))+ } else {+ log::debug!("produce: wait {}", self.0);+ state.0 = HostFutureProducerState::Waiting(cx.waker().clone());+ Poll::Pending+ }+ }+ HostFutureProducerState::Writing(item) => {+ log::debug!("produce: done {}", self.0);+ state.0 = HostFutureProducerState::Complete;+ Poll::Ready(Ok(Some(item)))+ }+ HostFutureProducerState::Complete => unreachable!(),+ }+ }+}++struct HostStreamConsumer(u32, #[expect(dead_code, reason = "drop-tracking")] Arc<()>);++#[derive(Debug)]+struct HostStreamConsumerState {+ waker: Option<Waker>,+ kind: HostStreamConsumerStateKind,+}++#[derive(Debug)]+enum HostStreamConsumerStateKind {+ Idle,+ Consuming(u32),+ Consumed(Vec<u32>),+}++impl HostStreamConsumerState {+ fn wake_by_ref(&mut self) {+ if let Some(waker) = self.waker.take() {+ waker.wake();+ }+ }+}++impl StreamConsumer<Data> for HostStreamConsumer {+ type Item = u32;++ fn poll_consume(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ mut store: StoreContextMut<'_, Data>,+ mut source: Source<'_, Self::Item>,+ finish: bool,+ ) -> Poll<Result<StreamResult>> {+ let remaining = source.remaining(&mut store);+ let state = match store.data_mut().host_stream_consumers.get_mut(&self.0) {+ Some((state, _)) => state,+ None => {+ log::debug!("stream consume: dropped {}", self.0);+ return Poll::Ready(Ok(StreamResult::Dropped));+ }+ };+ match state.kind {+ HostStreamConsumerStateKind::Idle | HostStreamConsumerStateKind::Consumed(_) => {+ if finish {+ log::debug!("stream consume: cancel {}", self.0);+ state.waker = None;+ Poll::Ready(Ok(StreamResult::Cancelled))+ } else {+ log::debug!("stream consume: wait {}", self.0);+ state.waker = Some(cx.waker().clone());+ Poll::Pending+ }+ }+ HostStreamConsumerStateKind::Consuming(amt) => {+ // The writer is performing a zero-length write. We always+ // complete that without updating our own state.+ if remaining == 0 {+ log::debug!("stream consume: completing zero-length write {}", self.0);+ return Poll::Ready(Ok(StreamResult::Completed));+ }++ // If this is a zero-length read then block the writer but update our own state.+ if amt == 0 {+ log::debug!("stream consume: finishing zero-length read {}", self.0);+ state.kind = HostStreamConsumerStateKind::Consumed(Vec::new());+ state.waker = Some(cx.waker().clone());+ return Poll::Pending;+ }++ // For non-zero sizes perform the read/copy.+ log::debug!("stream consume: done {}", self.0);+ let mut dst = Vec::with_capacity(amt as usize);+ source.read(&mut store, &mut dst).unwrap();+ let state = &mut store+ .data_mut()+ .host_stream_consumers+ .get_mut(&self.0)+ .unwrap()+ .0;+ state.kind = HostStreamConsumerStateKind::Consumed(dst);+ state.waker = None;+ Poll::Ready(Ok(StreamResult::Completed))+ }+ }+ }+}++impl Drop for HostStreamConsumer {+ fn drop(&mut self) {+ log::debug!("stream consume: drop {}", self.0);+ }+}++struct HostStreamProducer(u32, #[expect(dead_code, reason = "drop-tracking")] Arc<()>);++#[derive(Debug)]+struct HostStreamProducerState {+ kind: HostStreamProducerStateKind,+ waker: Option<Waker>,+}++#[derive(Debug)]+enum HostStreamProducerStateKind {+ Idle,+ Writing(Vec<u32>),+ Wrote(u32),+}++impl HostStreamProducerState {+ fn idle() -> Self {+ HostStreamProducerState {+ kind: HostStreamProducerStateKind::Idle,+ waker: None,+ }+ }++ fn wake_by_ref(&mut self) {+ if let Some(waker) = self.waker.take() {+ waker.wake();+ }+ }+}++impl StreamProducer<Data> for HostStreamProducer {+ type Item = u32;+ type Buffer = VecBuffer<u32>;++ fn poll_produce(+ self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ mut store: StoreContextMut<'_, Data>,+ mut dst: Destination<'_, Self::Item, Self::Buffer>,+ finish: bool,+ ) -> Poll<Result<StreamResult>> {+ let remaining = dst.remaining(&mut store);+ let data = store.data_mut();+ let state = match data.host_stream_producers.get_mut(&self.0) {+ Some((state, _)) => state,+ None => {+ log::debug!("stream produce: dropped {}", self.0);+ return Poll::Ready(Ok(StreamResult::Dropped));+ }+ };+ match &mut state.kind {+ HostStreamProducerStateKind::Idle | HostStreamProducerStateKind::Wrote(_) => {+ if finish {+ log::debug!("stream produce: cancel {}", self.0);+ state.waker = None;+ Poll::Ready(Ok(StreamResult::Cancelled))+ } else {+ log::debug!("stream produce: wait {}", self.0);+ state.waker = Some(cx.waker().clone());+ Poll::Pending+ }+ }+ HostStreamProducerStateKind::Writing(buf) => {+ // Keep the other side blocked for a zero-length write+ // originated from the host.+ if buf.len() == 0 {+ log::debug!("stream produce: zero-length write {}", self.0);+ state.kind = HostStreamProducerStateKind::Wrote(0);+ state.waker = Some(cx.waker().clone());+ return Poll::Pending;+ }+ log::debug!("stream produce: write {}", self.0);+ match remaining {+ Some(amt) => {+ // If the guest is doing a zero-length read then we've+ // got some data for them. Complete the read but leave+ // ourselves in the same `Writing` state as before.+ if amt == 0 {+ state.waker = None;+ return Poll::Ready(Ok(StreamResult::Completed));+ }++ // Don't let wasmtime buffer up data for us, so truncate+ // the buffer we're sending over to the amount that the+ // reader is requesting.+ if amt < buf.len() {+ buf.truncate(amt);+ }+ }++ // At this time host<->host stream reads/writes aren't+ // fuzzed since that brings up a bunch of weird edge cases+ // which aren't fun to deal with and aren't interesting+ // either.+ None => unreachable!(),+ }+ let count = buf.len() as u32;+ dst.set_buffer(mem::take(buf).into());+ state.kind = HostStreamProducerStateKind::Wrote(count);+ state.waker = None;+ Poll::Ready(Ok(StreamResult::Completed))+ }+ }+ }+}++impl Drop for HostStreamProducer {+ fn drop(&mut self) {+ log::debug!("stream produce: drop {}", self.0);+ }+}++struct SharedStream(Scope);++impl SharedStream {+ async fn next(&mut self, accessor: &Accessor<Data>) -> Option<Command> {+ std::future::poll_fn(|cx| {+ accessor.with(|mut store| {+ self.poll(cx, store.as_context_mut(), false)+ .map(|pair| match pair {+ (None, StreamResult::Dropped) => None,+ (Some(item), StreamResult::Completed) => Some(item),+ _ => unreachable!(),+ })+ })+ })+ .await+ }++ fn poll(+ &mut self,+ cx: &mut Context<'_>,+ mut store: StoreContextMut<'_, Data>,+ finish: bool,+ ) -> Poll<(Option<Command>, StreamResult)> {+ let data = store.data_mut();++ // If no more commands remain then this is a closed and dropped stream.+ let Some((scope, command)) = data.commands.last_mut() else {+ log::debug!("Stream closed: {:?}", self.0);+ return Poll::Ready((None, StreamResult::Dropped));+ };++ // If the next queued up command is for the scope that this stream is+ // attached to then send off the command.+ if *scope == self.0 {+ let ret = Some(*command);++ // All commands are followed up with an "ack", and after the "ack"+ // is delivered then the command is popped to move on to the next+ // command. The reason for this is to guarantee that a command has+ // been processed before moving on to the next command. This helps+ // make the fuzzing easier to work with by being able to implicitly+ // assume that a command has been processed by the time something+ // else is. Otherwise it might be possible that wasmtime has a set+ // of commands/callbacks that are all delivered at the same time and+ // the component model doesn't specify what order they happen+ // within. By forcing an "ack" it ensures a more expected ordering+ // of execution to assist with fuzzing without losing really all+ // that much coverage.+ if matches!(command, Command::Ack) {+ data.commands.pop();+ } else {+ *command = Command::Ack;+ }++ // After a command was popped other streams may be able to make+ // progress so wake them all up.+ for (_, waker) in data.wakers.drain() {+ waker.wake();+ }+ log::debug!("Delivering command {ret:?} for {:?}", self.0);+ return Poll::Ready((ret, StreamResult::Completed));+ }++ // The command queue is non-empty and the next command isn't meant for+ // us, so someone else needs to drain the queue. Enqueue our waker.+ if finish {+ Poll::Ready((None, StreamResult::Cancelled))+ } else {+ data.wakers.insert(self.0, cx.waker().clone());+ Poll::Pending+ }+ }+}++impl StreamProducer<Data> for SharedStream {+ type Item = Command;+ type Buffer = Option<Command>;++ fn poll_produce<'a>(+ mut self: Pin<&mut Self>,+ cx: &mut Context<'_>,+ store: StoreContextMut<'a, Data>,+ mut destination: Destination<'a, Self::Item, Self::Buffer>,+ finish: bool,+ ) -> Poll<Result<StreamResult>> {+ let (item, result) = std::task::ready!(self.poll(cx, store, finish));+ destination.set_buffer(item);+ Poll::Ready(Ok(result))+ }+}++#[cfg(test)]+mod tests {+ use super::{ComponentAsync, Scope, init, run};+ use crate::oracles::component_async::types::*;+ use crate::test::test_n_times;+ use Scope::*;++ #[test]+ fn smoke() {+ init();++ test_n_times(50, |c, _| {+ run(c);+ Ok(())+ });+ }++ // ========================================================================+ // A series of fuzz-generated test cases which caused problems during the+ // development of this fuzzer. Feel free to delete/edit/etc if the fuzzer+ // changes over time.++ #[test]+ fn simple() {+ init();++ run(ComponentAsync {+ commands: vec![+ (GuestCaller, Command::AsyncPendingImportCall(0)),+ (GuestCallee, Command::AsyncPendingImportCall(1)),+ (GuestCallee, Command::AsyncPendingExportComplete(0)),+ (GuestCaller, Command::AsyncPendingImportAssertReady(0)),+ (GuestCaller, Command::AsyncPendingImportCall(2)),+ ],+ });+ }++ #[test]+ fn somewhat_larger() {+ static COMMANDS: &[(Scope, Command)] = &[+ (GuestCallee, Command::FutureNew(0)),+ (HostCaller, Command::FutureNew(1)),+ (GuestCallee, Command::FutureReadPending(0)),+ (GuestCaller, Command::AsyncPendingImportCall(2)),+ (GuestCaller, Command::AsyncPendingImportCall(3)),+ (GuestCaller, Command::AsyncPendingImportCall(4)),+ (GuestCaller, Command::AsyncPendingImportCall(5)),+ (GuestCallee, Command::AsyncPendingExportComplete(5)),+ (GuestCallee, Command::AsyncPendingExportComplete(3)),+ (GuestCallee, Command::AsyncPendingExportComplete(4)),+ (GuestCallee, Command::AsyncPendingExportComplete(2)),+ (GuestCaller, Command::AsyncPendingImportCall(6)),+ (GuestCallee, Command::AsyncPendingExportComplete(6)),+ (GuestCaller, Command::AsyncPendingImportCall(7)),+ (GuestCallee, Command::AsyncPendingExportComplete(7)),+ (GuestCaller, Command::AsyncPendingImportCall(8)),+ (GuestCallee, Command::AsyncPendingExportComplete(8)),+ (GuestCaller, Command::AsyncPendingImportCall(9)),+ (GuestCallee, Command::AsyncPendingExportComplete(9)),+ (GuestCaller, Command::AsyncPendingImportCall(10)),+ (GuestCallee, Command::AsyncPendingExportComplete(10)),+ (GuestCaller, Command::AsyncPendingImportCall(11)),+ (GuestCallee, Command::AsyncPendingExportComplete(11)),+ (GuestCaller, Command::AsyncPendingImportCall(12)),+ (GuestCallee, Command::AsyncPendingExportComplete(12)),+ (GuestCaller, Command::AsyncPendingImportCall(13)),+ (GuestCallee, Command::AsyncPendingExportComplete(13)),+ (GuestCaller, Command::AsyncPendingImportCall(14)),+ (GuestCallee, Command::AsyncPendingExportComplete(14)),+ (GuestCaller, Command::AsyncPendingImportCall(15)),+ (GuestCallee, Command::AsyncPendingExportComplete(15)),+ (GuestCaller, Command::AsyncPendingImportCall(16)),+ (GuestCallee, Command::AsyncPendingExportComplete(16)),+ (GuestCaller, Command::AsyncPendingImportCall(17)),+ (GuestCallee, Command::AsyncPendingExportComplete(17)),+ (GuestCaller, Command::AsyncPendingImportCall(18)),+ (GuestCallee, Command::AsyncPendingExportComplete(18)),+ (GuestCaller, Command::AsyncPendingImportCall(19)),+ (GuestCallee, Command::AsyncPendingExportComplete(19)),+ (GuestCaller, Command::AsyncPendingImportCall(20)),+ (GuestCallee, Command::AsyncPendingExportComplete(20)),+ (GuestCaller, Command::AsyncPendingImportCall(21)),+ (GuestCallee, Command::AsyncPendingExportComplete(21)),+ (GuestCaller, Command::AsyncPendingImportCall(22)),+ (GuestCallee, Command::AsyncPendingExportComplete(22)),+ (GuestCaller, Command::AsyncPendingImportCall(23)),+ (GuestCallee, Command::AsyncPendingExportComplete(23)),+ (GuestCaller, Command::AsyncPendingImportCall(24)),+ (GuestCallee, Command::AsyncPendingExportComplete(24)),+ (GuestCaller, Command::AsyncPendingImportCall(25)),+ (GuestCallee, Command::AsyncPendingExportComplete(25)),+ (GuestCaller, Command::AsyncPendingImportCall(26)),+ (GuestCallee, Command::AsyncPendingExportComplete(26)),+ (GuestCaller, Command::AsyncPendingImportCall(27)),+ (GuestCallee, Command::AsyncPendingExportComplete(27)),+ (GuestCaller, Command::AsyncPendingImportCall(28)),+ (GuestCallee, Command::AsyncPendingExportComplete(28)),+ (GuestCaller, Command::AsyncPendingImportCall(29)),+ (GuestCallee, Command::AsyncPendingExportComplete(29)),+ (GuestCaller, Command::AsyncPendingImportCall(30)),+ (GuestCallee, Command::AsyncPendingExportComplete(30)),+ (GuestCaller, Command::AsyncPendingImportCall(31)),+ (GuestCallee, Command::AsyncPendingExportComplete(31)),+ (GuestCaller, Command::AsyncPendingImportCall(32)),+ (GuestCallee, Command::AsyncPendingExportComplete(32)),+ (GuestCaller, Command::AsyncPendingImportCall(33)),+ (GuestCallee, Command::AsyncPendingExportComplete(33)),+ (GuestCaller, Command::AsyncPendingImportCall(34)),+ (GuestCallee, Command::AsyncPendingExportComplete(34)),+ (GuestCaller, Command::AsyncPendingImportCall(35)),+ (GuestCallee, Command::AsyncPendingExportComplete(35)),+ (GuestCaller, Command::AsyncPendingImportCall(36)),+ (GuestCallee, Command::AsyncPendingExportComplete(36)),+ (GuestCaller, Command::AsyncPendingImportCall(37)),+ (GuestCallee, Command::AsyncPendingExportComplete(37)),+ (GuestCaller, Command::AsyncPendingImportAssertReady(36)),+ ];+ init();++ run(ComponentAsync {+ commands: COMMANDS.to_vec(),+ });+ }++ #[test]+ fn simple_stream1() {+ init();++ run(ComponentAsync {+ commands: vec![+ (HostCallee, Command::StreamNew(1)),+ (+ HostCallee,+ Command::StreamReadPending(StreamReadPayload {+ stream: 1,+ count: 2,+ }),+ ),+ (HostCallee, Command::StreamCancelRead(1)),+ (GuestCaller, Command::SyncReadyCall),+ (+ HostCallee,+ Command::StreamWritePending(StreamWritePayload {+ stream: 1,+ item: 3,+ count: 2,+ }),+ ),+ (HostCallee, Command::StreamCancelWrite(1)),+ (HostCallee, Command::StreamDropWritable(1)),+ (+ HostCallee,+ Command::StreamReadDropped(StreamReadPayload {+ stream: 1,+ count: 1,+ }),+ ),+ ],+ });+ }++ #[test]+ fn simple_stream3() {+ init();++ run(ComponentAsync {+ commands: vec![+ (GuestCaller, Command::StreamNew(26)),+ (+ GuestCaller,+ Command::StreamReadPending(StreamReadPayload {+ stream: 26,+ count: 10,+ }),+ ),+ (GuestCaller, Command::StreamDropWritable(26)),+ (GuestCaller, Command::StreamReadAssertDropped(26)),+ ],+ });+ }++ #[test]+ fn simple_stream4() {+ init();++ run(ComponentAsync {+ commands: vec![+ (GuestCaller, Command::StreamNew(23)),+ (+ GuestCaller,+ Command::StreamWritePending(StreamWritePayload {+ stream: 23,+ item: 24,+ count: 2,+ }),+ ),+ (GuestCaller, Command::StreamGive(23)),+ (GuestCallee, Command::StreamDropReadable(23)),+ (+ GuestCaller,+ Command::StreamWriteAssertDropped(StreamReadPayload {+ stream: 23,+ count: 0,+ }),+ ),+ ],+ });+ }++ #[test]+ fn zero_length_behavior() {+ init();++ run(ComponentAsync {+ commands: vec![+ (GuestCaller, Command::StreamNew(10)),+ (HostCaller, Command::StreamTake(10)),+ (+ GuestCaller,+ Command::StreamWritePending(StreamWritePayload {+ stream: 10,+ item: 13,+ count: 5,+ }),+ ),+ (+ HostCaller,+ Command::StreamReadReady(StreamReadyPayload {+ stream: 10,+ item: 0,+ op_count: 0,+ ready_count: 0,+ }),+ ),+ (+ HostCaller,+ Command::StreamReadReady(StreamReadyPayload {+ stream: 10,+ item: 0,+ op_count: 0,+ ready_count: 0,+ }),+ ),+ ],+ });+ }+}diff --git a/crates/fuzzing/wit/fuzz.wit b/crates/fuzzing/wit/fuzz.witnew file mode 100644index 0000000000..b98bdf93b3--- /dev/null+++ b/crates/fuzzing/wit/fuzz.wit@@ -0,0 +1,139 @@+// For more information on what this is used for, see `fuzz_async.rs`++package wasmtime-fuzz:fuzz;++interface types {+ variant command {+ // invoke the imported `sync-ready` function+ sync-ready-call,++ // invoke the imported `async-ready` function, and assert it's ready+ async-ready-call,++ // invoke the imported `async-pending` function, assert it's not+ // ready, and save it with the id provided.+ async-pending-import-call(u32),+ // cancel's a prior call of `async-pending` with the id specified+ async-pending-import-cancel(u32),+ // asserts that a prior call of `async-pending` with the id specified is+ // ready.+ async-pending-import-assert-ready(u32),+ // complete a previous invocation of this component's `async-pending`+ // export.+ async-pending-export-complete(u32),+ // assert a previous invocation of this component's `async-pending` export+ // is cancelled.+ async-pending-export-assert-cancelled(u32),++ // make a future read/write combo with the `id` specified.+ future-new(u32),+ // take a future readable end through the `future-take` import.+ future-take(u32),+ // pass the future specified to this component's `future-receive` import.+ future-give(u32),+ // drop the future end identified+ future-drop-readable(u32),+ // ...+ future-write-ready(future-payload),+ future-read-ready(future-payload),+ future-write-pending(future-payload),+ future-read-pending(u32),+ future-write-dropped(u32),+ future-cancel-write(u32),+ future-cancel-read(u32),+ future-write-assert-complete(u32),+ future-write-assert-dropped(u32),+ future-read-assert-complete(future-payload),++ // make a stream read/write combo with the `id` specified.+ stream-new(u32),+ // take a stream readable end through the `stream-take` import.+ stream-take(u32),+ // pass the stream specified to this component's `stream-receive` import.+ stream-give(u32),+ // drop the stream end identified+ stream-drop-readable(u32),+ stream-drop-writable(u32),+ // ...+ stream-write-ready(stream-ready-payload),+ stream-read-ready(stream-ready-payload),+ stream-write-pending(stream-write-payload),+ stream-read-pending(stream-read-payload),+ stream-write-dropped(stream-write-payload),+ stream-read-dropped(stream-read-payload),+ stream-cancel-write(u32),+ stream-cancel-read(u32),+ stream-write-assert-complete(stream-read-payload),+ stream-write-assert-dropped(stream-read-payload),+ stream-read-assert-complete(stream-write-payload),+ stream-read-assert-dropped(u32),++ ack,+ }++ record future-payload {+ %future: u32,+ item: u32,+ }++ record stream-ready-payload {+ %stream: u32,+ item: u32,+ op-count: u32,+ ready-count: u32,+ }++ record stream-write-payload {+ %stream: u32,+ item: u32,+ count: u32,+ }++ record stream-read-payload {+ %stream: u32,+ count: u32,+ }++ enum scope {+ caller,+ callee,+ }++ get-commands: func(s: scope) -> stream<command>;+}++interface async-test {+ use types.{command, scope};++ // Initialization function. Invokes `task.return` but keeps running to receive+ // commands. Commands come from the `get-commands` function which is passed+ // the `scope` provided here.+ //+ // This invokes the imported `init` function with the `callee` scope.+ init: async func(scope: scope);++ sync-ready: func();++ // Must return immediately.+ async-ready: async func();++ // Must not be ready when called. Status will be resolved through a later+ // command using the `id` provided.+ async-pending: async func(id: u32);++ // Remove the future reader `id` from this component's state and return it.+ future-take: func(id: u32) -> future<u32>;+ // Receive a future from another component.+ future-receive: func(id: u32, f: future<u32>);++ // Remove the stream reader `id` from this component's state and return it.+ stream-take: func(id: u32) -> stream<u32>;+ // Receive a stream from another component.+ stream-receive: func(id: u32, f: stream<u32>);++}++world fuzz-async {+ import async-test;+ export async-test;+}diff --git a/crates/misc/component-async-tests/tests/scenario/round_trip.rs b/crates/misc/component-async-tests/tests/scenario/round_trip.rsindex e524583b90..6800b5af13 100644--- a/crates/misc/component-async-tests/tests/scenario/round_trip.rs+++ b/crates/misc/component-async-tests/tests/scenario/round_trip.rs@@ -287,7 +287,7 @@ pub async fn test_round_trip(tx: oneshot::Sender<()>,}- impl AccessorTask<Ctx, HasSelf<Ctx>, Result<()>> for Task {+ impl AccessorTask<Ctx, HasSelf<Ctx>> for Task {async fn run(self, accessor: &Accessor<Ctx>) -> Result<()> {let round_trip = accessor.with(|mut store| {component_async_tests::round_trip::bindings::RoundTrip::new(diff --git a/crates/test-programs/Cargo.toml b/crates/test-programs/Cargo.tomlindex de5a80f1ab..a77657231d 100644--- a/crates/test-programs/Cargo.toml+++ b/crates/test-programs/Cargo.toml@@ -13,7 +13,7 @@ workspace = true[dependencies]anyhow = { workspace = true, features = ['std'] }wasi-nn = "0.6.0"-wit-bindgen = { workspace = true, features = ['default', 'async-spawn'] }+wit-bindgen = { workspace = true, features = ['default', 'async-spawn', 'inter-task-wakeup'] }libc = { workspace = true }futures = { workspace = true, default-features = false, features = ['alloc', 'async-await'] }url = { workspace = true }@@ -23,3 +23,6 @@ wasip1 = { version = "1.0.0", default-features = true }wasip2 = "1.0.0"once_cell = "1.19.0"flate2 = "1.0.28"+log = { workspace = true }+env_logger = { workspace = true }+pin-project-lite = { workspace = true }diff --git a/crates/test-programs/artifacts/build.rs b/crates/test-programs/artifacts/build.rsindex f0e8d6262b..8279c447d2 100644--- a/crates/test-programs/artifacts/build.rs+++ b/crates/test-programs/artifacts/build.rs@@ -88,6 +88,7 @@ impl Artifacts {s if s.starts_with("p3_http_") => "p3_http",s if s.starts_with("p3_api_") => "p3_api",s if s.starts_with("p3_") => "p3",+ s if s.starts_with("fuzz_") => "fuzz",// If you're reading this because you hit this panic, either add// it to a test suite above or add a new "suite". The purpose of// the categorization above is to have a static assertion thatdiff --git a/crates/test-programs/src/bin/fuzz_async.rs b/crates/test-programs/src/bin/fuzz_async.rsnew file mode 100644index 0000000000..6f6ac5a1fe--- /dev/null+++ b/crates/test-programs/src/bin/fuzz_async.rs@@ -0,0 +1,853 @@+//! Test case used with the `component_async` fuzzer which is part of the `misc`+//! fuzz target of Wasmtime.+//!+//! This test case is a binary that's suited for just that one fuzzer and has an+//! associated WIT world that it works with. This test case is composed with+//! itself and then run within the host as well. The exact semantics of this+//! program and all the exports/imports are defined within the context of the+//! fuzzer.+//!+//! The general idea is that this program creates an "async soup" and make sure+//! that everything works as expected, notably also not leading to any panics+//! anywhere within the runtime. An example of what this fuzzer intermingles+//! are:+//!+//! * Synchronous calls+//! * Async calls that are immediately ready+//! * Async calls that are not immediately ready and left pending+//! * Creation of futures/streams+//! * Moving futures/streams between components+//! * Reading/writing futures/streams+//! * Cancelling reads/writes of futures/streams+//! * Seeing futures/streams get dropped and the effect on active reads/writes+//! * Mixing host<->guest, guest<->guest, guest<->host, and host<->host+//! calls/primitives+//!+//! The purpose of this fuzzer is to stress the management of async stacks, the+//! async runtime, and in theory suss out various edge cases in the handling of+//! async events. This fuzzer does NOT stress lifting/lowering at all because+//! there is a static WIT signature that this fuzzer works with.+//!+//! Much of the code in this file is semi-duplicated in the host except written+//! with host `wasmtime` APIs instead of `wit-bindgen` APIs. The overall+//! structure is roughly the same.+//!+//! # Overall architecture+//!+//! The general structure of this fuzzer is that there's a "host sandwich" which+//! looks like:+//!+//! ```text+//! ╔══════╦══════════════════════════════════════════════════════════╗+//! ║ Host ║ ║+//! ╠══════╝ ║+//! ║ ║+//! ║ ┍┯┯┯━━━ wasmtime:fuzz/types ║+//! ║ ││││ ║+//! ║ ││││ ║+//! ║ ││││ ╔════════════════════╦════════════════════╗ ║+//! ║ ││││ ║ component_async.rs ║ ║ ║+//! ║ ││││ ╠════════════════════╝ ║ ║+//! ║ ││││ ║ ║ ║+//! ║ ││││ ║ HostCaller ║ ║+//! ║ ││││ ║ ║ ║+//! ║ │││└────────╫─→ stream<command> ║ ║+//! ║ │││ ╚═══════════════════╤═════════════════════╝ ║+//! ║ │││ │ ║+//! ║ │││ ┝ wasmtime-fuzz:fuzz/async-test ║+//! ║ │││ │ ║+//! ║ │││ ╔═══════════╦════════════╪═════════════════════════════╗ ║+//! ║ │││ ║ Component ║ │ ║ ║+//! ║ │││ ╠═══════════╝ │ ║ ║+//! ║ │││ ║ ↓ ║ ║+//! ║ │││ ║ ╔═════════════════╦═══════════════════════╗ ║ ║+//! ║ │││ ║ ║ fuzz-async.wasm ║ ║ ║ ║+//! ║ │││ ║ ╠═════════════════╝ ║ ║ ║+//! ║ │││ ║ ║ ║ ║ ║+//! ║ │││ ║ ║ GuestCaller ║ ║ ║+//! ║ │││ ║ ║ ║ ║ ║+//! ║ ││└────╫────╫─→ stream<command> ║ ║ ║+//! ║ ││ ║ ╚═══════╤═════════════════════════════════╝ ║ ║+//! ║ ││ ║ │ ║ ║+//! ║ ││ ║ ┝ wasmtime-fuzz:fuzz/async-test ║ ║+//! ║ ││ ║ │ ║ ║+//! ║ ││ ║ ↓ ║ ║+//! ║ ││ ║ ╔═════════════════╦═══════════════════════╗ ║ ║+//! ║ ││ ║ ║ fuzz-async.wasm ║ ║ ║ ║+//! ║ ││ ║ ╠═════════════════╝ ║ ║ ║+//! ║ ││ ║ ║ ║ ║ ║+//! ║ ││ ║ ║ GuestCallee ║ ║ ║+//! ║ ││ ║ ║ ║ ║ ║+//! ║ │└─────╫────╫─→ stream<command> ║ ║ ║+//! ║ │ ║ ╚═══════════════════╤═════════════════════╝ ║ ║+//! ║ │ ║ │ ║ ║+//! ║ │ ║ │ ║ ║+//! ║ │ ╚════════════════════════╪═════════════════════════════╝ ║+//! ║ │ │ ║+//! ║ │ ┝ wasmtime-fuzz:fuzz/async-test ║+//! ║ │ │ ║+//! ║ │ ↓ ║+//! ║ │ ╔════════════════════╦════════════════════╗ ║+//! ║ │ ║ component_async.rs ║ ║ ║+//! ║ │ ╠════════════════════╝ ║ ║+//! ║ │ ║ ║ ║+//! ║ │ ║ HostCallee ║ ║+//! ║ │ ║ ║ ║+//! ║ └───────────╫─→ stream<command> ║ ║+//! ║ ╚═════════════════════════════════════════╝ ║+//! ║ ║+//! ╚═════════════════════════════════════════════════════════════════╝+//! ```+//!+//! Here `fuzz-async.wasm` appears twice to model all the various types of+//! the host/guest interaction matrix. Everything is driven by a+//! `stream<command>` provided to each component part of the system which+//! serves as a means of forcing one particular component to take action.+//! Commands are then the test case itself where a series of commands are+//! executed for each fuzz iteration.+//!+//! # Yield-loops+//!+//! This program has a function `test_property` which is a similar analog to the+//! one in the host-side as well. The general idea is that while component model+//! async is generally deterministic it does not specify what should happen when+//! multiple events are ready at the same time. This can pretty easily happen in+//! this fuzzer meaning that it's not precise which event happens first. To+//! assist in managing this there are two primary mitigations:+//!+//! * The first is that whenever a command is dispatched to a component it's+//! followed up with an "ack" which is a noop. Delivery of the "ack" can't+//! happen until the previous command is completely finished being processed+//! meaning it's a kludge way of synchronizing the receipt of a message.+//!+//! * The second is that there can still be small races where an async event+//! hasn't quite happened yet but it's queued up to happen. To handle these+//! events calls to `test_property` are sprinkled around which has an+//! internally-bounded yield-loop. It's expected that while yielding other+//! code can run which resolves the property being tested at-hand, and then+//! this yield loop will panic if it turns too many times as it's probably a+//! bug.+//!+//! It's a bit of a hack but it's so far the most effective way of handling this+//! that's (a) not timing-dependent e.g. adding sleeps, (b) is+//! reliable/deterministic, and (c) is flexible where the constant number of+//! yields can be bumped without much concern. The number of yields specifically+//! is arbitrarily chosen and while it can't be said exactly how many yields+//! should be necessary it should be able to say "less than N should always+//! work".++wit_bindgen::generate!("fuzz-async" in "../fuzzing/wit");++use crate::exports::wasmtime_fuzz::fuzz::async_test as e;+use crate::wasmtime_fuzz::fuzz::async_test as i;+use crate::wasmtime_fuzz::fuzz::types::{self, Command, Scope};+use futures::FutureExt;+use futures::channel::oneshot;+use pin_project_lite::pin_project;+use std::collections::{HashMap, HashSet};+use std::mem;+use std::pin::{Pin, pin};+use std::sync::Mutex;+use std::sync::atomic::{AtomicBool, Ordering};+use std::task::{Context, Poll, Waker};+use wit_bindgen::{FutureReader, FutureWriter, StreamReader, StreamResult, StreamWriter};++struct Component;++export!(Component);++// Convenience macro to change the "target" of `log::debug!` based on whether+// this component is a `caller` or `callee` scope to distinguish logs in the+// output.+macro_rules! debug {+ ($($arg:tt)*) => {+ log::debug!(target: log_target(), $($arg)*);+ }+}++static IS_CALLER: AtomicBool = AtomicBool::new(false);++fn log_target() -> &'static str {+ if IS_CALLER.load(Ordering::Relaxed) {+ "wasmtime_fuzzing::fuzz_async::caller"+ } else {+ "wasmtime_fuzzing::fuzz_async::callee"+ }+}++impl e::Guest for Component {+ fn sync_ready() {}++ async fn async_ready() {}++ async fn async_pending(id: u32) {+ let (tx, rx) = oneshot::channel();+ State::with(|s| s.async_pending_exports_ready.insert(id, tx));+ let record = RecordCancelOnDrop(id);+ rx.await.unwrap();+ mem::forget(record);+ debug!("export {id} is complete");++ struct RecordCancelOnDrop(u32);++ impl Drop for RecordCancelOnDrop {+ fn drop(&mut self) {+ debug!("export {} was cancelled", self.0);+ State::with(|s| {+ s.async_pending_exports_cancelled.insert(self.0);+ });+ }+ }+ }++ async fn init(scope: Scope) {+ IS_CALLER.store(scope == Scope::Caller, Ordering::Relaxed);+ env_logger::init();+ i::init(Scope::Callee).await;+ let commands = types::get_commands(scope);+ wit_bindgen::spawn(run(commands));+ }++ fn future_take(id: u32) -> FutureReader<u32> {+ State::with(|s| s.future_readers.remove(&id).unwrap())+ }++ fn future_receive(id: u32, f: FutureReader<u32>) {+ let prev = State::with(|s| s.future_readers.insert(id, f));+ assert!(prev.is_none());+ }++ fn stream_take(id: u32) -> StreamReader<u32> {+ State::with(|s| s.stream_readers.remove(&id).unwrap())+ }++ fn stream_receive(id: u32, f: StreamReader<u32>) {+ let prev = State::with(|s| s.stream_readers.insert(id, f));+ assert!(prev.is_none());+ }+}++#[derive(Default)]+struct State {+ async_pending_imports_ready: HashSet<u32>,+ async_pending_imports_in_progress: HashMap<u32, oneshot::Sender<()>>,+ async_pending_exports_ready: HashMap<u32, oneshot::Sender<()>>,+ async_pending_exports_cancelled: HashSet<u32>,++ future_readers: HashMap<u32, FutureReader<u32>>,+ future_writers: HashMap<u32, FutureWriter<u32>>,+ future_write_cancel_signals: HashMap<u32, oneshot::Sender<()>>,+ future_read_cancel_signals: HashMap<u32, oneshot::Sender<()>>,+ future_writes_completed: HashMap<u32, bool>,+ future_reads_completed: HashMap<u32, u32>,++ stream_readers: HashMap<u32, StreamReader<u32>>,+ stream_writers: HashMap<u32, StreamWriter<u32>>,+ stream_write_cancel_signals: HashMap<u32, oneshot::Sender<()>>,+ stream_read_cancel_signals: HashMap<u32, oneshot::Sender<()>>,+ stream_writes_completed: HashMap<u32, Result<(usize, Vec<u32>), (usize, Vec<u32>)>>,+ stream_reads_completed: HashMap<u32, Option<Vec<u32>>>,+}++impl State {+ pub fn with<R>(f: impl FnOnce(&mut State) -> R) -> R {+ static STATE: Mutex<Option<State>> = Mutex::new(None);+ let mut state = STATE.lock().unwrap();+ let state = state.get_or_insert_with(|| State::default());+ f(state)+ }++ pub async fn test_property(mut f: impl FnMut(&mut State) -> bool) -> bool {+ // Test if the property is ready, but it might require a sibling future+ // task to run, so if it's not true yet then pump the executor a+ // few times to let it finish.+ for _ in 0..1000 {+ if State::with(&mut f) {+ return true;+ }+ wit_bindgen::yield_async().await;+ }+ return false;+ }+}++async fn run(mut commands: StreamReader<Command>) {+ while let Some(command) = commands.next().await {+ match command {+ Command::SyncReadyCall => i::sync_ready(),++ Command::AsyncReadyCall => assert_ready(pin!(i::async_ready())),++ Command::AsyncPendingExportComplete(i) => {+ assert!(+ State::test_property(|s| s.async_pending_exports_ready.contains_key(&i)).await,+ "expected async_pending export {i} should be pending",+ );+ debug!("finishing export {i}");+ State::with(|s| {+ s.async_pending_exports_ready+ .remove(&i)+ .unwrap()+ .send(())+ .unwrap();+ });+ }+ Command::AsyncPendingExportAssertCancelled(i) => {+ assert!(+ State::test_property(|s| s.async_pending_exports_cancelled.remove(&i)).await,+ "expected async_pending export {i} to be cancelled",+ );+ }+ Command::AsyncPendingImportCall(i) => {+ let mut future = Box::pin(i::async_pending(i));+ debug!("starting export {i}");+ assert_not_ready(future.as_mut());+ let (cancel_tx, mut cancel_rx) = oneshot::channel();+ State::with(|s| {+ s.async_pending_imports_in_progress.insert(i, cancel_tx);+ });+ wit_bindgen::spawn(async move {+ futures::select! {+ _ = cancel_rx => {}+ _ = future.fuse() => {+ State::with(|s| s.async_pending_imports_ready.insert(i));+ }+ }+ });+ }+ Command::AsyncPendingImportCancel(i) => {+ debug!("cancelling import {i}");+ State::with(|s| {+ s.async_pending_imports_in_progress+ .remove(&i)+ .unwrap()+ .send(())+ .unwrap();+ });+ }+ Command::AsyncPendingImportAssertReady(i) => {+ assert!(+ State::test_property(|s| s.async_pending_imports_ready.remove(&i)).await,+ "expected async_pending import {i} to be ready",+ );+ }++ Command::FutureNew(id) => {+ let (writer, reader) = wit_future::new(|| unreachable!());+ State::with(|s| {+ let prev = s.future_writers.insert(id, writer);+ assert!(prev.is_none());+ let prev = s.future_readers.insert(id, reader);+ assert!(prev.is_none());+ });+ }+ Command::FutureTake(id) => {+ let reader = i::future_take(id);+ State::with(|s| {+ let prev = s.future_readers.insert(id, reader);+ assert!(prev.is_none());+ });+ }+ Command::FutureGive(id) => {+ let reader = State::with(|s| s.future_readers.remove(&id).unwrap());+ i::future_receive(id, reader);+ }+ Command::FutureDropReadable(id) => {+ let _ = State::with(|s| s.future_readers.remove(&id).unwrap());+ }+ Command::FutureWriteReady(payload) => {+ let writer = State::with(|s| s.future_writers.remove(&payload.future).unwrap());+ assert_ready(pin!(writer.write(payload.item))).unwrap();+ }+ Command::FutureReadReady(payload) => {+ let reader = State::with(|s| s.future_readers.remove(&payload.future).unwrap());+ assert_eq!(assert_ready(pin!(reader.into_future())), payload.item);+ }+ Command::FutureWriteDropped(id) => {+ let writer = State::with(|s| s.future_writers.remove(&id).unwrap());+ match assert_ready(pin!(writer.write(0))) {+ Ok(_) => panic!("should be dropped"),+ Err(_) => {}+ }+ }+ Command::FutureWritePending(payload) => {+ use wit_bindgen::FutureWriteCancel;++ let writer = State::with(|s| s.future_writers.remove(&payload.future).unwrap());+ let (tx, rx) = oneshot::channel();+ let mut future = Box::pin(CancellableFutureWrite {+ cancel: rx,+ write: writer.write(payload.item),+ });+ assert_not_ready(future.as_mut());+ wit_bindgen::spawn(async move {+ let result = future.await;+ debug!("future write {} completed: {result:?}", payload.future);+ State::with(|s| match result {+ FutureWriteCancel::AlreadySent => {+ s.future_writes_completed.insert(payload.future, true);+ }+ FutureWriteCancel::Dropped(_) => {+ s.future_writes_completed.insert(payload.future, false);+ }+ FutureWriteCancel::Cancelled(_, writer) => {+ let prev = s.future_writers.insert(payload.future, writer);+ assert!(prev.is_none());+ }+ });+ });+ State::with(|s| {+ let prev = s.future_write_cancel_signals.insert(payload.future, tx);+ assert!(prev.is_none());+ });++ pin_project! {+ struct CancellableFutureWrite {+ #[pin]+ cancel: oneshot::Receiver<()>,+ #[pin]+ write: wit_bindgen::FutureWrite<u32>,+ }+ }++ impl Future for CancellableFutureWrite {+ type Output = FutureWriteCancel<u32>;++ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {+ let this = self.project();+ match this.cancel.poll(cx) {+ Poll::Ready(_) => return Poll::Ready(this.write.cancel()),+ Poll::Pending => {}+ }+ match this.write.poll(cx) {+ Poll::Ready(Ok(())) => Poll::Ready(FutureWriteCancel::AlreadySent),+ Poll::Ready(Err(val)) => {+ Poll::Ready(FutureWriteCancel::Dropped(val.value))+ }+ Poll::Pending => Poll::Pending,+ }+ }+ }+ }+ Command::FutureReadPending(id) => {+ let reader = State::with(|s| s.future_readers.remove(&id).unwrap());+ let (tx, rx) = oneshot::channel();+ let mut future = Box::pin(CancellableFutureRead {+ cancel: rx,+ read: reader.into_future(),+ });+ assert_not_ready(future.as_mut());+ wit_bindgen::spawn(async move {+ let result = future.await;+ State::with(|s| match result {+ Ok(result) => {+ let prev = s.future_reads_completed.insert(id, result);+ assert!(prev.is_none());+ }+ Err(reader) => {+ let prev = s.future_readers.insert(id, reader);+ assert!(prev.is_none());+ }+ });+ });+ State::with(|s| {+ let prev = s.future_read_cancel_signals.insert(id, tx);+ assert!(prev.is_none());+ });++ pin_project! {+ struct CancellableFutureRead {+ #[pin]+ cancel: oneshot::Receiver<()>,+ #[pin]+ read: wit_bindgen::FutureRead<u32>,+ }+ }++ impl Future for CancellableFutureRead {+ type Output = Result<u32, FutureReader<u32>>;++ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {+ let this = self.project();+ match this.cancel.poll(cx) {+ Poll::Ready(_) => return Poll::Ready(this.read.cancel()),+ Poll::Pending => {}+ }+ match this.read.poll(cx) {+ Poll::Ready(i) => Poll::Ready(Ok(i)),+ Poll::Pending => Poll::Pending,+ }+ }+ }+ }+ Command::FutureCancelWrite(id) => {+ State::with(|s| {+ s.future_write_cancel_signals+ .remove(&id)+ .unwrap()+ .send(())+ .unwrap();+ });+ assert!(+ State::test_property(|s| s.future_writers.contains_key(&id)).await,+ "expected future write {id} to be cancelled",+ );+ }+ Command::FutureCancelRead(id) => {+ State::with(|s| {+ s.future_read_cancel_signals+ .remove(&id)+ .unwrap()+ .send(())+ .unwrap();+ });+ assert!(+ State::test_property(|s| s.future_readers.contains_key(&id)).await,+ "expected future read {id} to be cancelled",+ );+ }+ Command::FutureWriteAssertComplete(id) => {+ assert!(+ State::test_property(|s| match s.future_writes_completed.remove(&id) {+ Some(true) => true,+ Some(false) => panic!("future was dropped"),+ None => false,+ })+ .await,+ "expected future write {id} to be complete",+ );+ }+ Command::FutureWriteAssertDropped(id) => {+ assert!(+ State::test_property(|s| match s.future_writes_completed.remove(&id) {+ Some(true) => panic!("future write completed"),+ Some(false) => true,+ None => false,+ })+ .await,+ "expected future write {id} to be complete",+ );+ }+ Command::FutureReadAssertComplete(payload) => {+ assert!(+ State::test_property(|s| {+ match s.future_reads_completed.remove(&payload.future) {+ Some(i) => {+ assert_eq!(i, payload.item);+ true+ }+ None => false,+ }+ })+ .await,+ "expected future read {} to be complete",+ payload.future,+ );+ }++ Command::StreamNew(id) => {+ let (writer, reader) = wit_stream::new();+ State::with(|s| {+ let prev = s.stream_writers.insert(id, writer);+ assert!(prev.is_none());+ let prev = s.stream_readers.insert(id, reader);+ assert!(prev.is_none());+ });+ }+ Command::StreamTake(id) => {+ let reader = i::stream_take(id);+ State::with(|s| {+ let prev = s.stream_readers.insert(id, reader);+ assert!(prev.is_none());+ });+ }+ Command::StreamGive(id) => {+ let reader = State::with(|s| s.stream_readers.remove(&id).unwrap());+ i::stream_receive(id, reader);+ }+ Command::StreamDropReadable(id) => {+ let _ = State::with(|s| s.stream_readers.remove(&id).unwrap());+ }+ Command::StreamDropWritable(id) => {+ let _ = State::with(|s| s.stream_writers.remove(&id).unwrap());+ }+ Command::StreamWriteReady(payload) => {+ State::with(|s| {+ let writer = s.stream_writers.get_mut(&payload.stream).unwrap();+ let (status, buffer) = assert_ready(pin!(+ writer.write(stream_payload(payload.item, payload.op_count))+ ));+ assert_eq!(status, StreamResult::Complete(payload.ready_count as usize));+ assert_eq!(+ buffer.remaining() as u32,+ payload.op_count - payload.ready_count+ );+ });+ }+ Command::StreamWriteDropped(payload) => {+ State::with(|s| {+ let writer = s.stream_writers.get_mut(&payload.stream).unwrap();+ let (status, buffer) = assert_ready(pin!(+ writer.write(stream_payload(payload.item, payload.count))+ ));+ assert_eq!(status, StreamResult::Dropped);+ assert_eq!(buffer.remaining() as u32, payload.count);+ });+ }+ Command::StreamReadReady(payload) => {+ State::with(|s| {+ let reader = s.stream_readers.get_mut(&payload.stream).unwrap();+ let (status, buffer) = assert_ready(pin!(+ reader.read(Vec::with_capacity(payload.op_count as usize))+ ));+ assert_eq!(status, StreamResult::Complete(payload.ready_count as usize));+ assert_eq!(buffer, stream_payload(payload.item, payload.ready_count));+ });+ }+ Command::StreamReadDropped(payload) => {+ State::with(|s| {+ let reader = s.stream_readers.get_mut(&payload.stream).unwrap();+ let (status, buffer) = assert_ready(pin!(+ reader.read(Vec::with_capacity(payload.count as usize))+ ));+ assert_eq!(status, StreamResult::Dropped);+ assert!(buffer.is_empty());+ });+ }+ Command::StreamWritePending(payload) => {+ debug!("write pending: {}", payload.stream);+ let mut writer = State::with(|s| s.stream_writers.remove(&payload.stream).unwrap());+ let (tx, rx) = oneshot::channel();+ State::with(|s| {+ let prev = s.stream_write_cancel_signals.insert(payload.stream, tx);+ assert!(prev.is_none());+ });+ let mut future = Box::pin(async move {+ debug!("write pending start: {}", payload.stream);+ let (result, remaining) = CancellableStreamWrite {+ cancel: rx,+ write: writer.write(stream_payload(payload.item, payload.count)),+ }+ .await;+ debug!("write pending done: {} {result:?}", payload.stream);+ State::with(|s| {+ let _ = s.stream_write_cancel_signals.remove(&payload.stream);+ match result {+ StreamResult::Complete(n) => {+ s.stream_writes_completed+ .insert(payload.stream, Ok((n, remaining)));+ }+ StreamResult::Dropped => {+ s.stream_writes_completed+ .insert(payload.stream, Err((0, remaining)));+ }+ StreamResult::Cancelled => {}+ }+ let prev = s.stream_writers.insert(payload.stream, writer);+ assert!(prev.is_none());+ });+ });+ assert_not_ready(future.as_mut());+ wit_bindgen::spawn(future);++ pin_project! {+ struct CancellableStreamWrite<'a> {+ #[pin]+ cancel: oneshot::Receiver<()>,+ #[pin]+ write: wit_bindgen::StreamWrite<'a, u32>,+ }+ }++ impl Future for CancellableStreamWrite<'_> {+ type Output = (StreamResult, Vec<u32>);++ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {+ let this = self.project();+ let (result, buffer) = match this.cancel.poll(cx) {+ Poll::Ready(_) => this.write.cancel(),+ Poll::Pending => match this.write.poll(cx) {+ Poll::Ready(result) => result,+ Poll::Pending => return Poll::Pending,+ },+ };+ Poll::Ready((result, buffer.into_vec()))+ }+ }+ }+ Command::StreamReadPending(payload) => {+ let mut reader = State::with(|s| s.stream_readers.remove(&payload.stream).unwrap());+ let (tx, rx) = oneshot::channel();+ State::with(|s| {+ let prev = s.stream_read_cancel_signals.insert(payload.stream, tx);+ assert!(prev.is_none());+ });+ let mut future = Box::pin(async move {+ let (result, buf) = CancellableStreamRead {+ cancel: rx,+ read: reader.read(Vec::with_capacity(payload.count as usize)),+ }+ .await;+ State::with(|s| {+ let _ = s.stream_read_cancel_signals.remove(&payload.stream);+ match result {+ StreamResult::Complete(_) => {+ s.stream_reads_completed.insert(payload.stream, Some(buf));+ }+ StreamResult::Dropped => {+ assert!(buf.is_empty(), "dropped but got {}", buf.len());+ s.stream_reads_completed.insert(payload.stream, None);+ }+ StreamResult::Cancelled => {}+ }+ let prev = s.stream_readers.insert(payload.stream, reader);+ assert!(prev.is_none());+ });+ });+ assert_not_ready(future.as_mut());+ wit_bindgen::spawn(future);++ pin_project! {+ struct CancellableStreamRead<'a> {+ #[pin]+ cancel: oneshot::Receiver<()>,+ #[pin]+ read: wit_bindgen::StreamRead<'a, u32>,+ }+ }++ impl Future for CancellableStreamRead<'_> {+ type Output = (StreamResult, Vec<u32>);++ fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {+ let this = self.project();+ let (result, buffer) = match this.cancel.poll(cx) {+ Poll::Ready(_) => this.read.cancel(),+ Poll::Pending => match this.read.poll(cx) {+ Poll::Ready(result) => result,+ Poll::Pending => return Poll::Pending,+ },+ };+ Poll::Ready((result, buffer))+ }+ }+ }+ Command::StreamCancelWrite(id) => {+ State::with(|s| {+ s.stream_write_cancel_signals+ .remove(&id)+ .unwrap()+ .send(())+ .unwrap();+ });+ assert!(+ State::test_property(|s| s.stream_writers.contains_key(&id)).await,+ "expected cancel write {id} to be cancelled",+ );+ }+ Command::StreamCancelRead(id) => {+ State::with(|s| {+ s.stream_read_cancel_signals+ .remove(&id)+ .unwrap()+ .send(())+ .unwrap();+ });+ assert!(+ State::test_property(|s| s.stream_readers.contains_key(&id)).await,+ "expected future read {id} to be cancelled",+ );+ }+ Command::StreamWriteAssertComplete(payload) => {+ assert!(+ State::test_property(|s| {+ match s.stream_writes_completed.remove(&payload.stream) {+ Some(Ok((size, _buf))) => {+ assert_eq!(size, payload.count as usize);+ true+ }+ Some(Err(_)) => panic!("stream was dropped"),+ None => false,+ }+ })+ .await,+ "expected stream write {} to be complete",+ payload.stream,+ );+ }+ Command::StreamWriteAssertDropped(payload) => {+ assert!(+ State::test_property(|s| {+ match s.stream_writes_completed.remove(&payload.stream) {+ Some(Err((size, _buf))) => {+ assert_eq!(size, payload.count as usize);+ true+ }+ Some(Ok(_)) => panic!("stream was not dropped"),+ None => false,+ }+ })+ .await,+ "expected stream write {} to be complete",+ payload.stream,+ );+ }+ Command::StreamReadAssertComplete(payload) => {+ assert!(+ State::test_property(|s| {+ match s.stream_reads_completed.remove(&payload.stream) {+ Some(Some(i)) => {+ assert_eq!(i, stream_payload(payload.item, payload.count));+ true+ }+ Some(None) => panic!("stream was dropped"),+ None => false,+ }+ })+ .await,+ "expected stream read {} to be complete",+ payload.stream,+ );+ }+ Command::StreamReadAssertDropped(id) => {+ assert!(+ State::test_property(|s| {+ match s.stream_reads_completed.remove(&id) {+ Some(None) => true,+ Some(Some(_)) => panic!("stream was not dropped"),+ None => false,+ }+ })+ .await,+ "expected stream read {id} to be complete",+ );+ }++ Command::Ack => {}+ }+ }+}++fn stream_payload(init: u32, count: u32) -> Vec<u32> {+ (init..init + count).collect()+}++fn assert_ready<F: Future>(f: Pin<&mut F>) -> F::Output {+ let mut cx = Context::from_waker(Waker::noop());+ match f.poll(&mut cx) {+ Poll::Ready(i) => i,+ Poll::Pending => panic!("future was pending"),+ }+}++fn assert_not_ready<F: Future>(f: Pin<&mut F>) {+ let mut cx = Context::from_waker(Waker::noop());+ match f.poll(&mut cx) {+ Poll::Ready(_) => panic!("future is ready"),+ Poll::Pending => {}+ }+}++fn main() {+ unreachable!();+}diff --git a/crates/wasmtime/src/runtime/component/concurrent.rs b/crates/wasmtime/src/runtime/component/concurrent.rsindex dc0fe129a8..2429aa82bc 100644--- a/crates/wasmtime/src/runtime/component/concurrent.rs+++ b/crates/wasmtime/src/runtime/component/concurrent.rs@@ -231,7 +231,7 @@ where/// Spawn a background task.////// See [`Accessor::spawn`] for details.- pub fn spawn(&mut self, task: impl AccessorTask<T, D, Result<()>>) -> JoinHandle+ pub fn spawn(&mut self, task: impl AccessorTask<T, D>) -> JoinHandlewhereT: 'static,{@@ -507,7 +507,7 @@ where/// Panics if called within a closure provided to the [`Accessor::with`]/// function. This can only be called outside an active invocation of/// [`Accessor::with`].- pub fn spawn(&self, task: impl AccessorTask<T, D, Result<()>>) -> JoinHandle+ pub fn spawn(&self, task: impl AccessorTask<T, D>) -> JoinHandlewhereT: 'static,{@@ -534,12 +534,12 @@ where// Send + Sync + 'static` fails with a type mismatch error when we try to pass// it an async closure (e.g. `async move |_| { ... }`). So this seems to be the// best we can do for the time being.-pub trait AccessorTask<T, D, R>: Send + 'static+pub trait AccessorTask<T, D = HasSelf<T>>: Send + 'staticwhereD: HasData + ?Sized,{/// Run the task.- fn run(self, accessor: &Accessor<T, D>) -> impl Future<Output = R> + Send;+ fn run(self, accessor: &Accessor<T, D>) -> impl Future<Output = Result<()>> + Send;}/// Represents parameter and result metadata for the caller side of a@@ -899,7 +899,7 @@ impl<T> Store<T> {}/// Convenience wrapper for [`StoreContextMut::spawn`].- pub fn spawn(&mut self, task: impl AccessorTask<T, HasSelf<T>, Result<()>>) -> JoinHandle+ pub fn spawn(&mut self, task: impl AccessorTask<T, HasSelf<T>>) -> JoinHandlewhereT: 'static,{@@ -951,7 +951,7 @@ impl<T> StoreContextMut<'_, T> {/// for this instance is run.////// The returned [`SpawnHandle`] may be used to cancel the task.- pub fn spawn(mut self, task: impl AccessorTask<T, HasSelf<T>, Result<()>>) -> JoinHandle+ pub fn spawn(mut self, task: impl AccessorTask<T>) -> JoinHandlewhereT: 'static,{@@ -964,7 +964,7 @@ impl<T> StoreContextMut<'_, T> {fn spawn_with_accessor<D>(self,accessor: Accessor<T, D>,- task: impl AccessorTask<T, D, Result<()>>,+ task: impl AccessorTask<T, D>,) -> JoinHandlewhereT: 'static,diff --git a/crates/wit-bindgen/src/lib.rs b/crates/wit-bindgen/src/lib.rsindex 82d6ee9c91..621a089fde 100644--- a/crates/wit-bindgen/src/lib.rs+++ b/crates/wit-bindgen/src/lib.rs@@ -536,6 +536,7 @@ impl Wasmtime {WorldKey::Name(name) => name,WorldKey::Interface(_) => iface.name.as_ref().unwrap(),};+ uwriteln!(generator.src, "#[derive(Clone)]");uwriteln!(generator.src, "pub struct {struct_name} {{");for (_, func) in iface.functions.iter() {uwriteln!(diff --git a/fuzz/fuzz_targets/misc.rs b/fuzz/fuzz_targets/misc.rsindex 792ce941ac..5d2b29b64b 100644--- a/fuzz/fuzz_targets/misc.rs+++ b/fuzz/fuzz_targets/misc.rs@@ -14,7 +14,9 @@ macro_rules! run_fuzzers {($($fuzzer:ident)*) => {static ENABLED: OnceLock<u32> = OnceLock::new();- fuzz_target!(|bytes: &[u8]| {+ fuzz_target!(+ init: wasmtime_fuzzing::misc_init(),+ |bytes: &[u8]| {// Use the first byte of input as a discriminant of which fuzzer to// select.let Some((which_fuzzer, bytes)) = bytes.split_first() else {@@ -26,7 +28,6 @@ macro_rules! run_fuzzers {// inside of `ENABLED` of enabled fuzzers, returned here as// `enabled`.let enabled = *ENABLED.get_or_init(|| {- env_logger::init();let configured = std::env::var("FUZZER").ok();let configured = configured.as_deref();let mut enabled = 0;@@ -67,6 +68,7 @@ run_fuzzers! {stacksapi_callsdominator_tree+ component_async}fn pulley_roundtrip(u: Unstructured<'_>) -> Result<()> {@@ -179,3 +181,8 @@ fn dominator_tree(mut data: Unstructured<'_>) -> Result<()> {Ok(())}++fn component_async(u: Unstructured<'_>) -> Result<()> {+ wasmtime_fuzzing::oracles::component_async::run(Arbitrary::arbitrary_take_rest(u)?);+ Ok(())+}