1 /// Auto-generated bindings for a pre-instantiated version of a 2 /// component which implements the world `the-lists`. 3 /// 4 /// This structure is created through [`TheListsPre::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 [`TheLists`] as well. 9 pub struct TheListsPre<T> { 10 instance_pre: wasmtime::component::InstancePre<T>, 11 indices: TheListsIndices, 12 } 13 impl<T> Clone for TheListsPre<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> TheListsPre<_T> { 22 /// Creates a new copy of `TheListsPre` 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 = TheListsIndices::new(instance_pre.component())?; 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 [`TheLists`] 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 async fn instantiate_async( 47 &self, 48 mut store: impl wasmtime::AsContextMut<Data = _T>, 49 ) -> wasmtime::Result<TheLists> 50 where 51 _T: Send + 'static, 52 { 53 let mut store = store.as_context_mut(); 54 let instance = self.instance_pre.instantiate_async(&mut store).await?; 55 self.indices.load(&mut store, &instance) 56 } 57 } 58 /// Auto-generated bindings for index of the exports of 59 /// `the-lists`. 60 /// 61 /// This is an implementation detail of [`TheListsPre`] and can 62 /// be constructed if needed as well. 63 /// 64 /// For more information see [`TheLists`] as well. 65 #[derive(Clone)] 66 pub struct TheListsIndices { 67 interface0: exports::foo::foo::lists::GuestIndices, 68 } 69 /// Auto-generated bindings for an instance a component which 70 /// implements the world `the-lists`. 71 /// 72 /// This structure can be created through a number of means 73 /// depending on your requirements and what you have on hand: 74 /// 75 /// * The most convenient way is to use 76 /// [`TheLists::instantiate_async`] which only needs a 77 /// [`Store`], [`Component`], and [`Linker`]. 78 /// 79 /// * Alternatively you can create a [`TheListsPre`] ahead of 80 /// time with a [`Component`] to front-load string lookups 81 /// of exports once instead of per-instantiation. This 82 /// method then uses [`TheListsPre::instantiate_async`] to 83 /// create a [`TheLists`]. 84 /// 85 /// * If you've instantiated the instance yourself already 86 /// then you can use [`TheLists::new`]. 87 /// 88 /// * You can also access the guts of instantiation through 89 /// [`TheListsIndices::new_instance`] followed 90 /// by [`TheListsIndices::load`] to crate an instance of this 91 /// type. 92 /// 93 /// These methods are all equivalent to one another and move 94 /// around the tradeoff of what work is performed when. 95 /// 96 /// [`Store`]: wasmtime::Store 97 /// [`Component`]: wasmtime::component::Component 98 /// [`Linker`]: wasmtime::component::Linker 99 pub struct TheLists { 100 interface0: exports::foo::foo::lists::Guest, 101 } 102 const _: () = { 103 #[allow(unused_imports)] 104 use wasmtime::component::__internal::anyhow; 105 impl TheListsIndices { 106 /// Creates a new copy of `TheListsIndices` bindings which can then 107 /// be used to instantiate into a particular store. 108 /// 109 /// This method may fail if the component does not have the 110 /// required exports. 111 pub fn new( 112 component: &wasmtime::component::Component, 113 ) -> wasmtime::Result<Self> { 114 let _component = component; 115 let interface0 = exports::foo::foo::lists::GuestIndices::new(_component)?; 116 Ok(TheListsIndices { interface0 }) 117 } 118 /// Creates a new instance of [`TheListsIndices`] from an 119 /// instantiated component. 120 /// 121 /// This method of creating a [`TheLists`] will perform string 122 /// lookups for all exports when this method is called. This 123 /// will only succeed if the provided instance matches the 124 /// requirements of [`TheLists`]. 125 pub fn new_instance( 126 mut store: impl wasmtime::AsContextMut, 127 instance: &wasmtime::component::Instance, 128 ) -> wasmtime::Result<Self> { 129 let _instance = instance; 130 let interface0 = exports::foo::foo::lists::GuestIndices::new_instance( 131 &mut store, 132 _instance, 133 )?; 134 Ok(TheListsIndices { interface0 }) 135 } 136 /// Uses the indices stored in `self` to load an instance 137 /// of [`TheLists`] from the instance provided. 138 /// 139 /// Note that at this time this method will additionally 140 /// perform type-checks of all exports. 141 pub fn load( 142 &self, 143 mut store: impl wasmtime::AsContextMut, 144 instance: &wasmtime::component::Instance, 145 ) -> wasmtime::Result<TheLists> { 146 let _instance = instance; 147 let interface0 = self.interface0.load(&mut store, &_instance)?; 148 Ok(TheLists { interface0 }) 149 } 150 } 151 impl TheLists { 152 /// Convenience wrapper around [`TheListsPre::new`] and 153 /// [`TheListsPre::instantiate_async`]. 154 pub async fn instantiate_async<_T>( 155 mut store: impl wasmtime::AsContextMut<Data = _T>, 156 component: &wasmtime::component::Component, 157 linker: &wasmtime::component::Linker<_T>, 158 ) -> wasmtime::Result<TheLists> 159 where 160 _T: Send + 'static, 161 { 162 let pre = linker.instantiate_pre(component)?; 163 TheListsPre::new(pre)?.instantiate_async(store).await 164 } 165 /// Convenience wrapper around [`TheListsIndices::new_instance`] and 166 /// [`TheListsIndices::load`]. 167 pub fn new( 168 mut store: impl wasmtime::AsContextMut, 169 instance: &wasmtime::component::Instance, 170 ) -> wasmtime::Result<TheLists> { 171 let indices = TheListsIndices::new_instance(&mut store, instance)?; 172 indices.load(store, instance) 173 } 174 pub fn add_to_linker<T, U>( 175 linker: &mut wasmtime::component::Linker<T>, 176 get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static, 177 ) -> wasmtime::Result<()> 178 where 179 T: Send + foo::foo::lists::Host<Data = T> + 'static, 180 U: Send + foo::foo::lists::Host<Data = T>, 181 { 182 foo::foo::lists::add_to_linker(linker, get)?; 183 Ok(()) 184 } 185 pub fn foo_foo_lists(&self) -> &exports::foo::foo::lists::Guest { 186 &self.interface0 187 } 188 } 189 }; 190 pub mod foo { 191 pub mod foo { 192 #[allow(clippy::all)] 193 pub mod lists { 194 #[allow(unused_imports)] 195 use wasmtime::component::__internal::{anyhow, Box}; 196 #[derive(wasmtime::component::ComponentType)] 197 #[derive(wasmtime::component::Lift)] 198 #[derive(wasmtime::component::Lower)] 199 #[component(record)] 200 #[derive(Clone)] 201 pub struct OtherRecord { 202 #[component(name = "a1")] 203 pub a1: u32, 204 #[component(name = "a2")] 205 pub a2: u64, 206 #[component(name = "a3")] 207 pub a3: i32, 208 #[component(name = "a4")] 209 pub a4: i64, 210 #[component(name = "b")] 211 pub b: wasmtime::component::__internal::String, 212 #[component(name = "c")] 213 pub c: wasmtime::component::__internal::Vec<u8>, 214 } 215 impl core::fmt::Debug for OtherRecord { 216 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 217 f.debug_struct("OtherRecord") 218 .field("a1", &self.a1) 219 .field("a2", &self.a2) 220 .field("a3", &self.a3) 221 .field("a4", &self.a4) 222 .field("b", &self.b) 223 .field("c", &self.c) 224 .finish() 225 } 226 } 227 const _: () = { 228 assert!( 229 48 == < OtherRecord as wasmtime::component::ComponentType >::SIZE32 230 ); 231 assert!( 232 8 == < OtherRecord as wasmtime::component::ComponentType >::ALIGN32 233 ); 234 }; 235 #[derive(wasmtime::component::ComponentType)] 236 #[derive(wasmtime::component::Lift)] 237 #[derive(wasmtime::component::Lower)] 238 #[component(record)] 239 #[derive(Clone)] 240 pub struct SomeRecord { 241 #[component(name = "x")] 242 pub x: wasmtime::component::__internal::String, 243 #[component(name = "y")] 244 pub y: OtherRecord, 245 #[component(name = "z")] 246 pub z: wasmtime::component::__internal::Vec<OtherRecord>, 247 #[component(name = "c1")] 248 pub c1: u32, 249 #[component(name = "c2")] 250 pub c2: u64, 251 #[component(name = "c3")] 252 pub c3: i32, 253 #[component(name = "c4")] 254 pub c4: i64, 255 } 256 impl core::fmt::Debug for SomeRecord { 257 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 258 f.debug_struct("SomeRecord") 259 .field("x", &self.x) 260 .field("y", &self.y) 261 .field("z", &self.z) 262 .field("c1", &self.c1) 263 .field("c2", &self.c2) 264 .field("c3", &self.c3) 265 .field("c4", &self.c4) 266 .finish() 267 } 268 } 269 const _: () = { 270 assert!( 271 96 == < SomeRecord as wasmtime::component::ComponentType >::SIZE32 272 ); 273 assert!( 274 8 == < SomeRecord as wasmtime::component::ComponentType >::ALIGN32 275 ); 276 }; 277 #[derive(wasmtime::component::ComponentType)] 278 #[derive(wasmtime::component::Lift)] 279 #[derive(wasmtime::component::Lower)] 280 #[component(variant)] 281 #[derive(Clone)] 282 pub enum OtherVariant { 283 #[component(name = "a")] 284 A, 285 #[component(name = "b")] 286 B(u32), 287 #[component(name = "c")] 288 C(wasmtime::component::__internal::String), 289 } 290 impl core::fmt::Debug for OtherVariant { 291 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 292 match self { 293 OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(), 294 OtherVariant::B(e) => { 295 f.debug_tuple("OtherVariant::B").field(e).finish() 296 } 297 OtherVariant::C(e) => { 298 f.debug_tuple("OtherVariant::C").field(e).finish() 299 } 300 } 301 } 302 } 303 const _: () = { 304 assert!( 305 12 == < OtherVariant as wasmtime::component::ComponentType >::SIZE32 306 ); 307 assert!( 308 4 == < OtherVariant as wasmtime::component::ComponentType >::ALIGN32 309 ); 310 }; 311 #[derive(wasmtime::component::ComponentType)] 312 #[derive(wasmtime::component::Lift)] 313 #[derive(wasmtime::component::Lower)] 314 #[component(variant)] 315 #[derive(Clone)] 316 pub enum SomeVariant { 317 #[component(name = "a")] 318 A(wasmtime::component::__internal::String), 319 #[component(name = "b")] 320 B, 321 #[component(name = "c")] 322 C(u32), 323 #[component(name = "d")] 324 D(wasmtime::component::__internal::Vec<OtherVariant>), 325 } 326 impl core::fmt::Debug for SomeVariant { 327 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 328 match self { 329 SomeVariant::A(e) => { 330 f.debug_tuple("SomeVariant::A").field(e).finish() 331 } 332 SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(), 333 SomeVariant::C(e) => { 334 f.debug_tuple("SomeVariant::C").field(e).finish() 335 } 336 SomeVariant::D(e) => { 337 f.debug_tuple("SomeVariant::D").field(e).finish() 338 } 339 } 340 } 341 } 342 const _: () = { 343 assert!( 344 12 == < SomeVariant as wasmtime::component::ComponentType >::SIZE32 345 ); 346 assert!( 347 4 == < SomeVariant as wasmtime::component::ComponentType >::ALIGN32 348 ); 349 }; 350 pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec< 351 ( 352 wasmtime::component::__internal::String, 353 u8, 354 i8, 355 u16, 356 i16, 357 u32, 358 i32, 359 u64, 360 i64, 361 f32, 362 f64, 363 char, 364 ), 365 >; 366 const _: () = { 367 assert!( 368 8 == < LoadStoreAllSizes as wasmtime::component::ComponentType 369 >::SIZE32 370 ); 371 assert!( 372 4 == < LoadStoreAllSizes as wasmtime::component::ComponentType 373 >::ALIGN32 374 ); 375 }; 376 pub trait Host { 377 type Data; 378 fn list_u8_param( 379 store: wasmtime::StoreContextMut<'_, Self::Data>, 380 x: wasmtime::component::__internal::Vec<u8>, 381 ) -> impl ::core::future::Future< 382 Output = impl FnOnce( 383 wasmtime::StoreContextMut<'_, Self::Data>, 384 ) -> () + Send + Sync + 'static, 385 > + Send + Sync + 'static 386 where 387 Self: Sized; 388 fn list_u16_param( 389 store: wasmtime::StoreContextMut<'_, Self::Data>, 390 x: wasmtime::component::__internal::Vec<u16>, 391 ) -> impl ::core::future::Future< 392 Output = impl FnOnce( 393 wasmtime::StoreContextMut<'_, Self::Data>, 394 ) -> () + Send + Sync + 'static, 395 > + Send + Sync + 'static 396 where 397 Self: Sized; 398 fn list_u32_param( 399 store: wasmtime::StoreContextMut<'_, Self::Data>, 400 x: wasmtime::component::__internal::Vec<u32>, 401 ) -> impl ::core::future::Future< 402 Output = impl FnOnce( 403 wasmtime::StoreContextMut<'_, Self::Data>, 404 ) -> () + Send + Sync + 'static, 405 > + Send + Sync + 'static 406 where 407 Self: Sized; 408 fn list_u64_param( 409 store: wasmtime::StoreContextMut<'_, Self::Data>, 410 x: wasmtime::component::__internal::Vec<u64>, 411 ) -> impl ::core::future::Future< 412 Output = impl FnOnce( 413 wasmtime::StoreContextMut<'_, Self::Data>, 414 ) -> () + Send + Sync + 'static, 415 > + Send + Sync + 'static 416 where 417 Self: Sized; 418 fn list_s8_param( 419 store: wasmtime::StoreContextMut<'_, Self::Data>, 420 x: wasmtime::component::__internal::Vec<i8>, 421 ) -> impl ::core::future::Future< 422 Output = impl FnOnce( 423 wasmtime::StoreContextMut<'_, Self::Data>, 424 ) -> () + Send + Sync + 'static, 425 > + Send + Sync + 'static 426 where 427 Self: Sized; 428 fn list_s16_param( 429 store: wasmtime::StoreContextMut<'_, Self::Data>, 430 x: wasmtime::component::__internal::Vec<i16>, 431 ) -> impl ::core::future::Future< 432 Output = impl FnOnce( 433 wasmtime::StoreContextMut<'_, Self::Data>, 434 ) -> () + Send + Sync + 'static, 435 > + Send + Sync + 'static 436 where 437 Self: Sized; 438 fn list_s32_param( 439 store: wasmtime::StoreContextMut<'_, Self::Data>, 440 x: wasmtime::component::__internal::Vec<i32>, 441 ) -> impl ::core::future::Future< 442 Output = impl FnOnce( 443 wasmtime::StoreContextMut<'_, Self::Data>, 444 ) -> () + Send + Sync + 'static, 445 > + Send + Sync + 'static 446 where 447 Self: Sized; 448 fn list_s64_param( 449 store: wasmtime::StoreContextMut<'_, Self::Data>, 450 x: wasmtime::component::__internal::Vec<i64>, 451 ) -> impl ::core::future::Future< 452 Output = impl FnOnce( 453 wasmtime::StoreContextMut<'_, Self::Data>, 454 ) -> () + Send + Sync + 'static, 455 > + Send + Sync + 'static 456 where 457 Self: Sized; 458 fn list_f32_param( 459 store: wasmtime::StoreContextMut<'_, Self::Data>, 460 x: wasmtime::component::__internal::Vec<f32>, 461 ) -> impl ::core::future::Future< 462 Output = impl FnOnce( 463 wasmtime::StoreContextMut<'_, Self::Data>, 464 ) -> () + Send + Sync + 'static, 465 > + Send + Sync + 'static 466 where 467 Self: Sized; 468 fn list_f64_param( 469 store: wasmtime::StoreContextMut<'_, Self::Data>, 470 x: wasmtime::component::__internal::Vec<f64>, 471 ) -> impl ::core::future::Future< 472 Output = impl FnOnce( 473 wasmtime::StoreContextMut<'_, Self::Data>, 474 ) -> () + Send + Sync + 'static, 475 > + Send + Sync + 'static 476 where 477 Self: Sized; 478 fn list_u8_ret( 479 store: wasmtime::StoreContextMut<'_, Self::Data>, 480 ) -> impl ::core::future::Future< 481 Output = impl FnOnce( 482 wasmtime::StoreContextMut<'_, Self::Data>, 483 ) -> wasmtime::component::__internal::Vec<u8> + Send + Sync + 'static, 484 > + Send + Sync + 'static 485 where 486 Self: Sized; 487 fn list_u16_ret( 488 store: wasmtime::StoreContextMut<'_, Self::Data>, 489 ) -> impl ::core::future::Future< 490 Output = impl FnOnce( 491 wasmtime::StoreContextMut<'_, Self::Data>, 492 ) -> wasmtime::component::__internal::Vec< 493 u16, 494 > + Send + Sync + 'static, 495 > + Send + Sync + 'static 496 where 497 Self: Sized; 498 fn list_u32_ret( 499 store: wasmtime::StoreContextMut<'_, Self::Data>, 500 ) -> impl ::core::future::Future< 501 Output = impl FnOnce( 502 wasmtime::StoreContextMut<'_, Self::Data>, 503 ) -> wasmtime::component::__internal::Vec< 504 u32, 505 > + Send + Sync + 'static, 506 > + Send + Sync + 'static 507 where 508 Self: Sized; 509 fn list_u64_ret( 510 store: wasmtime::StoreContextMut<'_, Self::Data>, 511 ) -> impl ::core::future::Future< 512 Output = impl FnOnce( 513 wasmtime::StoreContextMut<'_, Self::Data>, 514 ) -> wasmtime::component::__internal::Vec< 515 u64, 516 > + Send + Sync + 'static, 517 > + Send + Sync + 'static 518 where 519 Self: Sized; 520 fn list_s8_ret( 521 store: wasmtime::StoreContextMut<'_, Self::Data>, 522 ) -> impl ::core::future::Future< 523 Output = impl FnOnce( 524 wasmtime::StoreContextMut<'_, Self::Data>, 525 ) -> wasmtime::component::__internal::Vec<i8> + Send + Sync + 'static, 526 > + Send + Sync + 'static 527 where 528 Self: Sized; 529 fn list_s16_ret( 530 store: wasmtime::StoreContextMut<'_, Self::Data>, 531 ) -> impl ::core::future::Future< 532 Output = impl FnOnce( 533 wasmtime::StoreContextMut<'_, Self::Data>, 534 ) -> wasmtime::component::__internal::Vec< 535 i16, 536 > + Send + Sync + 'static, 537 > + Send + Sync + 'static 538 where 539 Self: Sized; 540 fn list_s32_ret( 541 store: wasmtime::StoreContextMut<'_, Self::Data>, 542 ) -> impl ::core::future::Future< 543 Output = impl FnOnce( 544 wasmtime::StoreContextMut<'_, Self::Data>, 545 ) -> wasmtime::component::__internal::Vec< 546 i32, 547 > + Send + Sync + 'static, 548 > + Send + Sync + 'static 549 where 550 Self: Sized; 551 fn list_s64_ret( 552 store: wasmtime::StoreContextMut<'_, Self::Data>, 553 ) -> impl ::core::future::Future< 554 Output = impl FnOnce( 555 wasmtime::StoreContextMut<'_, Self::Data>, 556 ) -> wasmtime::component::__internal::Vec< 557 i64, 558 > + Send + Sync + 'static, 559 > + Send + Sync + 'static 560 where 561 Self: Sized; 562 fn list_f32_ret( 563 store: wasmtime::StoreContextMut<'_, Self::Data>, 564 ) -> impl ::core::future::Future< 565 Output = impl FnOnce( 566 wasmtime::StoreContextMut<'_, Self::Data>, 567 ) -> wasmtime::component::__internal::Vec< 568 f32, 569 > + Send + Sync + 'static, 570 > + Send + Sync + 'static 571 where 572 Self: Sized; 573 fn list_f64_ret( 574 store: wasmtime::StoreContextMut<'_, Self::Data>, 575 ) -> impl ::core::future::Future< 576 Output = impl FnOnce( 577 wasmtime::StoreContextMut<'_, Self::Data>, 578 ) -> wasmtime::component::__internal::Vec< 579 f64, 580 > + Send + Sync + 'static, 581 > + Send + Sync + 'static 582 where 583 Self: Sized; 584 fn tuple_list( 585 store: wasmtime::StoreContextMut<'_, Self::Data>, 586 x: wasmtime::component::__internal::Vec<(u8, i8)>, 587 ) -> impl ::core::future::Future< 588 Output = impl FnOnce( 589 wasmtime::StoreContextMut<'_, Self::Data>, 590 ) -> wasmtime::component::__internal::Vec< 591 (i64, u32), 592 > + Send + Sync + 'static, 593 > + Send + Sync + 'static 594 where 595 Self: Sized; 596 fn string_list_arg( 597 store: wasmtime::StoreContextMut<'_, Self::Data>, 598 a: wasmtime::component::__internal::Vec< 599 wasmtime::component::__internal::String, 600 >, 601 ) -> impl ::core::future::Future< 602 Output = impl FnOnce( 603 wasmtime::StoreContextMut<'_, Self::Data>, 604 ) -> () + Send + Sync + 'static, 605 > + Send + Sync + 'static 606 where 607 Self: Sized; 608 fn string_list_ret( 609 store: wasmtime::StoreContextMut<'_, Self::Data>, 610 ) -> impl ::core::future::Future< 611 Output = impl FnOnce( 612 wasmtime::StoreContextMut<'_, Self::Data>, 613 ) -> wasmtime::component::__internal::Vec< 614 wasmtime::component::__internal::String, 615 > + Send + Sync + 'static, 616 > + Send + Sync + 'static 617 where 618 Self: Sized; 619 fn tuple_string_list( 620 store: wasmtime::StoreContextMut<'_, Self::Data>, 621 x: wasmtime::component::__internal::Vec< 622 (u8, wasmtime::component::__internal::String), 623 >, 624 ) -> impl ::core::future::Future< 625 Output = impl FnOnce( 626 wasmtime::StoreContextMut<'_, Self::Data>, 627 ) -> wasmtime::component::__internal::Vec< 628 (wasmtime::component::__internal::String, u8), 629 > + Send + Sync + 'static, 630 > + Send + Sync + 'static 631 where 632 Self: Sized; 633 fn string_list( 634 store: wasmtime::StoreContextMut<'_, Self::Data>, 635 x: wasmtime::component::__internal::Vec< 636 wasmtime::component::__internal::String, 637 >, 638 ) -> impl ::core::future::Future< 639 Output = impl FnOnce( 640 wasmtime::StoreContextMut<'_, Self::Data>, 641 ) -> wasmtime::component::__internal::Vec< 642 wasmtime::component::__internal::String, 643 > + Send + Sync + 'static, 644 > + Send + Sync + 'static 645 where 646 Self: Sized; 647 fn record_list( 648 store: wasmtime::StoreContextMut<'_, Self::Data>, 649 x: wasmtime::component::__internal::Vec<SomeRecord>, 650 ) -> impl ::core::future::Future< 651 Output = impl FnOnce( 652 wasmtime::StoreContextMut<'_, Self::Data>, 653 ) -> wasmtime::component::__internal::Vec< 654 OtherRecord, 655 > + Send + Sync + 'static, 656 > + Send + Sync + 'static 657 where 658 Self: Sized; 659 fn record_list_reverse( 660 store: wasmtime::StoreContextMut<'_, Self::Data>, 661 x: wasmtime::component::__internal::Vec<OtherRecord>, 662 ) -> impl ::core::future::Future< 663 Output = impl FnOnce( 664 wasmtime::StoreContextMut<'_, Self::Data>, 665 ) -> wasmtime::component::__internal::Vec< 666 SomeRecord, 667 > + Send + Sync + 'static, 668 > + Send + Sync + 'static 669 where 670 Self: Sized; 671 fn variant_list( 672 store: wasmtime::StoreContextMut<'_, Self::Data>, 673 x: wasmtime::component::__internal::Vec<SomeVariant>, 674 ) -> impl ::core::future::Future< 675 Output = impl FnOnce( 676 wasmtime::StoreContextMut<'_, Self::Data>, 677 ) -> wasmtime::component::__internal::Vec< 678 OtherVariant, 679 > + Send + Sync + 'static, 680 > + Send + Sync + 'static 681 where 682 Self: Sized; 683 fn load_store_everything( 684 store: wasmtime::StoreContextMut<'_, Self::Data>, 685 a: LoadStoreAllSizes, 686 ) -> impl ::core::future::Future< 687 Output = impl FnOnce( 688 wasmtime::StoreContextMut<'_, Self::Data>, 689 ) -> LoadStoreAllSizes + Send + Sync + 'static, 690 > + Send + Sync + 'static 691 where 692 Self: Sized; 693 } 694 pub trait GetHost< 695 T, 696 D, 697 >: Fn(T) -> <Self as GetHost<T, D>>::Host + Send + Sync + Copy + 'static { 698 type Host: Host<Data = D> + Send; 699 } 700 impl<F, T, D, O> GetHost<T, D> for F 701 where 702 F: Fn(T) -> O + Send + Sync + Copy + 'static, 703 O: Host<Data = D> + Send, 704 { 705 type Host = O; 706 } 707 pub fn add_to_linker_get_host< 708 T, 709 G: for<'a> GetHost<&'a mut T, T, Host: Host<Data = T> + Send>, 710 >( 711 linker: &mut wasmtime::component::Linker<T>, 712 host_getter: G, 713 ) -> wasmtime::Result<()> 714 where 715 T: Send + 'static, 716 { 717 let mut inst = linker.instance("foo:foo/lists")?; 718 inst.func_wrap_concurrent( 719 "list-u8-param", 720 move | 721 mut caller: wasmtime::StoreContextMut<'_, T>, 722 (arg0,): (wasmtime::component::__internal::Vec<u8>,)| 723 { 724 let host = caller; 725 let r = <G::Host as Host>::list_u8_param(host, arg0); 726 Box::pin(async move { 727 let fun = r.await; 728 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 729 let r = fun(caller); 730 Ok(r) 731 }) 732 as Box< 733 dyn FnOnce( 734 wasmtime::StoreContextMut<'_, T>, 735 ) -> wasmtime::Result<()> + Send + Sync, 736 > 737 }) 738 as ::core::pin::Pin< 739 Box< 740 dyn ::core::future::Future< 741 Output = Box< 742 dyn FnOnce( 743 wasmtime::StoreContextMut<'_, T>, 744 ) -> wasmtime::Result<()> + Send + Sync, 745 >, 746 > + Send + Sync + 'static, 747 >, 748 > 749 }, 750 )?; 751 inst.func_wrap_concurrent( 752 "list-u16-param", 753 move | 754 mut caller: wasmtime::StoreContextMut<'_, T>, 755 (arg0,): (wasmtime::component::__internal::Vec<u16>,)| 756 { 757 let host = caller; 758 let r = <G::Host as Host>::list_u16_param(host, arg0); 759 Box::pin(async move { 760 let fun = r.await; 761 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 762 let r = fun(caller); 763 Ok(r) 764 }) 765 as Box< 766 dyn FnOnce( 767 wasmtime::StoreContextMut<'_, T>, 768 ) -> wasmtime::Result<()> + Send + Sync, 769 > 770 }) 771 as ::core::pin::Pin< 772 Box< 773 dyn ::core::future::Future< 774 Output = Box< 775 dyn FnOnce( 776 wasmtime::StoreContextMut<'_, T>, 777 ) -> wasmtime::Result<()> + Send + Sync, 778 >, 779 > + Send + Sync + 'static, 780 >, 781 > 782 }, 783 )?; 784 inst.func_wrap_concurrent( 785 "list-u32-param", 786 move | 787 mut caller: wasmtime::StoreContextMut<'_, T>, 788 (arg0,): (wasmtime::component::__internal::Vec<u32>,)| 789 { 790 let host = caller; 791 let r = <G::Host as Host>::list_u32_param(host, arg0); 792 Box::pin(async move { 793 let fun = r.await; 794 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 795 let r = fun(caller); 796 Ok(r) 797 }) 798 as Box< 799 dyn FnOnce( 800 wasmtime::StoreContextMut<'_, T>, 801 ) -> wasmtime::Result<()> + Send + Sync, 802 > 803 }) 804 as ::core::pin::Pin< 805 Box< 806 dyn ::core::future::Future< 807 Output = Box< 808 dyn FnOnce( 809 wasmtime::StoreContextMut<'_, T>, 810 ) -> wasmtime::Result<()> + Send + Sync, 811 >, 812 > + Send + Sync + 'static, 813 >, 814 > 815 }, 816 )?; 817 inst.func_wrap_concurrent( 818 "list-u64-param", 819 move | 820 mut caller: wasmtime::StoreContextMut<'_, T>, 821 (arg0,): (wasmtime::component::__internal::Vec<u64>,)| 822 { 823 let host = caller; 824 let r = <G::Host as Host>::list_u64_param(host, arg0); 825 Box::pin(async move { 826 let fun = r.await; 827 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 828 let r = fun(caller); 829 Ok(r) 830 }) 831 as Box< 832 dyn FnOnce( 833 wasmtime::StoreContextMut<'_, T>, 834 ) -> wasmtime::Result<()> + Send + Sync, 835 > 836 }) 837 as ::core::pin::Pin< 838 Box< 839 dyn ::core::future::Future< 840 Output = Box< 841 dyn FnOnce( 842 wasmtime::StoreContextMut<'_, T>, 843 ) -> wasmtime::Result<()> + Send + Sync, 844 >, 845 > + Send + Sync + 'static, 846 >, 847 > 848 }, 849 )?; 850 inst.func_wrap_concurrent( 851 "list-s8-param", 852 move | 853 mut caller: wasmtime::StoreContextMut<'_, T>, 854 (arg0,): (wasmtime::component::__internal::Vec<i8>,)| 855 { 856 let host = caller; 857 let r = <G::Host as Host>::list_s8_param(host, arg0); 858 Box::pin(async move { 859 let fun = r.await; 860 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 861 let r = fun(caller); 862 Ok(r) 863 }) 864 as Box< 865 dyn FnOnce( 866 wasmtime::StoreContextMut<'_, T>, 867 ) -> wasmtime::Result<()> + Send + Sync, 868 > 869 }) 870 as ::core::pin::Pin< 871 Box< 872 dyn ::core::future::Future< 873 Output = Box< 874 dyn FnOnce( 875 wasmtime::StoreContextMut<'_, T>, 876 ) -> wasmtime::Result<()> + Send + Sync, 877 >, 878 > + Send + Sync + 'static, 879 >, 880 > 881 }, 882 )?; 883 inst.func_wrap_concurrent( 884 "list-s16-param", 885 move | 886 mut caller: wasmtime::StoreContextMut<'_, T>, 887 (arg0,): (wasmtime::component::__internal::Vec<i16>,)| 888 { 889 let host = caller; 890 let r = <G::Host as Host>::list_s16_param(host, arg0); 891 Box::pin(async move { 892 let fun = r.await; 893 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 894 let r = fun(caller); 895 Ok(r) 896 }) 897 as Box< 898 dyn FnOnce( 899 wasmtime::StoreContextMut<'_, T>, 900 ) -> wasmtime::Result<()> + Send + Sync, 901 > 902 }) 903 as ::core::pin::Pin< 904 Box< 905 dyn ::core::future::Future< 906 Output = Box< 907 dyn FnOnce( 908 wasmtime::StoreContextMut<'_, T>, 909 ) -> wasmtime::Result<()> + Send + Sync, 910 >, 911 > + Send + Sync + 'static, 912 >, 913 > 914 }, 915 )?; 916 inst.func_wrap_concurrent( 917 "list-s32-param", 918 move | 919 mut caller: wasmtime::StoreContextMut<'_, T>, 920 (arg0,): (wasmtime::component::__internal::Vec<i32>,)| 921 { 922 let host = caller; 923 let r = <G::Host as Host>::list_s32_param(host, arg0); 924 Box::pin(async move { 925 let fun = r.await; 926 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 927 let r = fun(caller); 928 Ok(r) 929 }) 930 as Box< 931 dyn FnOnce( 932 wasmtime::StoreContextMut<'_, T>, 933 ) -> wasmtime::Result<()> + Send + Sync, 934 > 935 }) 936 as ::core::pin::Pin< 937 Box< 938 dyn ::core::future::Future< 939 Output = Box< 940 dyn FnOnce( 941 wasmtime::StoreContextMut<'_, T>, 942 ) -> wasmtime::Result<()> + Send + Sync, 943 >, 944 > + Send + Sync + 'static, 945 >, 946 > 947 }, 948 )?; 949 inst.func_wrap_concurrent( 950 "list-s64-param", 951 move | 952 mut caller: wasmtime::StoreContextMut<'_, T>, 953 (arg0,): (wasmtime::component::__internal::Vec<i64>,)| 954 { 955 let host = caller; 956 let r = <G::Host as Host>::list_s64_param(host, arg0); 957 Box::pin(async move { 958 let fun = r.await; 959 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 960 let r = fun(caller); 961 Ok(r) 962 }) 963 as Box< 964 dyn FnOnce( 965 wasmtime::StoreContextMut<'_, T>, 966 ) -> wasmtime::Result<()> + Send + Sync, 967 > 968 }) 969 as ::core::pin::Pin< 970 Box< 971 dyn ::core::future::Future< 972 Output = Box< 973 dyn FnOnce( 974 wasmtime::StoreContextMut<'_, T>, 975 ) -> wasmtime::Result<()> + Send + Sync, 976 >, 977 > + Send + Sync + 'static, 978 >, 979 > 980 }, 981 )?; 982 inst.func_wrap_concurrent( 983 "list-f32-param", 984 move | 985 mut caller: wasmtime::StoreContextMut<'_, T>, 986 (arg0,): (wasmtime::component::__internal::Vec<f32>,)| 987 { 988 let host = caller; 989 let r = <G::Host as Host>::list_f32_param(host, arg0); 990 Box::pin(async move { 991 let fun = r.await; 992 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 993 let r = fun(caller); 994 Ok(r) 995 }) 996 as Box< 997 dyn FnOnce( 998 wasmtime::StoreContextMut<'_, T>, 999 ) -> wasmtime::Result<()> + Send + Sync, 1000 > 1001 }) 1002 as ::core::pin::Pin< 1003 Box< 1004 dyn ::core::future::Future< 1005 Output = Box< 1006 dyn FnOnce( 1007 wasmtime::StoreContextMut<'_, T>, 1008 ) -> wasmtime::Result<()> + Send + Sync, 1009 >, 1010 > + Send + Sync + 'static, 1011 >, 1012 > 1013 }, 1014 )?; 1015 inst.func_wrap_concurrent( 1016 "list-f64-param", 1017 move | 1018 mut caller: wasmtime::StoreContextMut<'_, T>, 1019 (arg0,): (wasmtime::component::__internal::Vec<f64>,)| 1020 { 1021 let host = caller; 1022 let r = <G::Host as Host>::list_f64_param(host, arg0); 1023 Box::pin(async move { 1024 let fun = r.await; 1025 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1026 let r = fun(caller); 1027 Ok(r) 1028 }) 1029 as Box< 1030 dyn FnOnce( 1031 wasmtime::StoreContextMut<'_, T>, 1032 ) -> wasmtime::Result<()> + Send + Sync, 1033 > 1034 }) 1035 as ::core::pin::Pin< 1036 Box< 1037 dyn ::core::future::Future< 1038 Output = Box< 1039 dyn FnOnce( 1040 wasmtime::StoreContextMut<'_, T>, 1041 ) -> wasmtime::Result<()> + Send + Sync, 1042 >, 1043 > + Send + Sync + 'static, 1044 >, 1045 > 1046 }, 1047 )?; 1048 inst.func_wrap_concurrent( 1049 "list-u8-ret", 1050 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1051 let host = caller; 1052 let r = <G::Host as Host>::list_u8_ret(host); 1053 Box::pin(async move { 1054 let fun = r.await; 1055 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1056 let r = fun(caller); 1057 Ok((r,)) 1058 }) 1059 as Box< 1060 dyn FnOnce( 1061 wasmtime::StoreContextMut<'_, T>, 1062 ) -> wasmtime::Result< 1063 (wasmtime::component::__internal::Vec<u8>,), 1064 > + Send + Sync, 1065 > 1066 }) 1067 as ::core::pin::Pin< 1068 Box< 1069 dyn ::core::future::Future< 1070 Output = Box< 1071 dyn FnOnce( 1072 wasmtime::StoreContextMut<'_, T>, 1073 ) -> wasmtime::Result< 1074 (wasmtime::component::__internal::Vec<u8>,), 1075 > + Send + Sync, 1076 >, 1077 > + Send + Sync + 'static, 1078 >, 1079 > 1080 }, 1081 )?; 1082 inst.func_wrap_concurrent( 1083 "list-u16-ret", 1084 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1085 let host = caller; 1086 let r = <G::Host as Host>::list_u16_ret(host); 1087 Box::pin(async move { 1088 let fun = r.await; 1089 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1090 let r = fun(caller); 1091 Ok((r,)) 1092 }) 1093 as Box< 1094 dyn FnOnce( 1095 wasmtime::StoreContextMut<'_, T>, 1096 ) -> wasmtime::Result< 1097 (wasmtime::component::__internal::Vec<u16>,), 1098 > + Send + Sync, 1099 > 1100 }) 1101 as ::core::pin::Pin< 1102 Box< 1103 dyn ::core::future::Future< 1104 Output = Box< 1105 dyn FnOnce( 1106 wasmtime::StoreContextMut<'_, T>, 1107 ) -> wasmtime::Result< 1108 (wasmtime::component::__internal::Vec<u16>,), 1109 > + Send + Sync, 1110 >, 1111 > + Send + Sync + 'static, 1112 >, 1113 > 1114 }, 1115 )?; 1116 inst.func_wrap_concurrent( 1117 "list-u32-ret", 1118 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1119 let host = caller; 1120 let r = <G::Host as Host>::list_u32_ret(host); 1121 Box::pin(async move { 1122 let fun = r.await; 1123 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1124 let r = fun(caller); 1125 Ok((r,)) 1126 }) 1127 as Box< 1128 dyn FnOnce( 1129 wasmtime::StoreContextMut<'_, T>, 1130 ) -> wasmtime::Result< 1131 (wasmtime::component::__internal::Vec<u32>,), 1132 > + Send + Sync, 1133 > 1134 }) 1135 as ::core::pin::Pin< 1136 Box< 1137 dyn ::core::future::Future< 1138 Output = Box< 1139 dyn FnOnce( 1140 wasmtime::StoreContextMut<'_, T>, 1141 ) -> wasmtime::Result< 1142 (wasmtime::component::__internal::Vec<u32>,), 1143 > + Send + Sync, 1144 >, 1145 > + Send + Sync + 'static, 1146 >, 1147 > 1148 }, 1149 )?; 1150 inst.func_wrap_concurrent( 1151 "list-u64-ret", 1152 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1153 let host = caller; 1154 let r = <G::Host as Host>::list_u64_ret(host); 1155 Box::pin(async move { 1156 let fun = r.await; 1157 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1158 let r = fun(caller); 1159 Ok((r,)) 1160 }) 1161 as Box< 1162 dyn FnOnce( 1163 wasmtime::StoreContextMut<'_, T>, 1164 ) -> wasmtime::Result< 1165 (wasmtime::component::__internal::Vec<u64>,), 1166 > + Send + Sync, 1167 > 1168 }) 1169 as ::core::pin::Pin< 1170 Box< 1171 dyn ::core::future::Future< 1172 Output = Box< 1173 dyn FnOnce( 1174 wasmtime::StoreContextMut<'_, T>, 1175 ) -> wasmtime::Result< 1176 (wasmtime::component::__internal::Vec<u64>,), 1177 > + Send + Sync, 1178 >, 1179 > + Send + Sync + 'static, 1180 >, 1181 > 1182 }, 1183 )?; 1184 inst.func_wrap_concurrent( 1185 "list-s8-ret", 1186 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1187 let host = caller; 1188 let r = <G::Host as Host>::list_s8_ret(host); 1189 Box::pin(async move { 1190 let fun = r.await; 1191 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1192 let r = fun(caller); 1193 Ok((r,)) 1194 }) 1195 as Box< 1196 dyn FnOnce( 1197 wasmtime::StoreContextMut<'_, T>, 1198 ) -> wasmtime::Result< 1199 (wasmtime::component::__internal::Vec<i8>,), 1200 > + Send + Sync, 1201 > 1202 }) 1203 as ::core::pin::Pin< 1204 Box< 1205 dyn ::core::future::Future< 1206 Output = Box< 1207 dyn FnOnce( 1208 wasmtime::StoreContextMut<'_, T>, 1209 ) -> wasmtime::Result< 1210 (wasmtime::component::__internal::Vec<i8>,), 1211 > + Send + Sync, 1212 >, 1213 > + Send + Sync + 'static, 1214 >, 1215 > 1216 }, 1217 )?; 1218 inst.func_wrap_concurrent( 1219 "list-s16-ret", 1220 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1221 let host = caller; 1222 let r = <G::Host as Host>::list_s16_ret(host); 1223 Box::pin(async move { 1224 let fun = r.await; 1225 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1226 let r = fun(caller); 1227 Ok((r,)) 1228 }) 1229 as Box< 1230 dyn FnOnce( 1231 wasmtime::StoreContextMut<'_, T>, 1232 ) -> wasmtime::Result< 1233 (wasmtime::component::__internal::Vec<i16>,), 1234 > + Send + Sync, 1235 > 1236 }) 1237 as ::core::pin::Pin< 1238 Box< 1239 dyn ::core::future::Future< 1240 Output = Box< 1241 dyn FnOnce( 1242 wasmtime::StoreContextMut<'_, T>, 1243 ) -> wasmtime::Result< 1244 (wasmtime::component::__internal::Vec<i16>,), 1245 > + Send + Sync, 1246 >, 1247 > + Send + Sync + 'static, 1248 >, 1249 > 1250 }, 1251 )?; 1252 inst.func_wrap_concurrent( 1253 "list-s32-ret", 1254 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1255 let host = caller; 1256 let r = <G::Host as Host>::list_s32_ret(host); 1257 Box::pin(async move { 1258 let fun = r.await; 1259 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1260 let r = fun(caller); 1261 Ok((r,)) 1262 }) 1263 as Box< 1264 dyn FnOnce( 1265 wasmtime::StoreContextMut<'_, T>, 1266 ) -> wasmtime::Result< 1267 (wasmtime::component::__internal::Vec<i32>,), 1268 > + Send + Sync, 1269 > 1270 }) 1271 as ::core::pin::Pin< 1272 Box< 1273 dyn ::core::future::Future< 1274 Output = Box< 1275 dyn FnOnce( 1276 wasmtime::StoreContextMut<'_, T>, 1277 ) -> wasmtime::Result< 1278 (wasmtime::component::__internal::Vec<i32>,), 1279 > + Send + Sync, 1280 >, 1281 > + Send + Sync + 'static, 1282 >, 1283 > 1284 }, 1285 )?; 1286 inst.func_wrap_concurrent( 1287 "list-s64-ret", 1288 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1289 let host = caller; 1290 let r = <G::Host as Host>::list_s64_ret(host); 1291 Box::pin(async move { 1292 let fun = r.await; 1293 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1294 let r = fun(caller); 1295 Ok((r,)) 1296 }) 1297 as Box< 1298 dyn FnOnce( 1299 wasmtime::StoreContextMut<'_, T>, 1300 ) -> wasmtime::Result< 1301 (wasmtime::component::__internal::Vec<i64>,), 1302 > + Send + Sync, 1303 > 1304 }) 1305 as ::core::pin::Pin< 1306 Box< 1307 dyn ::core::future::Future< 1308 Output = Box< 1309 dyn FnOnce( 1310 wasmtime::StoreContextMut<'_, T>, 1311 ) -> wasmtime::Result< 1312 (wasmtime::component::__internal::Vec<i64>,), 1313 > + Send + Sync, 1314 >, 1315 > + Send + Sync + 'static, 1316 >, 1317 > 1318 }, 1319 )?; 1320 inst.func_wrap_concurrent( 1321 "list-f32-ret", 1322 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1323 let host = caller; 1324 let r = <G::Host as Host>::list_f32_ret(host); 1325 Box::pin(async move { 1326 let fun = r.await; 1327 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1328 let r = fun(caller); 1329 Ok((r,)) 1330 }) 1331 as Box< 1332 dyn FnOnce( 1333 wasmtime::StoreContextMut<'_, T>, 1334 ) -> wasmtime::Result< 1335 (wasmtime::component::__internal::Vec<f32>,), 1336 > + Send + Sync, 1337 > 1338 }) 1339 as ::core::pin::Pin< 1340 Box< 1341 dyn ::core::future::Future< 1342 Output = Box< 1343 dyn FnOnce( 1344 wasmtime::StoreContextMut<'_, T>, 1345 ) -> wasmtime::Result< 1346 (wasmtime::component::__internal::Vec<f32>,), 1347 > + Send + Sync, 1348 >, 1349 > + Send + Sync + 'static, 1350 >, 1351 > 1352 }, 1353 )?; 1354 inst.func_wrap_concurrent( 1355 "list-f64-ret", 1356 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1357 let host = caller; 1358 let r = <G::Host as Host>::list_f64_ret(host); 1359 Box::pin(async move { 1360 let fun = r.await; 1361 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1362 let r = fun(caller); 1363 Ok((r,)) 1364 }) 1365 as Box< 1366 dyn FnOnce( 1367 wasmtime::StoreContextMut<'_, T>, 1368 ) -> wasmtime::Result< 1369 (wasmtime::component::__internal::Vec<f64>,), 1370 > + Send + Sync, 1371 > 1372 }) 1373 as ::core::pin::Pin< 1374 Box< 1375 dyn ::core::future::Future< 1376 Output = Box< 1377 dyn FnOnce( 1378 wasmtime::StoreContextMut<'_, T>, 1379 ) -> wasmtime::Result< 1380 (wasmtime::component::__internal::Vec<f64>,), 1381 > + Send + Sync, 1382 >, 1383 > + Send + Sync + 'static, 1384 >, 1385 > 1386 }, 1387 )?; 1388 inst.func_wrap_concurrent( 1389 "tuple-list", 1390 move | 1391 mut caller: wasmtime::StoreContextMut<'_, T>, 1392 (arg0,): (wasmtime::component::__internal::Vec<(u8, i8)>,)| 1393 { 1394 let host = caller; 1395 let r = <G::Host as Host>::tuple_list(host, arg0); 1396 Box::pin(async move { 1397 let fun = r.await; 1398 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1399 let r = fun(caller); 1400 Ok((r,)) 1401 }) 1402 as Box< 1403 dyn FnOnce( 1404 wasmtime::StoreContextMut<'_, T>, 1405 ) -> wasmtime::Result< 1406 (wasmtime::component::__internal::Vec<(i64, u32)>,), 1407 > + Send + Sync, 1408 > 1409 }) 1410 as ::core::pin::Pin< 1411 Box< 1412 dyn ::core::future::Future< 1413 Output = Box< 1414 dyn FnOnce( 1415 wasmtime::StoreContextMut<'_, T>, 1416 ) -> wasmtime::Result< 1417 (wasmtime::component::__internal::Vec<(i64, u32)>,), 1418 > + Send + Sync, 1419 >, 1420 > + Send + Sync + 'static, 1421 >, 1422 > 1423 }, 1424 )?; 1425 inst.func_wrap_concurrent( 1426 "string-list-arg", 1427 move | 1428 mut caller: wasmtime::StoreContextMut<'_, T>, 1429 ( 1430 arg0, 1431 ): ( 1432 wasmtime::component::__internal::Vec< 1433 wasmtime::component::__internal::String, 1434 >, 1435 )| 1436 { 1437 let host = caller; 1438 let r = <G::Host as Host>::string_list_arg(host, arg0); 1439 Box::pin(async move { 1440 let fun = r.await; 1441 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1442 let r = fun(caller); 1443 Ok(r) 1444 }) 1445 as Box< 1446 dyn FnOnce( 1447 wasmtime::StoreContextMut<'_, T>, 1448 ) -> wasmtime::Result<()> + Send + Sync, 1449 > 1450 }) 1451 as ::core::pin::Pin< 1452 Box< 1453 dyn ::core::future::Future< 1454 Output = Box< 1455 dyn FnOnce( 1456 wasmtime::StoreContextMut<'_, T>, 1457 ) -> wasmtime::Result<()> + Send + Sync, 1458 >, 1459 > + Send + Sync + 'static, 1460 >, 1461 > 1462 }, 1463 )?; 1464 inst.func_wrap_concurrent( 1465 "string-list-ret", 1466 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 1467 let host = caller; 1468 let r = <G::Host as Host>::string_list_ret(host); 1469 Box::pin(async move { 1470 let fun = r.await; 1471 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1472 let r = fun(caller); 1473 Ok((r,)) 1474 }) 1475 as Box< 1476 dyn FnOnce( 1477 wasmtime::StoreContextMut<'_, T>, 1478 ) -> wasmtime::Result< 1479 ( 1480 wasmtime::component::__internal::Vec< 1481 wasmtime::component::__internal::String, 1482 >, 1483 ), 1484 > + Send + Sync, 1485 > 1486 }) 1487 as ::core::pin::Pin< 1488 Box< 1489 dyn ::core::future::Future< 1490 Output = Box< 1491 dyn FnOnce( 1492 wasmtime::StoreContextMut<'_, T>, 1493 ) -> wasmtime::Result< 1494 ( 1495 wasmtime::component::__internal::Vec< 1496 wasmtime::component::__internal::String, 1497 >, 1498 ), 1499 > + Send + Sync, 1500 >, 1501 > + Send + Sync + 'static, 1502 >, 1503 > 1504 }, 1505 )?; 1506 inst.func_wrap_concurrent( 1507 "tuple-string-list", 1508 move | 1509 mut caller: wasmtime::StoreContextMut<'_, T>, 1510 ( 1511 arg0, 1512 ): ( 1513 wasmtime::component::__internal::Vec< 1514 (u8, wasmtime::component::__internal::String), 1515 >, 1516 )| 1517 { 1518 let host = caller; 1519 let r = <G::Host as Host>::tuple_string_list(host, arg0); 1520 Box::pin(async move { 1521 let fun = r.await; 1522 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1523 let r = fun(caller); 1524 Ok((r,)) 1525 }) 1526 as Box< 1527 dyn FnOnce( 1528 wasmtime::StoreContextMut<'_, T>, 1529 ) -> wasmtime::Result< 1530 ( 1531 wasmtime::component::__internal::Vec< 1532 (wasmtime::component::__internal::String, u8), 1533 >, 1534 ), 1535 > + Send + Sync, 1536 > 1537 }) 1538 as ::core::pin::Pin< 1539 Box< 1540 dyn ::core::future::Future< 1541 Output = Box< 1542 dyn FnOnce( 1543 wasmtime::StoreContextMut<'_, T>, 1544 ) -> wasmtime::Result< 1545 ( 1546 wasmtime::component::__internal::Vec< 1547 (wasmtime::component::__internal::String, u8), 1548 >, 1549 ), 1550 > + Send + Sync, 1551 >, 1552 > + Send + Sync + 'static, 1553 >, 1554 > 1555 }, 1556 )?; 1557 inst.func_wrap_concurrent( 1558 "string-list", 1559 move | 1560 mut caller: wasmtime::StoreContextMut<'_, T>, 1561 ( 1562 arg0, 1563 ): ( 1564 wasmtime::component::__internal::Vec< 1565 wasmtime::component::__internal::String, 1566 >, 1567 )| 1568 { 1569 let host = caller; 1570 let r = <G::Host as Host>::string_list(host, arg0); 1571 Box::pin(async move { 1572 let fun = r.await; 1573 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1574 let r = fun(caller); 1575 Ok((r,)) 1576 }) 1577 as Box< 1578 dyn FnOnce( 1579 wasmtime::StoreContextMut<'_, T>, 1580 ) -> wasmtime::Result< 1581 ( 1582 wasmtime::component::__internal::Vec< 1583 wasmtime::component::__internal::String, 1584 >, 1585 ), 1586 > + Send + Sync, 1587 > 1588 }) 1589 as ::core::pin::Pin< 1590 Box< 1591 dyn ::core::future::Future< 1592 Output = Box< 1593 dyn FnOnce( 1594 wasmtime::StoreContextMut<'_, T>, 1595 ) -> wasmtime::Result< 1596 ( 1597 wasmtime::component::__internal::Vec< 1598 wasmtime::component::__internal::String, 1599 >, 1600 ), 1601 > + Send + Sync, 1602 >, 1603 > + Send + Sync + 'static, 1604 >, 1605 > 1606 }, 1607 )?; 1608 inst.func_wrap_concurrent( 1609 "record-list", 1610 move | 1611 mut caller: wasmtime::StoreContextMut<'_, T>, 1612 (arg0,): (wasmtime::component::__internal::Vec<SomeRecord>,)| 1613 { 1614 let host = caller; 1615 let r = <G::Host as Host>::record_list(host, arg0); 1616 Box::pin(async move { 1617 let fun = r.await; 1618 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1619 let r = fun(caller); 1620 Ok((r,)) 1621 }) 1622 as Box< 1623 dyn FnOnce( 1624 wasmtime::StoreContextMut<'_, T>, 1625 ) -> wasmtime::Result< 1626 (wasmtime::component::__internal::Vec<OtherRecord>,), 1627 > + Send + Sync, 1628 > 1629 }) 1630 as ::core::pin::Pin< 1631 Box< 1632 dyn ::core::future::Future< 1633 Output = Box< 1634 dyn FnOnce( 1635 wasmtime::StoreContextMut<'_, T>, 1636 ) -> wasmtime::Result< 1637 (wasmtime::component::__internal::Vec<OtherRecord>,), 1638 > + Send + Sync, 1639 >, 1640 > + Send + Sync + 'static, 1641 >, 1642 > 1643 }, 1644 )?; 1645 inst.func_wrap_concurrent( 1646 "record-list-reverse", 1647 move | 1648 mut caller: wasmtime::StoreContextMut<'_, T>, 1649 (arg0,): (wasmtime::component::__internal::Vec<OtherRecord>,)| 1650 { 1651 let host = caller; 1652 let r = <G::Host as Host>::record_list_reverse(host, arg0); 1653 Box::pin(async move { 1654 let fun = r.await; 1655 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1656 let r = fun(caller); 1657 Ok((r,)) 1658 }) 1659 as Box< 1660 dyn FnOnce( 1661 wasmtime::StoreContextMut<'_, T>, 1662 ) -> wasmtime::Result< 1663 (wasmtime::component::__internal::Vec<SomeRecord>,), 1664 > + Send + Sync, 1665 > 1666 }) 1667 as ::core::pin::Pin< 1668 Box< 1669 dyn ::core::future::Future< 1670 Output = Box< 1671 dyn FnOnce( 1672 wasmtime::StoreContextMut<'_, T>, 1673 ) -> wasmtime::Result< 1674 (wasmtime::component::__internal::Vec<SomeRecord>,), 1675 > + Send + Sync, 1676 >, 1677 > + Send + Sync + 'static, 1678 >, 1679 > 1680 }, 1681 )?; 1682 inst.func_wrap_concurrent( 1683 "variant-list", 1684 move | 1685 mut caller: wasmtime::StoreContextMut<'_, T>, 1686 (arg0,): (wasmtime::component::__internal::Vec<SomeVariant>,)| 1687 { 1688 let host = caller; 1689 let r = <G::Host as Host>::variant_list(host, arg0); 1690 Box::pin(async move { 1691 let fun = r.await; 1692 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1693 let r = fun(caller); 1694 Ok((r,)) 1695 }) 1696 as Box< 1697 dyn FnOnce( 1698 wasmtime::StoreContextMut<'_, T>, 1699 ) -> wasmtime::Result< 1700 (wasmtime::component::__internal::Vec<OtherVariant>,), 1701 > + Send + Sync, 1702 > 1703 }) 1704 as ::core::pin::Pin< 1705 Box< 1706 dyn ::core::future::Future< 1707 Output = Box< 1708 dyn FnOnce( 1709 wasmtime::StoreContextMut<'_, T>, 1710 ) -> wasmtime::Result< 1711 (wasmtime::component::__internal::Vec<OtherVariant>,), 1712 > + Send + Sync, 1713 >, 1714 > + Send + Sync + 'static, 1715 >, 1716 > 1717 }, 1718 )?; 1719 inst.func_wrap_concurrent( 1720 "load-store-everything", 1721 move | 1722 mut caller: wasmtime::StoreContextMut<'_, T>, 1723 (arg0,): (LoadStoreAllSizes,)| 1724 { 1725 let host = caller; 1726 let r = <G::Host as Host>::load_store_everything(host, arg0); 1727 Box::pin(async move { 1728 let fun = r.await; 1729 Box::new(move |mut caller: wasmtime::StoreContextMut<'_, T>| { 1730 let r = fun(caller); 1731 Ok((r,)) 1732 }) 1733 as Box< 1734 dyn FnOnce( 1735 wasmtime::StoreContextMut<'_, T>, 1736 ) -> wasmtime::Result<(LoadStoreAllSizes,)> + Send + Sync, 1737 > 1738 }) 1739 as ::core::pin::Pin< 1740 Box< 1741 dyn ::core::future::Future< 1742 Output = Box< 1743 dyn FnOnce( 1744 wasmtime::StoreContextMut<'_, T>, 1745 ) -> wasmtime::Result<(LoadStoreAllSizes,)> + Send + Sync, 1746 >, 1747 > + Send + Sync + 'static, 1748 >, 1749 > 1750 }, 1751 )?; 1752 Ok(()) 1753 } 1754 pub fn add_to_linker<T, U>( 1755 linker: &mut wasmtime::component::Linker<T>, 1756 get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static, 1757 ) -> wasmtime::Result<()> 1758 where 1759 U: Host<Data = T> + Send, 1760 T: Send + 'static, 1761 { 1762 add_to_linker_get_host(linker, get) 1763 } 1764 impl<_T: Host> Host for &mut _T { 1765 type Data = _T::Data; 1766 fn list_u8_param( 1767 store: wasmtime::StoreContextMut<'_, Self::Data>, 1768 x: wasmtime::component::__internal::Vec<u8>, 1769 ) -> impl ::core::future::Future< 1770 Output = impl FnOnce( 1771 wasmtime::StoreContextMut<'_, Self::Data>, 1772 ) -> () + Send + Sync + 'static, 1773 > + Send + Sync + 'static 1774 where 1775 Self: Sized, 1776 { 1777 <_T as Host>::list_u8_param(store, x) 1778 } 1779 fn list_u16_param( 1780 store: wasmtime::StoreContextMut<'_, Self::Data>, 1781 x: wasmtime::component::__internal::Vec<u16>, 1782 ) -> impl ::core::future::Future< 1783 Output = impl FnOnce( 1784 wasmtime::StoreContextMut<'_, Self::Data>, 1785 ) -> () + Send + Sync + 'static, 1786 > + Send + Sync + 'static 1787 where 1788 Self: Sized, 1789 { 1790 <_T as Host>::list_u16_param(store, x) 1791 } 1792 fn list_u32_param( 1793 store: wasmtime::StoreContextMut<'_, Self::Data>, 1794 x: wasmtime::component::__internal::Vec<u32>, 1795 ) -> impl ::core::future::Future< 1796 Output = impl FnOnce( 1797 wasmtime::StoreContextMut<'_, Self::Data>, 1798 ) -> () + Send + Sync + 'static, 1799 > + Send + Sync + 'static 1800 where 1801 Self: Sized, 1802 { 1803 <_T as Host>::list_u32_param(store, x) 1804 } 1805 fn list_u64_param( 1806 store: wasmtime::StoreContextMut<'_, Self::Data>, 1807 x: wasmtime::component::__internal::Vec<u64>, 1808 ) -> impl ::core::future::Future< 1809 Output = impl FnOnce( 1810 wasmtime::StoreContextMut<'_, Self::Data>, 1811 ) -> () + Send + Sync + 'static, 1812 > + Send + Sync + 'static 1813 where 1814 Self: Sized, 1815 { 1816 <_T as Host>::list_u64_param(store, x) 1817 } 1818 fn list_s8_param( 1819 store: wasmtime::StoreContextMut<'_, Self::Data>, 1820 x: wasmtime::component::__internal::Vec<i8>, 1821 ) -> impl ::core::future::Future< 1822 Output = impl FnOnce( 1823 wasmtime::StoreContextMut<'_, Self::Data>, 1824 ) -> () + Send + Sync + 'static, 1825 > + Send + Sync + 'static 1826 where 1827 Self: Sized, 1828 { 1829 <_T as Host>::list_s8_param(store, x) 1830 } 1831 fn list_s16_param( 1832 store: wasmtime::StoreContextMut<'_, Self::Data>, 1833 x: wasmtime::component::__internal::Vec<i16>, 1834 ) -> impl ::core::future::Future< 1835 Output = impl FnOnce( 1836 wasmtime::StoreContextMut<'_, Self::Data>, 1837 ) -> () + Send + Sync + 'static, 1838 > + Send + Sync + 'static 1839 where 1840 Self: Sized, 1841 { 1842 <_T as Host>::list_s16_param(store, x) 1843 } 1844 fn list_s32_param( 1845 store: wasmtime::StoreContextMut<'_, Self::Data>, 1846 x: wasmtime::component::__internal::Vec<i32>, 1847 ) -> impl ::core::future::Future< 1848 Output = impl FnOnce( 1849 wasmtime::StoreContextMut<'_, Self::Data>, 1850 ) -> () + Send + Sync + 'static, 1851 > + Send + Sync + 'static 1852 where 1853 Self: Sized, 1854 { 1855 <_T as Host>::list_s32_param(store, x) 1856 } 1857 fn list_s64_param( 1858 store: wasmtime::StoreContextMut<'_, Self::Data>, 1859 x: wasmtime::component::__internal::Vec<i64>, 1860 ) -> impl ::core::future::Future< 1861 Output = impl FnOnce( 1862 wasmtime::StoreContextMut<'_, Self::Data>, 1863 ) -> () + Send + Sync + 'static, 1864 > + Send + Sync + 'static 1865 where 1866 Self: Sized, 1867 { 1868 <_T as Host>::list_s64_param(store, x) 1869 } 1870 fn list_f32_param( 1871 store: wasmtime::StoreContextMut<'_, Self::Data>, 1872 x: wasmtime::component::__internal::Vec<f32>, 1873 ) -> impl ::core::future::Future< 1874 Output = impl FnOnce( 1875 wasmtime::StoreContextMut<'_, Self::Data>, 1876 ) -> () + Send + Sync + 'static, 1877 > + Send + Sync + 'static 1878 where 1879 Self: Sized, 1880 { 1881 <_T as Host>::list_f32_param(store, x) 1882 } 1883 fn list_f64_param( 1884 store: wasmtime::StoreContextMut<'_, Self::Data>, 1885 x: wasmtime::component::__internal::Vec<f64>, 1886 ) -> impl ::core::future::Future< 1887 Output = impl FnOnce( 1888 wasmtime::StoreContextMut<'_, Self::Data>, 1889 ) -> () + Send + Sync + 'static, 1890 > + Send + Sync + 'static 1891 where 1892 Self: Sized, 1893 { 1894 <_T as Host>::list_f64_param(store, x) 1895 } 1896 fn list_u8_ret( 1897 store: wasmtime::StoreContextMut<'_, Self::Data>, 1898 ) -> impl ::core::future::Future< 1899 Output = impl FnOnce( 1900 wasmtime::StoreContextMut<'_, Self::Data>, 1901 ) -> wasmtime::component::__internal::Vec<u8> + Send + Sync + 'static, 1902 > + Send + Sync + 'static 1903 where 1904 Self: Sized, 1905 { 1906 <_T as Host>::list_u8_ret(store) 1907 } 1908 fn list_u16_ret( 1909 store: wasmtime::StoreContextMut<'_, Self::Data>, 1910 ) -> impl ::core::future::Future< 1911 Output = impl FnOnce( 1912 wasmtime::StoreContextMut<'_, Self::Data>, 1913 ) -> wasmtime::component::__internal::Vec< 1914 u16, 1915 > + Send + Sync + 'static, 1916 > + Send + Sync + 'static 1917 where 1918 Self: Sized, 1919 { 1920 <_T as Host>::list_u16_ret(store) 1921 } 1922 fn list_u32_ret( 1923 store: wasmtime::StoreContextMut<'_, Self::Data>, 1924 ) -> impl ::core::future::Future< 1925 Output = impl FnOnce( 1926 wasmtime::StoreContextMut<'_, Self::Data>, 1927 ) -> wasmtime::component::__internal::Vec< 1928 u32, 1929 > + Send + Sync + 'static, 1930 > + Send + Sync + 'static 1931 where 1932 Self: Sized, 1933 { 1934 <_T as Host>::list_u32_ret(store) 1935 } 1936 fn list_u64_ret( 1937 store: wasmtime::StoreContextMut<'_, Self::Data>, 1938 ) -> impl ::core::future::Future< 1939 Output = impl FnOnce( 1940 wasmtime::StoreContextMut<'_, Self::Data>, 1941 ) -> wasmtime::component::__internal::Vec< 1942 u64, 1943 > + Send + Sync + 'static, 1944 > + Send + Sync + 'static 1945 where 1946 Self: Sized, 1947 { 1948 <_T as Host>::list_u64_ret(store) 1949 } 1950 fn list_s8_ret( 1951 store: wasmtime::StoreContextMut<'_, Self::Data>, 1952 ) -> impl ::core::future::Future< 1953 Output = impl FnOnce( 1954 wasmtime::StoreContextMut<'_, Self::Data>, 1955 ) -> wasmtime::component::__internal::Vec<i8> + Send + Sync + 'static, 1956 > + Send + Sync + 'static 1957 where 1958 Self: Sized, 1959 { 1960 <_T as Host>::list_s8_ret(store) 1961 } 1962 fn list_s16_ret( 1963 store: wasmtime::StoreContextMut<'_, Self::Data>, 1964 ) -> impl ::core::future::Future< 1965 Output = impl FnOnce( 1966 wasmtime::StoreContextMut<'_, Self::Data>, 1967 ) -> wasmtime::component::__internal::Vec< 1968 i16, 1969 > + Send + Sync + 'static, 1970 > + Send + Sync + 'static 1971 where 1972 Self: Sized, 1973 { 1974 <_T as Host>::list_s16_ret(store) 1975 } 1976 fn list_s32_ret( 1977 store: wasmtime::StoreContextMut<'_, Self::Data>, 1978 ) -> impl ::core::future::Future< 1979 Output = impl FnOnce( 1980 wasmtime::StoreContextMut<'_, Self::Data>, 1981 ) -> wasmtime::component::__internal::Vec< 1982 i32, 1983 > + Send + Sync + 'static, 1984 > + Send + Sync + 'static 1985 where 1986 Self: Sized, 1987 { 1988 <_T as Host>::list_s32_ret(store) 1989 } 1990 fn list_s64_ret( 1991 store: wasmtime::StoreContextMut<'_, Self::Data>, 1992 ) -> impl ::core::future::Future< 1993 Output = impl FnOnce( 1994 wasmtime::StoreContextMut<'_, Self::Data>, 1995 ) -> wasmtime::component::__internal::Vec< 1996 i64, 1997 > + Send + Sync + 'static, 1998 > + Send + Sync + 'static 1999 where 2000 Self: Sized, 2001 { 2002 <_T as Host>::list_s64_ret(store) 2003 } 2004 fn list_f32_ret( 2005 store: wasmtime::StoreContextMut<'_, Self::Data>, 2006 ) -> impl ::core::future::Future< 2007 Output = impl FnOnce( 2008 wasmtime::StoreContextMut<'_, Self::Data>, 2009 ) -> wasmtime::component::__internal::Vec< 2010 f32, 2011 > + Send + Sync + 'static, 2012 > + Send + Sync + 'static 2013 where 2014 Self: Sized, 2015 { 2016 <_T as Host>::list_f32_ret(store) 2017 } 2018 fn list_f64_ret( 2019 store: wasmtime::StoreContextMut<'_, Self::Data>, 2020 ) -> impl ::core::future::Future< 2021 Output = impl FnOnce( 2022 wasmtime::StoreContextMut<'_, Self::Data>, 2023 ) -> wasmtime::component::__internal::Vec< 2024 f64, 2025 > + Send + Sync + 'static, 2026 > + Send + Sync + 'static 2027 where 2028 Self: Sized, 2029 { 2030 <_T as Host>::list_f64_ret(store) 2031 } 2032 fn tuple_list( 2033 store: wasmtime::StoreContextMut<'_, Self::Data>, 2034 x: wasmtime::component::__internal::Vec<(u8, i8)>, 2035 ) -> impl ::core::future::Future< 2036 Output = impl FnOnce( 2037 wasmtime::StoreContextMut<'_, Self::Data>, 2038 ) -> wasmtime::component::__internal::Vec< 2039 (i64, u32), 2040 > + Send + Sync + 'static, 2041 > + Send + Sync + 'static 2042 where 2043 Self: Sized, 2044 { 2045 <_T as Host>::tuple_list(store, x) 2046 } 2047 fn string_list_arg( 2048 store: wasmtime::StoreContextMut<'_, Self::Data>, 2049 a: wasmtime::component::__internal::Vec< 2050 wasmtime::component::__internal::String, 2051 >, 2052 ) -> impl ::core::future::Future< 2053 Output = impl FnOnce( 2054 wasmtime::StoreContextMut<'_, Self::Data>, 2055 ) -> () + Send + Sync + 'static, 2056 > + Send + Sync + 'static 2057 where 2058 Self: Sized, 2059 { 2060 <_T as Host>::string_list_arg(store, a) 2061 } 2062 fn string_list_ret( 2063 store: wasmtime::StoreContextMut<'_, Self::Data>, 2064 ) -> impl ::core::future::Future< 2065 Output = impl FnOnce( 2066 wasmtime::StoreContextMut<'_, Self::Data>, 2067 ) -> wasmtime::component::__internal::Vec< 2068 wasmtime::component::__internal::String, 2069 > + Send + Sync + 'static, 2070 > + Send + Sync + 'static 2071 where 2072 Self: Sized, 2073 { 2074 <_T as Host>::string_list_ret(store) 2075 } 2076 fn tuple_string_list( 2077 store: wasmtime::StoreContextMut<'_, Self::Data>, 2078 x: wasmtime::component::__internal::Vec< 2079 (u8, wasmtime::component::__internal::String), 2080 >, 2081 ) -> impl ::core::future::Future< 2082 Output = impl FnOnce( 2083 wasmtime::StoreContextMut<'_, Self::Data>, 2084 ) -> wasmtime::component::__internal::Vec< 2085 (wasmtime::component::__internal::String, u8), 2086 > + Send + Sync + 'static, 2087 > + Send + Sync + 'static 2088 where 2089 Self: Sized, 2090 { 2091 <_T as Host>::tuple_string_list(store, x) 2092 } 2093 fn string_list( 2094 store: wasmtime::StoreContextMut<'_, Self::Data>, 2095 x: wasmtime::component::__internal::Vec< 2096 wasmtime::component::__internal::String, 2097 >, 2098 ) -> impl ::core::future::Future< 2099 Output = impl FnOnce( 2100 wasmtime::StoreContextMut<'_, Self::Data>, 2101 ) -> wasmtime::component::__internal::Vec< 2102 wasmtime::component::__internal::String, 2103 > + Send + Sync + 'static, 2104 > + Send + Sync + 'static 2105 where 2106 Self: Sized, 2107 { 2108 <_T as Host>::string_list(store, x) 2109 } 2110 fn record_list( 2111 store: wasmtime::StoreContextMut<'_, Self::Data>, 2112 x: wasmtime::component::__internal::Vec<SomeRecord>, 2113 ) -> impl ::core::future::Future< 2114 Output = impl FnOnce( 2115 wasmtime::StoreContextMut<'_, Self::Data>, 2116 ) -> wasmtime::component::__internal::Vec< 2117 OtherRecord, 2118 > + Send + Sync + 'static, 2119 > + Send + Sync + 'static 2120 where 2121 Self: Sized, 2122 { 2123 <_T as Host>::record_list(store, x) 2124 } 2125 fn record_list_reverse( 2126 store: wasmtime::StoreContextMut<'_, Self::Data>, 2127 x: wasmtime::component::__internal::Vec<OtherRecord>, 2128 ) -> impl ::core::future::Future< 2129 Output = impl FnOnce( 2130 wasmtime::StoreContextMut<'_, Self::Data>, 2131 ) -> wasmtime::component::__internal::Vec< 2132 SomeRecord, 2133 > + Send + Sync + 'static, 2134 > + Send + Sync + 'static 2135 where 2136 Self: Sized, 2137 { 2138 <_T as Host>::record_list_reverse(store, x) 2139 } 2140 fn variant_list( 2141 store: wasmtime::StoreContextMut<'_, Self::Data>, 2142 x: wasmtime::component::__internal::Vec<SomeVariant>, 2143 ) -> impl ::core::future::Future< 2144 Output = impl FnOnce( 2145 wasmtime::StoreContextMut<'_, Self::Data>, 2146 ) -> wasmtime::component::__internal::Vec< 2147 OtherVariant, 2148 > + Send + Sync + 'static, 2149 > + Send + Sync + 'static 2150 where 2151 Self: Sized, 2152 { 2153 <_T as Host>::variant_list(store, x) 2154 } 2155 fn load_store_everything( 2156 store: wasmtime::StoreContextMut<'_, Self::Data>, 2157 a: LoadStoreAllSizes, 2158 ) -> impl ::core::future::Future< 2159 Output = impl FnOnce( 2160 wasmtime::StoreContextMut<'_, Self::Data>, 2161 ) -> LoadStoreAllSizes + Send + Sync + 'static, 2162 > + Send + Sync + 'static 2163 where 2164 Self: Sized, 2165 { 2166 <_T as Host>::load_store_everything(store, a) 2167 } 2168 } 2169 } 2170 } 2171 } 2172 pub mod exports { 2173 pub mod foo { 2174 pub mod foo { 2175 #[allow(clippy::all)] 2176 pub mod lists { 2177 #[allow(unused_imports)] 2178 use wasmtime::component::__internal::{anyhow, Box}; 2179 #[derive(wasmtime::component::ComponentType)] 2180 #[derive(wasmtime::component::Lift)] 2181 #[derive(wasmtime::component::Lower)] 2182 #[component(record)] 2183 #[derive(Clone)] 2184 pub struct OtherRecord { 2185 #[component(name = "a1")] 2186 pub a1: u32, 2187 #[component(name = "a2")] 2188 pub a2: u64, 2189 #[component(name = "a3")] 2190 pub a3: i32, 2191 #[component(name = "a4")] 2192 pub a4: i64, 2193 #[component(name = "b")] 2194 pub b: wasmtime::component::__internal::String, 2195 #[component(name = "c")] 2196 pub c: wasmtime::component::__internal::Vec<u8>, 2197 } 2198 impl core::fmt::Debug for OtherRecord { 2199 fn fmt( 2200 &self, 2201 f: &mut core::fmt::Formatter<'_>, 2202 ) -> core::fmt::Result { 2203 f.debug_struct("OtherRecord") 2204 .field("a1", &self.a1) 2205 .field("a2", &self.a2) 2206 .field("a3", &self.a3) 2207 .field("a4", &self.a4) 2208 .field("b", &self.b) 2209 .field("c", &self.c) 2210 .finish() 2211 } 2212 } 2213 const _: () = { 2214 assert!( 2215 48 == < OtherRecord as wasmtime::component::ComponentType 2216 >::SIZE32 2217 ); 2218 assert!( 2219 8 == < OtherRecord as wasmtime::component::ComponentType 2220 >::ALIGN32 2221 ); 2222 }; 2223 #[derive(wasmtime::component::ComponentType)] 2224 #[derive(wasmtime::component::Lift)] 2225 #[derive(wasmtime::component::Lower)] 2226 #[component(record)] 2227 #[derive(Clone)] 2228 pub struct SomeRecord { 2229 #[component(name = "x")] 2230 pub x: wasmtime::component::__internal::String, 2231 #[component(name = "y")] 2232 pub y: OtherRecord, 2233 #[component(name = "z")] 2234 pub z: wasmtime::component::__internal::Vec<OtherRecord>, 2235 #[component(name = "c1")] 2236 pub c1: u32, 2237 #[component(name = "c2")] 2238 pub c2: u64, 2239 #[component(name = "c3")] 2240 pub c3: i32, 2241 #[component(name = "c4")] 2242 pub c4: i64, 2243 } 2244 impl core::fmt::Debug for SomeRecord { 2245 fn fmt( 2246 &self, 2247 f: &mut core::fmt::Formatter<'_>, 2248 ) -> core::fmt::Result { 2249 f.debug_struct("SomeRecord") 2250 .field("x", &self.x) 2251 .field("y", &self.y) 2252 .field("z", &self.z) 2253 .field("c1", &self.c1) 2254 .field("c2", &self.c2) 2255 .field("c3", &self.c3) 2256 .field("c4", &self.c4) 2257 .finish() 2258 } 2259 } 2260 const _: () = { 2261 assert!( 2262 96 == < SomeRecord as wasmtime::component::ComponentType 2263 >::SIZE32 2264 ); 2265 assert!( 2266 8 == < SomeRecord as wasmtime::component::ComponentType 2267 >::ALIGN32 2268 ); 2269 }; 2270 #[derive(wasmtime::component::ComponentType)] 2271 #[derive(wasmtime::component::Lift)] 2272 #[derive(wasmtime::component::Lower)] 2273 #[component(variant)] 2274 #[derive(Clone)] 2275 pub enum OtherVariant { 2276 #[component(name = "a")] 2277 A, 2278 #[component(name = "b")] 2279 B(u32), 2280 #[component(name = "c")] 2281 C(wasmtime::component::__internal::String), 2282 } 2283 impl core::fmt::Debug for OtherVariant { 2284 fn fmt( 2285 &self, 2286 f: &mut core::fmt::Formatter<'_>, 2287 ) -> core::fmt::Result { 2288 match self { 2289 OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(), 2290 OtherVariant::B(e) => { 2291 f.debug_tuple("OtherVariant::B").field(e).finish() 2292 } 2293 OtherVariant::C(e) => { 2294 f.debug_tuple("OtherVariant::C").field(e).finish() 2295 } 2296 } 2297 } 2298 } 2299 const _: () = { 2300 assert!( 2301 12 == < OtherVariant as wasmtime::component::ComponentType 2302 >::SIZE32 2303 ); 2304 assert!( 2305 4 == < OtherVariant as wasmtime::component::ComponentType 2306 >::ALIGN32 2307 ); 2308 }; 2309 #[derive(wasmtime::component::ComponentType)] 2310 #[derive(wasmtime::component::Lift)] 2311 #[derive(wasmtime::component::Lower)] 2312 #[component(variant)] 2313 #[derive(Clone)] 2314 pub enum SomeVariant { 2315 #[component(name = "a")] 2316 A(wasmtime::component::__internal::String), 2317 #[component(name = "b")] 2318 B, 2319 #[component(name = "c")] 2320 C(u32), 2321 #[component(name = "d")] 2322 D(wasmtime::component::__internal::Vec<OtherVariant>), 2323 } 2324 impl core::fmt::Debug for SomeVariant { 2325 fn fmt( 2326 &self, 2327 f: &mut core::fmt::Formatter<'_>, 2328 ) -> core::fmt::Result { 2329 match self { 2330 SomeVariant::A(e) => { 2331 f.debug_tuple("SomeVariant::A").field(e).finish() 2332 } 2333 SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(), 2334 SomeVariant::C(e) => { 2335 f.debug_tuple("SomeVariant::C").field(e).finish() 2336 } 2337 SomeVariant::D(e) => { 2338 f.debug_tuple("SomeVariant::D").field(e).finish() 2339 } 2340 } 2341 } 2342 } 2343 const _: () = { 2344 assert!( 2345 12 == < SomeVariant as wasmtime::component::ComponentType 2346 >::SIZE32 2347 ); 2348 assert!( 2349 4 == < SomeVariant as wasmtime::component::ComponentType 2350 >::ALIGN32 2351 ); 2352 }; 2353 pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec< 2354 ( 2355 wasmtime::component::__internal::String, 2356 u8, 2357 i8, 2358 u16, 2359 i16, 2360 u32, 2361 i32, 2362 u64, 2363 i64, 2364 f32, 2365 f64, 2366 char, 2367 ), 2368 >; 2369 const _: () = { 2370 assert!( 2371 8 == < LoadStoreAllSizes as wasmtime::component::ComponentType 2372 >::SIZE32 2373 ); 2374 assert!( 2375 4 == < LoadStoreAllSizes as wasmtime::component::ComponentType 2376 >::ALIGN32 2377 ); 2378 }; 2379 pub struct Guest { 2380 list_u8_param: wasmtime::component::Func, 2381 list_u16_param: wasmtime::component::Func, 2382 list_u32_param: wasmtime::component::Func, 2383 list_u64_param: wasmtime::component::Func, 2384 list_s8_param: wasmtime::component::Func, 2385 list_s16_param: wasmtime::component::Func, 2386 list_s32_param: wasmtime::component::Func, 2387 list_s64_param: wasmtime::component::Func, 2388 list_f32_param: wasmtime::component::Func, 2389 list_f64_param: wasmtime::component::Func, 2390 list_u8_ret: wasmtime::component::Func, 2391 list_u16_ret: wasmtime::component::Func, 2392 list_u32_ret: wasmtime::component::Func, 2393 list_u64_ret: wasmtime::component::Func, 2394 list_s8_ret: wasmtime::component::Func, 2395 list_s16_ret: wasmtime::component::Func, 2396 list_s32_ret: wasmtime::component::Func, 2397 list_s64_ret: wasmtime::component::Func, 2398 list_f32_ret: wasmtime::component::Func, 2399 list_f64_ret: wasmtime::component::Func, 2400 tuple_list: wasmtime::component::Func, 2401 string_list_arg: wasmtime::component::Func, 2402 string_list_ret: wasmtime::component::Func, 2403 tuple_string_list: wasmtime::component::Func, 2404 string_list: wasmtime::component::Func, 2405 record_list: wasmtime::component::Func, 2406 record_list_reverse: wasmtime::component::Func, 2407 variant_list: wasmtime::component::Func, 2408 load_store_everything: wasmtime::component::Func, 2409 } 2410 #[derive(Clone)] 2411 pub struct GuestIndices { 2412 list_u8_param: wasmtime::component::ComponentExportIndex, 2413 list_u16_param: wasmtime::component::ComponentExportIndex, 2414 list_u32_param: wasmtime::component::ComponentExportIndex, 2415 list_u64_param: wasmtime::component::ComponentExportIndex, 2416 list_s8_param: wasmtime::component::ComponentExportIndex, 2417 list_s16_param: wasmtime::component::ComponentExportIndex, 2418 list_s32_param: wasmtime::component::ComponentExportIndex, 2419 list_s64_param: wasmtime::component::ComponentExportIndex, 2420 list_f32_param: wasmtime::component::ComponentExportIndex, 2421 list_f64_param: wasmtime::component::ComponentExportIndex, 2422 list_u8_ret: wasmtime::component::ComponentExportIndex, 2423 list_u16_ret: wasmtime::component::ComponentExportIndex, 2424 list_u32_ret: wasmtime::component::ComponentExportIndex, 2425 list_u64_ret: wasmtime::component::ComponentExportIndex, 2426 list_s8_ret: wasmtime::component::ComponentExportIndex, 2427 list_s16_ret: wasmtime::component::ComponentExportIndex, 2428 list_s32_ret: wasmtime::component::ComponentExportIndex, 2429 list_s64_ret: wasmtime::component::ComponentExportIndex, 2430 list_f32_ret: wasmtime::component::ComponentExportIndex, 2431 list_f64_ret: wasmtime::component::ComponentExportIndex, 2432 tuple_list: wasmtime::component::ComponentExportIndex, 2433 string_list_arg: wasmtime::component::ComponentExportIndex, 2434 string_list_ret: wasmtime::component::ComponentExportIndex, 2435 tuple_string_list: wasmtime::component::ComponentExportIndex, 2436 string_list: wasmtime::component::ComponentExportIndex, 2437 record_list: wasmtime::component::ComponentExportIndex, 2438 record_list_reverse: wasmtime::component::ComponentExportIndex, 2439 variant_list: wasmtime::component::ComponentExportIndex, 2440 load_store_everything: wasmtime::component::ComponentExportIndex, 2441 } 2442 impl GuestIndices { 2443 /// Constructor for [`GuestIndices`] which takes a 2444 /// [`Component`](wasmtime::component::Component) as input and can be executed 2445 /// before instantiation. 2446 /// 2447 /// This constructor can be used to front-load string lookups to find exports 2448 /// within a component. 2449 pub fn new( 2450 component: &wasmtime::component::Component, 2451 ) -> wasmtime::Result<GuestIndices> { 2452 let (_, instance) = component 2453 .export_index(None, "foo:foo/lists") 2454 .ok_or_else(|| { 2455 anyhow::anyhow!( 2456 "no exported instance named `foo:foo/lists`" 2457 ) 2458 })?; 2459 Self::_new(|name| { 2460 component.export_index(Some(&instance), name).map(|p| p.1) 2461 }) 2462 } 2463 /// This constructor is similar to [`GuestIndices::new`] except that it 2464 /// performs string lookups after instantiation time. 2465 pub fn new_instance( 2466 mut store: impl wasmtime::AsContextMut, 2467 instance: &wasmtime::component::Instance, 2468 ) -> wasmtime::Result<GuestIndices> { 2469 let instance_export = instance 2470 .get_export(&mut store, None, "foo:foo/lists") 2471 .ok_or_else(|| { 2472 anyhow::anyhow!( 2473 "no exported instance named `foo:foo/lists`" 2474 ) 2475 })?; 2476 Self::_new(|name| { 2477 instance.get_export(&mut store, Some(&instance_export), name) 2478 }) 2479 } 2480 fn _new( 2481 mut lookup: impl FnMut( 2482 &str, 2483 ) -> Option<wasmtime::component::ComponentExportIndex>, 2484 ) -> wasmtime::Result<GuestIndices> { 2485 let mut lookup = move |name| { 2486 lookup(name) 2487 .ok_or_else(|| { 2488 anyhow::anyhow!( 2489 "instance export `foo:foo/lists` does \ 2490 not have export `{name}`" 2491 ) 2492 }) 2493 }; 2494 let _ = &mut lookup; 2495 let list_u8_param = lookup("list-u8-param")?; 2496 let list_u16_param = lookup("list-u16-param")?; 2497 let list_u32_param = lookup("list-u32-param")?; 2498 let list_u64_param = lookup("list-u64-param")?; 2499 let list_s8_param = lookup("list-s8-param")?; 2500 let list_s16_param = lookup("list-s16-param")?; 2501 let list_s32_param = lookup("list-s32-param")?; 2502 let list_s64_param = lookup("list-s64-param")?; 2503 let list_f32_param = lookup("list-f32-param")?; 2504 let list_f64_param = lookup("list-f64-param")?; 2505 let list_u8_ret = lookup("list-u8-ret")?; 2506 let list_u16_ret = lookup("list-u16-ret")?; 2507 let list_u32_ret = lookup("list-u32-ret")?; 2508 let list_u64_ret = lookup("list-u64-ret")?; 2509 let list_s8_ret = lookup("list-s8-ret")?; 2510 let list_s16_ret = lookup("list-s16-ret")?; 2511 let list_s32_ret = lookup("list-s32-ret")?; 2512 let list_s64_ret = lookup("list-s64-ret")?; 2513 let list_f32_ret = lookup("list-f32-ret")?; 2514 let list_f64_ret = lookup("list-f64-ret")?; 2515 let tuple_list = lookup("tuple-list")?; 2516 let string_list_arg = lookup("string-list-arg")?; 2517 let string_list_ret = lookup("string-list-ret")?; 2518 let tuple_string_list = lookup("tuple-string-list")?; 2519 let string_list = lookup("string-list")?; 2520 let record_list = lookup("record-list")?; 2521 let record_list_reverse = lookup("record-list-reverse")?; 2522 let variant_list = lookup("variant-list")?; 2523 let load_store_everything = lookup("load-store-everything")?; 2524 Ok(GuestIndices { 2525 list_u8_param, 2526 list_u16_param, 2527 list_u32_param, 2528 list_u64_param, 2529 list_s8_param, 2530 list_s16_param, 2531 list_s32_param, 2532 list_s64_param, 2533 list_f32_param, 2534 list_f64_param, 2535 list_u8_ret, 2536 list_u16_ret, 2537 list_u32_ret, 2538 list_u64_ret, 2539 list_s8_ret, 2540 list_s16_ret, 2541 list_s32_ret, 2542 list_s64_ret, 2543 list_f32_ret, 2544 list_f64_ret, 2545 tuple_list, 2546 string_list_arg, 2547 string_list_ret, 2548 tuple_string_list, 2549 string_list, 2550 record_list, 2551 record_list_reverse, 2552 variant_list, 2553 load_store_everything, 2554 }) 2555 } 2556 pub fn load( 2557 &self, 2558 mut store: impl wasmtime::AsContextMut, 2559 instance: &wasmtime::component::Instance, 2560 ) -> wasmtime::Result<Guest> { 2561 let mut store = store.as_context_mut(); 2562 let _ = &mut store; 2563 let _instance = instance; 2564 let list_u8_param = *_instance 2565 .get_typed_func::< 2566 (&[u8],), 2567 (), 2568 >(&mut store, &self.list_u8_param)? 2569 .func(); 2570 let list_u16_param = *_instance 2571 .get_typed_func::< 2572 (&[u16],), 2573 (), 2574 >(&mut store, &self.list_u16_param)? 2575 .func(); 2576 let list_u32_param = *_instance 2577 .get_typed_func::< 2578 (&[u32],), 2579 (), 2580 >(&mut store, &self.list_u32_param)? 2581 .func(); 2582 let list_u64_param = *_instance 2583 .get_typed_func::< 2584 (&[u64],), 2585 (), 2586 >(&mut store, &self.list_u64_param)? 2587 .func(); 2588 let list_s8_param = *_instance 2589 .get_typed_func::< 2590 (&[i8],), 2591 (), 2592 >(&mut store, &self.list_s8_param)? 2593 .func(); 2594 let list_s16_param = *_instance 2595 .get_typed_func::< 2596 (&[i16],), 2597 (), 2598 >(&mut store, &self.list_s16_param)? 2599 .func(); 2600 let list_s32_param = *_instance 2601 .get_typed_func::< 2602 (&[i32],), 2603 (), 2604 >(&mut store, &self.list_s32_param)? 2605 .func(); 2606 let list_s64_param = *_instance 2607 .get_typed_func::< 2608 (&[i64],), 2609 (), 2610 >(&mut store, &self.list_s64_param)? 2611 .func(); 2612 let list_f32_param = *_instance 2613 .get_typed_func::< 2614 (&[f32],), 2615 (), 2616 >(&mut store, &self.list_f32_param)? 2617 .func(); 2618 let list_f64_param = *_instance 2619 .get_typed_func::< 2620 (&[f64],), 2621 (), 2622 >(&mut store, &self.list_f64_param)? 2623 .func(); 2624 let list_u8_ret = *_instance 2625 .get_typed_func::< 2626 (), 2627 (wasmtime::component::__internal::Vec<u8>,), 2628 >(&mut store, &self.list_u8_ret)? 2629 .func(); 2630 let list_u16_ret = *_instance 2631 .get_typed_func::< 2632 (), 2633 (wasmtime::component::__internal::Vec<u16>,), 2634 >(&mut store, &self.list_u16_ret)? 2635 .func(); 2636 let list_u32_ret = *_instance 2637 .get_typed_func::< 2638 (), 2639 (wasmtime::component::__internal::Vec<u32>,), 2640 >(&mut store, &self.list_u32_ret)? 2641 .func(); 2642 let list_u64_ret = *_instance 2643 .get_typed_func::< 2644 (), 2645 (wasmtime::component::__internal::Vec<u64>,), 2646 >(&mut store, &self.list_u64_ret)? 2647 .func(); 2648 let list_s8_ret = *_instance 2649 .get_typed_func::< 2650 (), 2651 (wasmtime::component::__internal::Vec<i8>,), 2652 >(&mut store, &self.list_s8_ret)? 2653 .func(); 2654 let list_s16_ret = *_instance 2655 .get_typed_func::< 2656 (), 2657 (wasmtime::component::__internal::Vec<i16>,), 2658 >(&mut store, &self.list_s16_ret)? 2659 .func(); 2660 let list_s32_ret = *_instance 2661 .get_typed_func::< 2662 (), 2663 (wasmtime::component::__internal::Vec<i32>,), 2664 >(&mut store, &self.list_s32_ret)? 2665 .func(); 2666 let list_s64_ret = *_instance 2667 .get_typed_func::< 2668 (), 2669 (wasmtime::component::__internal::Vec<i64>,), 2670 >(&mut store, &self.list_s64_ret)? 2671 .func(); 2672 let list_f32_ret = *_instance 2673 .get_typed_func::< 2674 (), 2675 (wasmtime::component::__internal::Vec<f32>,), 2676 >(&mut store, &self.list_f32_ret)? 2677 .func(); 2678 let list_f64_ret = *_instance 2679 .get_typed_func::< 2680 (), 2681 (wasmtime::component::__internal::Vec<f64>,), 2682 >(&mut store, &self.list_f64_ret)? 2683 .func(); 2684 let tuple_list = *_instance 2685 .get_typed_func::< 2686 (&[(u8, i8)],), 2687 (wasmtime::component::__internal::Vec<(i64, u32)>,), 2688 >(&mut store, &self.tuple_list)? 2689 .func(); 2690 let string_list_arg = *_instance 2691 .get_typed_func::< 2692 (&[wasmtime::component::__internal::String],), 2693 (), 2694 >(&mut store, &self.string_list_arg)? 2695 .func(); 2696 let string_list_ret = *_instance 2697 .get_typed_func::< 2698 (), 2699 ( 2700 wasmtime::component::__internal::Vec< 2701 wasmtime::component::__internal::String, 2702 >, 2703 ), 2704 >(&mut store, &self.string_list_ret)? 2705 .func(); 2706 let tuple_string_list = *_instance 2707 .get_typed_func::< 2708 (&[(u8, wasmtime::component::__internal::String)],), 2709 ( 2710 wasmtime::component::__internal::Vec< 2711 (wasmtime::component::__internal::String, u8), 2712 >, 2713 ), 2714 >(&mut store, &self.tuple_string_list)? 2715 .func(); 2716 let string_list = *_instance 2717 .get_typed_func::< 2718 (&[wasmtime::component::__internal::String],), 2719 ( 2720 wasmtime::component::__internal::Vec< 2721 wasmtime::component::__internal::String, 2722 >, 2723 ), 2724 >(&mut store, &self.string_list)? 2725 .func(); 2726 let record_list = *_instance 2727 .get_typed_func::< 2728 (&[SomeRecord],), 2729 (wasmtime::component::__internal::Vec<OtherRecord>,), 2730 >(&mut store, &self.record_list)? 2731 .func(); 2732 let record_list_reverse = *_instance 2733 .get_typed_func::< 2734 (&[OtherRecord],), 2735 (wasmtime::component::__internal::Vec<SomeRecord>,), 2736 >(&mut store, &self.record_list_reverse)? 2737 .func(); 2738 let variant_list = *_instance 2739 .get_typed_func::< 2740 (&[SomeVariant],), 2741 (wasmtime::component::__internal::Vec<OtherVariant>,), 2742 >(&mut store, &self.variant_list)? 2743 .func(); 2744 let load_store_everything = *_instance 2745 .get_typed_func::< 2746 (&LoadStoreAllSizes,), 2747 (LoadStoreAllSizes,), 2748 >(&mut store, &self.load_store_everything)? 2749 .func(); 2750 Ok(Guest { 2751 list_u8_param, 2752 list_u16_param, 2753 list_u32_param, 2754 list_u64_param, 2755 list_s8_param, 2756 list_s16_param, 2757 list_s32_param, 2758 list_s64_param, 2759 list_f32_param, 2760 list_f64_param, 2761 list_u8_ret, 2762 list_u16_ret, 2763 list_u32_ret, 2764 list_u64_ret, 2765 list_s8_ret, 2766 list_s16_ret, 2767 list_s32_ret, 2768 list_s64_ret, 2769 list_f32_ret, 2770 list_f64_ret, 2771 tuple_list, 2772 string_list_arg, 2773 string_list_ret, 2774 tuple_string_list, 2775 string_list, 2776 record_list, 2777 record_list_reverse, 2778 variant_list, 2779 load_store_everything, 2780 }) 2781 } 2782 } 2783 impl Guest { 2784 pub async fn call_list_u8_param<S: wasmtime::AsContextMut>( 2785 &self, 2786 mut store: S, 2787 arg0: wasmtime::component::__internal::Vec<u8>, 2788 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2789 where 2790 <S as wasmtime::AsContext>::Data: Send + 'static, 2791 { 2792 let callee = unsafe { 2793 wasmtime::component::TypedFunc::< 2794 (wasmtime::component::__internal::Vec<u8>,), 2795 (), 2796 >::new_unchecked(self.list_u8_param) 2797 }; 2798 let promise = callee 2799 .call_concurrent(store.as_context_mut(), (arg0,)) 2800 .await?; 2801 Ok(promise) 2802 } 2803 pub async fn call_list_u16_param<S: wasmtime::AsContextMut>( 2804 &self, 2805 mut store: S, 2806 arg0: wasmtime::component::__internal::Vec<u16>, 2807 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2808 where 2809 <S as wasmtime::AsContext>::Data: Send + 'static, 2810 { 2811 let callee = unsafe { 2812 wasmtime::component::TypedFunc::< 2813 (wasmtime::component::__internal::Vec<u16>,), 2814 (), 2815 >::new_unchecked(self.list_u16_param) 2816 }; 2817 let promise = callee 2818 .call_concurrent(store.as_context_mut(), (arg0,)) 2819 .await?; 2820 Ok(promise) 2821 } 2822 pub async fn call_list_u32_param<S: wasmtime::AsContextMut>( 2823 &self, 2824 mut store: S, 2825 arg0: wasmtime::component::__internal::Vec<u32>, 2826 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2827 where 2828 <S as wasmtime::AsContext>::Data: Send + 'static, 2829 { 2830 let callee = unsafe { 2831 wasmtime::component::TypedFunc::< 2832 (wasmtime::component::__internal::Vec<u32>,), 2833 (), 2834 >::new_unchecked(self.list_u32_param) 2835 }; 2836 let promise = callee 2837 .call_concurrent(store.as_context_mut(), (arg0,)) 2838 .await?; 2839 Ok(promise) 2840 } 2841 pub async fn call_list_u64_param<S: wasmtime::AsContextMut>( 2842 &self, 2843 mut store: S, 2844 arg0: wasmtime::component::__internal::Vec<u64>, 2845 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2846 where 2847 <S as wasmtime::AsContext>::Data: Send + 'static, 2848 { 2849 let callee = unsafe { 2850 wasmtime::component::TypedFunc::< 2851 (wasmtime::component::__internal::Vec<u64>,), 2852 (), 2853 >::new_unchecked(self.list_u64_param) 2854 }; 2855 let promise = callee 2856 .call_concurrent(store.as_context_mut(), (arg0,)) 2857 .await?; 2858 Ok(promise) 2859 } 2860 pub async fn call_list_s8_param<S: wasmtime::AsContextMut>( 2861 &self, 2862 mut store: S, 2863 arg0: wasmtime::component::__internal::Vec<i8>, 2864 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2865 where 2866 <S as wasmtime::AsContext>::Data: Send + 'static, 2867 { 2868 let callee = unsafe { 2869 wasmtime::component::TypedFunc::< 2870 (wasmtime::component::__internal::Vec<i8>,), 2871 (), 2872 >::new_unchecked(self.list_s8_param) 2873 }; 2874 let promise = callee 2875 .call_concurrent(store.as_context_mut(), (arg0,)) 2876 .await?; 2877 Ok(promise) 2878 } 2879 pub async fn call_list_s16_param<S: wasmtime::AsContextMut>( 2880 &self, 2881 mut store: S, 2882 arg0: wasmtime::component::__internal::Vec<i16>, 2883 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2884 where 2885 <S as wasmtime::AsContext>::Data: Send + 'static, 2886 { 2887 let callee = unsafe { 2888 wasmtime::component::TypedFunc::< 2889 (wasmtime::component::__internal::Vec<i16>,), 2890 (), 2891 >::new_unchecked(self.list_s16_param) 2892 }; 2893 let promise = callee 2894 .call_concurrent(store.as_context_mut(), (arg0,)) 2895 .await?; 2896 Ok(promise) 2897 } 2898 pub async fn call_list_s32_param<S: wasmtime::AsContextMut>( 2899 &self, 2900 mut store: S, 2901 arg0: wasmtime::component::__internal::Vec<i32>, 2902 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2903 where 2904 <S as wasmtime::AsContext>::Data: Send + 'static, 2905 { 2906 let callee = unsafe { 2907 wasmtime::component::TypedFunc::< 2908 (wasmtime::component::__internal::Vec<i32>,), 2909 (), 2910 >::new_unchecked(self.list_s32_param) 2911 }; 2912 let promise = callee 2913 .call_concurrent(store.as_context_mut(), (arg0,)) 2914 .await?; 2915 Ok(promise) 2916 } 2917 pub async fn call_list_s64_param<S: wasmtime::AsContextMut>( 2918 &self, 2919 mut store: S, 2920 arg0: wasmtime::component::__internal::Vec<i64>, 2921 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2922 where 2923 <S as wasmtime::AsContext>::Data: Send + 'static, 2924 { 2925 let callee = unsafe { 2926 wasmtime::component::TypedFunc::< 2927 (wasmtime::component::__internal::Vec<i64>,), 2928 (), 2929 >::new_unchecked(self.list_s64_param) 2930 }; 2931 let promise = callee 2932 .call_concurrent(store.as_context_mut(), (arg0,)) 2933 .await?; 2934 Ok(promise) 2935 } 2936 pub async fn call_list_f32_param<S: wasmtime::AsContextMut>( 2937 &self, 2938 mut store: S, 2939 arg0: wasmtime::component::__internal::Vec<f32>, 2940 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2941 where 2942 <S as wasmtime::AsContext>::Data: Send + 'static, 2943 { 2944 let callee = unsafe { 2945 wasmtime::component::TypedFunc::< 2946 (wasmtime::component::__internal::Vec<f32>,), 2947 (), 2948 >::new_unchecked(self.list_f32_param) 2949 }; 2950 let promise = callee 2951 .call_concurrent(store.as_context_mut(), (arg0,)) 2952 .await?; 2953 Ok(promise) 2954 } 2955 pub async fn call_list_f64_param<S: wasmtime::AsContextMut>( 2956 &self, 2957 mut store: S, 2958 arg0: wasmtime::component::__internal::Vec<f64>, 2959 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 2960 where 2961 <S as wasmtime::AsContext>::Data: Send + 'static, 2962 { 2963 let callee = unsafe { 2964 wasmtime::component::TypedFunc::< 2965 (wasmtime::component::__internal::Vec<f64>,), 2966 (), 2967 >::new_unchecked(self.list_f64_param) 2968 }; 2969 let promise = callee 2970 .call_concurrent(store.as_context_mut(), (arg0,)) 2971 .await?; 2972 Ok(promise) 2973 } 2974 pub async fn call_list_u8_ret<S: wasmtime::AsContextMut>( 2975 &self, 2976 mut store: S, 2977 ) -> wasmtime::Result< 2978 wasmtime::component::Promise< 2979 wasmtime::component::__internal::Vec<u8>, 2980 >, 2981 > 2982 where 2983 <S as wasmtime::AsContext>::Data: Send + 'static, 2984 { 2985 let callee = unsafe { 2986 wasmtime::component::TypedFunc::< 2987 (), 2988 (wasmtime::component::__internal::Vec<u8>,), 2989 >::new_unchecked(self.list_u8_ret) 2990 }; 2991 let promise = callee 2992 .call_concurrent(store.as_context_mut(), ()) 2993 .await?; 2994 Ok(promise.map(|(v,)| v)) 2995 } 2996 pub async fn call_list_u16_ret<S: wasmtime::AsContextMut>( 2997 &self, 2998 mut store: S, 2999 ) -> wasmtime::Result< 3000 wasmtime::component::Promise< 3001 wasmtime::component::__internal::Vec<u16>, 3002 >, 3003 > 3004 where 3005 <S as wasmtime::AsContext>::Data: Send + 'static, 3006 { 3007 let callee = unsafe { 3008 wasmtime::component::TypedFunc::< 3009 (), 3010 (wasmtime::component::__internal::Vec<u16>,), 3011 >::new_unchecked(self.list_u16_ret) 3012 }; 3013 let promise = callee 3014 .call_concurrent(store.as_context_mut(), ()) 3015 .await?; 3016 Ok(promise.map(|(v,)| v)) 3017 } 3018 pub async fn call_list_u32_ret<S: wasmtime::AsContextMut>( 3019 &self, 3020 mut store: S, 3021 ) -> wasmtime::Result< 3022 wasmtime::component::Promise< 3023 wasmtime::component::__internal::Vec<u32>, 3024 >, 3025 > 3026 where 3027 <S as wasmtime::AsContext>::Data: Send + 'static, 3028 { 3029 let callee = unsafe { 3030 wasmtime::component::TypedFunc::< 3031 (), 3032 (wasmtime::component::__internal::Vec<u32>,), 3033 >::new_unchecked(self.list_u32_ret) 3034 }; 3035 let promise = callee 3036 .call_concurrent(store.as_context_mut(), ()) 3037 .await?; 3038 Ok(promise.map(|(v,)| v)) 3039 } 3040 pub async fn call_list_u64_ret<S: wasmtime::AsContextMut>( 3041 &self, 3042 mut store: S, 3043 ) -> wasmtime::Result< 3044 wasmtime::component::Promise< 3045 wasmtime::component::__internal::Vec<u64>, 3046 >, 3047 > 3048 where 3049 <S as wasmtime::AsContext>::Data: Send + 'static, 3050 { 3051 let callee = unsafe { 3052 wasmtime::component::TypedFunc::< 3053 (), 3054 (wasmtime::component::__internal::Vec<u64>,), 3055 >::new_unchecked(self.list_u64_ret) 3056 }; 3057 let promise = callee 3058 .call_concurrent(store.as_context_mut(), ()) 3059 .await?; 3060 Ok(promise.map(|(v,)| v)) 3061 } 3062 pub async fn call_list_s8_ret<S: wasmtime::AsContextMut>( 3063 &self, 3064 mut store: S, 3065 ) -> wasmtime::Result< 3066 wasmtime::component::Promise< 3067 wasmtime::component::__internal::Vec<i8>, 3068 >, 3069 > 3070 where 3071 <S as wasmtime::AsContext>::Data: Send + 'static, 3072 { 3073 let callee = unsafe { 3074 wasmtime::component::TypedFunc::< 3075 (), 3076 (wasmtime::component::__internal::Vec<i8>,), 3077 >::new_unchecked(self.list_s8_ret) 3078 }; 3079 let promise = callee 3080 .call_concurrent(store.as_context_mut(), ()) 3081 .await?; 3082 Ok(promise.map(|(v,)| v)) 3083 } 3084 pub async fn call_list_s16_ret<S: wasmtime::AsContextMut>( 3085 &self, 3086 mut store: S, 3087 ) -> wasmtime::Result< 3088 wasmtime::component::Promise< 3089 wasmtime::component::__internal::Vec<i16>, 3090 >, 3091 > 3092 where 3093 <S as wasmtime::AsContext>::Data: Send + 'static, 3094 { 3095 let callee = unsafe { 3096 wasmtime::component::TypedFunc::< 3097 (), 3098 (wasmtime::component::__internal::Vec<i16>,), 3099 >::new_unchecked(self.list_s16_ret) 3100 }; 3101 let promise = callee 3102 .call_concurrent(store.as_context_mut(), ()) 3103 .await?; 3104 Ok(promise.map(|(v,)| v)) 3105 } 3106 pub async fn call_list_s32_ret<S: wasmtime::AsContextMut>( 3107 &self, 3108 mut store: S, 3109 ) -> wasmtime::Result< 3110 wasmtime::component::Promise< 3111 wasmtime::component::__internal::Vec<i32>, 3112 >, 3113 > 3114 where 3115 <S as wasmtime::AsContext>::Data: Send + 'static, 3116 { 3117 let callee = unsafe { 3118 wasmtime::component::TypedFunc::< 3119 (), 3120 (wasmtime::component::__internal::Vec<i32>,), 3121 >::new_unchecked(self.list_s32_ret) 3122 }; 3123 let promise = callee 3124 .call_concurrent(store.as_context_mut(), ()) 3125 .await?; 3126 Ok(promise.map(|(v,)| v)) 3127 } 3128 pub async fn call_list_s64_ret<S: wasmtime::AsContextMut>( 3129 &self, 3130 mut store: S, 3131 ) -> wasmtime::Result< 3132 wasmtime::component::Promise< 3133 wasmtime::component::__internal::Vec<i64>, 3134 >, 3135 > 3136 where 3137 <S as wasmtime::AsContext>::Data: Send + 'static, 3138 { 3139 let callee = unsafe { 3140 wasmtime::component::TypedFunc::< 3141 (), 3142 (wasmtime::component::__internal::Vec<i64>,), 3143 >::new_unchecked(self.list_s64_ret) 3144 }; 3145 let promise = callee 3146 .call_concurrent(store.as_context_mut(), ()) 3147 .await?; 3148 Ok(promise.map(|(v,)| v)) 3149 } 3150 pub async fn call_list_f32_ret<S: wasmtime::AsContextMut>( 3151 &self, 3152 mut store: S, 3153 ) -> wasmtime::Result< 3154 wasmtime::component::Promise< 3155 wasmtime::component::__internal::Vec<f32>, 3156 >, 3157 > 3158 where 3159 <S as wasmtime::AsContext>::Data: Send + 'static, 3160 { 3161 let callee = unsafe { 3162 wasmtime::component::TypedFunc::< 3163 (), 3164 (wasmtime::component::__internal::Vec<f32>,), 3165 >::new_unchecked(self.list_f32_ret) 3166 }; 3167 let promise = callee 3168 .call_concurrent(store.as_context_mut(), ()) 3169 .await?; 3170 Ok(promise.map(|(v,)| v)) 3171 } 3172 pub async fn call_list_f64_ret<S: wasmtime::AsContextMut>( 3173 &self, 3174 mut store: S, 3175 ) -> wasmtime::Result< 3176 wasmtime::component::Promise< 3177 wasmtime::component::__internal::Vec<f64>, 3178 >, 3179 > 3180 where 3181 <S as wasmtime::AsContext>::Data: Send + 'static, 3182 { 3183 let callee = unsafe { 3184 wasmtime::component::TypedFunc::< 3185 (), 3186 (wasmtime::component::__internal::Vec<f64>,), 3187 >::new_unchecked(self.list_f64_ret) 3188 }; 3189 let promise = callee 3190 .call_concurrent(store.as_context_mut(), ()) 3191 .await?; 3192 Ok(promise.map(|(v,)| v)) 3193 } 3194 pub async fn call_tuple_list<S: wasmtime::AsContextMut>( 3195 &self, 3196 mut store: S, 3197 arg0: wasmtime::component::__internal::Vec<(u8, i8)>, 3198 ) -> wasmtime::Result< 3199 wasmtime::component::Promise< 3200 wasmtime::component::__internal::Vec<(i64, u32)>, 3201 >, 3202 > 3203 where 3204 <S as wasmtime::AsContext>::Data: Send + 'static, 3205 { 3206 let callee = unsafe { 3207 wasmtime::component::TypedFunc::< 3208 (wasmtime::component::__internal::Vec<(u8, i8)>,), 3209 (wasmtime::component::__internal::Vec<(i64, u32)>,), 3210 >::new_unchecked(self.tuple_list) 3211 }; 3212 let promise = callee 3213 .call_concurrent(store.as_context_mut(), (arg0,)) 3214 .await?; 3215 Ok(promise.map(|(v,)| v)) 3216 } 3217 pub async fn call_string_list_arg<S: wasmtime::AsContextMut>( 3218 &self, 3219 mut store: S, 3220 arg0: wasmtime::component::__internal::Vec< 3221 wasmtime::component::__internal::String, 3222 >, 3223 ) -> wasmtime::Result<wasmtime::component::Promise<()>> 3224 where 3225 <S as wasmtime::AsContext>::Data: Send + 'static, 3226 { 3227 let callee = unsafe { 3228 wasmtime::component::TypedFunc::< 3229 ( 3230 wasmtime::component::__internal::Vec< 3231 wasmtime::component::__internal::String, 3232 >, 3233 ), 3234 (), 3235 >::new_unchecked(self.string_list_arg) 3236 }; 3237 let promise = callee 3238 .call_concurrent(store.as_context_mut(), (arg0,)) 3239 .await?; 3240 Ok(promise) 3241 } 3242 pub async fn call_string_list_ret<S: wasmtime::AsContextMut>( 3243 &self, 3244 mut store: S, 3245 ) -> wasmtime::Result< 3246 wasmtime::component::Promise< 3247 wasmtime::component::__internal::Vec< 3248 wasmtime::component::__internal::String, 3249 >, 3250 >, 3251 > 3252 where 3253 <S as wasmtime::AsContext>::Data: Send + 'static, 3254 { 3255 let callee = unsafe { 3256 wasmtime::component::TypedFunc::< 3257 (), 3258 ( 3259 wasmtime::component::__internal::Vec< 3260 wasmtime::component::__internal::String, 3261 >, 3262 ), 3263 >::new_unchecked(self.string_list_ret) 3264 }; 3265 let promise = callee 3266 .call_concurrent(store.as_context_mut(), ()) 3267 .await?; 3268 Ok(promise.map(|(v,)| v)) 3269 } 3270 pub async fn call_tuple_string_list<S: wasmtime::AsContextMut>( 3271 &self, 3272 mut store: S, 3273 arg0: wasmtime::component::__internal::Vec< 3274 (u8, wasmtime::component::__internal::String), 3275 >, 3276 ) -> wasmtime::Result< 3277 wasmtime::component::Promise< 3278 wasmtime::component::__internal::Vec< 3279 (wasmtime::component::__internal::String, u8), 3280 >, 3281 >, 3282 > 3283 where 3284 <S as wasmtime::AsContext>::Data: Send + 'static, 3285 { 3286 let callee = unsafe { 3287 wasmtime::component::TypedFunc::< 3288 ( 3289 wasmtime::component::__internal::Vec< 3290 (u8, wasmtime::component::__internal::String), 3291 >, 3292 ), 3293 ( 3294 wasmtime::component::__internal::Vec< 3295 (wasmtime::component::__internal::String, u8), 3296 >, 3297 ), 3298 >::new_unchecked(self.tuple_string_list) 3299 }; 3300 let promise = callee 3301 .call_concurrent(store.as_context_mut(), (arg0,)) 3302 .await?; 3303 Ok(promise.map(|(v,)| v)) 3304 } 3305 pub async fn call_string_list<S: wasmtime::AsContextMut>( 3306 &self, 3307 mut store: S, 3308 arg0: wasmtime::component::__internal::Vec< 3309 wasmtime::component::__internal::String, 3310 >, 3311 ) -> wasmtime::Result< 3312 wasmtime::component::Promise< 3313 wasmtime::component::__internal::Vec< 3314 wasmtime::component::__internal::String, 3315 >, 3316 >, 3317 > 3318 where 3319 <S as wasmtime::AsContext>::Data: Send + 'static, 3320 { 3321 let callee = unsafe { 3322 wasmtime::component::TypedFunc::< 3323 ( 3324 wasmtime::component::__internal::Vec< 3325 wasmtime::component::__internal::String, 3326 >, 3327 ), 3328 ( 3329 wasmtime::component::__internal::Vec< 3330 wasmtime::component::__internal::String, 3331 >, 3332 ), 3333 >::new_unchecked(self.string_list) 3334 }; 3335 let promise = callee 3336 .call_concurrent(store.as_context_mut(), (arg0,)) 3337 .await?; 3338 Ok(promise.map(|(v,)| v)) 3339 } 3340 pub async fn call_record_list<S: wasmtime::AsContextMut>( 3341 &self, 3342 mut store: S, 3343 arg0: wasmtime::component::__internal::Vec<SomeRecord>, 3344 ) -> wasmtime::Result< 3345 wasmtime::component::Promise< 3346 wasmtime::component::__internal::Vec<OtherRecord>, 3347 >, 3348 > 3349 where 3350 <S as wasmtime::AsContext>::Data: Send + 'static, 3351 { 3352 let callee = unsafe { 3353 wasmtime::component::TypedFunc::< 3354 (wasmtime::component::__internal::Vec<SomeRecord>,), 3355 (wasmtime::component::__internal::Vec<OtherRecord>,), 3356 >::new_unchecked(self.record_list) 3357 }; 3358 let promise = callee 3359 .call_concurrent(store.as_context_mut(), (arg0,)) 3360 .await?; 3361 Ok(promise.map(|(v,)| v)) 3362 } 3363 pub async fn call_record_list_reverse<S: wasmtime::AsContextMut>( 3364 &self, 3365 mut store: S, 3366 arg0: wasmtime::component::__internal::Vec<OtherRecord>, 3367 ) -> wasmtime::Result< 3368 wasmtime::component::Promise< 3369 wasmtime::component::__internal::Vec<SomeRecord>, 3370 >, 3371 > 3372 where 3373 <S as wasmtime::AsContext>::Data: Send + 'static, 3374 { 3375 let callee = unsafe { 3376 wasmtime::component::TypedFunc::< 3377 (wasmtime::component::__internal::Vec<OtherRecord>,), 3378 (wasmtime::component::__internal::Vec<SomeRecord>,), 3379 >::new_unchecked(self.record_list_reverse) 3380 }; 3381 let promise = callee 3382 .call_concurrent(store.as_context_mut(), (arg0,)) 3383 .await?; 3384 Ok(promise.map(|(v,)| v)) 3385 } 3386 pub async fn call_variant_list<S: wasmtime::AsContextMut>( 3387 &self, 3388 mut store: S, 3389 arg0: wasmtime::component::__internal::Vec<SomeVariant>, 3390 ) -> wasmtime::Result< 3391 wasmtime::component::Promise< 3392 wasmtime::component::__internal::Vec<OtherVariant>, 3393 >, 3394 > 3395 where 3396 <S as wasmtime::AsContext>::Data: Send + 'static, 3397 { 3398 let callee = unsafe { 3399 wasmtime::component::TypedFunc::< 3400 (wasmtime::component::__internal::Vec<SomeVariant>,), 3401 (wasmtime::component::__internal::Vec<OtherVariant>,), 3402 >::new_unchecked(self.variant_list) 3403 }; 3404 let promise = callee 3405 .call_concurrent(store.as_context_mut(), (arg0,)) 3406 .await?; 3407 Ok(promise.map(|(v,)| v)) 3408 } 3409 pub async fn call_load_store_everything<S: wasmtime::AsContextMut>( 3410 &self, 3411 mut store: S, 3412 arg0: LoadStoreAllSizes, 3413 ) -> wasmtime::Result< 3414 wasmtime::component::Promise<LoadStoreAllSizes>, 3415 > 3416 where 3417 <S as wasmtime::AsContext>::Data: Send + 'static, 3418 { 3419 let callee = unsafe { 3420 wasmtime::component::TypedFunc::< 3421 (LoadStoreAllSizes,), 3422 (LoadStoreAllSizes,), 3423 >::new_unchecked(self.load_store_everything) 3424 }; 3425 let promise = callee 3426 .call_concurrent(store.as_context_mut(), (arg0,)) 3427 .await?; 3428 Ok(promise.map(|(v,)| v)) 3429 } 3430 } 3431 } 3432 } 3433 } 3434 } 3435