1 /// Auto-generated bindings for a pre-instantiated version of a 2 /// component which implements the world `the-world`. 3 /// 4 /// This structure is created through [`TheWorldPre::new`] which 5 /// takes a [`InstancePre`](wasmtime::component::InstancePre) that 6 /// has been created through a [`Linker`](wasmtime::component::Linker). 7 /// 8 /// For more information see [`TheWorld`] as well. 9 pub struct TheWorldPre<T: 'static> { 10 instance_pre: wasmtime::component::InstancePre<T>, 11 indices: TheWorldIndices, 12 } 13 impl<T: 'static> Clone for TheWorldPre<T> { clone(&self) -> Self14 fn clone(&self) -> Self { 15 Self { 16 instance_pre: self.instance_pre.clone(), 17 indices: self.indices.clone(), 18 } 19 } 20 } 21 impl<_T: 'static> TheWorldPre<_T> { 22 /// Creates a new copy of `TheWorldPre` bindings which can then 23 /// be used to instantiate into a particular store. 24 /// 25 /// This method may fail if the component behind `instance_pre` 26 /// does not have the required exports. new( instance_pre: wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<Self>27 pub fn new( 28 instance_pre: wasmtime::component::InstancePre<_T>, 29 ) -> wasmtime::Result<Self> { 30 let indices = TheWorldIndices::new(&instance_pre)?; 31 Ok(Self { instance_pre, indices }) 32 } engine(&self) -> &wasmtime::Engine33 pub fn engine(&self) -> &wasmtime::Engine { 34 self.instance_pre.engine() 35 } instance_pre(&self) -> &wasmtime::component::InstancePre<_T>36 pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> { 37 &self.instance_pre 38 } 39 /// Instantiates a new instance of [`TheWorld`] within the 40 /// `store` provided. 41 /// 42 /// This function will use `self` as the pre-instantiated 43 /// instance to perform instantiation. Afterwards the preloaded 44 /// indices in `self` are used to lookup all exports on the 45 /// resulting instance. instantiate( &self, mut store: impl wasmtime::AsContextMut<Data = _T>, ) -> wasmtime::Result<TheWorld>46 pub fn instantiate( 47 &self, 48 mut store: impl wasmtime::AsContextMut<Data = _T>, 49 ) -> wasmtime::Result<TheWorld> { 50 let mut store = store.as_context_mut(); 51 let instance = self.instance_pre.instantiate(&mut store)?; 52 self.indices.load(&mut store, &instance) 53 } 54 } 55 impl<_T: Send + 'static> TheWorldPre<_T> { 56 /// Same as [`Self::instantiate`], except with `async`. instantiate_async( &self, mut store: impl wasmtime::AsContextMut<Data = _T>, ) -> wasmtime::Result<TheWorld>57 pub async fn instantiate_async( 58 &self, 59 mut store: impl wasmtime::AsContextMut<Data = _T>, 60 ) -> wasmtime::Result<TheWorld> { 61 let mut store = store.as_context_mut(); 62 let instance = self.instance_pre.instantiate_async(&mut store).await?; 63 self.indices.load(&mut store, &instance) 64 } 65 } 66 /// Auto-generated bindings for index of the exports of 67 /// `the-world`. 68 /// 69 /// This is an implementation detail of [`TheWorldPre`] and can 70 /// be constructed if needed as well. 71 /// 72 /// For more information see [`TheWorld`] as well. 73 #[derive(Clone)] 74 pub struct TheWorldIndices { 75 interface0: exports::foo::foo::manyarg::GuestIndices, 76 } 77 /// Auto-generated bindings for an instance a component which 78 /// implements the world `the-world`. 79 /// 80 /// This structure can be created through a number of means 81 /// depending on your requirements and what you have on hand: 82 /// 83 /// * The most convenient way is to use 84 /// [`TheWorld::instantiate`] which only needs a 85 /// [`Store`], [`Component`], and [`Linker`]. 86 /// 87 /// * Alternatively you can create a [`TheWorldPre`] ahead of 88 /// time with a [`Component`] to front-load string lookups 89 /// of exports once instead of per-instantiation. This 90 /// method then uses [`TheWorldPre::instantiate`] to 91 /// create a [`TheWorld`]. 92 /// 93 /// * If you've instantiated the instance yourself already 94 /// then you can use [`TheWorld::new`]. 95 /// 96 /// These methods are all equivalent to one another and move 97 /// around the tradeoff of what work is performed when. 98 /// 99 /// [`Store`]: wasmtime::Store 100 /// [`Component`]: wasmtime::component::Component 101 /// [`Linker`]: wasmtime::component::Linker 102 pub struct TheWorld { 103 interface0: exports::foo::foo::manyarg::Guest, 104 } 105 const _: () = { 106 impl TheWorldIndices { 107 /// Creates a new copy of `TheWorldIndices` 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. new<_T>( _instance_pre: &wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<Self>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::manyarg::GuestIndices::new( 118 _instance_pre, 119 )?; 120 Ok(TheWorldIndices { interface0 }) 121 } 122 /// Uses the indices stored in `self` to load an instance 123 /// of [`TheWorld`] from the instance provided. 124 /// 125 /// Note that at this time this method will additionally 126 /// perform type-checks of all exports. load( &self, mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<TheWorld>127 pub fn load( 128 &self, 129 mut store: impl wasmtime::AsContextMut, 130 instance: &wasmtime::component::Instance, 131 ) -> wasmtime::Result<TheWorld> { 132 let _ = &mut store; 133 let _instance = instance; 134 let interface0 = self.interface0.load(&mut store, &_instance)?; 135 Ok(TheWorld { interface0 }) 136 } 137 } 138 impl TheWorld { 139 /// Convenience wrapper around [`TheWorldPre::new`] and 140 /// [`TheWorldPre::instantiate`]. instantiate<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<TheWorld>141 pub fn instantiate<_T>( 142 store: impl wasmtime::AsContextMut<Data = _T>, 143 component: &wasmtime::component::Component, 144 linker: &wasmtime::component::Linker<_T>, 145 ) -> wasmtime::Result<TheWorld> { 146 let pre = linker.instantiate_pre(component)?; 147 TheWorldPre::new(pre)?.instantiate(store) 148 } 149 /// Convenience wrapper around [`TheWorldIndices::new`] and 150 /// [`TheWorldIndices::load`]. new( mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<TheWorld>151 pub fn new( 152 mut store: impl wasmtime::AsContextMut, 153 instance: &wasmtime::component::Instance, 154 ) -> wasmtime::Result<TheWorld> { 155 let indices = TheWorldIndices::new(&instance.instance_pre(&store))?; 156 indices.load(&mut store, instance) 157 } 158 /// Convenience wrapper around [`TheWorldPre::new`] and 159 /// [`TheWorldPre::instantiate_async`]. instantiate_async<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<TheWorld> where _T: Send,160 pub async fn instantiate_async<_T>( 161 store: impl wasmtime::AsContextMut<Data = _T>, 162 component: &wasmtime::component::Component, 163 linker: &wasmtime::component::Linker<_T>, 164 ) -> wasmtime::Result<TheWorld> 165 where 166 _T: Send, 167 { 168 let pre = linker.instantiate_pre(component)?; 169 TheWorldPre::new(pre)?.instantiate_async(store).await 170 } add_to_linker<T, D>( linker: &mut wasmtime::component::Linker<T>, host_getter: fn(&mut T) -> D::Data<'_>, ) -> wasmtime::Result<()> where D: foo::foo::manyarg::HostWithStore, for<'a> D::Data<'a>: foo::foo::manyarg::Host, T: 'static,171 pub fn add_to_linker<T, D>( 172 linker: &mut wasmtime::component::Linker<T>, 173 host_getter: fn(&mut T) -> D::Data<'_>, 174 ) -> wasmtime::Result<()> 175 where 176 D: foo::foo::manyarg::HostWithStore, 177 for<'a> D::Data<'a>: foo::foo::manyarg::Host, 178 T: 'static, 179 { 180 foo::foo::manyarg::add_to_linker::<T, D>(linker, host_getter)?; 181 Ok(()) 182 } foo_foo_manyarg(&self) -> &exports::foo::foo::manyarg::Guest183 pub fn foo_foo_manyarg(&self) -> &exports::foo::foo::manyarg::Guest { 184 &self.interface0 185 } 186 } 187 }; 188 pub mod foo { 189 pub mod foo { 190 #[allow(clippy::all)] 191 pub mod manyarg { 192 #[allow(unused_imports)] 193 use wasmtime::component::__internal::Box; 194 #[derive(wasmtime::component::ComponentType)] 195 #[derive(wasmtime::component::Lift)] 196 #[derive(wasmtime::component::Lower)] 197 #[component(record)] 198 #[derive(Clone)] 199 pub struct BigStruct { 200 #[component(name = "a1")] 201 pub a1: wasmtime::component::__internal::String, 202 #[component(name = "a2")] 203 pub a2: wasmtime::component::__internal::String, 204 #[component(name = "a3")] 205 pub a3: wasmtime::component::__internal::String, 206 #[component(name = "a4")] 207 pub a4: wasmtime::component::__internal::String, 208 #[component(name = "a5")] 209 pub a5: wasmtime::component::__internal::String, 210 #[component(name = "a6")] 211 pub a6: wasmtime::component::__internal::String, 212 #[component(name = "a7")] 213 pub a7: wasmtime::component::__internal::String, 214 #[component(name = "a8")] 215 pub a8: wasmtime::component::__internal::String, 216 #[component(name = "a9")] 217 pub a9: wasmtime::component::__internal::String, 218 #[component(name = "a10")] 219 pub a10: wasmtime::component::__internal::String, 220 #[component(name = "a11")] 221 pub a11: wasmtime::component::__internal::String, 222 #[component(name = "a12")] 223 pub a12: wasmtime::component::__internal::String, 224 #[component(name = "a13")] 225 pub a13: wasmtime::component::__internal::String, 226 #[component(name = "a14")] 227 pub a14: wasmtime::component::__internal::String, 228 #[component(name = "a15")] 229 pub a15: wasmtime::component::__internal::String, 230 #[component(name = "a16")] 231 pub a16: wasmtime::component::__internal::String, 232 #[component(name = "a17")] 233 pub a17: wasmtime::component::__internal::String, 234 #[component(name = "a18")] 235 pub a18: wasmtime::component::__internal::String, 236 #[component(name = "a19")] 237 pub a19: wasmtime::component::__internal::String, 238 #[component(name = "a20")] 239 pub a20: wasmtime::component::__internal::String, 240 } 241 impl core::fmt::Debug for BigStruct { fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result242 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 243 f.debug_struct("BigStruct") 244 .field("a1", &self.a1) 245 .field("a2", &self.a2) 246 .field("a3", &self.a3) 247 .field("a4", &self.a4) 248 .field("a5", &self.a5) 249 .field("a6", &self.a6) 250 .field("a7", &self.a7) 251 .field("a8", &self.a8) 252 .field("a9", &self.a9) 253 .field("a10", &self.a10) 254 .field("a11", &self.a11) 255 .field("a12", &self.a12) 256 .field("a13", &self.a13) 257 .field("a14", &self.a14) 258 .field("a15", &self.a15) 259 .field("a16", &self.a16) 260 .field("a17", &self.a17) 261 .field("a18", &self.a18) 262 .field("a19", &self.a19) 263 .field("a20", &self.a20) 264 .finish() 265 } 266 } 267 const _: () = { 268 assert!( 269 160 == < BigStruct as wasmtime::component::ComponentType >::SIZE32 270 ); 271 assert!( 272 4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32 273 ); 274 }; 275 pub trait HostWithStore: wasmtime::component::HasData {} 276 impl<_T: ?Sized> HostWithStore for _T 277 where 278 _T: wasmtime::component::HasData, 279 {} 280 pub trait Host { many_args( &mut self, a1: u64, a2: u64, a3: u64, a4: u64, a5: u64, a6: u64, a7: u64, a8: u64, a9: u64, a10: u64, a11: u64, a12: u64, a13: u64, a14: u64, a15: u64, a16: u64, ) -> ()281 fn many_args( 282 &mut self, 283 a1: u64, 284 a2: u64, 285 a3: u64, 286 a4: u64, 287 a5: u64, 288 a6: u64, 289 a7: u64, 290 a8: u64, 291 a9: u64, 292 a10: u64, 293 a11: u64, 294 a12: u64, 295 a13: u64, 296 a14: u64, 297 a15: u64, 298 a16: u64, 299 ) -> (); big_argument(&mut self, x: BigStruct) -> ()300 fn big_argument(&mut self, x: BigStruct) -> (); 301 } 302 impl<_T: Host + ?Sized> Host for &mut _T { many_args( &mut self, a1: u64, a2: u64, a3: u64, a4: u64, a5: u64, a6: u64, a7: u64, a8: u64, a9: u64, a10: u64, a11: u64, a12: u64, a13: u64, a14: u64, a15: u64, a16: u64, ) -> ()303 fn many_args( 304 &mut self, 305 a1: u64, 306 a2: u64, 307 a3: u64, 308 a4: u64, 309 a5: u64, 310 a6: u64, 311 a7: u64, 312 a8: u64, 313 a9: u64, 314 a10: u64, 315 a11: u64, 316 a12: u64, 317 a13: u64, 318 a14: u64, 319 a15: u64, 320 a16: u64, 321 ) -> () { 322 Host::many_args( 323 *self, 324 a1, 325 a2, 326 a3, 327 a4, 328 a5, 329 a6, 330 a7, 331 a8, 332 a9, 333 a10, 334 a11, 335 a12, 336 a13, 337 a14, 338 a15, 339 a16, 340 ) 341 } big_argument(&mut self, x: BigStruct) -> ()342 fn big_argument(&mut self, x: BigStruct) -> () { 343 Host::big_argument(*self, x) 344 } 345 } add_to_linker<T, D>( linker: &mut wasmtime::component::Linker<T>, host_getter: fn(&mut T) -> D::Data<'_>, ) -> wasmtime::Result<()> where D: HostWithStore, for<'a> D::Data<'a>: Host, T: 'static,346 pub fn add_to_linker<T, D>( 347 linker: &mut wasmtime::component::Linker<T>, 348 host_getter: fn(&mut T) -> D::Data<'_>, 349 ) -> wasmtime::Result<()> 350 where 351 D: HostWithStore, 352 for<'a> D::Data<'a>: Host, 353 T: 'static, 354 { 355 let mut inst = linker.instance("foo:foo/manyarg")?; 356 inst.func_wrap( 357 "many-args", 358 move | 359 mut caller: wasmtime::StoreContextMut<'_, T>, 360 ( 361 arg0, 362 arg1, 363 arg2, 364 arg3, 365 arg4, 366 arg5, 367 arg6, 368 arg7, 369 arg8, 370 arg9, 371 arg10, 372 arg11, 373 arg12, 374 arg13, 375 arg14, 376 arg15, 377 ): ( 378 u64, 379 u64, 380 u64, 381 u64, 382 u64, 383 u64, 384 u64, 385 u64, 386 u64, 387 u64, 388 u64, 389 u64, 390 u64, 391 u64, 392 u64, 393 u64, 394 )| 395 { 396 let host = &mut host_getter(caller.data_mut()); 397 let r = Host::many_args( 398 host, 399 arg0, 400 arg1, 401 arg2, 402 arg3, 403 arg4, 404 arg5, 405 arg6, 406 arg7, 407 arg8, 408 arg9, 409 arg10, 410 arg11, 411 arg12, 412 arg13, 413 arg14, 414 arg15, 415 ); 416 Ok(r) 417 }, 418 )?; 419 inst.func_wrap( 420 "big-argument", 421 move | 422 mut caller: wasmtime::StoreContextMut<'_, T>, 423 (arg0,): (BigStruct,)| 424 { 425 let host = &mut host_getter(caller.data_mut()); 426 let r = Host::big_argument(host, arg0); 427 Ok(r) 428 }, 429 )?; 430 Ok(()) 431 } 432 } 433 } 434 } 435 pub mod exports { 436 pub mod foo { 437 pub mod foo { 438 #[allow(clippy::all)] 439 pub mod manyarg { 440 #[allow(unused_imports)] 441 use wasmtime::component::__internal::Box; 442 #[derive(wasmtime::component::ComponentType)] 443 #[derive(wasmtime::component::Lift)] 444 #[derive(wasmtime::component::Lower)] 445 #[component(record)] 446 #[derive(Clone)] 447 pub struct BigStruct { 448 #[component(name = "a1")] 449 pub a1: wasmtime::component::__internal::String, 450 #[component(name = "a2")] 451 pub a2: wasmtime::component::__internal::String, 452 #[component(name = "a3")] 453 pub a3: wasmtime::component::__internal::String, 454 #[component(name = "a4")] 455 pub a4: wasmtime::component::__internal::String, 456 #[component(name = "a5")] 457 pub a5: wasmtime::component::__internal::String, 458 #[component(name = "a6")] 459 pub a6: wasmtime::component::__internal::String, 460 #[component(name = "a7")] 461 pub a7: wasmtime::component::__internal::String, 462 #[component(name = "a8")] 463 pub a8: wasmtime::component::__internal::String, 464 #[component(name = "a9")] 465 pub a9: wasmtime::component::__internal::String, 466 #[component(name = "a10")] 467 pub a10: wasmtime::component::__internal::String, 468 #[component(name = "a11")] 469 pub a11: wasmtime::component::__internal::String, 470 #[component(name = "a12")] 471 pub a12: wasmtime::component::__internal::String, 472 #[component(name = "a13")] 473 pub a13: wasmtime::component::__internal::String, 474 #[component(name = "a14")] 475 pub a14: wasmtime::component::__internal::String, 476 #[component(name = "a15")] 477 pub a15: wasmtime::component::__internal::String, 478 #[component(name = "a16")] 479 pub a16: wasmtime::component::__internal::String, 480 #[component(name = "a17")] 481 pub a17: wasmtime::component::__internal::String, 482 #[component(name = "a18")] 483 pub a18: wasmtime::component::__internal::String, 484 #[component(name = "a19")] 485 pub a19: wasmtime::component::__internal::String, 486 #[component(name = "a20")] 487 pub a20: wasmtime::component::__internal::String, 488 } 489 impl core::fmt::Debug for BigStruct { fmt( &self, f: &mut core::fmt::Formatter<'_>, ) -> core::fmt::Result490 fn fmt( 491 &self, 492 f: &mut core::fmt::Formatter<'_>, 493 ) -> core::fmt::Result { 494 f.debug_struct("BigStruct") 495 .field("a1", &self.a1) 496 .field("a2", &self.a2) 497 .field("a3", &self.a3) 498 .field("a4", &self.a4) 499 .field("a5", &self.a5) 500 .field("a6", &self.a6) 501 .field("a7", &self.a7) 502 .field("a8", &self.a8) 503 .field("a9", &self.a9) 504 .field("a10", &self.a10) 505 .field("a11", &self.a11) 506 .field("a12", &self.a12) 507 .field("a13", &self.a13) 508 .field("a14", &self.a14) 509 .field("a15", &self.a15) 510 .field("a16", &self.a16) 511 .field("a17", &self.a17) 512 .field("a18", &self.a18) 513 .field("a19", &self.a19) 514 .field("a20", &self.a20) 515 .finish() 516 } 517 } 518 const _: () = { 519 assert!( 520 160 == < BigStruct as wasmtime::component::ComponentType 521 >::SIZE32 522 ); 523 assert!( 524 4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32 525 ); 526 }; 527 #[derive(Clone)] 528 pub struct Guest { 529 many_args: wasmtime::component::Func, 530 big_argument: wasmtime::component::Func, 531 } 532 #[derive(Clone)] 533 pub struct GuestIndices { 534 many_args: wasmtime::component::ComponentExportIndex, 535 big_argument: wasmtime::component::ComponentExportIndex, 536 } 537 impl GuestIndices { 538 /// Constructor for [`GuestIndices`] which takes a 539 /// [`Component`](wasmtime::component::Component) as input and can be executed 540 /// before instantiation. 541 /// 542 /// This constructor can be used to front-load string lookups to find exports 543 /// within a component. new<_T>( _instance_pre: &wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<GuestIndices>544 pub fn new<_T>( 545 _instance_pre: &wasmtime::component::InstancePre<_T>, 546 ) -> wasmtime::Result<GuestIndices> { 547 let instance = _instance_pre 548 .component() 549 .get_export_index(None, "foo:foo/manyarg") 550 .ok_or_else(|| { 551 wasmtime::format_err!( 552 "no exported instance named `foo:foo/manyarg`" 553 ) 554 })?; 555 let mut lookup = move |name| { 556 _instance_pre 557 .component() 558 .get_export_index(Some(&instance), name) 559 .ok_or_else(|| { 560 wasmtime::format_err!( 561 "instance export `foo:foo/manyarg` does \ 562 not have export `{name}`" 563 ) 564 }) 565 }; 566 let _ = &mut lookup; 567 let many_args = lookup("many-args")?; 568 let big_argument = lookup("big-argument")?; 569 Ok(GuestIndices { 570 many_args, 571 big_argument, 572 }) 573 } load( &self, mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<Guest>574 pub fn load( 575 &self, 576 mut store: impl wasmtime::AsContextMut, 577 instance: &wasmtime::component::Instance, 578 ) -> wasmtime::Result<Guest> { 579 let _instance = instance; 580 let _instance_pre = _instance.instance_pre(&store); 581 let _instance_type = _instance_pre.instance_type(); 582 let mut store = store.as_context_mut(); 583 let _ = &mut store; 584 let many_args = *_instance 585 .get_typed_func::< 586 ( 587 u64, 588 u64, 589 u64, 590 u64, 591 u64, 592 u64, 593 u64, 594 u64, 595 u64, 596 u64, 597 u64, 598 u64, 599 u64, 600 u64, 601 u64, 602 u64, 603 ), 604 (), 605 >(&mut store, &self.many_args)? 606 .func(); 607 let big_argument = *_instance 608 .get_typed_func::< 609 (&BigStruct,), 610 (), 611 >(&mut store, &self.big_argument)? 612 .func(); 613 Ok(Guest { many_args, big_argument }) 614 } 615 } 616 impl Guest { call_many_args<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64, arg6: u64, arg7: u64, arg8: u64, arg9: u64, arg10: u64, arg11: u64, arg12: u64, arg13: u64, arg14: u64, arg15: u64, ) -> wasmtime::Result<()>617 pub fn call_many_args<S: wasmtime::AsContextMut>( 618 &self, 619 mut store: S, 620 arg0: u64, 621 arg1: u64, 622 arg2: u64, 623 arg3: u64, 624 arg4: u64, 625 arg5: u64, 626 arg6: u64, 627 arg7: u64, 628 arg8: u64, 629 arg9: u64, 630 arg10: u64, 631 arg11: u64, 632 arg12: u64, 633 arg13: u64, 634 arg14: u64, 635 arg15: u64, 636 ) -> wasmtime::Result<()> { 637 let callee = unsafe { 638 wasmtime::component::TypedFunc::< 639 ( 640 u64, 641 u64, 642 u64, 643 u64, 644 u64, 645 u64, 646 u64, 647 u64, 648 u64, 649 u64, 650 u64, 651 u64, 652 u64, 653 u64, 654 u64, 655 u64, 656 ), 657 (), 658 >::new_unchecked(self.many_args) 659 }; 660 let () = callee 661 .call( 662 store.as_context_mut(), 663 ( 664 arg0, 665 arg1, 666 arg2, 667 arg3, 668 arg4, 669 arg5, 670 arg6, 671 arg7, 672 arg8, 673 arg9, 674 arg10, 675 arg11, 676 arg12, 677 arg13, 678 arg14, 679 arg15, 680 ), 681 )?; 682 Ok(()) 683 } call_big_argument<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &BigStruct, ) -> wasmtime::Result<()>684 pub fn call_big_argument<S: wasmtime::AsContextMut>( 685 &self, 686 mut store: S, 687 arg0: &BigStruct, 688 ) -> wasmtime::Result<()> { 689 let callee = unsafe { 690 wasmtime::component::TypedFunc::< 691 (&BigStruct,), 692 (), 693 >::new_unchecked(self.big_argument) 694 }; 695 let () = callee.call(store.as_context_mut(), (arg0,))?; 696 Ok(()) 697 } 698 } 699 } 700 } 701 } 702 } 703