1 /// Auto-generated bindings for a pre-instantiated version of a 2 /// component which implements the world `the-world`. 3 /// 4 /// This structure is created through [`TheWorldPre::new`] which 5 /// takes a [`InstancePre`](wasmtime::component::InstancePre) that 6 /// has been created through a [`Linker`](wasmtime::component::Linker). 7 /// 8 /// For more information see [`TheWorld`] as well. 9 pub struct TheWorldPre<T: 'static> { 10 instance_pre: wasmtime::component::InstancePre<T>, 11 indices: TheWorldIndices, 12 } 13 impl<T: 'static> Clone for TheWorldPre<T> { 14 fn clone(&self) -> Self { 15 Self { 16 instance_pre: self.instance_pre.clone(), 17 indices: self.indices.clone(), 18 } 19 } 20 } 21 impl<_T: 'static> TheWorldPre<_T> { 22 /// Creates a new copy of `TheWorldPre` bindings which can then 23 /// be used to instantiate into a particular store. 24 /// 25 /// This method may fail if the component behind `instance_pre` 26 /// does not have the required exports. 27 pub fn new( 28 instance_pre: wasmtime::component::InstancePre<_T>, 29 ) -> wasmtime::Result<Self> { 30 let indices = TheWorldIndices::new(&instance_pre)?; 31 Ok(Self { instance_pre, indices }) 32 } 33 pub fn engine(&self) -> &wasmtime::Engine { 34 self.instance_pre.engine() 35 } 36 pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> { 37 &self.instance_pre 38 } 39 /// Instantiates a new instance of [`TheWorld`] within the 40 /// `store` provided. 41 /// 42 /// This function will use `self` as the pre-instantiated 43 /// instance to perform instantiation. Afterwards the preloaded 44 /// indices in `self` are used to lookup all exports on the 45 /// resulting instance. 46 pub fn instantiate( 47 &self, 48 mut store: impl wasmtime::AsContextMut<Data = _T>, 49 ) -> wasmtime::Result<TheWorld> { 50 let mut store = store.as_context_mut(); 51 let instance = self.instance_pre.instantiate(&mut store)?; 52 self.indices.load(&mut store, &instance) 53 } 54 } 55 impl<_T: Send + 'static> TheWorldPre<_T> { 56 /// Same as [`Self::instantiate`], except with `async`. 57 pub async fn instantiate_async( 58 &self, 59 mut store: impl wasmtime::AsContextMut<Data = _T>, 60 ) -> wasmtime::Result<TheWorld> { 61 let mut store = store.as_context_mut(); 62 let instance = self.instance_pre.instantiate_async(&mut store).await?; 63 self.indices.load(&mut store, &instance) 64 } 65 } 66 /// Auto-generated bindings for index of the exports of 67 /// `the-world`. 68 /// 69 /// This is an implementation detail of [`TheWorldPre`] and can 70 /// be constructed if needed as well. 71 /// 72 /// For more information see [`TheWorld`] as well. 73 #[derive(Clone)] 74 pub struct TheWorldIndices { 75 interface0: exports::foo::foo::strings::GuestIndices, 76 } 77 /// Auto-generated bindings for an instance a component which 78 /// implements the world `the-world`. 79 /// 80 /// This structure can be created through a number of means 81 /// depending on your requirements and what you have on hand: 82 /// 83 /// * The most convenient way is to use 84 /// [`TheWorld::instantiate`] which only needs a 85 /// [`Store`], [`Component`], and [`Linker`]. 86 /// 87 /// * Alternatively you can create a [`TheWorldPre`] ahead of 88 /// time with a [`Component`] to front-load string lookups 89 /// of exports once instead of per-instantiation. This 90 /// method then uses [`TheWorldPre::instantiate`] to 91 /// create a [`TheWorld`]. 92 /// 93 /// * If you've instantiated the instance yourself already 94 /// then you can use [`TheWorld::new`]. 95 /// 96 /// These methods are all equivalent to one another and move 97 /// around the tradeoff of what work is performed when. 98 /// 99 /// [`Store`]: wasmtime::Store 100 /// [`Component`]: wasmtime::component::Component 101 /// [`Linker`]: wasmtime::component::Linker 102 pub struct TheWorld { 103 interface0: exports::foo::foo::strings::Guest, 104 } 105 const _: () = { 106 #[allow(unused_imports)] 107 use wasmtime::component::__internal::anyhow; 108 impl TheWorldIndices { 109 /// Creates a new copy of `TheWorldIndices` bindings which can then 110 /// be used to instantiate into a particular store. 111 /// 112 /// This method may fail if the component does not have the 113 /// required exports. 114 pub fn new<_T>( 115 _instance_pre: &wasmtime::component::InstancePre<_T>, 116 ) -> wasmtime::Result<Self> { 117 let _component = _instance_pre.component(); 118 let _instance_type = _instance_pre.instance_type(); 119 let interface0 = exports::foo::foo::strings::GuestIndices::new( 120 _instance_pre, 121 )?; 122 Ok(TheWorldIndices { interface0 }) 123 } 124 /// Uses the indices stored in `self` to load an instance 125 /// of [`TheWorld`] from the instance provided. 126 /// 127 /// Note that at this time this method will additionally 128 /// perform type-checks of all exports. 129 pub fn load( 130 &self, 131 mut store: impl wasmtime::AsContextMut, 132 instance: &wasmtime::component::Instance, 133 ) -> wasmtime::Result<TheWorld> { 134 let _ = &mut store; 135 let _instance = instance; 136 let interface0 = self.interface0.load(&mut store, &_instance)?; 137 Ok(TheWorld { interface0 }) 138 } 139 } 140 impl TheWorld { 141 /// Convenience wrapper around [`TheWorldPre::new`] and 142 /// [`TheWorldPre::instantiate`]. 143 pub fn instantiate<_T>( 144 store: impl wasmtime::AsContextMut<Data = _T>, 145 component: &wasmtime::component::Component, 146 linker: &wasmtime::component::Linker<_T>, 147 ) -> wasmtime::Result<TheWorld> { 148 let pre = linker.instantiate_pre(component)?; 149 TheWorldPre::new(pre)?.instantiate(store) 150 } 151 /// Convenience wrapper around [`TheWorldIndices::new`] and 152 /// [`TheWorldIndices::load`]. 153 pub fn new( 154 mut store: impl wasmtime::AsContextMut, 155 instance: &wasmtime::component::Instance, 156 ) -> wasmtime::Result<TheWorld> { 157 let indices = TheWorldIndices::new(&instance.instance_pre(&store))?; 158 indices.load(&mut store, instance) 159 } 160 /// Convenience wrapper around [`TheWorldPre::new`] and 161 /// [`TheWorldPre::instantiate_async`]. 162 pub async fn instantiate_async<_T>( 163 store: impl wasmtime::AsContextMut<Data = _T>, 164 component: &wasmtime::component::Component, 165 linker: &wasmtime::component::Linker<_T>, 166 ) -> wasmtime::Result<TheWorld> 167 where 168 _T: Send, 169 { 170 let pre = linker.instantiate_pre(component)?; 171 TheWorldPre::new(pre)?.instantiate_async(store).await 172 } 173 pub fn add_to_linker<T, D>( 174 linker: &mut wasmtime::component::Linker<T>, 175 host_getter: fn(&mut T) -> D::Data<'_>, 176 ) -> wasmtime::Result<()> 177 where 178 D: foo::foo::strings::HostWithStore + Send, 179 for<'a> D::Data<'a>: foo::foo::strings::Host + Send, 180 T: 'static + Send, 181 { 182 foo::foo::strings::add_to_linker::<T, D>(linker, host_getter)?; 183 Ok(()) 184 } 185 pub fn foo_foo_strings(&self) -> &exports::foo::foo::strings::Guest { 186 &self.interface0 187 } 188 } 189 }; 190 pub mod foo { 191 pub mod foo { 192 #[allow(clippy::all)] 193 pub mod strings { 194 #[allow(unused_imports)] 195 use wasmtime::component::__internal::{anyhow, Box}; 196 pub trait HostWithStore: wasmtime::component::HasData + Send {} 197 impl<_T: ?Sized> HostWithStore for _T 198 where 199 _T: wasmtime::component::HasData + Send, 200 {} 201 pub trait Host: Send { 202 fn a( 203 &mut self, 204 x: wasmtime::component::__internal::String, 205 ) -> impl ::core::future::Future<Output = ()> + Send; 206 fn b( 207 &mut self, 208 ) -> impl ::core::future::Future< 209 Output = wasmtime::component::__internal::String, 210 > + Send; 211 fn c( 212 &mut self, 213 a: wasmtime::component::__internal::String, 214 b: wasmtime::component::__internal::String, 215 ) -> impl ::core::future::Future< 216 Output = wasmtime::component::__internal::String, 217 > + Send; 218 } 219 impl<_T: Host + ?Sized + Send> Host for &mut _T { 220 fn a( 221 &mut self, 222 x: wasmtime::component::__internal::String, 223 ) -> impl ::core::future::Future<Output = ()> + Send { 224 async move { Host::a(*self, x).await } 225 } 226 fn b( 227 &mut self, 228 ) -> impl ::core::future::Future< 229 Output = wasmtime::component::__internal::String, 230 > + Send { 231 async move { Host::b(*self).await } 232 } 233 fn c( 234 &mut self, 235 a: wasmtime::component::__internal::String, 236 b: wasmtime::component::__internal::String, 237 ) -> impl ::core::future::Future< 238 Output = wasmtime::component::__internal::String, 239 > + Send { 240 async move { Host::c(*self, a, b).await } 241 } 242 } 243 pub fn add_to_linker<T, D>( 244 linker: &mut wasmtime::component::Linker<T>, 245 host_getter: fn(&mut T) -> D::Data<'_>, 246 ) -> wasmtime::Result<()> 247 where 248 D: HostWithStore, 249 for<'a> D::Data<'a>: Host, 250 T: 'static + Send, 251 { 252 let mut inst = linker.instance("foo:foo/strings")?; 253 inst.func_wrap_async( 254 "a", 255 move | 256 mut caller: wasmtime::StoreContextMut<'_, T>, 257 (arg0,): (wasmtime::component::__internal::String,)| 258 { 259 wasmtime::component::__internal::Box::new(async move { 260 let host = &mut host_getter(caller.data_mut()); 261 let r = Host::a(host, arg0).await; 262 Ok(r) 263 }) 264 }, 265 )?; 266 inst.func_wrap_async( 267 "b", 268 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 269 wasmtime::component::__internal::Box::new(async move { 270 let host = &mut host_getter(caller.data_mut()); 271 let r = Host::b(host).await; 272 Ok((r,)) 273 }) 274 }, 275 )?; 276 inst.func_wrap_async( 277 "c", 278 move | 279 mut caller: wasmtime::StoreContextMut<'_, T>, 280 ( 281 arg0, 282 arg1, 283 ): ( 284 wasmtime::component::__internal::String, 285 wasmtime::component::__internal::String, 286 )| 287 { 288 wasmtime::component::__internal::Box::new(async move { 289 let host = &mut host_getter(caller.data_mut()); 290 let r = Host::c(host, arg0, arg1).await; 291 Ok((r,)) 292 }) 293 }, 294 )?; 295 Ok(()) 296 } 297 } 298 } 299 } 300 pub mod exports { 301 pub mod foo { 302 pub mod foo { 303 #[allow(clippy::all)] 304 pub mod strings { 305 #[allow(unused_imports)] 306 use wasmtime::component::__internal::{anyhow, Box}; 307 #[derive(Clone)] 308 pub struct Guest { 309 a: wasmtime::component::Func, 310 b: wasmtime::component::Func, 311 c: wasmtime::component::Func, 312 } 313 #[derive(Clone)] 314 pub struct GuestIndices { 315 a: wasmtime::component::ComponentExportIndex, 316 b: wasmtime::component::ComponentExportIndex, 317 c: wasmtime::component::ComponentExportIndex, 318 } 319 impl GuestIndices { 320 /// Constructor for [`GuestIndices`] which takes a 321 /// [`Component`](wasmtime::component::Component) as input and can be executed 322 /// before instantiation. 323 /// 324 /// This constructor can be used to front-load string lookups to find exports 325 /// within a component. 326 pub fn new<_T>( 327 _instance_pre: &wasmtime::component::InstancePre<_T>, 328 ) -> wasmtime::Result<GuestIndices> { 329 let instance = _instance_pre 330 .component() 331 .get_export_index(None, "foo:foo/strings") 332 .ok_or_else(|| { 333 anyhow::anyhow!( 334 "no exported instance named `foo:foo/strings`" 335 ) 336 })?; 337 let mut lookup = move |name| { 338 _instance_pre 339 .component() 340 .get_export_index(Some(&instance), name) 341 .ok_or_else(|| { 342 anyhow::anyhow!( 343 "instance export `foo:foo/strings` does \ 344 not have export `{name}`" 345 ) 346 }) 347 }; 348 let _ = &mut lookup; 349 let a = lookup("a")?; 350 let b = lookup("b")?; 351 let c = lookup("c")?; 352 Ok(GuestIndices { a, b, c }) 353 } 354 pub fn load( 355 &self, 356 mut store: impl wasmtime::AsContextMut, 357 instance: &wasmtime::component::Instance, 358 ) -> wasmtime::Result<Guest> { 359 let _instance = instance; 360 let _instance_pre = _instance.instance_pre(&store); 361 let _instance_type = _instance_pre.instance_type(); 362 let mut store = store.as_context_mut(); 363 let _ = &mut store; 364 let a = *_instance 365 .get_typed_func::<(&str,), ()>(&mut store, &self.a)? 366 .func(); 367 let b = *_instance 368 .get_typed_func::< 369 (), 370 (wasmtime::component::__internal::String,), 371 >(&mut store, &self.b)? 372 .func(); 373 let c = *_instance 374 .get_typed_func::< 375 (&str, &str), 376 (wasmtime::component::__internal::String,), 377 >(&mut store, &self.c)? 378 .func(); 379 Ok(Guest { a, b, c }) 380 } 381 } 382 impl Guest { 383 pub async fn call_a<S: wasmtime::AsContextMut>( 384 &self, 385 mut store: S, 386 arg0: &str, 387 ) -> wasmtime::Result<()> 388 where 389 <S as wasmtime::AsContext>::Data: Send, 390 { 391 let callee = unsafe { 392 wasmtime::component::TypedFunc::< 393 (&str,), 394 (), 395 >::new_unchecked(self.a) 396 }; 397 let () = callee 398 .call_async(store.as_context_mut(), (arg0,)) 399 .await?; 400 callee.post_return_async(store.as_context_mut()).await?; 401 Ok(()) 402 } 403 pub async fn call_b<S: wasmtime::AsContextMut>( 404 &self, 405 mut store: S, 406 ) -> wasmtime::Result<wasmtime::component::__internal::String> 407 where 408 <S as wasmtime::AsContext>::Data: Send, 409 { 410 let callee = unsafe { 411 wasmtime::component::TypedFunc::< 412 (), 413 (wasmtime::component::__internal::String,), 414 >::new_unchecked(self.b) 415 }; 416 let (ret0,) = callee 417 .call_async(store.as_context_mut(), ()) 418 .await?; 419 callee.post_return_async(store.as_context_mut()).await?; 420 Ok(ret0) 421 } 422 pub async fn call_c<S: wasmtime::AsContextMut>( 423 &self, 424 mut store: S, 425 arg0: &str, 426 arg1: &str, 427 ) -> wasmtime::Result<wasmtime::component::__internal::String> 428 where 429 <S as wasmtime::AsContext>::Data: Send, 430 { 431 let callee = unsafe { 432 wasmtime::component::TypedFunc::< 433 (&str, &str), 434 (wasmtime::component::__internal::String,), 435 >::new_unchecked(self.c) 436 }; 437 let (ret0,) = callee 438 .call_async(store.as_context_mut(), (arg0, arg1)) 439 .await?; 440 callee.post_return_async(store.as_context_mut()).await?; 441 Ok(ret0) 442 } 443 } 444 } 445 } 446 } 447 } 448