Description: use older versions of wasm-tools crates This essentially reverts upstream git commit 6844ed1. Author: Jonas Smedegaard Bug-Debian: https://bugs.debian.org/1095699 Forwarded: not-needed Last-Update: 2025-10-09 --- This patch header follows DEP-3: http://dep.debian.net/deps/dep3/ --- a/Cargo.toml +++ b/Cargo.toml @@ -263,15 +263,15 @@ wit-bindgen-rust-macro = { version = "0.33.0", default-features = false } # wasm-tools family: -wasmparser = { version = "0.218.0", default-features = false } -wat = "1.218.0" -wast = "218.0.0" -wasmprinter = "0.218.0" -wasm-encoder = "0.218.0" -wasm-smith = "0.218.0" -wasm-mutate = "0.218.0" -wit-parser = "0.218.0" -wit-component = "0.218.0" +wasmparser = { version = "0.217.0", default-features = false } +wat = "1.217.0" +wast = "217.0.0" +wasmprinter = "0.217.0" +wasm-encoder = "0.217.0" +wasm-smith = "0.217.0" +wasm-mutate = "0.217.0" +wit-parser = "0.217.0" +wit-component = "0.217.0" # Non-Bytecode Alliance maintained dependencies: # -------------------------- --- a/crates/component-macro/tests/codegen/floats.wit +++ b/crates/component-macro/tests/codegen/floats.wit @@ -1,10 +1,10 @@ package foo:foo; interface floats { - f32-param: func(x: f32); - f64-param: func(x: f64); - f32-result: func() -> f32; - f64-result: func() -> f64; + float32-param: func(x: float32); + float64-param: func(x: float64); + float32-result: func() -> float32; + float64-result: func() -> float64; } world the-world { --- a/crates/component-macro/tests/codegen/lists.wit +++ b/crates/component-macro/tests/codegen/lists.wit @@ -9,8 +9,8 @@ list-s16-param: func(x: list); list-s32-param: func(x: list); list-s64-param: func(x: list); - list-f32-param: func(x: list); - list-f64-param: func(x: list); + list-float32-param: func(x: list); + list-float64-param: func(x: list); list-u8-ret: func() -> list; list-u16-ret: func() -> list; @@ -20,8 +20,8 @@ list-s16-ret: func() -> list; list-s32-ret: func() -> list; list-s64-ret: func() -> list; - list-f32-ret: func() -> list; - list-f64-ret: func() -> list; + list-float32-ret: func() -> list; + list-float64-ret: func() -> list; tuple-list: func(x: list>) -> list>; string-list-arg: func(a: list); @@ -72,8 +72,8 @@ s32, u64, s64, - f32, - f64, + float32, + float64, char, >>; load-store-everything: func(a: load-store-all-sizes) -> load-store-all-sizes; --- a/crates/component-macro/tests/codegen/multi-return.wit +++ b/crates/component-macro/tests/codegen/multi-return.wit @@ -5,7 +5,7 @@ mrb: func() -> (); mrc: func() -> u32; mrd: func() -> (a: u32); - mre: func() -> (a: u32, b: f32); + mre: func() -> (a: u32, b: float32); } world the-world { --- a/crates/component-macro/tests/codegen/variants.wit +++ b/crates/component-macro/tests/codegen/variants.wit @@ -30,7 +30,7 @@ b: option>, c: option, d: option, - e: option, + e: option, g: option>, ); option-result: func() -> tuple< @@ -38,22 +38,22 @@ option>, option, option, - option, + option, option>, >; variant casts1 { a(s32), - b(f32), + b(float32), } variant casts2 { - a(f64), - b(f32), + a(float64), + b(float32), } variant casts3 { - a(f64), + a(float64), b(u64), } @@ -63,12 +63,12 @@ } variant casts5 { - a(f32), + a(float32), b(s64), } variant casts6 { - a(tuple), + a(tuple), b(tuple), } --- a/crates/component-macro/tests/expanded/floats.rs +++ b/crates/component-macro/tests/expanded/floats.rs @@ -187,10 +187,10 @@ #[allow(unused_imports)] use wasmtime::component::__internal::anyhow; pub trait Host { - fn f32_param(&mut self, x: f32) -> (); - fn f64_param(&mut self, x: f64) -> (); - fn f32_result(&mut self) -> f32; - fn f64_result(&mut self) -> f64; + fn float32_param(&mut self, x: f32) -> (); + fn float64_param(&mut self, x: f64) -> (); + fn float32_result(&mut self) -> f32; + fn float64_result(&mut self) -> f64; } pub trait GetHost< T, @@ -210,34 +210,34 @@ ) -> wasmtime::Result<()> { let mut inst = linker.instance("foo:foo/floats")?; inst.func_wrap( - "f32-param", + "float32-param", move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f32,)| { let host = &mut host_getter(caller.data_mut()); - let r = Host::f32_param(host, arg0); + let r = Host::float32_param(host, arg0); Ok(r) }, )?; inst.func_wrap( - "f64-param", + "float64-param", move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f64,)| { let host = &mut host_getter(caller.data_mut()); - let r = Host::f64_param(host, arg0); + let r = Host::float64_param(host, arg0); Ok(r) }, )?; inst.func_wrap( - "f32-result", + "float32-result", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { let host = &mut host_getter(caller.data_mut()); - let r = Host::f32_result(host); + let r = Host::float32_result(host); Ok((r,)) }, )?; inst.func_wrap( - "f64-result", + "float64-result", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { let host = &mut host_getter(caller.data_mut()); - let r = Host::f64_result(host); + let r = Host::float64_result(host); Ok((r,)) }, )?; @@ -253,17 +253,17 @@ add_to_linker_get_host(linker, get) } impl<_T: Host + ?Sized> Host for &mut _T { - fn f32_param(&mut self, x: f32) -> () { - Host::f32_param(*self, x) + fn float32_param(&mut self, x: f32) -> () { + Host::float32_param(*self, x) } - fn f64_param(&mut self, x: f64) -> () { - Host::f64_param(*self, x) + fn float64_param(&mut self, x: f64) -> () { + Host::float64_param(*self, x) } - fn f32_result(&mut self) -> f32 { - Host::f32_result(*self) + fn float32_result(&mut self) -> f32 { + Host::float32_result(*self) } - fn f64_result(&mut self) -> f64 { - Host::f64_result(*self) + fn float64_result(&mut self) -> f64 { + Host::float64_result(*self) } } } @@ -277,17 +277,17 @@ #[allow(unused_imports)] use wasmtime::component::__internal::anyhow; pub struct Guest { - f32_param: wasmtime::component::Func, - f64_param: wasmtime::component::Func, - f32_result: wasmtime::component::Func, - f64_result: wasmtime::component::Func, + float32_param: wasmtime::component::Func, + float64_param: wasmtime::component::Func, + float32_result: wasmtime::component::Func, + float64_result: wasmtime::component::Func, } #[derive(Clone)] pub struct GuestIndices { - f32_param: wasmtime::component::ComponentExportIndex, - f64_param: wasmtime::component::ComponentExportIndex, - f32_result: wasmtime::component::ComponentExportIndex, - f64_result: wasmtime::component::ComponentExportIndex, + float32_param: wasmtime::component::ComponentExportIndex, + float64_param: wasmtime::component::ComponentExportIndex, + float32_result: wasmtime::component::ComponentExportIndex, + float64_result: wasmtime::component::ComponentExportIndex, } impl GuestIndices { /// Constructor for [`GuestIndices`] which takes a @@ -342,15 +342,15 @@ }) }; let _ = &mut lookup; - let f32_param = lookup("f32-param")?; - let f64_param = lookup("f64-param")?; - let f32_result = lookup("f32-result")?; - let f64_result = lookup("f64-result")?; + let float32_param = lookup("float32-param")?; + let float64_param = lookup("float64-param")?; + let float32_result = lookup("float32-result")?; + let float64_result = lookup("float64-result")?; Ok(GuestIndices { - f32_param, - f64_param, - f32_result, - f64_result, + float32_param, + float64_param, + float32_result, + float64_result, }) } pub fn load( @@ -361,28 +361,40 @@ let mut store = store.as_context_mut(); let _ = &mut store; let _instance = instance; - let f32_param = *_instance - .get_typed_func::<(f32,), ()>(&mut store, &self.f32_param)? + let float32_param = *_instance + .get_typed_func::< + (f32,), + (), + >(&mut store, &self.float32_param)? .func(); - let f64_param = *_instance - .get_typed_func::<(f64,), ()>(&mut store, &self.f64_param)? + let float64_param = *_instance + .get_typed_func::< + (f64,), + (), + >(&mut store, &self.float64_param)? .func(); - let f32_result = *_instance - .get_typed_func::<(), (f32,)>(&mut store, &self.f32_result)? + let float32_result = *_instance + .get_typed_func::< + (), + (f32,), + >(&mut store, &self.float32_result)? .func(); - let f64_result = *_instance - .get_typed_func::<(), (f64,)>(&mut store, &self.f64_result)? + let float64_result = *_instance + .get_typed_func::< + (), + (f64,), + >(&mut store, &self.float64_result)? .func(); Ok(Guest { - f32_param, - f64_param, - f32_result, - f64_result, + float32_param, + float64_param, + float32_result, + float64_result, }) } } impl Guest { - pub fn call_f32_param( + pub fn call_float32_param( &self, mut store: S, arg0: f32, @@ -391,13 +403,13 @@ wasmtime::component::TypedFunc::< (f32,), (), - >::new_unchecked(self.f32_param) + >::new_unchecked(self.float32_param) }; let () = callee.call(store.as_context_mut(), (arg0,))?; callee.post_return(store.as_context_mut())?; Ok(()) } - pub fn call_f64_param( + pub fn call_float64_param( &self, mut store: S, arg0: f64, @@ -406,13 +418,13 @@ wasmtime::component::TypedFunc::< (f64,), (), - >::new_unchecked(self.f64_param) + >::new_unchecked(self.float64_param) }; let () = callee.call(store.as_context_mut(), (arg0,))?; callee.post_return(store.as_context_mut())?; Ok(()) } - pub fn call_f32_result( + pub fn call_float32_result( &self, mut store: S, ) -> wasmtime::Result { @@ -420,13 +432,13 @@ wasmtime::component::TypedFunc::< (), (f32,), - >::new_unchecked(self.f32_result) + >::new_unchecked(self.float32_result) }; let (ret0,) = callee.call(store.as_context_mut(), ())?; callee.post_return(store.as_context_mut())?; Ok(ret0) } - pub fn call_f64_result( + pub fn call_float64_result( &self, mut store: S, ) -> wasmtime::Result { @@ -434,7 +446,7 @@ wasmtime::component::TypedFunc::< (), (f64,), - >::new_unchecked(self.f64_result) + >::new_unchecked(self.float64_result) }; let (ret0,) = callee.call(store.as_context_mut(), ())?; callee.post_return(store.as_context_mut())?; --- a/crates/component-macro/tests/expanded/floats_async.rs +++ b/crates/component-macro/tests/expanded/floats_async.rs @@ -195,10 +195,10 @@ use wasmtime::component::__internal::anyhow; #[wasmtime::component::__internal::async_trait] pub trait Host: Send { - async fn f32_param(&mut self, x: f32) -> (); - async fn f64_param(&mut self, x: f64) -> (); - async fn f32_result(&mut self) -> f32; - async fn f64_result(&mut self) -> f64; + async fn float32_param(&mut self, x: f32) -> (); + async fn float64_param(&mut self, x: f64) -> (); + async fn float32_result(&mut self) -> f32; + async fn float64_result(&mut self) -> f64; } pub trait GetHost< T, @@ -221,41 +221,41 @@ { let mut inst = linker.instance("foo:foo/floats")?; inst.func_wrap_async( - "f32-param", + "float32-param", move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f32,)| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::f32_param(host, arg0).await; + let r = Host::float32_param(host, arg0).await; Ok(r) }) }, )?; inst.func_wrap_async( - "f64-param", + "float64-param", move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f64,)| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::f64_param(host, arg0).await; + let r = Host::float64_param(host, arg0).await; Ok(r) }) }, )?; inst.func_wrap_async( - "f32-result", + "float32-result", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::f32_result(host).await; + let r = Host::float32_result(host).await; Ok((r,)) }) }, )?; inst.func_wrap_async( - "f64-result", + "float64-result", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::f64_result(host).await; + let r = Host::float64_result(host).await; Ok((r,)) }) }, @@ -274,17 +274,17 @@ } #[wasmtime::component::__internal::async_trait] impl<_T: Host + ?Sized + Send> Host for &mut _T { - async fn f32_param(&mut self, x: f32) -> () { - Host::f32_param(*self, x).await + async fn float32_param(&mut self, x: f32) -> () { + Host::float32_param(*self, x).await } - async fn f64_param(&mut self, x: f64) -> () { - Host::f64_param(*self, x).await + async fn float64_param(&mut self, x: f64) -> () { + Host::float64_param(*self, x).await } - async fn f32_result(&mut self) -> f32 { - Host::f32_result(*self).await + async fn float32_result(&mut self) -> f32 { + Host::float32_result(*self).await } - async fn f64_result(&mut self) -> f64 { - Host::f64_result(*self).await + async fn float64_result(&mut self) -> f64 { + Host::float64_result(*self).await } } } @@ -298,17 +298,17 @@ #[allow(unused_imports)] use wasmtime::component::__internal::anyhow; pub struct Guest { - f32_param: wasmtime::component::Func, - f64_param: wasmtime::component::Func, - f32_result: wasmtime::component::Func, - f64_result: wasmtime::component::Func, + float32_param: wasmtime::component::Func, + float64_param: wasmtime::component::Func, + float32_result: wasmtime::component::Func, + float64_result: wasmtime::component::Func, } #[derive(Clone)] pub struct GuestIndices { - f32_param: wasmtime::component::ComponentExportIndex, - f64_param: wasmtime::component::ComponentExportIndex, - f32_result: wasmtime::component::ComponentExportIndex, - f64_result: wasmtime::component::ComponentExportIndex, + float32_param: wasmtime::component::ComponentExportIndex, + float64_param: wasmtime::component::ComponentExportIndex, + float32_result: wasmtime::component::ComponentExportIndex, + float64_result: wasmtime::component::ComponentExportIndex, } impl GuestIndices { /// Constructor for [`GuestIndices`] which takes a @@ -363,15 +363,15 @@ }) }; let _ = &mut lookup; - let f32_param = lookup("f32-param")?; - let f64_param = lookup("f64-param")?; - let f32_result = lookup("f32-result")?; - let f64_result = lookup("f64-result")?; + let float32_param = lookup("float32-param")?; + let float64_param = lookup("float64-param")?; + let float32_result = lookup("float32-result")?; + let float64_result = lookup("float64-result")?; Ok(GuestIndices { - f32_param, - f64_param, - f32_result, - f64_result, + float32_param, + float64_param, + float32_result, + float64_result, }) } pub fn load( @@ -382,28 +382,40 @@ let mut store = store.as_context_mut(); let _ = &mut store; let _instance = instance; - let f32_param = *_instance - .get_typed_func::<(f32,), ()>(&mut store, &self.f32_param)? + let float32_param = *_instance + .get_typed_func::< + (f32,), + (), + >(&mut store, &self.float32_param)? .func(); - let f64_param = *_instance - .get_typed_func::<(f64,), ()>(&mut store, &self.f64_param)? + let float64_param = *_instance + .get_typed_func::< + (f64,), + (), + >(&mut store, &self.float64_param)? .func(); - let f32_result = *_instance - .get_typed_func::<(), (f32,)>(&mut store, &self.f32_result)? + let float32_result = *_instance + .get_typed_func::< + (), + (f32,), + >(&mut store, &self.float32_result)? .func(); - let f64_result = *_instance - .get_typed_func::<(), (f64,)>(&mut store, &self.f64_result)? + let float64_result = *_instance + .get_typed_func::< + (), + (f64,), + >(&mut store, &self.float64_result)? .func(); Ok(Guest { - f32_param, - f64_param, - f32_result, - f64_result, + float32_param, + float64_param, + float32_result, + float64_result, }) } } impl Guest { - pub async fn call_f32_param( + pub async fn call_float32_param( &self, mut store: S, arg0: f32, @@ -415,7 +427,7 @@ wasmtime::component::TypedFunc::< (f32,), (), - >::new_unchecked(self.f32_param) + >::new_unchecked(self.float32_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -423,7 +435,7 @@ callee.post_return_async(store.as_context_mut()).await?; Ok(()) } - pub async fn call_f64_param( + pub async fn call_float64_param( &self, mut store: S, arg0: f64, @@ -435,7 +447,7 @@ wasmtime::component::TypedFunc::< (f64,), (), - >::new_unchecked(self.f64_param) + >::new_unchecked(self.float64_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -443,7 +455,7 @@ callee.post_return_async(store.as_context_mut()).await?; Ok(()) } - pub async fn call_f32_result( + pub async fn call_float32_result( &self, mut store: S, ) -> wasmtime::Result @@ -454,7 +466,7 @@ wasmtime::component::TypedFunc::< (), (f32,), - >::new_unchecked(self.f32_result) + >::new_unchecked(self.float32_result) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) @@ -462,7 +474,7 @@ callee.post_return_async(store.as_context_mut()).await?; Ok(ret0) } - pub async fn call_f64_result( + pub async fn call_float64_result( &self, mut store: S, ) -> wasmtime::Result @@ -473,7 +485,7 @@ wasmtime::component::TypedFunc::< (), (f64,), - >::new_unchecked(self.f64_result) + >::new_unchecked(self.float64_result) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) --- a/crates/component-macro/tests/expanded/floats_tracing_async.rs +++ b/crates/component-macro/tests/expanded/floats_tracing_async.rs @@ -195,10 +195,10 @@ use wasmtime::component::__internal::anyhow; #[wasmtime::component::__internal::async_trait] pub trait Host: Send { - async fn f32_param(&mut self, x: f32) -> (); - async fn f64_param(&mut self, x: f64) -> (); - async fn f32_result(&mut self) -> f32; - async fn f64_result(&mut self) -> f64; + async fn float32_param(&mut self, x: f32) -> (); + async fn float64_param(&mut self, x: f64) -> (); + async fn float32_result(&mut self) -> f32; + async fn float64_result(&mut self) -> f64; } pub trait GetHost< T, @@ -221,12 +221,12 @@ { let mut inst = linker.instance("foo:foo/floats")?; inst.func_wrap_async( - "f32-param", + "float32-param", move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f32,)| { use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "floats", function = "f32-param", + "floats", function = "float32-param", ); wasmtime::component::__internal::Box::new( async move { @@ -235,7 +235,7 @@ "call" ); let host = &mut host_getter(caller.data_mut()); - let r = Host::f32_param(host, arg0).await; + let r = Host::float32_param(host, arg0).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug(& r), "return" @@ -247,12 +247,12 @@ }, )?; inst.func_wrap_async( - "f64-param", + "float64-param", move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f64,)| { use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "floats", function = "f64-param", + "floats", function = "float64-param", ); wasmtime::component::__internal::Box::new( async move { @@ -261,7 +261,7 @@ "call" ); let host = &mut host_getter(caller.data_mut()); - let r = Host::f64_param(host, arg0).await; + let r = Host::float64_param(host, arg0).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug(& r), "return" @@ -273,18 +273,18 @@ }, )?; inst.func_wrap_async( - "f32-result", + "float32-result", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "floats", function = "f32-result", + "floats", function = "float32-result", ); wasmtime::component::__internal::Box::new( async move { tracing::event!(tracing::Level::TRACE, "call"); let host = &mut host_getter(caller.data_mut()); - let r = Host::f32_result(host).await; + let r = Host::float32_result(host).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug(& r), "return" @@ -296,18 +296,18 @@ }, )?; inst.func_wrap_async( - "f64-result", + "float64-result", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "floats", function = "f64-result", + "floats", function = "float64-result", ); wasmtime::component::__internal::Box::new( async move { tracing::event!(tracing::Level::TRACE, "call"); let host = &mut host_getter(caller.data_mut()); - let r = Host::f64_result(host).await; + let r = Host::float64_result(host).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug(& r), "return" @@ -332,17 +332,17 @@ } #[wasmtime::component::__internal::async_trait] impl<_T: Host + ?Sized + Send> Host for &mut _T { - async fn f32_param(&mut self, x: f32) -> () { - Host::f32_param(*self, x).await + async fn float32_param(&mut self, x: f32) -> () { + Host::float32_param(*self, x).await } - async fn f64_param(&mut self, x: f64) -> () { - Host::f64_param(*self, x).await + async fn float64_param(&mut self, x: f64) -> () { + Host::float64_param(*self, x).await } - async fn f32_result(&mut self) -> f32 { - Host::f32_result(*self).await + async fn float32_result(&mut self) -> f32 { + Host::float32_result(*self).await } - async fn f64_result(&mut self) -> f64 { - Host::f64_result(*self).await + async fn float64_result(&mut self) -> f64 { + Host::float64_result(*self).await } } } @@ -356,17 +356,17 @@ #[allow(unused_imports)] use wasmtime::component::__internal::anyhow; pub struct Guest { - f32_param: wasmtime::component::Func, - f64_param: wasmtime::component::Func, - f32_result: wasmtime::component::Func, - f64_result: wasmtime::component::Func, + float32_param: wasmtime::component::Func, + float64_param: wasmtime::component::Func, + float32_result: wasmtime::component::Func, + float64_result: wasmtime::component::Func, } #[derive(Clone)] pub struct GuestIndices { - f32_param: wasmtime::component::ComponentExportIndex, - f64_param: wasmtime::component::ComponentExportIndex, - f32_result: wasmtime::component::ComponentExportIndex, - f64_result: wasmtime::component::ComponentExportIndex, + float32_param: wasmtime::component::ComponentExportIndex, + float64_param: wasmtime::component::ComponentExportIndex, + float32_result: wasmtime::component::ComponentExportIndex, + float64_result: wasmtime::component::ComponentExportIndex, } impl GuestIndices { /// Constructor for [`GuestIndices`] which takes a @@ -421,15 +421,15 @@ }) }; let _ = &mut lookup; - let f32_param = lookup("f32-param")?; - let f64_param = lookup("f64-param")?; - let f32_result = lookup("f32-result")?; - let f64_result = lookup("f64-result")?; + let float32_param = lookup("float32-param")?; + let float64_param = lookup("float64-param")?; + let float32_result = lookup("float32-result")?; + let float64_result = lookup("float64-result")?; Ok(GuestIndices { - f32_param, - f64_param, - f32_result, - f64_result, + float32_param, + float64_param, + float32_result, + float64_result, }) } pub fn load( @@ -440,28 +440,40 @@ let mut store = store.as_context_mut(); let _ = &mut store; let _instance = instance; - let f32_param = *_instance - .get_typed_func::<(f32,), ()>(&mut store, &self.f32_param)? + let float32_param = *_instance + .get_typed_func::< + (f32,), + (), + >(&mut store, &self.float32_param)? .func(); - let f64_param = *_instance - .get_typed_func::<(f64,), ()>(&mut store, &self.f64_param)? + let float64_param = *_instance + .get_typed_func::< + (f64,), + (), + >(&mut store, &self.float64_param)? .func(); - let f32_result = *_instance - .get_typed_func::<(), (f32,)>(&mut store, &self.f32_result)? + let float32_result = *_instance + .get_typed_func::< + (), + (f32,), + >(&mut store, &self.float32_result)? .func(); - let f64_result = *_instance - .get_typed_func::<(), (f64,)>(&mut store, &self.f64_result)? + let float64_result = *_instance + .get_typed_func::< + (), + (f64,), + >(&mut store, &self.float64_result)? .func(); Ok(Guest { - f32_param, - f64_param, - f32_result, - f64_result, + float32_param, + float64_param, + float32_result, + float64_result, }) } } impl Guest { - pub async fn call_f32_param( + pub async fn call_float32_param( &self, mut store: S, arg0: f32, @@ -472,13 +484,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/floats", function = "f32-param", + "foo:foo/floats", function = "float32-param", ); let callee = unsafe { wasmtime::component::TypedFunc::< (f32,), (), - >::new_unchecked(self.f32_param) + >::new_unchecked(self.float32_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -490,7 +502,7 @@ .await?; Ok(()) } - pub async fn call_f64_param( + pub async fn call_float64_param( &self, mut store: S, arg0: f64, @@ -501,13 +513,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/floats", function = "f64-param", + "foo:foo/floats", function = "float64-param", ); let callee = unsafe { wasmtime::component::TypedFunc::< (f64,), (), - >::new_unchecked(self.f64_param) + >::new_unchecked(self.float64_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -519,7 +531,7 @@ .await?; Ok(()) } - pub async fn call_f32_result( + pub async fn call_float32_result( &self, mut store: S, ) -> wasmtime::Result @@ -529,13 +541,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/floats", function = "f32-result", + "foo:foo/floats", function = "float32-result", ); let callee = unsafe { wasmtime::component::TypedFunc::< (), (f32,), - >::new_unchecked(self.f32_result) + >::new_unchecked(self.float32_result) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) @@ -547,7 +559,7 @@ .await?; Ok(ret0) } - pub async fn call_f64_result( + pub async fn call_float64_result( &self, mut store: S, ) -> wasmtime::Result @@ -557,13 +569,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/floats", function = "f64-result", + "foo:foo/floats", function = "float64-result", ); let callee = unsafe { wasmtime::component::TypedFunc::< (), (f64,), - >::new_unchecked(self.f64_result) + >::new_unchecked(self.float64_result) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) --- a/crates/component-macro/tests/expanded/lists.rs +++ b/crates/component-macro/tests/expanded/lists.rs @@ -399,11 +399,11 @@ &mut self, x: wasmtime::component::__internal::Vec, ) -> (); - fn list_f32_param( + fn list_float32_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> (); - fn list_f64_param( + fn list_float64_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> (); @@ -415,8 +415,12 @@ fn list_s16_ret(&mut self) -> wasmtime::component::__internal::Vec; fn list_s32_ret(&mut self) -> wasmtime::component::__internal::Vec; fn list_s64_ret(&mut self) -> wasmtime::component::__internal::Vec; - fn list_f32_ret(&mut self) -> wasmtime::component::__internal::Vec; - fn list_f64_ret(&mut self) -> wasmtime::component::__internal::Vec; + fn list_float32_ret( + &mut self, + ) -> wasmtime::component::__internal::Vec; + fn list_float64_ret( + &mut self, + ) -> wasmtime::component::__internal::Vec; fn tuple_list( &mut self, x: wasmtime::component::__internal::Vec<(u8, i8)>, @@ -571,24 +575,24 @@ }, )?; inst.func_wrap( - "list-f32-param", + "list-float32-param", move | mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (wasmtime::component::__internal::Vec,)| { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f32_param(host, arg0); + let r = Host::list_float32_param(host, arg0); Ok(r) }, )?; inst.func_wrap( - "list-f64-param", + "list-float64-param", move | mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (wasmtime::component::__internal::Vec,)| { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f64_param(host, arg0); + let r = Host::list_float64_param(host, arg0); Ok(r) }, )?; @@ -657,18 +661,18 @@ }, )?; inst.func_wrap( - "list-f32-ret", + "list-float32-ret", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f32_ret(host); + let r = Host::list_float32_ret(host); Ok((r,)) }, )?; inst.func_wrap( - "list-f64-ret", + "list-float64-ret", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f64_ret(host); + let r = Host::list_float64_ret(host); Ok((r,)) }, )?; @@ -846,17 +850,17 @@ ) -> () { Host::list_s64_param(*self, x) } - fn list_f32_param( + fn list_float32_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> () { - Host::list_f32_param(*self, x) + Host::list_float32_param(*self, x) } - fn list_f64_param( + fn list_float64_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> () { - Host::list_f64_param(*self, x) + Host::list_float64_param(*self, x) } fn list_u8_ret(&mut self) -> wasmtime::component::__internal::Vec { Host::list_u8_ret(*self) @@ -882,11 +886,15 @@ fn list_s64_ret(&mut self) -> wasmtime::component::__internal::Vec { Host::list_s64_ret(*self) } - fn list_f32_ret(&mut self) -> wasmtime::component::__internal::Vec { - Host::list_f32_ret(*self) + fn list_float32_ret( + &mut self, + ) -> wasmtime::component::__internal::Vec { + Host::list_float32_ret(*self) } - fn list_f64_ret(&mut self) -> wasmtime::component::__internal::Vec { - Host::list_f64_ret(*self) + fn list_float64_ret( + &mut self, + ) -> wasmtime::component::__internal::Vec { + Host::list_float64_ret(*self) } fn tuple_list( &mut self, @@ -1173,8 +1181,8 @@ list_s16_param: wasmtime::component::Func, list_s32_param: wasmtime::component::Func, list_s64_param: wasmtime::component::Func, - list_f32_param: wasmtime::component::Func, - list_f64_param: wasmtime::component::Func, + list_float32_param: wasmtime::component::Func, + list_float64_param: wasmtime::component::Func, list_u8_ret: wasmtime::component::Func, list_u16_ret: wasmtime::component::Func, list_u32_ret: wasmtime::component::Func, @@ -1183,8 +1191,8 @@ list_s16_ret: wasmtime::component::Func, list_s32_ret: wasmtime::component::Func, list_s64_ret: wasmtime::component::Func, - list_f32_ret: wasmtime::component::Func, - list_f64_ret: wasmtime::component::Func, + list_float32_ret: wasmtime::component::Func, + list_float64_ret: wasmtime::component::Func, tuple_list: wasmtime::component::Func, string_list_arg: wasmtime::component::Func, string_list_ret: wasmtime::component::Func, @@ -1205,8 +1213,8 @@ list_s16_param: wasmtime::component::ComponentExportIndex, list_s32_param: wasmtime::component::ComponentExportIndex, list_s64_param: wasmtime::component::ComponentExportIndex, - list_f32_param: wasmtime::component::ComponentExportIndex, - list_f64_param: wasmtime::component::ComponentExportIndex, + list_float32_param: wasmtime::component::ComponentExportIndex, + list_float64_param: wasmtime::component::ComponentExportIndex, list_u8_ret: wasmtime::component::ComponentExportIndex, list_u16_ret: wasmtime::component::ComponentExportIndex, list_u32_ret: wasmtime::component::ComponentExportIndex, @@ -1215,8 +1223,8 @@ list_s16_ret: wasmtime::component::ComponentExportIndex, list_s32_ret: wasmtime::component::ComponentExportIndex, list_s64_ret: wasmtime::component::ComponentExportIndex, - list_f32_ret: wasmtime::component::ComponentExportIndex, - list_f64_ret: wasmtime::component::ComponentExportIndex, + list_float32_ret: wasmtime::component::ComponentExportIndex, + list_float64_ret: wasmtime::component::ComponentExportIndex, tuple_list: wasmtime::component::ComponentExportIndex, string_list_arg: wasmtime::component::ComponentExportIndex, string_list_ret: wasmtime::component::ComponentExportIndex, @@ -1288,8 +1296,8 @@ let list_s16_param = lookup("list-s16-param")?; let list_s32_param = lookup("list-s32-param")?; let list_s64_param = lookup("list-s64-param")?; - let list_f32_param = lookup("list-f32-param")?; - let list_f64_param = lookup("list-f64-param")?; + let list_float32_param = lookup("list-float32-param")?; + let list_float64_param = lookup("list-float64-param")?; let list_u8_ret = lookup("list-u8-ret")?; let list_u16_ret = lookup("list-u16-ret")?; let list_u32_ret = lookup("list-u32-ret")?; @@ -1298,8 +1306,8 @@ let list_s16_ret = lookup("list-s16-ret")?; let list_s32_ret = lookup("list-s32-ret")?; let list_s64_ret = lookup("list-s64-ret")?; - let list_f32_ret = lookup("list-f32-ret")?; - let list_f64_ret = lookup("list-f64-ret")?; + let list_float32_ret = lookup("list-float32-ret")?; + let list_float64_ret = lookup("list-float64-ret")?; let tuple_list = lookup("tuple-list")?; let string_list_arg = lookup("string-list-arg")?; let string_list_ret = lookup("string-list-ret")?; @@ -1318,8 +1326,8 @@ list_s16_param, list_s32_param, list_s64_param, - list_f32_param, - list_f64_param, + list_float32_param, + list_float64_param, list_u8_ret, list_u16_ret, list_u32_ret, @@ -1328,8 +1336,8 @@ list_s16_ret, list_s32_ret, list_s64_ret, - list_f32_ret, - list_f64_ret, + list_float32_ret, + list_float64_ret, tuple_list, string_list_arg, string_list_ret, @@ -1397,17 +1405,17 @@ (), >(&mut store, &self.list_s64_param)? .func(); - let list_f32_param = *_instance + let list_float32_param = *_instance .get_typed_func::< (&[f32],), (), - >(&mut store, &self.list_f32_param)? + >(&mut store, &self.list_float32_param)? .func(); - let list_f64_param = *_instance + let list_float64_param = *_instance .get_typed_func::< (&[f64],), (), - >(&mut store, &self.list_f64_param)? + >(&mut store, &self.list_float64_param)? .func(); let list_u8_ret = *_instance .get_typed_func::< @@ -1457,17 +1465,17 @@ (wasmtime::component::__internal::Vec,), >(&mut store, &self.list_s64_ret)? .func(); - let list_f32_ret = *_instance + let list_float32_ret = *_instance .get_typed_func::< (), (wasmtime::component::__internal::Vec,), - >(&mut store, &self.list_f32_ret)? + >(&mut store, &self.list_float32_ret)? .func(); - let list_f64_ret = *_instance + let list_float64_ret = *_instance .get_typed_func::< (), (wasmtime::component::__internal::Vec,), - >(&mut store, &self.list_f64_ret)? + >(&mut store, &self.list_float64_ret)? .func(); let tuple_list = *_instance .get_typed_func::< @@ -1544,8 +1552,8 @@ list_s16_param, list_s32_param, list_s64_param, - list_f32_param, - list_f64_param, + list_float32_param, + list_float64_param, list_u8_ret, list_u16_ret, list_u32_ret, @@ -1554,8 +1562,8 @@ list_s16_ret, list_s32_ret, list_s64_ret, - list_f32_ret, - list_f64_ret, + list_float32_ret, + list_float64_ret, tuple_list, string_list_arg, string_list_ret, @@ -1689,7 +1697,7 @@ callee.post_return(store.as_context_mut())?; Ok(()) } - pub fn call_list_f32_param( + pub fn call_list_float32_param( &self, mut store: S, arg0: &[f32], @@ -1698,13 +1706,13 @@ wasmtime::component::TypedFunc::< (&[f32],), (), - >::new_unchecked(self.list_f32_param) + >::new_unchecked(self.list_float32_param) }; let () = callee.call(store.as_context_mut(), (arg0,))?; callee.post_return(store.as_context_mut())?; Ok(()) } - pub fn call_list_f64_param( + pub fn call_list_float64_param( &self, mut store: S, arg0: &[f64], @@ -1713,7 +1721,7 @@ wasmtime::component::TypedFunc::< (&[f64],), (), - >::new_unchecked(self.list_f64_param) + >::new_unchecked(self.list_float64_param) }; let () = callee.call(store.as_context_mut(), (arg0,))?; callee.post_return(store.as_context_mut())?; @@ -1831,7 +1839,7 @@ callee.post_return(store.as_context_mut())?; Ok(ret0) } - pub fn call_list_f32_ret( + pub fn call_list_float32_ret( &self, mut store: S, ) -> wasmtime::Result> { @@ -1839,13 +1847,13 @@ wasmtime::component::TypedFunc::< (), (wasmtime::component::__internal::Vec,), - >::new_unchecked(self.list_f32_ret) + >::new_unchecked(self.list_float32_ret) }; let (ret0,) = callee.call(store.as_context_mut(), ())?; callee.post_return(store.as_context_mut())?; Ok(ret0) } - pub fn call_list_f64_ret( + pub fn call_list_float64_ret( &self, mut store: S, ) -> wasmtime::Result> { @@ -1853,7 +1861,7 @@ wasmtime::component::TypedFunc::< (), (wasmtime::component::__internal::Vec,), - >::new_unchecked(self.list_f64_ret) + >::new_unchecked(self.list_float64_ret) }; let (ret0,) = callee.call(store.as_context_mut(), ())?; callee.post_return(store.as_context_mut())?; --- a/crates/component-macro/tests/expanded/lists_async.rs +++ b/crates/component-macro/tests/expanded/lists_async.rs @@ -407,11 +407,11 @@ &mut self, x: wasmtime::component::__internal::Vec, ) -> (); - async fn list_f32_param( + async fn list_float32_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> (); - async fn list_f64_param( + async fn list_float64_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> (); @@ -439,10 +439,10 @@ async fn list_s64_ret( &mut self, ) -> wasmtime::component::__internal::Vec; - async fn list_f32_ret( + async fn list_float32_ret( &mut self, ) -> wasmtime::component::__internal::Vec; - async fn list_f64_ret( + async fn list_float64_ret( &mut self, ) -> wasmtime::component::__internal::Vec; async fn tuple_list( @@ -618,27 +618,27 @@ }, )?; inst.func_wrap_async( - "list-f32-param", + "list-float32-param", move | mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (wasmtime::component::__internal::Vec,)| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f32_param(host, arg0).await; + let r = Host::list_float32_param(host, arg0).await; Ok(r) }) }, )?; inst.func_wrap_async( - "list-f64-param", + "list-float64-param", move | mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (wasmtime::component::__internal::Vec,)| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f64_param(host, arg0).await; + let r = Host::list_float64_param(host, arg0).await; Ok(r) }) }, @@ -724,21 +724,21 @@ }, )?; inst.func_wrap_async( - "list-f32-ret", + "list-float32-ret", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f32_ret(host).await; + let r = Host::list_float32_ret(host).await; Ok((r,)) }) }, )?; inst.func_wrap_async( - "list-f64-ret", + "list-float64-ret", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { wasmtime::component::__internal::Box::new(async move { let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f64_ret(host).await; + let r = Host::list_float64_ret(host).await; Ok((r,)) }) }, @@ -937,17 +937,17 @@ ) -> () { Host::list_s64_param(*self, x).await } - async fn list_f32_param( + async fn list_float32_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> () { - Host::list_f32_param(*self, x).await + Host::list_float32_param(*self, x).await } - async fn list_f64_param( + async fn list_float64_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> () { - Host::list_f64_param(*self, x).await + Host::list_float64_param(*self, x).await } async fn list_u8_ret( &mut self, @@ -989,15 +989,15 @@ ) -> wasmtime::component::__internal::Vec { Host::list_s64_ret(*self).await } - async fn list_f32_ret( + async fn list_float32_ret( &mut self, ) -> wasmtime::component::__internal::Vec { - Host::list_f32_ret(*self).await + Host::list_float32_ret(*self).await } - async fn list_f64_ret( + async fn list_float64_ret( &mut self, ) -> wasmtime::component::__internal::Vec { - Host::list_f64_ret(*self).await + Host::list_float64_ret(*self).await } async fn tuple_list( &mut self, @@ -1284,8 +1284,8 @@ list_s16_param: wasmtime::component::Func, list_s32_param: wasmtime::component::Func, list_s64_param: wasmtime::component::Func, - list_f32_param: wasmtime::component::Func, - list_f64_param: wasmtime::component::Func, + list_float32_param: wasmtime::component::Func, + list_float64_param: wasmtime::component::Func, list_u8_ret: wasmtime::component::Func, list_u16_ret: wasmtime::component::Func, list_u32_ret: wasmtime::component::Func, @@ -1294,8 +1294,8 @@ list_s16_ret: wasmtime::component::Func, list_s32_ret: wasmtime::component::Func, list_s64_ret: wasmtime::component::Func, - list_f32_ret: wasmtime::component::Func, - list_f64_ret: wasmtime::component::Func, + list_float32_ret: wasmtime::component::Func, + list_float64_ret: wasmtime::component::Func, tuple_list: wasmtime::component::Func, string_list_arg: wasmtime::component::Func, string_list_ret: wasmtime::component::Func, @@ -1316,8 +1316,8 @@ list_s16_param: wasmtime::component::ComponentExportIndex, list_s32_param: wasmtime::component::ComponentExportIndex, list_s64_param: wasmtime::component::ComponentExportIndex, - list_f32_param: wasmtime::component::ComponentExportIndex, - list_f64_param: wasmtime::component::ComponentExportIndex, + list_float32_param: wasmtime::component::ComponentExportIndex, + list_float64_param: wasmtime::component::ComponentExportIndex, list_u8_ret: wasmtime::component::ComponentExportIndex, list_u16_ret: wasmtime::component::ComponentExportIndex, list_u32_ret: wasmtime::component::ComponentExportIndex, @@ -1326,8 +1326,8 @@ list_s16_ret: wasmtime::component::ComponentExportIndex, list_s32_ret: wasmtime::component::ComponentExportIndex, list_s64_ret: wasmtime::component::ComponentExportIndex, - list_f32_ret: wasmtime::component::ComponentExportIndex, - list_f64_ret: wasmtime::component::ComponentExportIndex, + list_float32_ret: wasmtime::component::ComponentExportIndex, + list_float64_ret: wasmtime::component::ComponentExportIndex, tuple_list: wasmtime::component::ComponentExportIndex, string_list_arg: wasmtime::component::ComponentExportIndex, string_list_ret: wasmtime::component::ComponentExportIndex, @@ -1399,8 +1399,8 @@ let list_s16_param = lookup("list-s16-param")?; let list_s32_param = lookup("list-s32-param")?; let list_s64_param = lookup("list-s64-param")?; - let list_f32_param = lookup("list-f32-param")?; - let list_f64_param = lookup("list-f64-param")?; + let list_float32_param = lookup("list-float32-param")?; + let list_float64_param = lookup("list-float64-param")?; let list_u8_ret = lookup("list-u8-ret")?; let list_u16_ret = lookup("list-u16-ret")?; let list_u32_ret = lookup("list-u32-ret")?; @@ -1409,8 +1409,8 @@ let list_s16_ret = lookup("list-s16-ret")?; let list_s32_ret = lookup("list-s32-ret")?; let list_s64_ret = lookup("list-s64-ret")?; - let list_f32_ret = lookup("list-f32-ret")?; - let list_f64_ret = lookup("list-f64-ret")?; + let list_float32_ret = lookup("list-float32-ret")?; + let list_float64_ret = lookup("list-float64-ret")?; let tuple_list = lookup("tuple-list")?; let string_list_arg = lookup("string-list-arg")?; let string_list_ret = lookup("string-list-ret")?; @@ -1429,8 +1429,8 @@ list_s16_param, list_s32_param, list_s64_param, - list_f32_param, - list_f64_param, + list_float32_param, + list_float64_param, list_u8_ret, list_u16_ret, list_u32_ret, @@ -1439,8 +1439,8 @@ list_s16_ret, list_s32_ret, list_s64_ret, - list_f32_ret, - list_f64_ret, + list_float32_ret, + list_float64_ret, tuple_list, string_list_arg, string_list_ret, @@ -1508,17 +1508,17 @@ (), >(&mut store, &self.list_s64_param)? .func(); - let list_f32_param = *_instance + let list_float32_param = *_instance .get_typed_func::< (&[f32],), (), - >(&mut store, &self.list_f32_param)? + >(&mut store, &self.list_float32_param)? .func(); - let list_f64_param = *_instance + let list_float64_param = *_instance .get_typed_func::< (&[f64],), (), - >(&mut store, &self.list_f64_param)? + >(&mut store, &self.list_float64_param)? .func(); let list_u8_ret = *_instance .get_typed_func::< @@ -1568,17 +1568,17 @@ (wasmtime::component::__internal::Vec,), >(&mut store, &self.list_s64_ret)? .func(); - let list_f32_ret = *_instance + let list_float32_ret = *_instance .get_typed_func::< (), (wasmtime::component::__internal::Vec,), - >(&mut store, &self.list_f32_ret)? + >(&mut store, &self.list_float32_ret)? .func(); - let list_f64_ret = *_instance + let list_float64_ret = *_instance .get_typed_func::< (), (wasmtime::component::__internal::Vec,), - >(&mut store, &self.list_f64_ret)? + >(&mut store, &self.list_float64_ret)? .func(); let tuple_list = *_instance .get_typed_func::< @@ -1655,8 +1655,8 @@ list_s16_param, list_s32_param, list_s64_param, - list_f32_param, - list_f64_param, + list_float32_param, + list_float64_param, list_u8_ret, list_u16_ret, list_u32_ret, @@ -1665,8 +1665,8 @@ list_s16_ret, list_s32_ret, list_s64_ret, - list_f32_ret, - list_f64_ret, + list_float32_ret, + list_float64_ret, tuple_list, string_list_arg, string_list_ret, @@ -1840,7 +1840,7 @@ callee.post_return_async(store.as_context_mut()).await?; Ok(()) } - pub async fn call_list_f32_param( + pub async fn call_list_float32_param( &self, mut store: S, arg0: &[f32], @@ -1852,7 +1852,7 @@ wasmtime::component::TypedFunc::< (&[f32],), (), - >::new_unchecked(self.list_f32_param) + >::new_unchecked(self.list_float32_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -1860,7 +1860,7 @@ callee.post_return_async(store.as_context_mut()).await?; Ok(()) } - pub async fn call_list_f64_param( + pub async fn call_list_float64_param( &self, mut store: S, arg0: &[f64], @@ -1872,7 +1872,7 @@ wasmtime::component::TypedFunc::< (&[f64],), (), - >::new_unchecked(self.list_f64_param) + >::new_unchecked(self.list_float64_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -2032,7 +2032,7 @@ callee.post_return_async(store.as_context_mut()).await?; Ok(ret0) } - pub async fn call_list_f32_ret( + pub async fn call_list_float32_ret( &self, mut store: S, ) -> wasmtime::Result> @@ -2043,7 +2043,7 @@ wasmtime::component::TypedFunc::< (), (wasmtime::component::__internal::Vec,), - >::new_unchecked(self.list_f32_ret) + >::new_unchecked(self.list_float32_ret) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) @@ -2051,7 +2051,7 @@ callee.post_return_async(store.as_context_mut()).await?; Ok(ret0) } - pub async fn call_list_f64_ret( + pub async fn call_list_float64_ret( &self, mut store: S, ) -> wasmtime::Result> @@ -2062,7 +2062,7 @@ wasmtime::component::TypedFunc::< (), (wasmtime::component::__internal::Vec,), - >::new_unchecked(self.list_f64_ret) + >::new_unchecked(self.list_float64_ret) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) --- a/crates/component-macro/tests/expanded/lists_tracing_async.rs +++ b/crates/component-macro/tests/expanded/lists_tracing_async.rs @@ -407,11 +407,11 @@ &mut self, x: wasmtime::component::__internal::Vec, ) -> (); - async fn list_f32_param( + async fn list_float32_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> (); - async fn list_f64_param( + async fn list_float64_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> (); @@ -439,10 +439,10 @@ async fn list_s64_ret( &mut self, ) -> wasmtime::component::__internal::Vec; - async fn list_f32_ret( + async fn list_float32_ret( &mut self, ) -> wasmtime::component::__internal::Vec; - async fn list_f64_ret( + async fn list_float64_ret( &mut self, ) -> wasmtime::component::__internal::Vec; async fn tuple_list( @@ -746,7 +746,7 @@ }, )?; inst.func_wrap_async( - "list-f32-param", + "list-float32-param", move | mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (wasmtime::component::__internal::Vec,)| @@ -754,7 +754,7 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "lists", function = "list-f32-param", + "lists", function = "list-float32-param", ); wasmtime::component::__internal::Box::new( async move { @@ -763,7 +763,7 @@ "call" ); let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f32_param(host, arg0).await; + let r = Host::list_float32_param(host, arg0).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug(& r), "return" @@ -775,7 +775,7 @@ }, )?; inst.func_wrap_async( - "list-f64-param", + "list-float64-param", move | mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (wasmtime::component::__internal::Vec,)| @@ -783,7 +783,7 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "lists", function = "list-f64-param", + "lists", function = "list-float64-param", ); wasmtime::component::__internal::Box::new( async move { @@ -792,7 +792,7 @@ "call" ); let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f64_param(host, arg0).await; + let r = Host::list_float64_param(host, arg0).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug(& r), "return" @@ -988,18 +988,18 @@ }, )?; inst.func_wrap_async( - "list-f32-ret", + "list-float32-ret", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "lists", function = "list-f32-ret", + "lists", function = "list-float32-ret", ); wasmtime::component::__internal::Box::new( async move { tracing::event!(tracing::Level::TRACE, "call"); let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f32_ret(host).await; + let r = Host::list_float32_ret(host).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug("..."), "return" @@ -1011,18 +1011,18 @@ }, )?; inst.func_wrap_async( - "list-f64-ret", + "list-float64-ret", move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen import", module = - "lists", function = "list-f64-ret", + "lists", function = "list-float64-ret", ); wasmtime::component::__internal::Box::new( async move { tracing::event!(tracing::Level::TRACE, "call"); let host = &mut host_getter(caller.data_mut()); - let r = Host::list_f64_ret(host).await; + let r = Host::list_float64_ret(host).await; tracing::event!( tracing::Level::TRACE, result = tracing::field::debug("..."), "return" @@ -1368,17 +1368,17 @@ ) -> () { Host::list_s64_param(*self, x).await } - async fn list_f32_param( + async fn list_float32_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> () { - Host::list_f32_param(*self, x).await + Host::list_float32_param(*self, x).await } - async fn list_f64_param( + async fn list_float64_param( &mut self, x: wasmtime::component::__internal::Vec, ) -> () { - Host::list_f64_param(*self, x).await + Host::list_float64_param(*self, x).await } async fn list_u8_ret( &mut self, @@ -1420,15 +1420,15 @@ ) -> wasmtime::component::__internal::Vec { Host::list_s64_ret(*self).await } - async fn list_f32_ret( + async fn list_float32_ret( &mut self, ) -> wasmtime::component::__internal::Vec { - Host::list_f32_ret(*self).await + Host::list_float32_ret(*self).await } - async fn list_f64_ret( + async fn list_float64_ret( &mut self, ) -> wasmtime::component::__internal::Vec { - Host::list_f64_ret(*self).await + Host::list_float64_ret(*self).await } async fn tuple_list( &mut self, @@ -1715,8 +1715,8 @@ list_s16_param: wasmtime::component::Func, list_s32_param: wasmtime::component::Func, list_s64_param: wasmtime::component::Func, - list_f32_param: wasmtime::component::Func, - list_f64_param: wasmtime::component::Func, + list_float32_param: wasmtime::component::Func, + list_float64_param: wasmtime::component::Func, list_u8_ret: wasmtime::component::Func, list_u16_ret: wasmtime::component::Func, list_u32_ret: wasmtime::component::Func, @@ -1725,8 +1725,8 @@ list_s16_ret: wasmtime::component::Func, list_s32_ret: wasmtime::component::Func, list_s64_ret: wasmtime::component::Func, - list_f32_ret: wasmtime::component::Func, - list_f64_ret: wasmtime::component::Func, + list_float32_ret: wasmtime::component::Func, + list_float64_ret: wasmtime::component::Func, tuple_list: wasmtime::component::Func, string_list_arg: wasmtime::component::Func, string_list_ret: wasmtime::component::Func, @@ -1747,8 +1747,8 @@ list_s16_param: wasmtime::component::ComponentExportIndex, list_s32_param: wasmtime::component::ComponentExportIndex, list_s64_param: wasmtime::component::ComponentExportIndex, - list_f32_param: wasmtime::component::ComponentExportIndex, - list_f64_param: wasmtime::component::ComponentExportIndex, + list_float32_param: wasmtime::component::ComponentExportIndex, + list_float64_param: wasmtime::component::ComponentExportIndex, list_u8_ret: wasmtime::component::ComponentExportIndex, list_u16_ret: wasmtime::component::ComponentExportIndex, list_u32_ret: wasmtime::component::ComponentExportIndex, @@ -1757,8 +1757,8 @@ list_s16_ret: wasmtime::component::ComponentExportIndex, list_s32_ret: wasmtime::component::ComponentExportIndex, list_s64_ret: wasmtime::component::ComponentExportIndex, - list_f32_ret: wasmtime::component::ComponentExportIndex, - list_f64_ret: wasmtime::component::ComponentExportIndex, + list_float32_ret: wasmtime::component::ComponentExportIndex, + list_float64_ret: wasmtime::component::ComponentExportIndex, tuple_list: wasmtime::component::ComponentExportIndex, string_list_arg: wasmtime::component::ComponentExportIndex, string_list_ret: wasmtime::component::ComponentExportIndex, @@ -1830,8 +1830,8 @@ let list_s16_param = lookup("list-s16-param")?; let list_s32_param = lookup("list-s32-param")?; let list_s64_param = lookup("list-s64-param")?; - let list_f32_param = lookup("list-f32-param")?; - let list_f64_param = lookup("list-f64-param")?; + let list_float32_param = lookup("list-float32-param")?; + let list_float64_param = lookup("list-float64-param")?; let list_u8_ret = lookup("list-u8-ret")?; let list_u16_ret = lookup("list-u16-ret")?; let list_u32_ret = lookup("list-u32-ret")?; @@ -1840,8 +1840,8 @@ let list_s16_ret = lookup("list-s16-ret")?; let list_s32_ret = lookup("list-s32-ret")?; let list_s64_ret = lookup("list-s64-ret")?; - let list_f32_ret = lookup("list-f32-ret")?; - let list_f64_ret = lookup("list-f64-ret")?; + let list_float32_ret = lookup("list-float32-ret")?; + let list_float64_ret = lookup("list-float64-ret")?; let tuple_list = lookup("tuple-list")?; let string_list_arg = lookup("string-list-arg")?; let string_list_ret = lookup("string-list-ret")?; @@ -1860,8 +1860,8 @@ list_s16_param, list_s32_param, list_s64_param, - list_f32_param, - list_f64_param, + list_float32_param, + list_float64_param, list_u8_ret, list_u16_ret, list_u32_ret, @@ -1870,8 +1870,8 @@ list_s16_ret, list_s32_ret, list_s64_ret, - list_f32_ret, - list_f64_ret, + list_float32_ret, + list_float64_ret, tuple_list, string_list_arg, string_list_ret, @@ -1939,17 +1939,17 @@ (), >(&mut store, &self.list_s64_param)? .func(); - let list_f32_param = *_instance + let list_float32_param = *_instance .get_typed_func::< (&[f32],), (), - >(&mut store, &self.list_f32_param)? + >(&mut store, &self.list_float32_param)? .func(); - let list_f64_param = *_instance + let list_float64_param = *_instance .get_typed_func::< (&[f64],), (), - >(&mut store, &self.list_f64_param)? + >(&mut store, &self.list_float64_param)? .func(); let list_u8_ret = *_instance .get_typed_func::< @@ -1999,17 +1999,17 @@ (wasmtime::component::__internal::Vec,), >(&mut store, &self.list_s64_ret)? .func(); - let list_f32_ret = *_instance + let list_float32_ret = *_instance .get_typed_func::< (), (wasmtime::component::__internal::Vec,), - >(&mut store, &self.list_f32_ret)? + >(&mut store, &self.list_float32_ret)? .func(); - let list_f64_ret = *_instance + let list_float64_ret = *_instance .get_typed_func::< (), (wasmtime::component::__internal::Vec,), - >(&mut store, &self.list_f64_ret)? + >(&mut store, &self.list_float64_ret)? .func(); let tuple_list = *_instance .get_typed_func::< @@ -2086,8 +2086,8 @@ list_s16_param, list_s32_param, list_s64_param, - list_f32_param, - list_f64_param, + list_float32_param, + list_float64_param, list_u8_ret, list_u16_ret, list_u32_ret, @@ -2096,8 +2096,8 @@ list_s16_ret, list_s32_ret, list_s64_ret, - list_f32_ret, - list_f64_ret, + list_float32_ret, + list_float64_ret, tuple_list, string_list_arg, string_list_ret, @@ -2343,7 +2343,7 @@ .await?; Ok(()) } - pub async fn call_list_f32_param( + pub async fn call_list_float32_param( &self, mut store: S, arg0: &[f32], @@ -2354,13 +2354,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/lists", function = "list-f32-param", + "foo:foo/lists", function = "list-float32-param", ); let callee = unsafe { wasmtime::component::TypedFunc::< (&[f32],), (), - >::new_unchecked(self.list_f32_param) + >::new_unchecked(self.list_float32_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -2372,7 +2372,7 @@ .await?; Ok(()) } - pub async fn call_list_f64_param( + pub async fn call_list_float64_param( &self, mut store: S, arg0: &[f64], @@ -2383,13 +2383,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/lists", function = "list-f64-param", + "foo:foo/lists", function = "list-float64-param", ); let callee = unsafe { wasmtime::component::TypedFunc::< (&[f64],), (), - >::new_unchecked(self.list_f64_param) + >::new_unchecked(self.list_float64_param) }; let () = callee .call_async(store.as_context_mut(), (arg0,)) @@ -2625,7 +2625,7 @@ .await?; Ok(ret0) } - pub async fn call_list_f32_ret( + pub async fn call_list_float32_ret( &self, mut store: S, ) -> wasmtime::Result> @@ -2635,13 +2635,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/lists", function = "list-f32-ret", + "foo:foo/lists", function = "list-float32-ret", ); let callee = unsafe { wasmtime::component::TypedFunc::< (), (wasmtime::component::__internal::Vec,), - >::new_unchecked(self.list_f32_ret) + >::new_unchecked(self.list_float32_ret) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) @@ -2653,7 +2653,7 @@ .await?; Ok(ret0) } - pub async fn call_list_f64_ret( + pub async fn call_list_float64_ret( &self, mut store: S, ) -> wasmtime::Result> @@ -2663,13 +2663,13 @@ use tracing::Instrument; let span = tracing::span!( tracing::Level::TRACE, "wit-bindgen export", module = - "foo:foo/lists", function = "list-f64-ret", + "foo:foo/lists", function = "list-float64-ret", ); let callee = unsafe { wasmtime::component::TypedFunc::< (), (wasmtime::component::__internal::Vec,), - >::new_unchecked(self.list_f64_ret) + >::new_unchecked(self.list_float64_ret) }; let (ret0,) = callee .call_async(store.as_context_mut(), ()) --- a/crates/environ/src/compile/module_types.rs +++ b/crates/environ/src/compile/module_types.rs @@ -404,9 +404,6 @@ wasmparser::CompositeInnerType::Struct(_) => { WasmHeapType::ConcreteStruct(index) } - wasmparser::CompositeInnerType::Cont(_) => { - panic!("unimplemented continuation types") - } } } else { panic!("forward reference to type outside of rec group?") @@ -447,9 +444,6 @@ wasmparser::CompositeInnerType::Struct(_) => { WasmHeapType::ConcreteStruct(index) } - wasmparser::CompositeInnerType::Cont(_) => { - panic!("unimplemented continuation types") - } } } else { panic!("forward reference to type outside of rec group?") --- a/crates/environ/src/component/translate.rs +++ b/crates/environ/src/component/translate.rs @@ -522,11 +522,6 @@ core_func_index += 1; LocalInitializer::ResourceRep(resource, ty) } - - wasmparser::CanonicalFunction::ThreadSpawn { .. } - | wasmparser::CanonicalFunction::ThreadHwConcurrency => { - bail!("unsupported intrinsic") - } }; self.result.initializers.push(init); } --- a/crates/environ/src/fact/core_types.rs +++ b/crates/environ/src/fact/core_types.rs @@ -18,7 +18,6 @@ .or_insert_with(|| { let idx = self.section.len(); self.section - .ty() .function(params.iter().copied(), results.iter().copied()); idx }) --- a/crates/fuzzing/src/generators/single_inst_module.rs +++ b/crates/fuzzing/src/generators/single_inst_module.rs @@ -57,7 +57,7 @@ // Encode the type section. let mut types = TypeSection::new(); - types.ty().function( + types.function( self.parameters.iter().cloned(), self.results.iter().cloned(), ); @@ -589,12 +589,12 @@ wat, r#"(module (type (;0;) (func (param i32 i32) (result i32))) - (export "test" (func 0)) (func (;0;) (type 0) (param i32 i32) (result i32) local.get 0 local.get 1 i32.add ) + (export "test" (func 0)) ) "# ) --- a/crates/fuzzing/src/generators/stacks.rs +++ b/crates/fuzzing/src/generators/stacks.rs @@ -110,23 +110,19 @@ let mut types = wasm_encoder::TypeSection::new(); let run_type = types.len(); - types - .ty() - .function(vec![wasm_encoder::ValType::I32], vec![]); + types.function(vec![wasm_encoder::ValType::I32], vec![]); let get_stack_type = types.len(); - types.ty().function( + types.function( vec![], vec![wasm_encoder::ValType::I32, wasm_encoder::ValType::I32], ); let null_type = types.len(); - types.ty().function(vec![], vec![]); + types.function(vec![], vec![]); let call_func_type = types.len(); - types - .ty() - .function(vec![wasm_encoder::ValType::FUNCREF], vec![]); + types.function(vec![wasm_encoder::ValType::FUNCREF], vec![]); section(&mut module, types); @@ -197,9 +193,7 @@ let mut elems = wasm_encoder::ElementSection::new(); elems.declared(wasm_encoder::Elements::Functions( - (0..num_imported_funcs + u32::try_from(self.funcs.len()).unwrap()) - .collect::>() - .into(), + &(0..num_imported_funcs + u32::try_from(self.funcs.len()).unwrap()).collect::>(), )); section(&mut module, elems); --- a/crates/fuzzing/src/generators/table_ops.rs +++ b/crates/fuzzing/src/generators/table_ops.rs @@ -42,7 +42,7 @@ let mut types = TypeSection::new(); // 0: "gc" - types.ty().function( + types.function( vec![], // Return a bunch of stuff from `gc` so that we exercise GCing when // there is return pointer space allocated on the stack. This is @@ -59,16 +59,16 @@ params.push(ValType::EXTERNREF); } let results = vec![]; - types.ty().function(params, results); + types.function(params, results); // 2: `take_refs` - types.ty().function( + types.function( vec![ValType::EXTERNREF, ValType::EXTERNREF, ValType::EXTERNREF], vec![], ); // 3: `make_refs` - types.ty().function( + types.function( vec![], vec![ValType::EXTERNREF, ValType::EXTERNREF, ValType::EXTERNREF], ); @@ -322,18 +322,6 @@ (import "" "gc" (func (;0;) (type 0))) (import "" "take_refs" (func (;1;) (type 2))) (import "" "make_refs" (func (;2;) (type 3))) - (table (;0;) 20 externref) - (global (;0;) (mut externref) ref.null extern) - (global (;1;) (mut externref) ref.null extern) - (global (;2;) (mut externref) ref.null extern) - (global (;3;) (mut externref) ref.null extern) - (global (;4;) (mut externref) ref.null extern) - (global (;5;) (mut externref) ref.null extern) - (global (;6;) (mut externref) ref.null extern) - (global (;7;) (mut externref) ref.null extern) - (global (;8;) (mut externref) ref.null extern) - (global (;9;) (mut externref) ref.null extern) - (export "run" (func 3)) (func (;3;) (type 1) (param externref externref externref externref externref externref externref externref externref externref) (local externref) loop ;; label = @1 @@ -355,6 +343,18 @@ br 0 (;@1;) end ) + (table (;0;) 20 externref) + (global (;0;) (mut externref) ref.null extern) + (global (;1;) (mut externref) ref.null extern) + (global (;2;) (mut externref) ref.null extern) + (global (;3;) (mut externref) ref.null extern) + (global (;4;) (mut externref) ref.null extern) + (global (;5;) (mut externref) ref.null extern) + (global (;6;) (mut externref) ref.null extern) + (global (;7;) (mut externref) ref.null extern) + (global (;8;) (mut externref) ref.null extern) + (global (;9;) (mut externref) ref.null extern) + (export "run" (func 3)) ) "#; eprintln!("expected WAT = {expected}"); --- a/crates/fuzzing/src/oracles/memory.rs +++ b/crates/fuzzing/src/oracles/memory.rs @@ -259,12 +259,8 @@ { let mut types = wasm_encoder::TypeSection::new(); - types - .ty() - .function([wasm_encoder::ValType::I64], [wasm_encoder::ValType::I32]); - types - .ty() - .function([wasm_encoder::ValType::I64], [wasm_encoder::ValType::I64]); + types.function([wasm_encoder::ValType::I64], [wasm_encoder::ValType::I32]); + types.function([wasm_encoder::ValType::I64], [wasm_encoder::ValType::I64]); module.section(&types); } --- a/crates/fuzzing/src/single_module_fuzzer.rs +++ b/crates/fuzzing/src/single_module_fuzzer.rs @@ -300,7 +300,7 @@ // should have been the same. let mut rng = SmallRng::seed_from_u64(0); - let max_size = 4096; + let max_size = 2048; let seed_size = 128; let mut buf = vec![0; max_size]; let mut compares = 0; --- a/crates/wasi-preview1-component-adapter/build.rs +++ b/crates/wasi-preview1-component-adapter/build.rs @@ -74,8 +74,8 @@ let mut module = Module::new(); let mut types = TypeSection::new(); - types.ty().function([], [ValType::I32]); - types.ty().function([ValType::I32], []); + types.function([], [ValType::I32]); + types.function([ValType::I32], []); module.section(&types); // Declare the functions, using the type we just added. --- a/crates/wasmtime/src/engine/serialization.rs +++ b/crates/wasmtime/src/engine/serialization.rs @@ -234,7 +234,6 @@ component_model_multiple_returns, legacy_exceptions, gc_types, - stack_switching, // Always on; we don't currently have knobs for these. mutable_global: _, @@ -251,7 +250,6 @@ assert!(!component_model_nested_names); assert!(!shared_everything_threads); assert!(!legacy_exceptions); - assert!(!stack_switching); Metadata { target: engine.compiler().triple().to_string(), --- a/crates/wast/src/wast.rs +++ b/crates/wast/src/wast.rs @@ -599,10 +599,6 @@ .join() .unwrap()?; } - - AssertSuspension { .. } => { - bail!("unimplemented wast directive"); - } } Ok(()) --- a/examples/component/convert.wit +++ b/examples/component/convert.wit @@ -4,8 +4,8 @@ /// This interface needs to be provided by the host import host: interface { /// Example function that does a simple a × b operation - multiply: func(a: f32, b: f32) -> f32; + multiply: func(a: float32, b: float32) -> float32; } /// Exported function for computing: (°C × 9/5) + 32 = °F - export convert-celsius-to-fahrenheit: func(x: f32) -> f32; + export convert-celsius-to-fahrenheit: func(x: float32) -> float32; } --- a/supply-chain/imports.lock +++ b/supply-chain/imports.lock @@ -1916,12 +1916,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wasm-encoder]] -version = "0.218.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.wasm-metadata]] version = "0.214.0" when = "2024-07-16" @@ -1946,12 +1940,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wasm-metadata]] -version = "0.218.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.wasmparser]] version = "0.214.0" when = "2024-07-16" @@ -1976,12 +1964,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wasmparser]] -version = "0.218.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.wasmprinter]] version = "0.214.0" when = "2024-07-16" @@ -2006,12 +1988,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wasmprinter]] -version = "0.218.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.wasmtime]] version = "23.0.1" when = "2024-07-22" @@ -2456,12 +2432,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wast]] -version = "218.0.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.wat]] version = "1.214.0" when = "2024-07-16" @@ -2486,12 +2456,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wat]] -version = "1.218.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.wiggle]] version = "23.0.1" when = "2024-07-22" @@ -3019,12 +2983,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wit-component]] -version = "0.218.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.wit-parser]] version = "0.214.0" when = "2024-07-16" @@ -3049,12 +3007,6 @@ user-id = 73222 user-login = "wasmtime-publish" -[[publisher.wit-parser]] -version = "0.218.0" -when = "2024-09-30" -user-id = 73222 -user-login = "wasmtime-publish" - [[publisher.witx]] version = "0.9.1" when = "2021-06-22" --- a/tests/all/component_model/bindgen/results.rs +++ b/tests/all/component_model/bindgen/results.rs @@ -12,10 +12,10 @@ package inline:inline; world result-playground { import imports: interface { - empty-error: func(a: f64) -> result; + empty-error: func(a: float64) -> result; } - export empty-error: func(a: f64) -> result; + export empty-error: func(a: float64) -> result; }", trappable_imports: true, }); @@ -28,7 +28,7 @@ r#" (component (import "imports" (instance $i - (export "empty-error" (func (param "a" f64) (result (result f64)))) + (export "empty-error" (func (param "a" float64) (result (result float64)))) )) (core module $libc (memory (export "memory") 1) @@ -51,8 +51,8 @@ )) (func $f_empty_error (export "empty-error") - (param "a" f64) - (result (result f64)) + (param "a" float64) + (result (result float64)) (canon lift (core func $i "core_empty_error_export") (memory $libc "memory")) ) ) @@ -114,10 +114,10 @@ package inline:inline; world result-playground { import imports: interface { - string-error: func(a: f64) -> result; + string-error: func(a: float64) -> result; } - export string-error: func(a: f64) -> result; + export string-error: func(a: float64) -> result; }", trappable_imports: true, }); @@ -131,7 +131,7 @@ r#" (component (import "imports" (instance $i - (export "string-error" (func (param "a" f64) (result (result f64 (error string))))) + (export "string-error" (func (param "a" float64) (result (result float64 (error string))))) )) (core module $libc (memory (export "memory") 1) @@ -163,8 +163,8 @@ )) (func $f_string_error (export "string-error") - (param "a" f64) - (result (result f64 (error string))) + (param "a" float64) + (result (result float64 (error string))) (canon lift (core func $i "core_string_error_export") (memory $libc "memory")) ) ) @@ -231,13 +231,13 @@ package inline:inline; interface imports { enum e1 { a, b, c } - enum-error: func(a: f64) -> result; + enum-error: func(a: float64) -> result; } world result-playground { import imports; export foo: interface { enum e1 { a, b, c } - enum-error: func(a: f64) -> result; + enum-error: func(a: float64) -> result; } }", trappable_error_type: { "inline:inline/imports/e1" => TrappableE1 }, @@ -288,7 +288,7 @@ (type $err' (enum "a" "b" "c")) (import (interface "inline:inline/imports") (instance $i (export $err "err" (type (eq $err'))) - (export "enum-error" (func (param "a" f64) (result (result f64 (error $err))))) + (export "enum-error" (func (param "a" float64) (result (result float64 (error $err))))) )) (core module $libc (memory (export "memory") 1) @@ -319,16 +319,16 @@ (with "libc" (instance $libc)) )) (func $f_enum_error - (param "a" f64) - (result (result f64 (error $err'))) + (param "a" float64) + (result (result float64 (error $err'))) (canon lift (core func $i "core_enum_error_export") (memory $libc "memory")) ) (component $nested (import "f-err" (type $err (eq $err'))) - (import "f" (func $f (param "a" f64) (result (result f64 (error $err))))) + (import "f" (func $f (param "a" float64) (result (result float64 (error $err))))) (export $err2 "err" (type $err')) - (export "enum-error" (func $f) (func (param "a" f64) (result (result f64 (error $err2))))) + (export "enum-error" (func $f) (func (param "a" float64) (result (result float64 (error $err2))))) ) (instance $n (instantiate $nested @@ -412,13 +412,13 @@ package inline:inline; interface imports { record e2 { line: u32, col: u32 } - record-error: func(a: f64) -> result; + record-error: func(a: float64) -> result; } world result-playground { import imports; export foo: interface { record e2 { line: u32, col: u32 } - record-error: func(a: f64) -> result; + record-error: func(a: float64) -> result; } }", trappable_error_type: { "inline:inline/imports/e2" => TrappableE2 }, @@ -450,8 +450,8 @@ )) (import (interface "inline:inline/imports") (instance $i (export $e2 "e2" (type (eq $e2'))) - (type $result (result f64 (error $e2))) - (export "record-error" (func (param "a" f64) (result $result))) + (type $result (result float64 (error $e2))) + (export "record-error" (func (param "a" float64) (result $result))) )) (core module $libc (memory (export "memory") 1) @@ -482,16 +482,16 @@ (with "libc" (instance $libc)) )) (func $f_record_error - (param "a" f64) - (result (result f64 (error (record (field "line" u32) (field "col" u32))))) + (param "a" float64) + (result (result float64 (error (record (field "line" u32) (field "col" u32))))) (canon lift (core func $i "core_record_error_export") (memory $libc "memory")) ) (component $nested (import "f-e2" (type $f-e2 (eq $e2'))) - (import "f" (func $f (param "a" f64) (result (result f64 (error $f-e2))))) + (import "f" (func $f (param "a" float64) (result (result float64 (error $f-e2))))) (export $e2 "e2" (type $e2')) - (export "record-error" (func $f) (func (param "a" f64) (result (result f64 (error $e2))))) + (export "record-error" (func $f) (func (param "a" float64) (result (result float64 (error $e2))))) ) (instance (export "foo") (instantiate $nested @@ -582,7 +582,7 @@ enum e1 { a, b, c } record e2 { line: u32, col: u32 } variant e3 { E1(e1), E2(e2) } - variant-error: func(a: f64) -> result; + variant-error: func(a: float64) -> result; } world result-playground { import imports; @@ -590,7 +590,7 @@ enum e1 { a, b, c } record e2 { line: u32, col: u32 } variant e3 { E1(e1), E2(e2) } - variant-error: func(a: f64) -> result; + variant-error: func(a: float64) -> result; } }", trappable_error_type: { "inline:inline/imports/e3" => TrappableE3 }, @@ -630,8 +630,8 @@ (case "E2" $e2) )) (export $e3 "e3" (type (eq $e3'))) - (type $result (result f64 (error $e3))) - (export "variant-error" (func (param "a" f64) (result $result))) + (type $result (result float64 (error $e3))) + (export "variant-error" (func (param "a" float64) (result $result))) )) (core module $libc (memory (export "memory") 1) @@ -662,8 +662,8 @@ (with "libc" (instance $libc)) )) (func $f_variant_error - (param "a" f64) - (result (result f64 (error $e3'))) + (param "a" float64) + (result (result float64 (error $e3'))) (canon lift (core func $i "core_variant_error_export") (memory $libc "memory")) ) @@ -675,7 +675,7 @@ (case "E2" $e2i) )) (import "f-e3" (type $e3i (eq $e3i'))) - (import "f" (func $f (param "a" f64) (result (result f64 (error $e3i))))) + (import "f" (func $f (param "a" float64) (result (result float64 (error $e3i))))) (export $e1 "e1" (type $e1')) (export $e2 "e2" (type $e2')) (type $e3' (variant @@ -684,7 +684,7 @@ )) (export $e3 "e3" (type $e3')) (export "variant-error" (func $f) - (func (param "a" f64) (result (result f64 (error $e3))))) + (func (param "a" float64) (result (result float64 (error $e3))))) ) (instance (export "foo") (instantiate $nested @@ -776,17 +776,17 @@ package inline:inline; interface types { enum e1 { a, b, c } - enum-error: func(a: f64) -> result; + enum-error: func(a: float64) -> result; } interface imports { use types.{e1}; - enum-error: func(a: f64) -> result; + enum-error: func(a: float64) -> result; } world result-playground { import imports; export foo: interface { enum e1 { a, b, c } - enum-error: func(a: f64) -> result; + enum-error: func(a: float64) -> result; } }", trappable_error_type: { "inline:inline/types/e1" => TrappableE1 }, @@ -817,7 +817,7 @@ (type $err' (enum "a" "b" "c")) (import (interface "inline:inline/imports") (instance $i (export $e1 "e1" (type (eq $err'))) - (export "enum-error" (func (param "a" f64) (result (result f64 (error $e1))))) + (export "enum-error" (func (param "a" float64) (result (result float64 (error $e1))))) )) (core module $libc (memory (export "memory") 1) @@ -848,16 +848,16 @@ (with "libc" (instance $libc)) )) (func $f_enum_error - (param "a" f64) - (result (result f64 (error $err'))) + (param "a" float64) + (result (result float64 (error $err'))) (canon lift (core func $i "core_enum_error_export") (memory $libc "memory")) ) (component $nested (import "f-err" (type $err (eq $err'))) - (import "f" (func $f (param "a" f64) (result (result f64 (error $err))))) + (import "f" (func $f (param "a" float64) (result (result float64 (error $err))))) (export $err2 "err" (type $err')) - (export "enum-error" (func $f) (func (param "a" f64) (result (result f64 (error $err2))))) + (export "enum-error" (func $f) (func (param "a" float64) (result (result float64 (error $err2))))) ) (instance $n (instantiate $nested @@ -971,7 +971,7 @@ wasmtime::component::bindgen!({ interfaces: " import imports: interface { - empty-error: func(a: f64) -> result; + empty-error: func(a: float64) -> result; }", trappable_imports: true, }); @@ -982,10 +982,10 @@ package inline:inline; world result-playground { import imports: interface { - empty-error: func(a: f64) -> result; + empty-error: func(a: float64) -> result; } - export empty-error: func(a: f64) -> result; + export empty-error: func(a: float64) -> result; }", with: { "imports": interfaces::imports, @@ -1001,7 +1001,7 @@ r#" (component (import "imports" (instance $i - (export "empty-error" (func (param "a" f64) (result (result f64)))) + (export "empty-error" (func (param "a" float64) (result (result float64)))) )) (core module $libc (memory (export "memory") 1) @@ -1024,8 +1024,8 @@ )) (func $f_empty_error (export "empty-error") - (param "a" f64) - (result (result f64)) + (param "a" float64) + (result (result float64)) (canon lift (core func $i "core_empty_error_export") (memory $libc "memory")) ) ) --- a/winch/codegen/src/codegen/mod.rs +++ b/winch/codegen/src/codegen/mod.rs @@ -246,7 +246,7 @@ struct ValidateThenVisit<'a, T, U>(T, &'a mut U, usize); macro_rules! validate_then_visit { - ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident $ann:tt)*) => { + ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => { $( fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output { self.0.$visit($($($arg.clone()),*)?)?; --- a/winch/codegen/src/visitor.rs +++ b/winch/codegen/src/visitor.rs @@ -28,7 +28,7 @@ /// 2. Defines the visitor function and panics when /// matching an unsupported operator. macro_rules! def_unsupported { - ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident $ann:tt)*) => { + ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => { $( def_unsupported!( emit --- a/crates/cranelift/src/translate/code_translator.rs +++ b/crates/cranelift/src/translate/code_translator.rs @@ -2776,17 +2776,6 @@ "shared-everything-threads operators are not yet implemented" )); } - - Operator::ContNew { .. } - | Operator::ContBind { .. } - | Operator::Suspend { .. } - | Operator::Resume { .. } - | Operator::ResumeThrow { .. } - | Operator::Switch { .. } => { - return Err(wasm_unsupported!( - "stack-switching operators are not yet implemented" - )); - } }; Ok(()) } --- a/crates/environ/src/types.rs +++ b/crates/environ/src/types.rs @@ -1805,9 +1805,6 @@ wasmparser::CompositeInnerType::Struct(s) => { WasmCompositeType::Struct(self.convert_struct_type(s)) } - wasmparser::CompositeInnerType::Cont(_) => { - unimplemented!("continuation types") - } } } @@ -1891,10 +1888,7 @@ wasmparser::AbstractHeapType::Struct => WasmHeapType::Struct, wasmparser::AbstractHeapType::None => WasmHeapType::None, - wasmparser::AbstractHeapType::Exn - | wasmparser::AbstractHeapType::NoExn - | wasmparser::AbstractHeapType::Cont - | wasmparser::AbstractHeapType::NoCont => { + wasmparser::AbstractHeapType::Exn | wasmparser::AbstractHeapType::NoExn => { unimplemented!("unsupported heap type {ty:?}"); } },