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: 'static> { 10 instance_pre: wasmtime::component::InstancePre<T>, 11 indices: TheListsIndices, 12 } 13 impl<T: 'static> 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: 'static> 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)?; 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 fn instantiate( 47 &self, 48 mut store: impl wasmtime::AsContextMut<Data = _T>, 49 ) -> wasmtime::Result<TheLists> { 50 let mut store = store.as_context_mut(); 51 let instance = self.instance_pre.instantiate(&mut store)?; 52 self.indices.load(&mut store, &instance) 53 } 54 } 55 impl<_T: Send + 'static> TheListsPre<_T> { 56 /// Same as [`Self::instantiate`], except with `async`. 57 pub async fn instantiate_async( 58 &self, 59 mut store: impl wasmtime::AsContextMut<Data = _T>, 60 ) -> wasmtime::Result<TheLists> { 61 let mut store = store.as_context_mut(); 62 let instance = self.instance_pre.instantiate_async(&mut store).await?; 63 self.indices.load(&mut store, &instance) 64 } 65 } 66 /// Auto-generated bindings for index of the exports of 67 /// `the-lists`. 68 /// 69 /// This is an implementation detail of [`TheListsPre`] and can 70 /// be constructed if needed as well. 71 /// 72 /// For more information see [`TheLists`] as well. 73 #[derive(Clone)] 74 pub struct TheListsIndices { 75 interface0: exports::foo::foo::lists::GuestIndices, 76 } 77 /// Auto-generated bindings for an instance a component which 78 /// implements the world `the-lists`. 79 /// 80 /// This structure can be created through a number of means 81 /// depending on your requirements and what you have on hand: 82 /// 83 /// * The most convenient way is to use 84 /// [`TheLists::instantiate`] which only needs a 85 /// [`Store`], [`Component`], and [`Linker`]. 86 /// 87 /// * Alternatively you can create a [`TheListsPre`] ahead of 88 /// time with a [`Component`] to front-load string lookups 89 /// of exports once instead of per-instantiation. This 90 /// method then uses [`TheListsPre::instantiate`] to 91 /// create a [`TheLists`]. 92 /// 93 /// * If you've instantiated the instance yourself already 94 /// then you can use [`TheLists::new`]. 95 /// 96 /// These methods are all equivalent to one another and move 97 /// around the tradeoff of what work is performed when. 98 /// 99 /// [`Store`]: wasmtime::Store 100 /// [`Component`]: wasmtime::component::Component 101 /// [`Linker`]: wasmtime::component::Linker 102 pub struct TheLists { 103 interface0: exports::foo::foo::lists::Guest, 104 } 105 const _: () = { 106 impl TheListsIndices { 107 /// Creates a new copy of `TheListsIndices` bindings which can then 108 /// be used to instantiate into a particular store. 109 /// 110 /// This method may fail if the component does not have the 111 /// required exports. 112 pub fn new<_T>( 113 _instance_pre: &wasmtime::component::InstancePre<_T>, 114 ) -> wasmtime::Result<Self> { 115 let _component = _instance_pre.component(); 116 let _instance_type = _instance_pre.instance_type(); 117 let interface0 = exports::foo::foo::lists::GuestIndices::new(_instance_pre)?; 118 Ok(TheListsIndices { interface0 }) 119 } 120 /// Uses the indices stored in `self` to load an instance 121 /// of [`TheLists`] from the instance provided. 122 /// 123 /// Note that at this time this method will additionally 124 /// perform type-checks of all exports. 125 pub fn load( 126 &self, 127 mut store: impl wasmtime::AsContextMut, 128 instance: &wasmtime::component::Instance, 129 ) -> wasmtime::Result<TheLists> { 130 let _ = &mut store; 131 let _instance = instance; 132 let interface0 = self.interface0.load(&mut store, &_instance)?; 133 Ok(TheLists { interface0 }) 134 } 135 } 136 impl TheLists { 137 /// Convenience wrapper around [`TheListsPre::new`] and 138 /// [`TheListsPre::instantiate`]. 139 pub fn instantiate<_T>( 140 store: impl wasmtime::AsContextMut<Data = _T>, 141 component: &wasmtime::component::Component, 142 linker: &wasmtime::component::Linker<_T>, 143 ) -> wasmtime::Result<TheLists> { 144 let pre = linker.instantiate_pre(component)?; 145 TheListsPre::new(pre)?.instantiate(store) 146 } 147 /// Convenience wrapper around [`TheListsIndices::new`] and 148 /// [`TheListsIndices::load`]. 149 pub fn new( 150 mut store: impl wasmtime::AsContextMut, 151 instance: &wasmtime::component::Instance, 152 ) -> wasmtime::Result<TheLists> { 153 let indices = TheListsIndices::new(&instance.instance_pre(&store))?; 154 indices.load(&mut store, instance) 155 } 156 /// Convenience wrapper around [`TheListsPre::new`] and 157 /// [`TheListsPre::instantiate_async`]. 158 pub async fn instantiate_async<_T>( 159 store: impl wasmtime::AsContextMut<Data = _T>, 160 component: &wasmtime::component::Component, 161 linker: &wasmtime::component::Linker<_T>, 162 ) -> wasmtime::Result<TheLists> 163 where 164 _T: Send, 165 { 166 let pre = linker.instantiate_pre(component)?; 167 TheListsPre::new(pre)?.instantiate_async(store).await 168 } 169 pub fn add_to_linker<T, D>( 170 linker: &mut wasmtime::component::Linker<T>, 171 host_getter: fn(&mut T) -> D::Data<'_>, 172 ) -> wasmtime::Result<()> 173 where 174 D: foo::foo::lists::HostWithStore, 175 for<'a> D::Data<'a>: foo::foo::lists::Host, 176 T: 'static, 177 { 178 foo::foo::lists::add_to_linker::<T, D>(linker, host_getter)?; 179 Ok(()) 180 } 181 pub fn foo_foo_lists(&self) -> &exports::foo::foo::lists::Guest { 182 &self.interface0 183 } 184 } 185 }; 186 pub mod foo { 187 pub mod foo { 188 #[allow(clippy::all)] 189 pub mod lists { 190 #[allow(unused_imports)] 191 use wasmtime::component::__internal::Box; 192 #[derive(wasmtime::component::ComponentType)] 193 #[derive(wasmtime::component::Lift)] 194 #[derive(wasmtime::component::Lower)] 195 #[component(record)] 196 #[derive(Clone)] 197 pub struct OtherRecord { 198 #[component(name = "a1")] 199 pub a1: u32, 200 #[component(name = "a2")] 201 pub a2: u64, 202 #[component(name = "a3")] 203 pub a3: i32, 204 #[component(name = "a4")] 205 pub a4: i64, 206 #[component(name = "b")] 207 pub b: wasmtime::component::__internal::String, 208 #[component(name = "c")] 209 pub c: wasmtime::component::__internal::Vec<u8>, 210 } 211 impl core::fmt::Debug for OtherRecord { 212 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 213 f.debug_struct("OtherRecord") 214 .field("a1", &self.a1) 215 .field("a2", &self.a2) 216 .field("a3", &self.a3) 217 .field("a4", &self.a4) 218 .field("b", &self.b) 219 .field("c", &self.c) 220 .finish() 221 } 222 } 223 const _: () = { 224 assert!( 225 48 == < OtherRecord as wasmtime::component::ComponentType >::SIZE32 226 ); 227 assert!( 228 8 == < OtherRecord as wasmtime::component::ComponentType >::ALIGN32 229 ); 230 }; 231 #[derive(wasmtime::component::ComponentType)] 232 #[derive(wasmtime::component::Lift)] 233 #[derive(wasmtime::component::Lower)] 234 #[component(record)] 235 #[derive(Clone)] 236 pub struct SomeRecord { 237 #[component(name = "x")] 238 pub x: wasmtime::component::__internal::String, 239 #[component(name = "y")] 240 pub y: OtherRecord, 241 #[component(name = "z")] 242 pub z: wasmtime::component::__internal::Vec<OtherRecord>, 243 #[component(name = "c1")] 244 pub c1: u32, 245 #[component(name = "c2")] 246 pub c2: u64, 247 #[component(name = "c3")] 248 pub c3: i32, 249 #[component(name = "c4")] 250 pub c4: i64, 251 } 252 impl core::fmt::Debug for SomeRecord { 253 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 254 f.debug_struct("SomeRecord") 255 .field("x", &self.x) 256 .field("y", &self.y) 257 .field("z", &self.z) 258 .field("c1", &self.c1) 259 .field("c2", &self.c2) 260 .field("c3", &self.c3) 261 .field("c4", &self.c4) 262 .finish() 263 } 264 } 265 const _: () = { 266 assert!( 267 96 == < SomeRecord as wasmtime::component::ComponentType >::SIZE32 268 ); 269 assert!( 270 8 == < SomeRecord as wasmtime::component::ComponentType >::ALIGN32 271 ); 272 }; 273 #[derive(wasmtime::component::ComponentType)] 274 #[derive(wasmtime::component::Lift)] 275 #[derive(wasmtime::component::Lower)] 276 #[component(variant)] 277 #[derive(Clone)] 278 pub enum OtherVariant { 279 #[component(name = "a")] 280 A, 281 #[component(name = "b")] 282 B(u32), 283 #[component(name = "c")] 284 C(wasmtime::component::__internal::String), 285 } 286 impl core::fmt::Debug for OtherVariant { 287 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 288 match self { 289 OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(), 290 OtherVariant::B(e) => { 291 f.debug_tuple("OtherVariant::B").field(e).finish() 292 } 293 OtherVariant::C(e) => { 294 f.debug_tuple("OtherVariant::C").field(e).finish() 295 } 296 } 297 } 298 } 299 const _: () = { 300 assert!( 301 12 == < OtherVariant as wasmtime::component::ComponentType >::SIZE32 302 ); 303 assert!( 304 4 == < OtherVariant as wasmtime::component::ComponentType >::ALIGN32 305 ); 306 }; 307 #[derive(wasmtime::component::ComponentType)] 308 #[derive(wasmtime::component::Lift)] 309 #[derive(wasmtime::component::Lower)] 310 #[component(variant)] 311 #[derive(Clone)] 312 pub enum SomeVariant { 313 #[component(name = "a")] 314 A(wasmtime::component::__internal::String), 315 #[component(name = "b")] 316 B, 317 #[component(name = "c")] 318 C(u32), 319 #[component(name = "d")] 320 D(wasmtime::component::__internal::Vec<OtherVariant>), 321 } 322 impl core::fmt::Debug for SomeVariant { 323 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 324 match self { 325 SomeVariant::A(e) => { 326 f.debug_tuple("SomeVariant::A").field(e).finish() 327 } 328 SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(), 329 SomeVariant::C(e) => { 330 f.debug_tuple("SomeVariant::C").field(e).finish() 331 } 332 SomeVariant::D(e) => { 333 f.debug_tuple("SomeVariant::D").field(e).finish() 334 } 335 } 336 } 337 } 338 const _: () = { 339 assert!( 340 12 == < SomeVariant as wasmtime::component::ComponentType >::SIZE32 341 ); 342 assert!( 343 4 == < SomeVariant as wasmtime::component::ComponentType >::ALIGN32 344 ); 345 }; 346 pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec< 347 ( 348 wasmtime::component::__internal::String, 349 u8, 350 i8, 351 u16, 352 i16, 353 u32, 354 i32, 355 u64, 356 i64, 357 f32, 358 f64, 359 char, 360 ), 361 >; 362 const _: () = { 363 assert!( 364 8 == < LoadStoreAllSizes as wasmtime::component::ComponentType 365 >::SIZE32 366 ); 367 assert!( 368 4 == < LoadStoreAllSizes as wasmtime::component::ComponentType 369 >::ALIGN32 370 ); 371 }; 372 pub trait HostWithStore: wasmtime::component::HasData {} 373 impl<_T: ?Sized> HostWithStore for _T 374 where 375 _T: wasmtime::component::HasData, 376 {} 377 pub trait Host { 378 fn list_u8_param( 379 &mut self, 380 x: wasmtime::component::__internal::Vec<u8>, 381 ) -> (); 382 fn list_u16_param( 383 &mut self, 384 x: wasmtime::component::__internal::Vec<u16>, 385 ) -> (); 386 fn list_u32_param( 387 &mut self, 388 x: wasmtime::component::__internal::Vec<u32>, 389 ) -> (); 390 fn list_u64_param( 391 &mut self, 392 x: wasmtime::component::__internal::Vec<u64>, 393 ) -> (); 394 fn list_s8_param( 395 &mut self, 396 x: wasmtime::component::__internal::Vec<i8>, 397 ) -> (); 398 fn list_s16_param( 399 &mut self, 400 x: wasmtime::component::__internal::Vec<i16>, 401 ) -> (); 402 fn list_s32_param( 403 &mut self, 404 x: wasmtime::component::__internal::Vec<i32>, 405 ) -> (); 406 fn list_s64_param( 407 &mut self, 408 x: wasmtime::component::__internal::Vec<i64>, 409 ) -> (); 410 fn list_f32_param( 411 &mut self, 412 x: wasmtime::component::__internal::Vec<f32>, 413 ) -> (); 414 fn list_f64_param( 415 &mut self, 416 x: wasmtime::component::__internal::Vec<f64>, 417 ) -> (); 418 fn list_u8_ret(&mut self) -> wasmtime::component::__internal::Vec<u8>; 419 fn list_u16_ret(&mut self) -> wasmtime::component::__internal::Vec<u16>; 420 fn list_u32_ret(&mut self) -> wasmtime::component::__internal::Vec<u32>; 421 fn list_u64_ret(&mut self) -> wasmtime::component::__internal::Vec<u64>; 422 fn list_s8_ret(&mut self) -> wasmtime::component::__internal::Vec<i8>; 423 fn list_s16_ret(&mut self) -> wasmtime::component::__internal::Vec<i16>; 424 fn list_s32_ret(&mut self) -> wasmtime::component::__internal::Vec<i32>; 425 fn list_s64_ret(&mut self) -> wasmtime::component::__internal::Vec<i64>; 426 fn list_f32_ret(&mut self) -> wasmtime::component::__internal::Vec<f32>; 427 fn list_f64_ret(&mut self) -> wasmtime::component::__internal::Vec<f64>; 428 fn tuple_list( 429 &mut self, 430 x: wasmtime::component::__internal::Vec<(u8, i8)>, 431 ) -> wasmtime::component::__internal::Vec<(i64, u32)>; 432 fn string_list_arg( 433 &mut self, 434 a: wasmtime::component::__internal::Vec< 435 wasmtime::component::__internal::String, 436 >, 437 ) -> (); 438 fn string_list_ret( 439 &mut self, 440 ) -> wasmtime::component::__internal::Vec< 441 wasmtime::component::__internal::String, 442 >; 443 fn tuple_string_list( 444 &mut self, 445 x: wasmtime::component::__internal::Vec< 446 (u8, wasmtime::component::__internal::String), 447 >, 448 ) -> wasmtime::component::__internal::Vec< 449 (wasmtime::component::__internal::String, u8), 450 >; 451 fn string_list( 452 &mut self, 453 x: wasmtime::component::__internal::Vec< 454 wasmtime::component::__internal::String, 455 >, 456 ) -> wasmtime::component::__internal::Vec< 457 wasmtime::component::__internal::String, 458 >; 459 fn record_list( 460 &mut self, 461 x: wasmtime::component::__internal::Vec<SomeRecord>, 462 ) -> wasmtime::component::__internal::Vec<OtherRecord>; 463 fn record_list_reverse( 464 &mut self, 465 x: wasmtime::component::__internal::Vec<OtherRecord>, 466 ) -> wasmtime::component::__internal::Vec<SomeRecord>; 467 fn variant_list( 468 &mut self, 469 x: wasmtime::component::__internal::Vec<SomeVariant>, 470 ) -> wasmtime::component::__internal::Vec<OtherVariant>; 471 fn load_store_everything( 472 &mut self, 473 a: LoadStoreAllSizes, 474 ) -> LoadStoreAllSizes; 475 } 476 impl<_T: Host + ?Sized> Host for &mut _T { 477 fn list_u8_param( 478 &mut self, 479 x: wasmtime::component::__internal::Vec<u8>, 480 ) -> () { 481 Host::list_u8_param(*self, x) 482 } 483 fn list_u16_param( 484 &mut self, 485 x: wasmtime::component::__internal::Vec<u16>, 486 ) -> () { 487 Host::list_u16_param(*self, x) 488 } 489 fn list_u32_param( 490 &mut self, 491 x: wasmtime::component::__internal::Vec<u32>, 492 ) -> () { 493 Host::list_u32_param(*self, x) 494 } 495 fn list_u64_param( 496 &mut self, 497 x: wasmtime::component::__internal::Vec<u64>, 498 ) -> () { 499 Host::list_u64_param(*self, x) 500 } 501 fn list_s8_param( 502 &mut self, 503 x: wasmtime::component::__internal::Vec<i8>, 504 ) -> () { 505 Host::list_s8_param(*self, x) 506 } 507 fn list_s16_param( 508 &mut self, 509 x: wasmtime::component::__internal::Vec<i16>, 510 ) -> () { 511 Host::list_s16_param(*self, x) 512 } 513 fn list_s32_param( 514 &mut self, 515 x: wasmtime::component::__internal::Vec<i32>, 516 ) -> () { 517 Host::list_s32_param(*self, x) 518 } 519 fn list_s64_param( 520 &mut self, 521 x: wasmtime::component::__internal::Vec<i64>, 522 ) -> () { 523 Host::list_s64_param(*self, x) 524 } 525 fn list_f32_param( 526 &mut self, 527 x: wasmtime::component::__internal::Vec<f32>, 528 ) -> () { 529 Host::list_f32_param(*self, x) 530 } 531 fn list_f64_param( 532 &mut self, 533 x: wasmtime::component::__internal::Vec<f64>, 534 ) -> () { 535 Host::list_f64_param(*self, x) 536 } 537 fn list_u8_ret(&mut self) -> wasmtime::component::__internal::Vec<u8> { 538 Host::list_u8_ret(*self) 539 } 540 fn list_u16_ret(&mut self) -> wasmtime::component::__internal::Vec<u16> { 541 Host::list_u16_ret(*self) 542 } 543 fn list_u32_ret(&mut self) -> wasmtime::component::__internal::Vec<u32> { 544 Host::list_u32_ret(*self) 545 } 546 fn list_u64_ret(&mut self) -> wasmtime::component::__internal::Vec<u64> { 547 Host::list_u64_ret(*self) 548 } 549 fn list_s8_ret(&mut self) -> wasmtime::component::__internal::Vec<i8> { 550 Host::list_s8_ret(*self) 551 } 552 fn list_s16_ret(&mut self) -> wasmtime::component::__internal::Vec<i16> { 553 Host::list_s16_ret(*self) 554 } 555 fn list_s32_ret(&mut self) -> wasmtime::component::__internal::Vec<i32> { 556 Host::list_s32_ret(*self) 557 } 558 fn list_s64_ret(&mut self) -> wasmtime::component::__internal::Vec<i64> { 559 Host::list_s64_ret(*self) 560 } 561 fn list_f32_ret(&mut self) -> wasmtime::component::__internal::Vec<f32> { 562 Host::list_f32_ret(*self) 563 } 564 fn list_f64_ret(&mut self) -> wasmtime::component::__internal::Vec<f64> { 565 Host::list_f64_ret(*self) 566 } 567 fn tuple_list( 568 &mut self, 569 x: wasmtime::component::__internal::Vec<(u8, i8)>, 570 ) -> wasmtime::component::__internal::Vec<(i64, u32)> { 571 Host::tuple_list(*self, x) 572 } 573 fn string_list_arg( 574 &mut self, 575 a: wasmtime::component::__internal::Vec< 576 wasmtime::component::__internal::String, 577 >, 578 ) -> () { 579 Host::string_list_arg(*self, a) 580 } 581 fn string_list_ret( 582 &mut self, 583 ) -> wasmtime::component::__internal::Vec< 584 wasmtime::component::__internal::String, 585 > { 586 Host::string_list_ret(*self) 587 } 588 fn tuple_string_list( 589 &mut self, 590 x: wasmtime::component::__internal::Vec< 591 (u8, wasmtime::component::__internal::String), 592 >, 593 ) -> wasmtime::component::__internal::Vec< 594 (wasmtime::component::__internal::String, u8), 595 > { 596 Host::tuple_string_list(*self, x) 597 } 598 fn string_list( 599 &mut self, 600 x: wasmtime::component::__internal::Vec< 601 wasmtime::component::__internal::String, 602 >, 603 ) -> wasmtime::component::__internal::Vec< 604 wasmtime::component::__internal::String, 605 > { 606 Host::string_list(*self, x) 607 } 608 fn record_list( 609 &mut self, 610 x: wasmtime::component::__internal::Vec<SomeRecord>, 611 ) -> wasmtime::component::__internal::Vec<OtherRecord> { 612 Host::record_list(*self, x) 613 } 614 fn record_list_reverse( 615 &mut self, 616 x: wasmtime::component::__internal::Vec<OtherRecord>, 617 ) -> wasmtime::component::__internal::Vec<SomeRecord> { 618 Host::record_list_reverse(*self, x) 619 } 620 fn variant_list( 621 &mut self, 622 x: wasmtime::component::__internal::Vec<SomeVariant>, 623 ) -> wasmtime::component::__internal::Vec<OtherVariant> { 624 Host::variant_list(*self, x) 625 } 626 fn load_store_everything( 627 &mut self, 628 a: LoadStoreAllSizes, 629 ) -> LoadStoreAllSizes { 630 Host::load_store_everything(*self, a) 631 } 632 } 633 pub fn add_to_linker<T, D>( 634 linker: &mut wasmtime::component::Linker<T>, 635 host_getter: fn(&mut T) -> D::Data<'_>, 636 ) -> wasmtime::Result<()> 637 where 638 D: HostWithStore, 639 for<'a> D::Data<'a>: Host, 640 T: 'static, 641 { 642 let mut inst = linker.instance("foo:foo/lists")?; 643 inst.func_wrap( 644 "list-u8-param", 645 move | 646 mut caller: wasmtime::StoreContextMut<'_, T>, 647 (arg0,): (wasmtime::component::__internal::Vec<u8>,)| 648 { 649 let host = &mut host_getter(caller.data_mut()); 650 let r = Host::list_u8_param(host, arg0); 651 Ok(r) 652 }, 653 )?; 654 inst.func_wrap( 655 "list-u16-param", 656 move | 657 mut caller: wasmtime::StoreContextMut<'_, T>, 658 (arg0,): (wasmtime::component::__internal::Vec<u16>,)| 659 { 660 let host = &mut host_getter(caller.data_mut()); 661 let r = Host::list_u16_param(host, arg0); 662 Ok(r) 663 }, 664 )?; 665 inst.func_wrap( 666 "list-u32-param", 667 move | 668 mut caller: wasmtime::StoreContextMut<'_, T>, 669 (arg0,): (wasmtime::component::__internal::Vec<u32>,)| 670 { 671 let host = &mut host_getter(caller.data_mut()); 672 let r = Host::list_u32_param(host, arg0); 673 Ok(r) 674 }, 675 )?; 676 inst.func_wrap( 677 "list-u64-param", 678 move | 679 mut caller: wasmtime::StoreContextMut<'_, T>, 680 (arg0,): (wasmtime::component::__internal::Vec<u64>,)| 681 { 682 let host = &mut host_getter(caller.data_mut()); 683 let r = Host::list_u64_param(host, arg0); 684 Ok(r) 685 }, 686 )?; 687 inst.func_wrap( 688 "list-s8-param", 689 move | 690 mut caller: wasmtime::StoreContextMut<'_, T>, 691 (arg0,): (wasmtime::component::__internal::Vec<i8>,)| 692 { 693 let host = &mut host_getter(caller.data_mut()); 694 let r = Host::list_s8_param(host, arg0); 695 Ok(r) 696 }, 697 )?; 698 inst.func_wrap( 699 "list-s16-param", 700 move | 701 mut caller: wasmtime::StoreContextMut<'_, T>, 702 (arg0,): (wasmtime::component::__internal::Vec<i16>,)| 703 { 704 let host = &mut host_getter(caller.data_mut()); 705 let r = Host::list_s16_param(host, arg0); 706 Ok(r) 707 }, 708 )?; 709 inst.func_wrap( 710 "list-s32-param", 711 move | 712 mut caller: wasmtime::StoreContextMut<'_, T>, 713 (arg0,): (wasmtime::component::__internal::Vec<i32>,)| 714 { 715 let host = &mut host_getter(caller.data_mut()); 716 let r = Host::list_s32_param(host, arg0); 717 Ok(r) 718 }, 719 )?; 720 inst.func_wrap( 721 "list-s64-param", 722 move | 723 mut caller: wasmtime::StoreContextMut<'_, T>, 724 (arg0,): (wasmtime::component::__internal::Vec<i64>,)| 725 { 726 let host = &mut host_getter(caller.data_mut()); 727 let r = Host::list_s64_param(host, arg0); 728 Ok(r) 729 }, 730 )?; 731 inst.func_wrap( 732 "list-f32-param", 733 move | 734 mut caller: wasmtime::StoreContextMut<'_, T>, 735 (arg0,): (wasmtime::component::__internal::Vec<f32>,)| 736 { 737 let host = &mut host_getter(caller.data_mut()); 738 let r = Host::list_f32_param(host, arg0); 739 Ok(r) 740 }, 741 )?; 742 inst.func_wrap( 743 "list-f64-param", 744 move | 745 mut caller: wasmtime::StoreContextMut<'_, T>, 746 (arg0,): (wasmtime::component::__internal::Vec<f64>,)| 747 { 748 let host = &mut host_getter(caller.data_mut()); 749 let r = Host::list_f64_param(host, arg0); 750 Ok(r) 751 }, 752 )?; 753 inst.func_wrap( 754 "list-u8-ret", 755 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 756 let host = &mut host_getter(caller.data_mut()); 757 let r = Host::list_u8_ret(host); 758 Ok((r,)) 759 }, 760 )?; 761 inst.func_wrap( 762 "list-u16-ret", 763 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 764 let host = &mut host_getter(caller.data_mut()); 765 let r = Host::list_u16_ret(host); 766 Ok((r,)) 767 }, 768 )?; 769 inst.func_wrap( 770 "list-u32-ret", 771 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 772 let host = &mut host_getter(caller.data_mut()); 773 let r = Host::list_u32_ret(host); 774 Ok((r,)) 775 }, 776 )?; 777 inst.func_wrap( 778 "list-u64-ret", 779 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 780 let host = &mut host_getter(caller.data_mut()); 781 let r = Host::list_u64_ret(host); 782 Ok((r,)) 783 }, 784 )?; 785 inst.func_wrap( 786 "list-s8-ret", 787 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 788 let host = &mut host_getter(caller.data_mut()); 789 let r = Host::list_s8_ret(host); 790 Ok((r,)) 791 }, 792 )?; 793 inst.func_wrap( 794 "list-s16-ret", 795 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 796 let host = &mut host_getter(caller.data_mut()); 797 let r = Host::list_s16_ret(host); 798 Ok((r,)) 799 }, 800 )?; 801 inst.func_wrap( 802 "list-s32-ret", 803 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 804 let host = &mut host_getter(caller.data_mut()); 805 let r = Host::list_s32_ret(host); 806 Ok((r,)) 807 }, 808 )?; 809 inst.func_wrap( 810 "list-s64-ret", 811 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 812 let host = &mut host_getter(caller.data_mut()); 813 let r = Host::list_s64_ret(host); 814 Ok((r,)) 815 }, 816 )?; 817 inst.func_wrap( 818 "list-f32-ret", 819 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 820 let host = &mut host_getter(caller.data_mut()); 821 let r = Host::list_f32_ret(host); 822 Ok((r,)) 823 }, 824 )?; 825 inst.func_wrap( 826 "list-f64-ret", 827 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 828 let host = &mut host_getter(caller.data_mut()); 829 let r = Host::list_f64_ret(host); 830 Ok((r,)) 831 }, 832 )?; 833 inst.func_wrap( 834 "tuple-list", 835 move | 836 mut caller: wasmtime::StoreContextMut<'_, T>, 837 (arg0,): (wasmtime::component::__internal::Vec<(u8, i8)>,)| 838 { 839 let host = &mut host_getter(caller.data_mut()); 840 let r = Host::tuple_list(host, arg0); 841 Ok((r,)) 842 }, 843 )?; 844 inst.func_wrap( 845 "string-list-arg", 846 move | 847 mut caller: wasmtime::StoreContextMut<'_, T>, 848 ( 849 arg0, 850 ): ( 851 wasmtime::component::__internal::Vec< 852 wasmtime::component::__internal::String, 853 >, 854 )| 855 { 856 let host = &mut host_getter(caller.data_mut()); 857 let r = Host::string_list_arg(host, arg0); 858 Ok(r) 859 }, 860 )?; 861 inst.func_wrap( 862 "string-list-ret", 863 move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| { 864 let host = &mut host_getter(caller.data_mut()); 865 let r = Host::string_list_ret(host); 866 Ok((r,)) 867 }, 868 )?; 869 inst.func_wrap( 870 "tuple-string-list", 871 move | 872 mut caller: wasmtime::StoreContextMut<'_, T>, 873 ( 874 arg0, 875 ): ( 876 wasmtime::component::__internal::Vec< 877 (u8, wasmtime::component::__internal::String), 878 >, 879 )| 880 { 881 let host = &mut host_getter(caller.data_mut()); 882 let r = Host::tuple_string_list(host, arg0); 883 Ok((r,)) 884 }, 885 )?; 886 inst.func_wrap( 887 "string-list", 888 move | 889 mut caller: wasmtime::StoreContextMut<'_, T>, 890 ( 891 arg0, 892 ): ( 893 wasmtime::component::__internal::Vec< 894 wasmtime::component::__internal::String, 895 >, 896 )| 897 { 898 let host = &mut host_getter(caller.data_mut()); 899 let r = Host::string_list(host, arg0); 900 Ok((r,)) 901 }, 902 )?; 903 inst.func_wrap( 904 "record-list", 905 move | 906 mut caller: wasmtime::StoreContextMut<'_, T>, 907 (arg0,): (wasmtime::component::__internal::Vec<SomeRecord>,)| 908 { 909 let host = &mut host_getter(caller.data_mut()); 910 let r = Host::record_list(host, arg0); 911 Ok((r,)) 912 }, 913 )?; 914 inst.func_wrap( 915 "record-list-reverse", 916 move | 917 mut caller: wasmtime::StoreContextMut<'_, T>, 918 (arg0,): (wasmtime::component::__internal::Vec<OtherRecord>,)| 919 { 920 let host = &mut host_getter(caller.data_mut()); 921 let r = Host::record_list_reverse(host, arg0); 922 Ok((r,)) 923 }, 924 )?; 925 inst.func_wrap( 926 "variant-list", 927 move | 928 mut caller: wasmtime::StoreContextMut<'_, T>, 929 (arg0,): (wasmtime::component::__internal::Vec<SomeVariant>,)| 930 { 931 let host = &mut host_getter(caller.data_mut()); 932 let r = Host::variant_list(host, arg0); 933 Ok((r,)) 934 }, 935 )?; 936 inst.func_wrap( 937 "load-store-everything", 938 move | 939 mut caller: wasmtime::StoreContextMut<'_, T>, 940 (arg0,): (LoadStoreAllSizes,)| 941 { 942 let host = &mut host_getter(caller.data_mut()); 943 let r = Host::load_store_everything(host, arg0); 944 Ok((r,)) 945 }, 946 )?; 947 Ok(()) 948 } 949 } 950 } 951 } 952 pub mod exports { 953 pub mod foo { 954 pub mod foo { 955 #[allow(clippy::all)] 956 pub mod lists { 957 #[allow(unused_imports)] 958 use wasmtime::component::__internal::Box; 959 #[derive(wasmtime::component::ComponentType)] 960 #[derive(wasmtime::component::Lift)] 961 #[derive(wasmtime::component::Lower)] 962 #[component(record)] 963 #[derive(Clone)] 964 pub struct OtherRecord { 965 #[component(name = "a1")] 966 pub a1: u32, 967 #[component(name = "a2")] 968 pub a2: u64, 969 #[component(name = "a3")] 970 pub a3: i32, 971 #[component(name = "a4")] 972 pub a4: i64, 973 #[component(name = "b")] 974 pub b: wasmtime::component::__internal::String, 975 #[component(name = "c")] 976 pub c: wasmtime::component::__internal::Vec<u8>, 977 } 978 impl core::fmt::Debug for OtherRecord { 979 fn fmt( 980 &self, 981 f: &mut core::fmt::Formatter<'_>, 982 ) -> core::fmt::Result { 983 f.debug_struct("OtherRecord") 984 .field("a1", &self.a1) 985 .field("a2", &self.a2) 986 .field("a3", &self.a3) 987 .field("a4", &self.a4) 988 .field("b", &self.b) 989 .field("c", &self.c) 990 .finish() 991 } 992 } 993 const _: () = { 994 assert!( 995 48 == < OtherRecord as wasmtime::component::ComponentType 996 >::SIZE32 997 ); 998 assert!( 999 8 == < OtherRecord as wasmtime::component::ComponentType 1000 >::ALIGN32 1001 ); 1002 }; 1003 #[derive(wasmtime::component::ComponentType)] 1004 #[derive(wasmtime::component::Lift)] 1005 #[derive(wasmtime::component::Lower)] 1006 #[component(record)] 1007 #[derive(Clone)] 1008 pub struct SomeRecord { 1009 #[component(name = "x")] 1010 pub x: wasmtime::component::__internal::String, 1011 #[component(name = "y")] 1012 pub y: OtherRecord, 1013 #[component(name = "z")] 1014 pub z: wasmtime::component::__internal::Vec<OtherRecord>, 1015 #[component(name = "c1")] 1016 pub c1: u32, 1017 #[component(name = "c2")] 1018 pub c2: u64, 1019 #[component(name = "c3")] 1020 pub c3: i32, 1021 #[component(name = "c4")] 1022 pub c4: i64, 1023 } 1024 impl core::fmt::Debug for SomeRecord { 1025 fn fmt( 1026 &self, 1027 f: &mut core::fmt::Formatter<'_>, 1028 ) -> core::fmt::Result { 1029 f.debug_struct("SomeRecord") 1030 .field("x", &self.x) 1031 .field("y", &self.y) 1032 .field("z", &self.z) 1033 .field("c1", &self.c1) 1034 .field("c2", &self.c2) 1035 .field("c3", &self.c3) 1036 .field("c4", &self.c4) 1037 .finish() 1038 } 1039 } 1040 const _: () = { 1041 assert!( 1042 96 == < SomeRecord as wasmtime::component::ComponentType 1043 >::SIZE32 1044 ); 1045 assert!( 1046 8 == < SomeRecord as wasmtime::component::ComponentType 1047 >::ALIGN32 1048 ); 1049 }; 1050 #[derive(wasmtime::component::ComponentType)] 1051 #[derive(wasmtime::component::Lift)] 1052 #[derive(wasmtime::component::Lower)] 1053 #[component(variant)] 1054 #[derive(Clone)] 1055 pub enum OtherVariant { 1056 #[component(name = "a")] 1057 A, 1058 #[component(name = "b")] 1059 B(u32), 1060 #[component(name = "c")] 1061 C(wasmtime::component::__internal::String), 1062 } 1063 impl core::fmt::Debug for OtherVariant { 1064 fn fmt( 1065 &self, 1066 f: &mut core::fmt::Formatter<'_>, 1067 ) -> core::fmt::Result { 1068 match self { 1069 OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(), 1070 OtherVariant::B(e) => { 1071 f.debug_tuple("OtherVariant::B").field(e).finish() 1072 } 1073 OtherVariant::C(e) => { 1074 f.debug_tuple("OtherVariant::C").field(e).finish() 1075 } 1076 } 1077 } 1078 } 1079 const _: () = { 1080 assert!( 1081 12 == < OtherVariant as wasmtime::component::ComponentType 1082 >::SIZE32 1083 ); 1084 assert!( 1085 4 == < OtherVariant as wasmtime::component::ComponentType 1086 >::ALIGN32 1087 ); 1088 }; 1089 #[derive(wasmtime::component::ComponentType)] 1090 #[derive(wasmtime::component::Lift)] 1091 #[derive(wasmtime::component::Lower)] 1092 #[component(variant)] 1093 #[derive(Clone)] 1094 pub enum SomeVariant { 1095 #[component(name = "a")] 1096 A(wasmtime::component::__internal::String), 1097 #[component(name = "b")] 1098 B, 1099 #[component(name = "c")] 1100 C(u32), 1101 #[component(name = "d")] 1102 D(wasmtime::component::__internal::Vec<OtherVariant>), 1103 } 1104 impl core::fmt::Debug for SomeVariant { 1105 fn fmt( 1106 &self, 1107 f: &mut core::fmt::Formatter<'_>, 1108 ) -> core::fmt::Result { 1109 match self { 1110 SomeVariant::A(e) => { 1111 f.debug_tuple("SomeVariant::A").field(e).finish() 1112 } 1113 SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(), 1114 SomeVariant::C(e) => { 1115 f.debug_tuple("SomeVariant::C").field(e).finish() 1116 } 1117 SomeVariant::D(e) => { 1118 f.debug_tuple("SomeVariant::D").field(e).finish() 1119 } 1120 } 1121 } 1122 } 1123 const _: () = { 1124 assert!( 1125 12 == < SomeVariant as wasmtime::component::ComponentType 1126 >::SIZE32 1127 ); 1128 assert!( 1129 4 == < SomeVariant as wasmtime::component::ComponentType 1130 >::ALIGN32 1131 ); 1132 }; 1133 pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec< 1134 ( 1135 wasmtime::component::__internal::String, 1136 u8, 1137 i8, 1138 u16, 1139 i16, 1140 u32, 1141 i32, 1142 u64, 1143 i64, 1144 f32, 1145 f64, 1146 char, 1147 ), 1148 >; 1149 const _: () = { 1150 assert!( 1151 8 == < LoadStoreAllSizes as wasmtime::component::ComponentType 1152 >::SIZE32 1153 ); 1154 assert!( 1155 4 == < LoadStoreAllSizes as wasmtime::component::ComponentType 1156 >::ALIGN32 1157 ); 1158 }; 1159 #[derive(Clone)] 1160 pub struct Guest { 1161 list_u8_param: wasmtime::component::Func, 1162 list_u16_param: wasmtime::component::Func, 1163 list_u32_param: wasmtime::component::Func, 1164 list_u64_param: wasmtime::component::Func, 1165 list_s8_param: wasmtime::component::Func, 1166 list_s16_param: wasmtime::component::Func, 1167 list_s32_param: wasmtime::component::Func, 1168 list_s64_param: wasmtime::component::Func, 1169 list_f32_param: wasmtime::component::Func, 1170 list_f64_param: wasmtime::component::Func, 1171 list_u8_ret: wasmtime::component::Func, 1172 list_u16_ret: wasmtime::component::Func, 1173 list_u32_ret: wasmtime::component::Func, 1174 list_u64_ret: wasmtime::component::Func, 1175 list_s8_ret: wasmtime::component::Func, 1176 list_s16_ret: wasmtime::component::Func, 1177 list_s32_ret: wasmtime::component::Func, 1178 list_s64_ret: wasmtime::component::Func, 1179 list_f32_ret: wasmtime::component::Func, 1180 list_f64_ret: wasmtime::component::Func, 1181 tuple_list: wasmtime::component::Func, 1182 string_list_arg: wasmtime::component::Func, 1183 string_list_ret: wasmtime::component::Func, 1184 tuple_string_list: wasmtime::component::Func, 1185 string_list: wasmtime::component::Func, 1186 record_list: wasmtime::component::Func, 1187 record_list_reverse: wasmtime::component::Func, 1188 variant_list: wasmtime::component::Func, 1189 load_store_everything: wasmtime::component::Func, 1190 } 1191 #[derive(Clone)] 1192 pub struct GuestIndices { 1193 list_u8_param: wasmtime::component::ComponentExportIndex, 1194 list_u16_param: wasmtime::component::ComponentExportIndex, 1195 list_u32_param: wasmtime::component::ComponentExportIndex, 1196 list_u64_param: wasmtime::component::ComponentExportIndex, 1197 list_s8_param: wasmtime::component::ComponentExportIndex, 1198 list_s16_param: wasmtime::component::ComponentExportIndex, 1199 list_s32_param: wasmtime::component::ComponentExportIndex, 1200 list_s64_param: wasmtime::component::ComponentExportIndex, 1201 list_f32_param: wasmtime::component::ComponentExportIndex, 1202 list_f64_param: wasmtime::component::ComponentExportIndex, 1203 list_u8_ret: wasmtime::component::ComponentExportIndex, 1204 list_u16_ret: wasmtime::component::ComponentExportIndex, 1205 list_u32_ret: wasmtime::component::ComponentExportIndex, 1206 list_u64_ret: wasmtime::component::ComponentExportIndex, 1207 list_s8_ret: wasmtime::component::ComponentExportIndex, 1208 list_s16_ret: wasmtime::component::ComponentExportIndex, 1209 list_s32_ret: wasmtime::component::ComponentExportIndex, 1210 list_s64_ret: wasmtime::component::ComponentExportIndex, 1211 list_f32_ret: wasmtime::component::ComponentExportIndex, 1212 list_f64_ret: wasmtime::component::ComponentExportIndex, 1213 tuple_list: wasmtime::component::ComponentExportIndex, 1214 string_list_arg: wasmtime::component::ComponentExportIndex, 1215 string_list_ret: wasmtime::component::ComponentExportIndex, 1216 tuple_string_list: wasmtime::component::ComponentExportIndex, 1217 string_list: wasmtime::component::ComponentExportIndex, 1218 record_list: wasmtime::component::ComponentExportIndex, 1219 record_list_reverse: wasmtime::component::ComponentExportIndex, 1220 variant_list: wasmtime::component::ComponentExportIndex, 1221 load_store_everything: wasmtime::component::ComponentExportIndex, 1222 } 1223 impl GuestIndices { 1224 /// Constructor for [`GuestIndices`] which takes a 1225 /// [`Component`](wasmtime::component::Component) as input and can be executed 1226 /// before instantiation. 1227 /// 1228 /// This constructor can be used to front-load string lookups to find exports 1229 /// within a component. 1230 pub fn new<_T>( 1231 _instance_pre: &wasmtime::component::InstancePre<_T>, 1232 ) -> wasmtime::Result<GuestIndices> { 1233 let instance = _instance_pre 1234 .component() 1235 .get_export_index(None, "foo:foo/lists") 1236 .ok_or_else(|| { 1237 wasmtime::format_err!( 1238 "no exported instance named `foo:foo/lists`" 1239 ) 1240 })?; 1241 let mut lookup = move |name| { 1242 _instance_pre 1243 .component() 1244 .get_export_index(Some(&instance), name) 1245 .ok_or_else(|| { 1246 wasmtime::format_err!( 1247 "instance export `foo:foo/lists` does \ 1248 not have export `{name}`" 1249 ) 1250 }) 1251 }; 1252 let _ = &mut lookup; 1253 let list_u8_param = lookup("list-u8-param")?; 1254 let list_u16_param = lookup("list-u16-param")?; 1255 let list_u32_param = lookup("list-u32-param")?; 1256 let list_u64_param = lookup("list-u64-param")?; 1257 let list_s8_param = lookup("list-s8-param")?; 1258 let list_s16_param = lookup("list-s16-param")?; 1259 let list_s32_param = lookup("list-s32-param")?; 1260 let list_s64_param = lookup("list-s64-param")?; 1261 let list_f32_param = lookup("list-f32-param")?; 1262 let list_f64_param = lookup("list-f64-param")?; 1263 let list_u8_ret = lookup("list-u8-ret")?; 1264 let list_u16_ret = lookup("list-u16-ret")?; 1265 let list_u32_ret = lookup("list-u32-ret")?; 1266 let list_u64_ret = lookup("list-u64-ret")?; 1267 let list_s8_ret = lookup("list-s8-ret")?; 1268 let list_s16_ret = lookup("list-s16-ret")?; 1269 let list_s32_ret = lookup("list-s32-ret")?; 1270 let list_s64_ret = lookup("list-s64-ret")?; 1271 let list_f32_ret = lookup("list-f32-ret")?; 1272 let list_f64_ret = lookup("list-f64-ret")?; 1273 let tuple_list = lookup("tuple-list")?; 1274 let string_list_arg = lookup("string-list-arg")?; 1275 let string_list_ret = lookup("string-list-ret")?; 1276 let tuple_string_list = lookup("tuple-string-list")?; 1277 let string_list = lookup("string-list")?; 1278 let record_list = lookup("record-list")?; 1279 let record_list_reverse = lookup("record-list-reverse")?; 1280 let variant_list = lookup("variant-list")?; 1281 let load_store_everything = lookup("load-store-everything")?; 1282 Ok(GuestIndices { 1283 list_u8_param, 1284 list_u16_param, 1285 list_u32_param, 1286 list_u64_param, 1287 list_s8_param, 1288 list_s16_param, 1289 list_s32_param, 1290 list_s64_param, 1291 list_f32_param, 1292 list_f64_param, 1293 list_u8_ret, 1294 list_u16_ret, 1295 list_u32_ret, 1296 list_u64_ret, 1297 list_s8_ret, 1298 list_s16_ret, 1299 list_s32_ret, 1300 list_s64_ret, 1301 list_f32_ret, 1302 list_f64_ret, 1303 tuple_list, 1304 string_list_arg, 1305 string_list_ret, 1306 tuple_string_list, 1307 string_list, 1308 record_list, 1309 record_list_reverse, 1310 variant_list, 1311 load_store_everything, 1312 }) 1313 } 1314 pub fn load( 1315 &self, 1316 mut store: impl wasmtime::AsContextMut, 1317 instance: &wasmtime::component::Instance, 1318 ) -> wasmtime::Result<Guest> { 1319 let _instance = instance; 1320 let _instance_pre = _instance.instance_pre(&store); 1321 let _instance_type = _instance_pre.instance_type(); 1322 let mut store = store.as_context_mut(); 1323 let _ = &mut store; 1324 let list_u8_param = *_instance 1325 .get_typed_func::< 1326 (&[u8],), 1327 (), 1328 >(&mut store, &self.list_u8_param)? 1329 .func(); 1330 let list_u16_param = *_instance 1331 .get_typed_func::< 1332 (&[u16],), 1333 (), 1334 >(&mut store, &self.list_u16_param)? 1335 .func(); 1336 let list_u32_param = *_instance 1337 .get_typed_func::< 1338 (&[u32],), 1339 (), 1340 >(&mut store, &self.list_u32_param)? 1341 .func(); 1342 let list_u64_param = *_instance 1343 .get_typed_func::< 1344 (&[u64],), 1345 (), 1346 >(&mut store, &self.list_u64_param)? 1347 .func(); 1348 let list_s8_param = *_instance 1349 .get_typed_func::< 1350 (&[i8],), 1351 (), 1352 >(&mut store, &self.list_s8_param)? 1353 .func(); 1354 let list_s16_param = *_instance 1355 .get_typed_func::< 1356 (&[i16],), 1357 (), 1358 >(&mut store, &self.list_s16_param)? 1359 .func(); 1360 let list_s32_param = *_instance 1361 .get_typed_func::< 1362 (&[i32],), 1363 (), 1364 >(&mut store, &self.list_s32_param)? 1365 .func(); 1366 let list_s64_param = *_instance 1367 .get_typed_func::< 1368 (&[i64],), 1369 (), 1370 >(&mut store, &self.list_s64_param)? 1371 .func(); 1372 let list_f32_param = *_instance 1373 .get_typed_func::< 1374 (&[f32],), 1375 (), 1376 >(&mut store, &self.list_f32_param)? 1377 .func(); 1378 let list_f64_param = *_instance 1379 .get_typed_func::< 1380 (&[f64],), 1381 (), 1382 >(&mut store, &self.list_f64_param)? 1383 .func(); 1384 let list_u8_ret = *_instance 1385 .get_typed_func::< 1386 (), 1387 (wasmtime::component::__internal::Vec<u8>,), 1388 >(&mut store, &self.list_u8_ret)? 1389 .func(); 1390 let list_u16_ret = *_instance 1391 .get_typed_func::< 1392 (), 1393 (wasmtime::component::__internal::Vec<u16>,), 1394 >(&mut store, &self.list_u16_ret)? 1395 .func(); 1396 let list_u32_ret = *_instance 1397 .get_typed_func::< 1398 (), 1399 (wasmtime::component::__internal::Vec<u32>,), 1400 >(&mut store, &self.list_u32_ret)? 1401 .func(); 1402 let list_u64_ret = *_instance 1403 .get_typed_func::< 1404 (), 1405 (wasmtime::component::__internal::Vec<u64>,), 1406 >(&mut store, &self.list_u64_ret)? 1407 .func(); 1408 let list_s8_ret = *_instance 1409 .get_typed_func::< 1410 (), 1411 (wasmtime::component::__internal::Vec<i8>,), 1412 >(&mut store, &self.list_s8_ret)? 1413 .func(); 1414 let list_s16_ret = *_instance 1415 .get_typed_func::< 1416 (), 1417 (wasmtime::component::__internal::Vec<i16>,), 1418 >(&mut store, &self.list_s16_ret)? 1419 .func(); 1420 let list_s32_ret = *_instance 1421 .get_typed_func::< 1422 (), 1423 (wasmtime::component::__internal::Vec<i32>,), 1424 >(&mut store, &self.list_s32_ret)? 1425 .func(); 1426 let list_s64_ret = *_instance 1427 .get_typed_func::< 1428 (), 1429 (wasmtime::component::__internal::Vec<i64>,), 1430 >(&mut store, &self.list_s64_ret)? 1431 .func(); 1432 let list_f32_ret = *_instance 1433 .get_typed_func::< 1434 (), 1435 (wasmtime::component::__internal::Vec<f32>,), 1436 >(&mut store, &self.list_f32_ret)? 1437 .func(); 1438 let list_f64_ret = *_instance 1439 .get_typed_func::< 1440 (), 1441 (wasmtime::component::__internal::Vec<f64>,), 1442 >(&mut store, &self.list_f64_ret)? 1443 .func(); 1444 let tuple_list = *_instance 1445 .get_typed_func::< 1446 (&[(u8, i8)],), 1447 (wasmtime::component::__internal::Vec<(i64, u32)>,), 1448 >(&mut store, &self.tuple_list)? 1449 .func(); 1450 let string_list_arg = *_instance 1451 .get_typed_func::< 1452 (&[wasmtime::component::__internal::String],), 1453 (), 1454 >(&mut store, &self.string_list_arg)? 1455 .func(); 1456 let string_list_ret = *_instance 1457 .get_typed_func::< 1458 (), 1459 ( 1460 wasmtime::component::__internal::Vec< 1461 wasmtime::component::__internal::String, 1462 >, 1463 ), 1464 >(&mut store, &self.string_list_ret)? 1465 .func(); 1466 let tuple_string_list = *_instance 1467 .get_typed_func::< 1468 (&[(u8, wasmtime::component::__internal::String)],), 1469 ( 1470 wasmtime::component::__internal::Vec< 1471 (wasmtime::component::__internal::String, u8), 1472 >, 1473 ), 1474 >(&mut store, &self.tuple_string_list)? 1475 .func(); 1476 let string_list = *_instance 1477 .get_typed_func::< 1478 (&[wasmtime::component::__internal::String],), 1479 ( 1480 wasmtime::component::__internal::Vec< 1481 wasmtime::component::__internal::String, 1482 >, 1483 ), 1484 >(&mut store, &self.string_list)? 1485 .func(); 1486 let record_list = *_instance 1487 .get_typed_func::< 1488 (&[SomeRecord],), 1489 (wasmtime::component::__internal::Vec<OtherRecord>,), 1490 >(&mut store, &self.record_list)? 1491 .func(); 1492 let record_list_reverse = *_instance 1493 .get_typed_func::< 1494 (&[OtherRecord],), 1495 (wasmtime::component::__internal::Vec<SomeRecord>,), 1496 >(&mut store, &self.record_list_reverse)? 1497 .func(); 1498 let variant_list = *_instance 1499 .get_typed_func::< 1500 (&[SomeVariant],), 1501 (wasmtime::component::__internal::Vec<OtherVariant>,), 1502 >(&mut store, &self.variant_list)? 1503 .func(); 1504 let load_store_everything = *_instance 1505 .get_typed_func::< 1506 (&LoadStoreAllSizes,), 1507 (LoadStoreAllSizes,), 1508 >(&mut store, &self.load_store_everything)? 1509 .func(); 1510 Ok(Guest { 1511 list_u8_param, 1512 list_u16_param, 1513 list_u32_param, 1514 list_u64_param, 1515 list_s8_param, 1516 list_s16_param, 1517 list_s32_param, 1518 list_s64_param, 1519 list_f32_param, 1520 list_f64_param, 1521 list_u8_ret, 1522 list_u16_ret, 1523 list_u32_ret, 1524 list_u64_ret, 1525 list_s8_ret, 1526 list_s16_ret, 1527 list_s32_ret, 1528 list_s64_ret, 1529 list_f32_ret, 1530 list_f64_ret, 1531 tuple_list, 1532 string_list_arg, 1533 string_list_ret, 1534 tuple_string_list, 1535 string_list, 1536 record_list, 1537 record_list_reverse, 1538 variant_list, 1539 load_store_everything, 1540 }) 1541 } 1542 } 1543 impl Guest { 1544 pub fn call_list_u8_param<S: wasmtime::AsContextMut>( 1545 &self, 1546 mut store: S, 1547 arg0: &[u8], 1548 ) -> wasmtime::Result<()> { 1549 let callee = unsafe { 1550 wasmtime::component::TypedFunc::< 1551 (&[u8],), 1552 (), 1553 >::new_unchecked(self.list_u8_param) 1554 }; 1555 let () = callee.call(store.as_context_mut(), (arg0,))?; 1556 Ok(()) 1557 } 1558 pub fn call_list_u16_param<S: wasmtime::AsContextMut>( 1559 &self, 1560 mut store: S, 1561 arg0: &[u16], 1562 ) -> wasmtime::Result<()> { 1563 let callee = unsafe { 1564 wasmtime::component::TypedFunc::< 1565 (&[u16],), 1566 (), 1567 >::new_unchecked(self.list_u16_param) 1568 }; 1569 let () = callee.call(store.as_context_mut(), (arg0,))?; 1570 Ok(()) 1571 } 1572 pub fn call_list_u32_param<S: wasmtime::AsContextMut>( 1573 &self, 1574 mut store: S, 1575 arg0: &[u32], 1576 ) -> wasmtime::Result<()> { 1577 let callee = unsafe { 1578 wasmtime::component::TypedFunc::< 1579 (&[u32],), 1580 (), 1581 >::new_unchecked(self.list_u32_param) 1582 }; 1583 let () = callee.call(store.as_context_mut(), (arg0,))?; 1584 Ok(()) 1585 } 1586 pub fn call_list_u64_param<S: wasmtime::AsContextMut>( 1587 &self, 1588 mut store: S, 1589 arg0: &[u64], 1590 ) -> wasmtime::Result<()> { 1591 let callee = unsafe { 1592 wasmtime::component::TypedFunc::< 1593 (&[u64],), 1594 (), 1595 >::new_unchecked(self.list_u64_param) 1596 }; 1597 let () = callee.call(store.as_context_mut(), (arg0,))?; 1598 Ok(()) 1599 } 1600 pub fn call_list_s8_param<S: wasmtime::AsContextMut>( 1601 &self, 1602 mut store: S, 1603 arg0: &[i8], 1604 ) -> wasmtime::Result<()> { 1605 let callee = unsafe { 1606 wasmtime::component::TypedFunc::< 1607 (&[i8],), 1608 (), 1609 >::new_unchecked(self.list_s8_param) 1610 }; 1611 let () = callee.call(store.as_context_mut(), (arg0,))?; 1612 Ok(()) 1613 } 1614 pub fn call_list_s16_param<S: wasmtime::AsContextMut>( 1615 &self, 1616 mut store: S, 1617 arg0: &[i16], 1618 ) -> wasmtime::Result<()> { 1619 let callee = unsafe { 1620 wasmtime::component::TypedFunc::< 1621 (&[i16],), 1622 (), 1623 >::new_unchecked(self.list_s16_param) 1624 }; 1625 let () = callee.call(store.as_context_mut(), (arg0,))?; 1626 Ok(()) 1627 } 1628 pub fn call_list_s32_param<S: wasmtime::AsContextMut>( 1629 &self, 1630 mut store: S, 1631 arg0: &[i32], 1632 ) -> wasmtime::Result<()> { 1633 let callee = unsafe { 1634 wasmtime::component::TypedFunc::< 1635 (&[i32],), 1636 (), 1637 >::new_unchecked(self.list_s32_param) 1638 }; 1639 let () = callee.call(store.as_context_mut(), (arg0,))?; 1640 Ok(()) 1641 } 1642 pub fn call_list_s64_param<S: wasmtime::AsContextMut>( 1643 &self, 1644 mut store: S, 1645 arg0: &[i64], 1646 ) -> wasmtime::Result<()> { 1647 let callee = unsafe { 1648 wasmtime::component::TypedFunc::< 1649 (&[i64],), 1650 (), 1651 >::new_unchecked(self.list_s64_param) 1652 }; 1653 let () = callee.call(store.as_context_mut(), (arg0,))?; 1654 Ok(()) 1655 } 1656 pub fn call_list_f32_param<S: wasmtime::AsContextMut>( 1657 &self, 1658 mut store: S, 1659 arg0: &[f32], 1660 ) -> wasmtime::Result<()> { 1661 let callee = unsafe { 1662 wasmtime::component::TypedFunc::< 1663 (&[f32],), 1664 (), 1665 >::new_unchecked(self.list_f32_param) 1666 }; 1667 let () = callee.call(store.as_context_mut(), (arg0,))?; 1668 Ok(()) 1669 } 1670 pub fn call_list_f64_param<S: wasmtime::AsContextMut>( 1671 &self, 1672 mut store: S, 1673 arg0: &[f64], 1674 ) -> wasmtime::Result<()> { 1675 let callee = unsafe { 1676 wasmtime::component::TypedFunc::< 1677 (&[f64],), 1678 (), 1679 >::new_unchecked(self.list_f64_param) 1680 }; 1681 let () = callee.call(store.as_context_mut(), (arg0,))?; 1682 Ok(()) 1683 } 1684 pub fn call_list_u8_ret<S: wasmtime::AsContextMut>( 1685 &self, 1686 mut store: S, 1687 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u8>> { 1688 let callee = unsafe { 1689 wasmtime::component::TypedFunc::< 1690 (), 1691 (wasmtime::component::__internal::Vec<u8>,), 1692 >::new_unchecked(self.list_u8_ret) 1693 }; 1694 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1695 Ok(ret0) 1696 } 1697 pub fn call_list_u16_ret<S: wasmtime::AsContextMut>( 1698 &self, 1699 mut store: S, 1700 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u16>> { 1701 let callee = unsafe { 1702 wasmtime::component::TypedFunc::< 1703 (), 1704 (wasmtime::component::__internal::Vec<u16>,), 1705 >::new_unchecked(self.list_u16_ret) 1706 }; 1707 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1708 Ok(ret0) 1709 } 1710 pub fn call_list_u32_ret<S: wasmtime::AsContextMut>( 1711 &self, 1712 mut store: S, 1713 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u32>> { 1714 let callee = unsafe { 1715 wasmtime::component::TypedFunc::< 1716 (), 1717 (wasmtime::component::__internal::Vec<u32>,), 1718 >::new_unchecked(self.list_u32_ret) 1719 }; 1720 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1721 Ok(ret0) 1722 } 1723 pub fn call_list_u64_ret<S: wasmtime::AsContextMut>( 1724 &self, 1725 mut store: S, 1726 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u64>> { 1727 let callee = unsafe { 1728 wasmtime::component::TypedFunc::< 1729 (), 1730 (wasmtime::component::__internal::Vec<u64>,), 1731 >::new_unchecked(self.list_u64_ret) 1732 }; 1733 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1734 Ok(ret0) 1735 } 1736 pub fn call_list_s8_ret<S: wasmtime::AsContextMut>( 1737 &self, 1738 mut store: S, 1739 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i8>> { 1740 let callee = unsafe { 1741 wasmtime::component::TypedFunc::< 1742 (), 1743 (wasmtime::component::__internal::Vec<i8>,), 1744 >::new_unchecked(self.list_s8_ret) 1745 }; 1746 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1747 Ok(ret0) 1748 } 1749 pub fn call_list_s16_ret<S: wasmtime::AsContextMut>( 1750 &self, 1751 mut store: S, 1752 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i16>> { 1753 let callee = unsafe { 1754 wasmtime::component::TypedFunc::< 1755 (), 1756 (wasmtime::component::__internal::Vec<i16>,), 1757 >::new_unchecked(self.list_s16_ret) 1758 }; 1759 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1760 Ok(ret0) 1761 } 1762 pub fn call_list_s32_ret<S: wasmtime::AsContextMut>( 1763 &self, 1764 mut store: S, 1765 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i32>> { 1766 let callee = unsafe { 1767 wasmtime::component::TypedFunc::< 1768 (), 1769 (wasmtime::component::__internal::Vec<i32>,), 1770 >::new_unchecked(self.list_s32_ret) 1771 }; 1772 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1773 Ok(ret0) 1774 } 1775 pub fn call_list_s64_ret<S: wasmtime::AsContextMut>( 1776 &self, 1777 mut store: S, 1778 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i64>> { 1779 let callee = unsafe { 1780 wasmtime::component::TypedFunc::< 1781 (), 1782 (wasmtime::component::__internal::Vec<i64>,), 1783 >::new_unchecked(self.list_s64_ret) 1784 }; 1785 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1786 Ok(ret0) 1787 } 1788 pub fn call_list_f32_ret<S: wasmtime::AsContextMut>( 1789 &self, 1790 mut store: S, 1791 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f32>> { 1792 let callee = unsafe { 1793 wasmtime::component::TypedFunc::< 1794 (), 1795 (wasmtime::component::__internal::Vec<f32>,), 1796 >::new_unchecked(self.list_f32_ret) 1797 }; 1798 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1799 Ok(ret0) 1800 } 1801 pub fn call_list_f64_ret<S: wasmtime::AsContextMut>( 1802 &self, 1803 mut store: S, 1804 ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f64>> { 1805 let callee = unsafe { 1806 wasmtime::component::TypedFunc::< 1807 (), 1808 (wasmtime::component::__internal::Vec<f64>,), 1809 >::new_unchecked(self.list_f64_ret) 1810 }; 1811 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1812 Ok(ret0) 1813 } 1814 pub fn call_tuple_list<S: wasmtime::AsContextMut>( 1815 &self, 1816 mut store: S, 1817 arg0: &[(u8, i8)], 1818 ) -> wasmtime::Result< 1819 wasmtime::component::__internal::Vec<(i64, u32)>, 1820 > { 1821 let callee = unsafe { 1822 wasmtime::component::TypedFunc::< 1823 (&[(u8, i8)],), 1824 (wasmtime::component::__internal::Vec<(i64, u32)>,), 1825 >::new_unchecked(self.tuple_list) 1826 }; 1827 let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?; 1828 Ok(ret0) 1829 } 1830 pub fn call_string_list_arg<S: wasmtime::AsContextMut>( 1831 &self, 1832 mut store: S, 1833 arg0: &[wasmtime::component::__internal::String], 1834 ) -> wasmtime::Result<()> { 1835 let callee = unsafe { 1836 wasmtime::component::TypedFunc::< 1837 (&[wasmtime::component::__internal::String],), 1838 (), 1839 >::new_unchecked(self.string_list_arg) 1840 }; 1841 let () = callee.call(store.as_context_mut(), (arg0,))?; 1842 Ok(()) 1843 } 1844 pub fn call_string_list_ret<S: wasmtime::AsContextMut>( 1845 &self, 1846 mut store: S, 1847 ) -> wasmtime::Result< 1848 wasmtime::component::__internal::Vec< 1849 wasmtime::component::__internal::String, 1850 >, 1851 > { 1852 let callee = unsafe { 1853 wasmtime::component::TypedFunc::< 1854 (), 1855 ( 1856 wasmtime::component::__internal::Vec< 1857 wasmtime::component::__internal::String, 1858 >, 1859 ), 1860 >::new_unchecked(self.string_list_ret) 1861 }; 1862 let (ret0,) = callee.call(store.as_context_mut(), ())?; 1863 Ok(ret0) 1864 } 1865 pub fn call_tuple_string_list<S: wasmtime::AsContextMut>( 1866 &self, 1867 mut store: S, 1868 arg0: &[(u8, wasmtime::component::__internal::String)], 1869 ) -> wasmtime::Result< 1870 wasmtime::component::__internal::Vec< 1871 (wasmtime::component::__internal::String, u8), 1872 >, 1873 > { 1874 let callee = unsafe { 1875 wasmtime::component::TypedFunc::< 1876 (&[(u8, wasmtime::component::__internal::String)],), 1877 ( 1878 wasmtime::component::__internal::Vec< 1879 (wasmtime::component::__internal::String, u8), 1880 >, 1881 ), 1882 >::new_unchecked(self.tuple_string_list) 1883 }; 1884 let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?; 1885 Ok(ret0) 1886 } 1887 pub fn call_string_list<S: wasmtime::AsContextMut>( 1888 &self, 1889 mut store: S, 1890 arg0: &[wasmtime::component::__internal::String], 1891 ) -> wasmtime::Result< 1892 wasmtime::component::__internal::Vec< 1893 wasmtime::component::__internal::String, 1894 >, 1895 > { 1896 let callee = unsafe { 1897 wasmtime::component::TypedFunc::< 1898 (&[wasmtime::component::__internal::String],), 1899 ( 1900 wasmtime::component::__internal::Vec< 1901 wasmtime::component::__internal::String, 1902 >, 1903 ), 1904 >::new_unchecked(self.string_list) 1905 }; 1906 let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?; 1907 Ok(ret0) 1908 } 1909 pub fn call_record_list<S: wasmtime::AsContextMut>( 1910 &self, 1911 mut store: S, 1912 arg0: &[SomeRecord], 1913 ) -> wasmtime::Result< 1914 wasmtime::component::__internal::Vec<OtherRecord>, 1915 > { 1916 let callee = unsafe { 1917 wasmtime::component::TypedFunc::< 1918 (&[SomeRecord],), 1919 (wasmtime::component::__internal::Vec<OtherRecord>,), 1920 >::new_unchecked(self.record_list) 1921 }; 1922 let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?; 1923 Ok(ret0) 1924 } 1925 pub fn call_record_list_reverse<S: wasmtime::AsContextMut>( 1926 &self, 1927 mut store: S, 1928 arg0: &[OtherRecord], 1929 ) -> wasmtime::Result< 1930 wasmtime::component::__internal::Vec<SomeRecord>, 1931 > { 1932 let callee = unsafe { 1933 wasmtime::component::TypedFunc::< 1934 (&[OtherRecord],), 1935 (wasmtime::component::__internal::Vec<SomeRecord>,), 1936 >::new_unchecked(self.record_list_reverse) 1937 }; 1938 let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?; 1939 Ok(ret0) 1940 } 1941 pub fn call_variant_list<S: wasmtime::AsContextMut>( 1942 &self, 1943 mut store: S, 1944 arg0: &[SomeVariant], 1945 ) -> wasmtime::Result< 1946 wasmtime::component::__internal::Vec<OtherVariant>, 1947 > { 1948 let callee = unsafe { 1949 wasmtime::component::TypedFunc::< 1950 (&[SomeVariant],), 1951 (wasmtime::component::__internal::Vec<OtherVariant>,), 1952 >::new_unchecked(self.variant_list) 1953 }; 1954 let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?; 1955 Ok(ret0) 1956 } 1957 pub fn call_load_store_everything<S: wasmtime::AsContextMut>( 1958 &self, 1959 mut store: S, 1960 arg0: &LoadStoreAllSizes, 1961 ) -> wasmtime::Result<LoadStoreAllSizes> { 1962 let callee = unsafe { 1963 wasmtime::component::TypedFunc::< 1964 (&LoadStoreAllSizes,), 1965 (LoadStoreAllSizes,), 1966 >::new_unchecked(self.load_store_everything) 1967 }; 1968 let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?; 1969 Ok(ret0) 1970 } 1971 } 1972 } 1973 } 1974 } 1975 } 1976