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> {
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> 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.
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 = TheListsIndices::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 [`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.
instantiate( &self, mut store: impl wasmtime::AsContextMut<Data = _T>, ) -> wasmtime::Result<TheLists>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`.
instantiate_async( &self, mut store: impl wasmtime::AsContextMut<Data = _T>, ) -> wasmtime::Result<TheLists>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.
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::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.
load( &self, mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<TheLists>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`].
instantiate<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<TheLists>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`].
new( mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<TheLists>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`].
instantiate_async<_T>( store: impl wasmtime::AsContextMut<Data = _T>, component: &wasmtime::component::Component, linker: &wasmtime::component::Linker<_T>, ) -> wasmtime::Result<TheLists> where _T: Send,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         }
add_to_linker<T, D>( linker: &mut wasmtime::component::Linker<T>, host_getter: fn(&mut T) -> D::Data<'_>, ) -> wasmtime::Result<()> where D: foo::foo::lists::HostWithStore + Send, for<'a> D::Data<'a>: foo::foo::lists::Host + Send, T: 'static + Send,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 + Send,
175             for<'a> D::Data<'a>: foo::foo::lists::Host + Send,
176             T: 'static + Send,
177         {
178             foo::foo::lists::add_to_linker::<T, D>(linker, host_getter)?;
179             Ok(())
180         }
foo_foo_lists(&self) -> &exports::foo::foo::lists::Guest181         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 {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result212                 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 {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result253                 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 {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result287                 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 {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result323                 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 + Send {}
373             impl<_T: ?Sized> HostWithStore for _T
374             where
375                 _T: wasmtime::component::HasData + Send,
376             {}
377             pub trait Host: Send {
list_u8_param( &mut self, x: wasmtime::component::__internal::Vec<u8>, ) -> impl ::core::future::Future<Output = ()> + Send378                 fn list_u8_param(
379                     &mut self,
380                     x: wasmtime::component::__internal::Vec<u8>,
381                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_u16_param( &mut self, x: wasmtime::component::__internal::Vec<u16>, ) -> impl ::core::future::Future<Output = ()> + Send382                 fn list_u16_param(
383                     &mut self,
384                     x: wasmtime::component::__internal::Vec<u16>,
385                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_u32_param( &mut self, x: wasmtime::component::__internal::Vec<u32>, ) -> impl ::core::future::Future<Output = ()> + Send386                 fn list_u32_param(
387                     &mut self,
388                     x: wasmtime::component::__internal::Vec<u32>,
389                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_u64_param( &mut self, x: wasmtime::component::__internal::Vec<u64>, ) -> impl ::core::future::Future<Output = ()> + Send390                 fn list_u64_param(
391                     &mut self,
392                     x: wasmtime::component::__internal::Vec<u64>,
393                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_s8_param( &mut self, x: wasmtime::component::__internal::Vec<i8>, ) -> impl ::core::future::Future<Output = ()> + Send394                 fn list_s8_param(
395                     &mut self,
396                     x: wasmtime::component::__internal::Vec<i8>,
397                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_s16_param( &mut self, x: wasmtime::component::__internal::Vec<i16>, ) -> impl ::core::future::Future<Output = ()> + Send398                 fn list_s16_param(
399                     &mut self,
400                     x: wasmtime::component::__internal::Vec<i16>,
401                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_s32_param( &mut self, x: wasmtime::component::__internal::Vec<i32>, ) -> impl ::core::future::Future<Output = ()> + Send402                 fn list_s32_param(
403                     &mut self,
404                     x: wasmtime::component::__internal::Vec<i32>,
405                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_s64_param( &mut self, x: wasmtime::component::__internal::Vec<i64>, ) -> impl ::core::future::Future<Output = ()> + Send406                 fn list_s64_param(
407                     &mut self,
408                     x: wasmtime::component::__internal::Vec<i64>,
409                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_f32_param( &mut self, x: wasmtime::component::__internal::Vec<f32>, ) -> impl ::core::future::Future<Output = ()> + Send410                 fn list_f32_param(
411                     &mut self,
412                     x: wasmtime::component::__internal::Vec<f32>,
413                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_f64_param( &mut self, x: wasmtime::component::__internal::Vec<f64>, ) -> impl ::core::future::Future<Output = ()> + Send414                 fn list_f64_param(
415                     &mut self,
416                     x: wasmtime::component::__internal::Vec<f64>,
417                 ) -> impl ::core::future::Future<Output = ()> + Send;
list_u8_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u8>, > + Send418                 fn list_u8_ret(
419                     &mut self,
420                 ) -> impl ::core::future::Future<
421                     Output = wasmtime::component::__internal::Vec<u8>,
422                 > + Send;
list_u16_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u16>, > + Send423                 fn list_u16_ret(
424                     &mut self,
425                 ) -> impl ::core::future::Future<
426                     Output = wasmtime::component::__internal::Vec<u16>,
427                 > + Send;
list_u32_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u32>, > + Send428                 fn list_u32_ret(
429                     &mut self,
430                 ) -> impl ::core::future::Future<
431                     Output = wasmtime::component::__internal::Vec<u32>,
432                 > + Send;
list_u64_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u64>, > + Send433                 fn list_u64_ret(
434                     &mut self,
435                 ) -> impl ::core::future::Future<
436                     Output = wasmtime::component::__internal::Vec<u64>,
437                 > + Send;
list_s8_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i8>, > + Send438                 fn list_s8_ret(
439                     &mut self,
440                 ) -> impl ::core::future::Future<
441                     Output = wasmtime::component::__internal::Vec<i8>,
442                 > + Send;
list_s16_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i16>, > + Send443                 fn list_s16_ret(
444                     &mut self,
445                 ) -> impl ::core::future::Future<
446                     Output = wasmtime::component::__internal::Vec<i16>,
447                 > + Send;
list_s32_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i32>, > + Send448                 fn list_s32_ret(
449                     &mut self,
450                 ) -> impl ::core::future::Future<
451                     Output = wasmtime::component::__internal::Vec<i32>,
452                 > + Send;
list_s64_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i64>, > + Send453                 fn list_s64_ret(
454                     &mut self,
455                 ) -> impl ::core::future::Future<
456                     Output = wasmtime::component::__internal::Vec<i64>,
457                 > + Send;
list_f32_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<f32>, > + Send458                 fn list_f32_ret(
459                     &mut self,
460                 ) -> impl ::core::future::Future<
461                     Output = wasmtime::component::__internal::Vec<f32>,
462                 > + Send;
list_f64_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<f64>, > + Send463                 fn list_f64_ret(
464                     &mut self,
465                 ) -> impl ::core::future::Future<
466                     Output = wasmtime::component::__internal::Vec<f64>,
467                 > + Send;
tuple_list( &mut self, x: wasmtime::component::__internal::Vec<(u8, i8)>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<(i64, u32)>, > + Send468                 fn tuple_list(
469                     &mut self,
470                     x: wasmtime::component::__internal::Vec<(u8, i8)>,
471                 ) -> impl ::core::future::Future<
472                     Output = wasmtime::component::__internal::Vec<(i64, u32)>,
473                 > + Send;
string_list_arg( &mut self, a: wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, ) -> impl ::core::future::Future<Output = ()> + Send474                 fn string_list_arg(
475                     &mut self,
476                     a: wasmtime::component::__internal::Vec<
477                         wasmtime::component::__internal::String,
478                     >,
479                 ) -> impl ::core::future::Future<Output = ()> + Send;
string_list_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, > + Send480                 fn string_list_ret(
481                     &mut self,
482                 ) -> impl ::core::future::Future<
483                     Output = wasmtime::component::__internal::Vec<
484                         wasmtime::component::__internal::String,
485                     >,
486                 > + Send;
tuple_string_list( &mut self, x: wasmtime::component::__internal::Vec< (u8, wasmtime::component::__internal::String), >, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec< (wasmtime::component::__internal::String, u8), >, > + Send487                 fn tuple_string_list(
488                     &mut self,
489                     x: wasmtime::component::__internal::Vec<
490                         (u8, wasmtime::component::__internal::String),
491                     >,
492                 ) -> impl ::core::future::Future<
493                     Output = wasmtime::component::__internal::Vec<
494                         (wasmtime::component::__internal::String, u8),
495                     >,
496                 > + Send;
string_list( &mut self, x: wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, > + Send497                 fn string_list(
498                     &mut self,
499                     x: wasmtime::component::__internal::Vec<
500                         wasmtime::component::__internal::String,
501                     >,
502                 ) -> impl ::core::future::Future<
503                     Output = wasmtime::component::__internal::Vec<
504                         wasmtime::component::__internal::String,
505                     >,
506                 > + Send;
record_list( &mut self, x: wasmtime::component::__internal::Vec<SomeRecord>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<OtherRecord>, > + Send507                 fn record_list(
508                     &mut self,
509                     x: wasmtime::component::__internal::Vec<SomeRecord>,
510                 ) -> impl ::core::future::Future<
511                     Output = wasmtime::component::__internal::Vec<OtherRecord>,
512                 > + Send;
record_list_reverse( &mut self, x: wasmtime::component::__internal::Vec<OtherRecord>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<SomeRecord>, > + Send513                 fn record_list_reverse(
514                     &mut self,
515                     x: wasmtime::component::__internal::Vec<OtherRecord>,
516                 ) -> impl ::core::future::Future<
517                     Output = wasmtime::component::__internal::Vec<SomeRecord>,
518                 > + Send;
variant_list( &mut self, x: wasmtime::component::__internal::Vec<SomeVariant>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<OtherVariant>, > + Send519                 fn variant_list(
520                     &mut self,
521                     x: wasmtime::component::__internal::Vec<SomeVariant>,
522                 ) -> impl ::core::future::Future<
523                     Output = wasmtime::component::__internal::Vec<OtherVariant>,
524                 > + Send;
load_store_everything( &mut self, a: LoadStoreAllSizes, ) -> impl ::core::future::Future<Output = LoadStoreAllSizes> + Send525                 fn load_store_everything(
526                     &mut self,
527                     a: LoadStoreAllSizes,
528                 ) -> impl ::core::future::Future<Output = LoadStoreAllSizes> + Send;
529             }
530             impl<_T: Host + ?Sized + Send> Host for &mut _T {
list_u8_param( &mut self, x: wasmtime::component::__internal::Vec<u8>, ) -> impl ::core::future::Future<Output = ()> + Send531                 fn list_u8_param(
532                     &mut self,
533                     x: wasmtime::component::__internal::Vec<u8>,
534                 ) -> impl ::core::future::Future<Output = ()> + Send {
535                     async move { Host::list_u8_param(*self, x).await }
536                 }
list_u16_param( &mut self, x: wasmtime::component::__internal::Vec<u16>, ) -> impl ::core::future::Future<Output = ()> + Send537                 fn list_u16_param(
538                     &mut self,
539                     x: wasmtime::component::__internal::Vec<u16>,
540                 ) -> impl ::core::future::Future<Output = ()> + Send {
541                     async move { Host::list_u16_param(*self, x).await }
542                 }
list_u32_param( &mut self, x: wasmtime::component::__internal::Vec<u32>, ) -> impl ::core::future::Future<Output = ()> + Send543                 fn list_u32_param(
544                     &mut self,
545                     x: wasmtime::component::__internal::Vec<u32>,
546                 ) -> impl ::core::future::Future<Output = ()> + Send {
547                     async move { Host::list_u32_param(*self, x).await }
548                 }
list_u64_param( &mut self, x: wasmtime::component::__internal::Vec<u64>, ) -> impl ::core::future::Future<Output = ()> + Send549                 fn list_u64_param(
550                     &mut self,
551                     x: wasmtime::component::__internal::Vec<u64>,
552                 ) -> impl ::core::future::Future<Output = ()> + Send {
553                     async move { Host::list_u64_param(*self, x).await }
554                 }
list_s8_param( &mut self, x: wasmtime::component::__internal::Vec<i8>, ) -> impl ::core::future::Future<Output = ()> + Send555                 fn list_s8_param(
556                     &mut self,
557                     x: wasmtime::component::__internal::Vec<i8>,
558                 ) -> impl ::core::future::Future<Output = ()> + Send {
559                     async move { Host::list_s8_param(*self, x).await }
560                 }
list_s16_param( &mut self, x: wasmtime::component::__internal::Vec<i16>, ) -> impl ::core::future::Future<Output = ()> + Send561                 fn list_s16_param(
562                     &mut self,
563                     x: wasmtime::component::__internal::Vec<i16>,
564                 ) -> impl ::core::future::Future<Output = ()> + Send {
565                     async move { Host::list_s16_param(*self, x).await }
566                 }
list_s32_param( &mut self, x: wasmtime::component::__internal::Vec<i32>, ) -> impl ::core::future::Future<Output = ()> + Send567                 fn list_s32_param(
568                     &mut self,
569                     x: wasmtime::component::__internal::Vec<i32>,
570                 ) -> impl ::core::future::Future<Output = ()> + Send {
571                     async move { Host::list_s32_param(*self, x).await }
572                 }
list_s64_param( &mut self, x: wasmtime::component::__internal::Vec<i64>, ) -> impl ::core::future::Future<Output = ()> + Send573                 fn list_s64_param(
574                     &mut self,
575                     x: wasmtime::component::__internal::Vec<i64>,
576                 ) -> impl ::core::future::Future<Output = ()> + Send {
577                     async move { Host::list_s64_param(*self, x).await }
578                 }
list_f32_param( &mut self, x: wasmtime::component::__internal::Vec<f32>, ) -> impl ::core::future::Future<Output = ()> + Send579                 fn list_f32_param(
580                     &mut self,
581                     x: wasmtime::component::__internal::Vec<f32>,
582                 ) -> impl ::core::future::Future<Output = ()> + Send {
583                     async move { Host::list_f32_param(*self, x).await }
584                 }
list_f64_param( &mut self, x: wasmtime::component::__internal::Vec<f64>, ) -> impl ::core::future::Future<Output = ()> + Send585                 fn list_f64_param(
586                     &mut self,
587                     x: wasmtime::component::__internal::Vec<f64>,
588                 ) -> impl ::core::future::Future<Output = ()> + Send {
589                     async move { Host::list_f64_param(*self, x).await }
590                 }
list_u8_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u8>, > + Send591                 fn list_u8_ret(
592                     &mut self,
593                 ) -> impl ::core::future::Future<
594                     Output = wasmtime::component::__internal::Vec<u8>,
595                 > + Send {
596                     async move { Host::list_u8_ret(*self).await }
597                 }
list_u16_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u16>, > + Send598                 fn list_u16_ret(
599                     &mut self,
600                 ) -> impl ::core::future::Future<
601                     Output = wasmtime::component::__internal::Vec<u16>,
602                 > + Send {
603                     async move { Host::list_u16_ret(*self).await }
604                 }
list_u32_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u32>, > + Send605                 fn list_u32_ret(
606                     &mut self,
607                 ) -> impl ::core::future::Future<
608                     Output = wasmtime::component::__internal::Vec<u32>,
609                 > + Send {
610                     async move { Host::list_u32_ret(*self).await }
611                 }
list_u64_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<u64>, > + Send612                 fn list_u64_ret(
613                     &mut self,
614                 ) -> impl ::core::future::Future<
615                     Output = wasmtime::component::__internal::Vec<u64>,
616                 > + Send {
617                     async move { Host::list_u64_ret(*self).await }
618                 }
list_s8_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i8>, > + Send619                 fn list_s8_ret(
620                     &mut self,
621                 ) -> impl ::core::future::Future<
622                     Output = wasmtime::component::__internal::Vec<i8>,
623                 > + Send {
624                     async move { Host::list_s8_ret(*self).await }
625                 }
list_s16_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i16>, > + Send626                 fn list_s16_ret(
627                     &mut self,
628                 ) -> impl ::core::future::Future<
629                     Output = wasmtime::component::__internal::Vec<i16>,
630                 > + Send {
631                     async move { Host::list_s16_ret(*self).await }
632                 }
list_s32_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i32>, > + Send633                 fn list_s32_ret(
634                     &mut self,
635                 ) -> impl ::core::future::Future<
636                     Output = wasmtime::component::__internal::Vec<i32>,
637                 > + Send {
638                     async move { Host::list_s32_ret(*self).await }
639                 }
list_s64_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<i64>, > + Send640                 fn list_s64_ret(
641                     &mut self,
642                 ) -> impl ::core::future::Future<
643                     Output = wasmtime::component::__internal::Vec<i64>,
644                 > + Send {
645                     async move { Host::list_s64_ret(*self).await }
646                 }
list_f32_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<f32>, > + Send647                 fn list_f32_ret(
648                     &mut self,
649                 ) -> impl ::core::future::Future<
650                     Output = wasmtime::component::__internal::Vec<f32>,
651                 > + Send {
652                     async move { Host::list_f32_ret(*self).await }
653                 }
list_f64_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<f64>, > + Send654                 fn list_f64_ret(
655                     &mut self,
656                 ) -> impl ::core::future::Future<
657                     Output = wasmtime::component::__internal::Vec<f64>,
658                 > + Send {
659                     async move { Host::list_f64_ret(*self).await }
660                 }
tuple_list( &mut self, x: wasmtime::component::__internal::Vec<(u8, i8)>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<(i64, u32)>, > + Send661                 fn tuple_list(
662                     &mut self,
663                     x: wasmtime::component::__internal::Vec<(u8, i8)>,
664                 ) -> impl ::core::future::Future<
665                     Output = wasmtime::component::__internal::Vec<(i64, u32)>,
666                 > + Send {
667                     async move { Host::tuple_list(*self, x).await }
668                 }
string_list_arg( &mut self, a: wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, ) -> impl ::core::future::Future<Output = ()> + Send669                 fn string_list_arg(
670                     &mut self,
671                     a: wasmtime::component::__internal::Vec<
672                         wasmtime::component::__internal::String,
673                     >,
674                 ) -> impl ::core::future::Future<Output = ()> + Send {
675                     async move { Host::string_list_arg(*self, a).await }
676                 }
string_list_ret( &mut self, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, > + Send677                 fn string_list_ret(
678                     &mut self,
679                 ) -> impl ::core::future::Future<
680                     Output = wasmtime::component::__internal::Vec<
681                         wasmtime::component::__internal::String,
682                     >,
683                 > + Send {
684                     async move { Host::string_list_ret(*self).await }
685                 }
tuple_string_list( &mut self, x: wasmtime::component::__internal::Vec< (u8, wasmtime::component::__internal::String), >, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec< (wasmtime::component::__internal::String, u8), >, > + Send686                 fn tuple_string_list(
687                     &mut self,
688                     x: wasmtime::component::__internal::Vec<
689                         (u8, wasmtime::component::__internal::String),
690                     >,
691                 ) -> impl ::core::future::Future<
692                     Output = wasmtime::component::__internal::Vec<
693                         (wasmtime::component::__internal::String, u8),
694                     >,
695                 > + Send {
696                     async move { Host::tuple_string_list(*self, x).await }
697                 }
string_list( &mut self, x: wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, > + Send698                 fn string_list(
699                     &mut self,
700                     x: wasmtime::component::__internal::Vec<
701                         wasmtime::component::__internal::String,
702                     >,
703                 ) -> impl ::core::future::Future<
704                     Output = wasmtime::component::__internal::Vec<
705                         wasmtime::component::__internal::String,
706                     >,
707                 > + Send {
708                     async move { Host::string_list(*self, x).await }
709                 }
record_list( &mut self, x: wasmtime::component::__internal::Vec<SomeRecord>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<OtherRecord>, > + Send710                 fn record_list(
711                     &mut self,
712                     x: wasmtime::component::__internal::Vec<SomeRecord>,
713                 ) -> impl ::core::future::Future<
714                     Output = wasmtime::component::__internal::Vec<OtherRecord>,
715                 > + Send {
716                     async move { Host::record_list(*self, x).await }
717                 }
record_list_reverse( &mut self, x: wasmtime::component::__internal::Vec<OtherRecord>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<SomeRecord>, > + Send718                 fn record_list_reverse(
719                     &mut self,
720                     x: wasmtime::component::__internal::Vec<OtherRecord>,
721                 ) -> impl ::core::future::Future<
722                     Output = wasmtime::component::__internal::Vec<SomeRecord>,
723                 > + Send {
724                     async move { Host::record_list_reverse(*self, x).await }
725                 }
variant_list( &mut self, x: wasmtime::component::__internal::Vec<SomeVariant>, ) -> impl ::core::future::Future< Output = wasmtime::component::__internal::Vec<OtherVariant>, > + Send726                 fn variant_list(
727                     &mut self,
728                     x: wasmtime::component::__internal::Vec<SomeVariant>,
729                 ) -> impl ::core::future::Future<
730                     Output = wasmtime::component::__internal::Vec<OtherVariant>,
731                 > + Send {
732                     async move { Host::variant_list(*self, x).await }
733                 }
load_store_everything( &mut self, a: LoadStoreAllSizes, ) -> impl ::core::future::Future<Output = LoadStoreAllSizes> + Send734                 fn load_store_everything(
735                     &mut self,
736                     a: LoadStoreAllSizes,
737                 ) -> impl ::core::future::Future<Output = LoadStoreAllSizes> + Send {
738                     async move { Host::load_store_everything(*self, a).await }
739                 }
740             }
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 + Send,741             pub fn add_to_linker<T, D>(
742                 linker: &mut wasmtime::component::Linker<T>,
743                 host_getter: fn(&mut T) -> D::Data<'_>,
744             ) -> wasmtime::Result<()>
745             where
746                 D: HostWithStore,
747                 for<'a> D::Data<'a>: Host,
748                 T: 'static + Send,
749             {
750                 let mut inst = linker.instance("foo:foo/lists")?;
751                 inst.func_wrap_async(
752                     "list-u8-param",
753                     move |
754                         mut caller: wasmtime::StoreContextMut<'_, T>,
755                         (arg0,): (wasmtime::component::__internal::Vec<u8>,)|
756                     {
757                         use tracing::Instrument;
758                         let span = tracing::span!(
759                             tracing::Level::TRACE, "wit-bindgen import", module =
760                             "lists", function = "list-u8-param",
761                         );
762                         wasmtime::component::__internal::Box::new(
763                             async move {
764                                 tracing::event!(
765                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
766                                     "call"
767                                 );
768                                 let host = &mut host_getter(caller.data_mut());
769                                 let r = Host::list_u8_param(host, arg0).await;
770                                 tracing::event!(
771                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
772                                     "return"
773                                 );
774                                 Ok(r)
775                             }
776                                 .instrument(span),
777                         )
778                     },
779                 )?;
780                 inst.func_wrap_async(
781                     "list-u16-param",
782                     move |
783                         mut caller: wasmtime::StoreContextMut<'_, T>,
784                         (arg0,): (wasmtime::component::__internal::Vec<u16>,)|
785                     {
786                         use tracing::Instrument;
787                         let span = tracing::span!(
788                             tracing::Level::TRACE, "wit-bindgen import", module =
789                             "lists", function = "list-u16-param",
790                         );
791                         wasmtime::component::__internal::Box::new(
792                             async move {
793                                 tracing::event!(
794                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
795                                     "call"
796                                 );
797                                 let host = &mut host_getter(caller.data_mut());
798                                 let r = Host::list_u16_param(host, arg0).await;
799                                 tracing::event!(
800                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
801                                     "return"
802                                 );
803                                 Ok(r)
804                             }
805                                 .instrument(span),
806                         )
807                     },
808                 )?;
809                 inst.func_wrap_async(
810                     "list-u32-param",
811                     move |
812                         mut caller: wasmtime::StoreContextMut<'_, T>,
813                         (arg0,): (wasmtime::component::__internal::Vec<u32>,)|
814                     {
815                         use tracing::Instrument;
816                         let span = tracing::span!(
817                             tracing::Level::TRACE, "wit-bindgen import", module =
818                             "lists", function = "list-u32-param",
819                         );
820                         wasmtime::component::__internal::Box::new(
821                             async move {
822                                 tracing::event!(
823                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
824                                     "call"
825                                 );
826                                 let host = &mut host_getter(caller.data_mut());
827                                 let r = Host::list_u32_param(host, arg0).await;
828                                 tracing::event!(
829                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
830                                     "return"
831                                 );
832                                 Ok(r)
833                             }
834                                 .instrument(span),
835                         )
836                     },
837                 )?;
838                 inst.func_wrap_async(
839                     "list-u64-param",
840                     move |
841                         mut caller: wasmtime::StoreContextMut<'_, T>,
842                         (arg0,): (wasmtime::component::__internal::Vec<u64>,)|
843                     {
844                         use tracing::Instrument;
845                         let span = tracing::span!(
846                             tracing::Level::TRACE, "wit-bindgen import", module =
847                             "lists", function = "list-u64-param",
848                         );
849                         wasmtime::component::__internal::Box::new(
850                             async move {
851                                 tracing::event!(
852                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
853                                     "call"
854                                 );
855                                 let host = &mut host_getter(caller.data_mut());
856                                 let r = Host::list_u64_param(host, arg0).await;
857                                 tracing::event!(
858                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
859                                     "return"
860                                 );
861                                 Ok(r)
862                             }
863                                 .instrument(span),
864                         )
865                     },
866                 )?;
867                 inst.func_wrap_async(
868                     "list-s8-param",
869                     move |
870                         mut caller: wasmtime::StoreContextMut<'_, T>,
871                         (arg0,): (wasmtime::component::__internal::Vec<i8>,)|
872                     {
873                         use tracing::Instrument;
874                         let span = tracing::span!(
875                             tracing::Level::TRACE, "wit-bindgen import", module =
876                             "lists", function = "list-s8-param",
877                         );
878                         wasmtime::component::__internal::Box::new(
879                             async move {
880                                 tracing::event!(
881                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
882                                     "call"
883                                 );
884                                 let host = &mut host_getter(caller.data_mut());
885                                 let r = Host::list_s8_param(host, arg0).await;
886                                 tracing::event!(
887                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
888                                     "return"
889                                 );
890                                 Ok(r)
891                             }
892                                 .instrument(span),
893                         )
894                     },
895                 )?;
896                 inst.func_wrap_async(
897                     "list-s16-param",
898                     move |
899                         mut caller: wasmtime::StoreContextMut<'_, T>,
900                         (arg0,): (wasmtime::component::__internal::Vec<i16>,)|
901                     {
902                         use tracing::Instrument;
903                         let span = tracing::span!(
904                             tracing::Level::TRACE, "wit-bindgen import", module =
905                             "lists", function = "list-s16-param",
906                         );
907                         wasmtime::component::__internal::Box::new(
908                             async move {
909                                 tracing::event!(
910                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
911                                     "call"
912                                 );
913                                 let host = &mut host_getter(caller.data_mut());
914                                 let r = Host::list_s16_param(host, arg0).await;
915                                 tracing::event!(
916                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
917                                     "return"
918                                 );
919                                 Ok(r)
920                             }
921                                 .instrument(span),
922                         )
923                     },
924                 )?;
925                 inst.func_wrap_async(
926                     "list-s32-param",
927                     move |
928                         mut caller: wasmtime::StoreContextMut<'_, T>,
929                         (arg0,): (wasmtime::component::__internal::Vec<i32>,)|
930                     {
931                         use tracing::Instrument;
932                         let span = tracing::span!(
933                             tracing::Level::TRACE, "wit-bindgen import", module =
934                             "lists", function = "list-s32-param",
935                         );
936                         wasmtime::component::__internal::Box::new(
937                             async move {
938                                 tracing::event!(
939                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
940                                     "call"
941                                 );
942                                 let host = &mut host_getter(caller.data_mut());
943                                 let r = Host::list_s32_param(host, arg0).await;
944                                 tracing::event!(
945                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
946                                     "return"
947                                 );
948                                 Ok(r)
949                             }
950                                 .instrument(span),
951                         )
952                     },
953                 )?;
954                 inst.func_wrap_async(
955                     "list-s64-param",
956                     move |
957                         mut caller: wasmtime::StoreContextMut<'_, T>,
958                         (arg0,): (wasmtime::component::__internal::Vec<i64>,)|
959                     {
960                         use tracing::Instrument;
961                         let span = tracing::span!(
962                             tracing::Level::TRACE, "wit-bindgen import", module =
963                             "lists", function = "list-s64-param",
964                         );
965                         wasmtime::component::__internal::Box::new(
966                             async move {
967                                 tracing::event!(
968                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
969                                     "call"
970                                 );
971                                 let host = &mut host_getter(caller.data_mut());
972                                 let r = Host::list_s64_param(host, arg0).await;
973                                 tracing::event!(
974                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
975                                     "return"
976                                 );
977                                 Ok(r)
978                             }
979                                 .instrument(span),
980                         )
981                     },
982                 )?;
983                 inst.func_wrap_async(
984                     "list-f32-param",
985                     move |
986                         mut caller: wasmtime::StoreContextMut<'_, T>,
987                         (arg0,): (wasmtime::component::__internal::Vec<f32>,)|
988                     {
989                         use tracing::Instrument;
990                         let span = tracing::span!(
991                             tracing::Level::TRACE, "wit-bindgen import", module =
992                             "lists", function = "list-f32-param",
993                         );
994                         wasmtime::component::__internal::Box::new(
995                             async move {
996                                 tracing::event!(
997                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
998                                     "call"
999                                 );
1000                                 let host = &mut host_getter(caller.data_mut());
1001                                 let r = Host::list_f32_param(host, arg0).await;
1002                                 tracing::event!(
1003                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
1004                                     "return"
1005                                 );
1006                                 Ok(r)
1007                             }
1008                                 .instrument(span),
1009                         )
1010                     },
1011                 )?;
1012                 inst.func_wrap_async(
1013                     "list-f64-param",
1014                     move |
1015                         mut caller: wasmtime::StoreContextMut<'_, T>,
1016                         (arg0,): (wasmtime::component::__internal::Vec<f64>,)|
1017                     {
1018                         use tracing::Instrument;
1019                         let span = tracing::span!(
1020                             tracing::Level::TRACE, "wit-bindgen import", module =
1021                             "lists", function = "list-f64-param",
1022                         );
1023                         wasmtime::component::__internal::Box::new(
1024                             async move {
1025                                 tracing::event!(
1026                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
1027                                     "call"
1028                                 );
1029                                 let host = &mut host_getter(caller.data_mut());
1030                                 let r = Host::list_f64_param(host, arg0).await;
1031                                 tracing::event!(
1032                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
1033                                     "return"
1034                                 );
1035                                 Ok(r)
1036                             }
1037                                 .instrument(span),
1038                         )
1039                     },
1040                 )?;
1041                 inst.func_wrap_async(
1042                     "list-u8-ret",
1043                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1044                         use tracing::Instrument;
1045                         let span = tracing::span!(
1046                             tracing::Level::TRACE, "wit-bindgen import", module =
1047                             "lists", function = "list-u8-ret",
1048                         );
1049                         wasmtime::component::__internal::Box::new(
1050                             async move {
1051                                 tracing::event!(tracing::Level::TRACE, "call");
1052                                 let host = &mut host_getter(caller.data_mut());
1053                                 let r = Host::list_u8_ret(host).await;
1054                                 tracing::event!(
1055                                     tracing::Level::TRACE, result =
1056                                     tracing::field::debug("..."), "return"
1057                                 );
1058                                 Ok((r,))
1059                             }
1060                                 .instrument(span),
1061                         )
1062                     },
1063                 )?;
1064                 inst.func_wrap_async(
1065                     "list-u16-ret",
1066                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1067                         use tracing::Instrument;
1068                         let span = tracing::span!(
1069                             tracing::Level::TRACE, "wit-bindgen import", module =
1070                             "lists", function = "list-u16-ret",
1071                         );
1072                         wasmtime::component::__internal::Box::new(
1073                             async move {
1074                                 tracing::event!(tracing::Level::TRACE, "call");
1075                                 let host = &mut host_getter(caller.data_mut());
1076                                 let r = Host::list_u16_ret(host).await;
1077                                 tracing::event!(
1078                                     tracing::Level::TRACE, result =
1079                                     tracing::field::debug("..."), "return"
1080                                 );
1081                                 Ok((r,))
1082                             }
1083                                 .instrument(span),
1084                         )
1085                     },
1086                 )?;
1087                 inst.func_wrap_async(
1088                     "list-u32-ret",
1089                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1090                         use tracing::Instrument;
1091                         let span = tracing::span!(
1092                             tracing::Level::TRACE, "wit-bindgen import", module =
1093                             "lists", function = "list-u32-ret",
1094                         );
1095                         wasmtime::component::__internal::Box::new(
1096                             async move {
1097                                 tracing::event!(tracing::Level::TRACE, "call");
1098                                 let host = &mut host_getter(caller.data_mut());
1099                                 let r = Host::list_u32_ret(host).await;
1100                                 tracing::event!(
1101                                     tracing::Level::TRACE, result =
1102                                     tracing::field::debug("..."), "return"
1103                                 );
1104                                 Ok((r,))
1105                             }
1106                                 .instrument(span),
1107                         )
1108                     },
1109                 )?;
1110                 inst.func_wrap_async(
1111                     "list-u64-ret",
1112                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1113                         use tracing::Instrument;
1114                         let span = tracing::span!(
1115                             tracing::Level::TRACE, "wit-bindgen import", module =
1116                             "lists", function = "list-u64-ret",
1117                         );
1118                         wasmtime::component::__internal::Box::new(
1119                             async move {
1120                                 tracing::event!(tracing::Level::TRACE, "call");
1121                                 let host = &mut host_getter(caller.data_mut());
1122                                 let r = Host::list_u64_ret(host).await;
1123                                 tracing::event!(
1124                                     tracing::Level::TRACE, result =
1125                                     tracing::field::debug("..."), "return"
1126                                 );
1127                                 Ok((r,))
1128                             }
1129                                 .instrument(span),
1130                         )
1131                     },
1132                 )?;
1133                 inst.func_wrap_async(
1134                     "list-s8-ret",
1135                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1136                         use tracing::Instrument;
1137                         let span = tracing::span!(
1138                             tracing::Level::TRACE, "wit-bindgen import", module =
1139                             "lists", function = "list-s8-ret",
1140                         );
1141                         wasmtime::component::__internal::Box::new(
1142                             async move {
1143                                 tracing::event!(tracing::Level::TRACE, "call");
1144                                 let host = &mut host_getter(caller.data_mut());
1145                                 let r = Host::list_s8_ret(host).await;
1146                                 tracing::event!(
1147                                     tracing::Level::TRACE, result =
1148                                     tracing::field::debug("..."), "return"
1149                                 );
1150                                 Ok((r,))
1151                             }
1152                                 .instrument(span),
1153                         )
1154                     },
1155                 )?;
1156                 inst.func_wrap_async(
1157                     "list-s16-ret",
1158                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1159                         use tracing::Instrument;
1160                         let span = tracing::span!(
1161                             tracing::Level::TRACE, "wit-bindgen import", module =
1162                             "lists", function = "list-s16-ret",
1163                         );
1164                         wasmtime::component::__internal::Box::new(
1165                             async move {
1166                                 tracing::event!(tracing::Level::TRACE, "call");
1167                                 let host = &mut host_getter(caller.data_mut());
1168                                 let r = Host::list_s16_ret(host).await;
1169                                 tracing::event!(
1170                                     tracing::Level::TRACE, result =
1171                                     tracing::field::debug("..."), "return"
1172                                 );
1173                                 Ok((r,))
1174                             }
1175                                 .instrument(span),
1176                         )
1177                     },
1178                 )?;
1179                 inst.func_wrap_async(
1180                     "list-s32-ret",
1181                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1182                         use tracing::Instrument;
1183                         let span = tracing::span!(
1184                             tracing::Level::TRACE, "wit-bindgen import", module =
1185                             "lists", function = "list-s32-ret",
1186                         );
1187                         wasmtime::component::__internal::Box::new(
1188                             async move {
1189                                 tracing::event!(tracing::Level::TRACE, "call");
1190                                 let host = &mut host_getter(caller.data_mut());
1191                                 let r = Host::list_s32_ret(host).await;
1192                                 tracing::event!(
1193                                     tracing::Level::TRACE, result =
1194                                     tracing::field::debug("..."), "return"
1195                                 );
1196                                 Ok((r,))
1197                             }
1198                                 .instrument(span),
1199                         )
1200                     },
1201                 )?;
1202                 inst.func_wrap_async(
1203                     "list-s64-ret",
1204                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1205                         use tracing::Instrument;
1206                         let span = tracing::span!(
1207                             tracing::Level::TRACE, "wit-bindgen import", module =
1208                             "lists", function = "list-s64-ret",
1209                         );
1210                         wasmtime::component::__internal::Box::new(
1211                             async move {
1212                                 tracing::event!(tracing::Level::TRACE, "call");
1213                                 let host = &mut host_getter(caller.data_mut());
1214                                 let r = Host::list_s64_ret(host).await;
1215                                 tracing::event!(
1216                                     tracing::Level::TRACE, result =
1217                                     tracing::field::debug("..."), "return"
1218                                 );
1219                                 Ok((r,))
1220                             }
1221                                 .instrument(span),
1222                         )
1223                     },
1224                 )?;
1225                 inst.func_wrap_async(
1226                     "list-f32-ret",
1227                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1228                         use tracing::Instrument;
1229                         let span = tracing::span!(
1230                             tracing::Level::TRACE, "wit-bindgen import", module =
1231                             "lists", function = "list-f32-ret",
1232                         );
1233                         wasmtime::component::__internal::Box::new(
1234                             async move {
1235                                 tracing::event!(tracing::Level::TRACE, "call");
1236                                 let host = &mut host_getter(caller.data_mut());
1237                                 let r = Host::list_f32_ret(host).await;
1238                                 tracing::event!(
1239                                     tracing::Level::TRACE, result =
1240                                     tracing::field::debug("..."), "return"
1241                                 );
1242                                 Ok((r,))
1243                             }
1244                                 .instrument(span),
1245                         )
1246                     },
1247                 )?;
1248                 inst.func_wrap_async(
1249                     "list-f64-ret",
1250                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1251                         use tracing::Instrument;
1252                         let span = tracing::span!(
1253                             tracing::Level::TRACE, "wit-bindgen import", module =
1254                             "lists", function = "list-f64-ret",
1255                         );
1256                         wasmtime::component::__internal::Box::new(
1257                             async move {
1258                                 tracing::event!(tracing::Level::TRACE, "call");
1259                                 let host = &mut host_getter(caller.data_mut());
1260                                 let r = Host::list_f64_ret(host).await;
1261                                 tracing::event!(
1262                                     tracing::Level::TRACE, result =
1263                                     tracing::field::debug("..."), "return"
1264                                 );
1265                                 Ok((r,))
1266                             }
1267                                 .instrument(span),
1268                         )
1269                     },
1270                 )?;
1271                 inst.func_wrap_async(
1272                     "tuple-list",
1273                     move |
1274                         mut caller: wasmtime::StoreContextMut<'_, T>,
1275                         (arg0,): (wasmtime::component::__internal::Vec<(u8, i8)>,)|
1276                     {
1277                         use tracing::Instrument;
1278                         let span = tracing::span!(
1279                             tracing::Level::TRACE, "wit-bindgen import", module =
1280                             "lists", function = "tuple-list",
1281                         );
1282                         wasmtime::component::__internal::Box::new(
1283                             async move {
1284                                 tracing::event!(
1285                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
1286                                     "call"
1287                                 );
1288                                 let host = &mut host_getter(caller.data_mut());
1289                                 let r = Host::tuple_list(host, arg0).await;
1290                                 tracing::event!(
1291                                     tracing::Level::TRACE, result =
1292                                     tracing::field::debug("..."), "return"
1293                                 );
1294                                 Ok((r,))
1295                             }
1296                                 .instrument(span),
1297                         )
1298                     },
1299                 )?;
1300                 inst.func_wrap_async(
1301                     "string-list-arg",
1302                     move |
1303                         mut caller: wasmtime::StoreContextMut<'_, T>,
1304                         (
1305                             arg0,
1306                         ): (
1307                             wasmtime::component::__internal::Vec<
1308                                 wasmtime::component::__internal::String,
1309                             >,
1310                         )|
1311                     {
1312                         use tracing::Instrument;
1313                         let span = tracing::span!(
1314                             tracing::Level::TRACE, "wit-bindgen import", module =
1315                             "lists", function = "string-list-arg",
1316                         );
1317                         wasmtime::component::__internal::Box::new(
1318                             async move {
1319                                 tracing::event!(
1320                                     tracing::Level::TRACE, a = tracing::field::debug("..."),
1321                                     "call"
1322                                 );
1323                                 let host = &mut host_getter(caller.data_mut());
1324                                 let r = Host::string_list_arg(host, arg0).await;
1325                                 tracing::event!(
1326                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
1327                                     "return"
1328                                 );
1329                                 Ok(r)
1330                             }
1331                                 .instrument(span),
1332                         )
1333                     },
1334                 )?;
1335                 inst.func_wrap_async(
1336                     "string-list-ret",
1337                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
1338                         use tracing::Instrument;
1339                         let span = tracing::span!(
1340                             tracing::Level::TRACE, "wit-bindgen import", module =
1341                             "lists", function = "string-list-ret",
1342                         );
1343                         wasmtime::component::__internal::Box::new(
1344                             async move {
1345                                 tracing::event!(tracing::Level::TRACE, "call");
1346                                 let host = &mut host_getter(caller.data_mut());
1347                                 let r = Host::string_list_ret(host).await;
1348                                 tracing::event!(
1349                                     tracing::Level::TRACE, result =
1350                                     tracing::field::debug("..."), "return"
1351                                 );
1352                                 Ok((r,))
1353                             }
1354                                 .instrument(span),
1355                         )
1356                     },
1357                 )?;
1358                 inst.func_wrap_async(
1359                     "tuple-string-list",
1360                     move |
1361                         mut caller: wasmtime::StoreContextMut<'_, T>,
1362                         (
1363                             arg0,
1364                         ): (
1365                             wasmtime::component::__internal::Vec<
1366                                 (u8, wasmtime::component::__internal::String),
1367                             >,
1368                         )|
1369                     {
1370                         use tracing::Instrument;
1371                         let span = tracing::span!(
1372                             tracing::Level::TRACE, "wit-bindgen import", module =
1373                             "lists", function = "tuple-string-list",
1374                         );
1375                         wasmtime::component::__internal::Box::new(
1376                             async move {
1377                                 tracing::event!(
1378                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
1379                                     "call"
1380                                 );
1381                                 let host = &mut host_getter(caller.data_mut());
1382                                 let r = Host::tuple_string_list(host, arg0).await;
1383                                 tracing::event!(
1384                                     tracing::Level::TRACE, result =
1385                                     tracing::field::debug("..."), "return"
1386                                 );
1387                                 Ok((r,))
1388                             }
1389                                 .instrument(span),
1390                         )
1391                     },
1392                 )?;
1393                 inst.func_wrap_async(
1394                     "string-list",
1395                     move |
1396                         mut caller: wasmtime::StoreContextMut<'_, T>,
1397                         (
1398                             arg0,
1399                         ): (
1400                             wasmtime::component::__internal::Vec<
1401                                 wasmtime::component::__internal::String,
1402                             >,
1403                         )|
1404                     {
1405                         use tracing::Instrument;
1406                         let span = tracing::span!(
1407                             tracing::Level::TRACE, "wit-bindgen import", module =
1408                             "lists", function = "string-list",
1409                         );
1410                         wasmtime::component::__internal::Box::new(
1411                             async move {
1412                                 tracing::event!(
1413                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
1414                                     "call"
1415                                 );
1416                                 let host = &mut host_getter(caller.data_mut());
1417                                 let r = Host::string_list(host, arg0).await;
1418                                 tracing::event!(
1419                                     tracing::Level::TRACE, result =
1420                                     tracing::field::debug("..."), "return"
1421                                 );
1422                                 Ok((r,))
1423                             }
1424                                 .instrument(span),
1425                         )
1426                     },
1427                 )?;
1428                 inst.func_wrap_async(
1429                     "record-list",
1430                     move |
1431                         mut caller: wasmtime::StoreContextMut<'_, T>,
1432                         (arg0,): (wasmtime::component::__internal::Vec<SomeRecord>,)|
1433                     {
1434                         use tracing::Instrument;
1435                         let span = tracing::span!(
1436                             tracing::Level::TRACE, "wit-bindgen import", module =
1437                             "lists", function = "record-list",
1438                         );
1439                         wasmtime::component::__internal::Box::new(
1440                             async move {
1441                                 tracing::event!(
1442                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
1443                                     "call"
1444                                 );
1445                                 let host = &mut host_getter(caller.data_mut());
1446                                 let r = Host::record_list(host, arg0).await;
1447                                 tracing::event!(
1448                                     tracing::Level::TRACE, result =
1449                                     tracing::field::debug("..."), "return"
1450                                 );
1451                                 Ok((r,))
1452                             }
1453                                 .instrument(span),
1454                         )
1455                     },
1456                 )?;
1457                 inst.func_wrap_async(
1458                     "record-list-reverse",
1459                     move |
1460                         mut caller: wasmtime::StoreContextMut<'_, T>,
1461                         (arg0,): (wasmtime::component::__internal::Vec<OtherRecord>,)|
1462                     {
1463                         use tracing::Instrument;
1464                         let span = tracing::span!(
1465                             tracing::Level::TRACE, "wit-bindgen import", module =
1466                             "lists", function = "record-list-reverse",
1467                         );
1468                         wasmtime::component::__internal::Box::new(
1469                             async move {
1470                                 tracing::event!(
1471                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
1472                                     "call"
1473                                 );
1474                                 let host = &mut host_getter(caller.data_mut());
1475                                 let r = Host::record_list_reverse(host, arg0).await;
1476                                 tracing::event!(
1477                                     tracing::Level::TRACE, result =
1478                                     tracing::field::debug("..."), "return"
1479                                 );
1480                                 Ok((r,))
1481                             }
1482                                 .instrument(span),
1483                         )
1484                     },
1485                 )?;
1486                 inst.func_wrap_async(
1487                     "variant-list",
1488                     move |
1489                         mut caller: wasmtime::StoreContextMut<'_, T>,
1490                         (arg0,): (wasmtime::component::__internal::Vec<SomeVariant>,)|
1491                     {
1492                         use tracing::Instrument;
1493                         let span = tracing::span!(
1494                             tracing::Level::TRACE, "wit-bindgen import", module =
1495                             "lists", function = "variant-list",
1496                         );
1497                         wasmtime::component::__internal::Box::new(
1498                             async move {
1499                                 tracing::event!(
1500                                     tracing::Level::TRACE, x = tracing::field::debug("..."),
1501                                     "call"
1502                                 );
1503                                 let host = &mut host_getter(caller.data_mut());
1504                                 let r = Host::variant_list(host, arg0).await;
1505                                 tracing::event!(
1506                                     tracing::Level::TRACE, result =
1507                                     tracing::field::debug("..."), "return"
1508                                 );
1509                                 Ok((r,))
1510                             }
1511                                 .instrument(span),
1512                         )
1513                     },
1514                 )?;
1515                 inst.func_wrap_async(
1516                     "load-store-everything",
1517                     move |
1518                         mut caller: wasmtime::StoreContextMut<'_, T>,
1519                         (arg0,): (LoadStoreAllSizes,)|
1520                     {
1521                         use tracing::Instrument;
1522                         let span = tracing::span!(
1523                             tracing::Level::TRACE, "wit-bindgen import", module =
1524                             "lists", function = "load-store-everything",
1525                         );
1526                         wasmtime::component::__internal::Box::new(
1527                             async move {
1528                                 tracing::event!(
1529                                     tracing::Level::TRACE, a = tracing::field::debug("..."),
1530                                     "call"
1531                                 );
1532                                 let host = &mut host_getter(caller.data_mut());
1533                                 let r = Host::load_store_everything(host, arg0).await;
1534                                 tracing::event!(
1535                                     tracing::Level::TRACE, result =
1536                                     tracing::field::debug("..."), "return"
1537                                 );
1538                                 Ok((r,))
1539                             }
1540                                 .instrument(span),
1541                         )
1542                     },
1543                 )?;
1544                 Ok(())
1545             }
1546         }
1547     }
1548 }
1549 pub mod exports {
1550     pub mod foo {
1551         pub mod foo {
1552             #[allow(clippy::all)]
1553             pub mod lists {
1554                 #[allow(unused_imports)]
1555                 use wasmtime::component::__internal::Box;
1556                 #[derive(wasmtime::component::ComponentType)]
1557                 #[derive(wasmtime::component::Lift)]
1558                 #[derive(wasmtime::component::Lower)]
1559                 #[component(record)]
1560                 #[derive(Clone)]
1561                 pub struct OtherRecord {
1562                     #[component(name = "a1")]
1563                     pub a1: u32,
1564                     #[component(name = "a2")]
1565                     pub a2: u64,
1566                     #[component(name = "a3")]
1567                     pub a3: i32,
1568                     #[component(name = "a4")]
1569                     pub a4: i64,
1570                     #[component(name = "b")]
1571                     pub b: wasmtime::component::__internal::String,
1572                     #[component(name = "c")]
1573                     pub c: wasmtime::component::__internal::Vec<u8>,
1574                 }
1575                 impl core::fmt::Debug for OtherRecord {
fmt( &self, f: &mut core::fmt::Formatter<'_>, ) -> core::fmt::Result1576                     fn fmt(
1577                         &self,
1578                         f: &mut core::fmt::Formatter<'_>,
1579                     ) -> core::fmt::Result {
1580                         f.debug_struct("OtherRecord")
1581                             .field("a1", &self.a1)
1582                             .field("a2", &self.a2)
1583                             .field("a3", &self.a3)
1584                             .field("a4", &self.a4)
1585                             .field("b", &self.b)
1586                             .field("c", &self.c)
1587                             .finish()
1588                     }
1589                 }
1590                 const _: () = {
1591                     assert!(
1592                         48 == < OtherRecord as wasmtime::component::ComponentType
1593                         >::SIZE32
1594                     );
1595                     assert!(
1596                         8 == < OtherRecord as wasmtime::component::ComponentType
1597                         >::ALIGN32
1598                     );
1599                 };
1600                 #[derive(wasmtime::component::ComponentType)]
1601                 #[derive(wasmtime::component::Lift)]
1602                 #[derive(wasmtime::component::Lower)]
1603                 #[component(record)]
1604                 #[derive(Clone)]
1605                 pub struct SomeRecord {
1606                     #[component(name = "x")]
1607                     pub x: wasmtime::component::__internal::String,
1608                     #[component(name = "y")]
1609                     pub y: OtherRecord,
1610                     #[component(name = "z")]
1611                     pub z: wasmtime::component::__internal::Vec<OtherRecord>,
1612                     #[component(name = "c1")]
1613                     pub c1: u32,
1614                     #[component(name = "c2")]
1615                     pub c2: u64,
1616                     #[component(name = "c3")]
1617                     pub c3: i32,
1618                     #[component(name = "c4")]
1619                     pub c4: i64,
1620                 }
1621                 impl core::fmt::Debug for SomeRecord {
fmt( &self, f: &mut core::fmt::Formatter<'_>, ) -> core::fmt::Result1622                     fn fmt(
1623                         &self,
1624                         f: &mut core::fmt::Formatter<'_>,
1625                     ) -> core::fmt::Result {
1626                         f.debug_struct("SomeRecord")
1627                             .field("x", &self.x)
1628                             .field("y", &self.y)
1629                             .field("z", &self.z)
1630                             .field("c1", &self.c1)
1631                             .field("c2", &self.c2)
1632                             .field("c3", &self.c3)
1633                             .field("c4", &self.c4)
1634                             .finish()
1635                     }
1636                 }
1637                 const _: () = {
1638                     assert!(
1639                         96 == < SomeRecord as wasmtime::component::ComponentType
1640                         >::SIZE32
1641                     );
1642                     assert!(
1643                         8 == < SomeRecord as wasmtime::component::ComponentType
1644                         >::ALIGN32
1645                     );
1646                 };
1647                 #[derive(wasmtime::component::ComponentType)]
1648                 #[derive(wasmtime::component::Lift)]
1649                 #[derive(wasmtime::component::Lower)]
1650                 #[component(variant)]
1651                 #[derive(Clone)]
1652                 pub enum OtherVariant {
1653                     #[component(name = "a")]
1654                     A,
1655                     #[component(name = "b")]
1656                     B(u32),
1657                     #[component(name = "c")]
1658                     C(wasmtime::component::__internal::String),
1659                 }
1660                 impl core::fmt::Debug for OtherVariant {
fmt( &self, f: &mut core::fmt::Formatter<'_>, ) -> core::fmt::Result1661                     fn fmt(
1662                         &self,
1663                         f: &mut core::fmt::Formatter<'_>,
1664                     ) -> core::fmt::Result {
1665                         match self {
1666                             OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(),
1667                             OtherVariant::B(e) => {
1668                                 f.debug_tuple("OtherVariant::B").field(e).finish()
1669                             }
1670                             OtherVariant::C(e) => {
1671                                 f.debug_tuple("OtherVariant::C").field(e).finish()
1672                             }
1673                         }
1674                     }
1675                 }
1676                 const _: () = {
1677                     assert!(
1678                         12 == < OtherVariant as wasmtime::component::ComponentType
1679                         >::SIZE32
1680                     );
1681                     assert!(
1682                         4 == < OtherVariant as wasmtime::component::ComponentType
1683                         >::ALIGN32
1684                     );
1685                 };
1686                 #[derive(wasmtime::component::ComponentType)]
1687                 #[derive(wasmtime::component::Lift)]
1688                 #[derive(wasmtime::component::Lower)]
1689                 #[component(variant)]
1690                 #[derive(Clone)]
1691                 pub enum SomeVariant {
1692                     #[component(name = "a")]
1693                     A(wasmtime::component::__internal::String),
1694                     #[component(name = "b")]
1695                     B,
1696                     #[component(name = "c")]
1697                     C(u32),
1698                     #[component(name = "d")]
1699                     D(wasmtime::component::__internal::Vec<OtherVariant>),
1700                 }
1701                 impl core::fmt::Debug for SomeVariant {
fmt( &self, f: &mut core::fmt::Formatter<'_>, ) -> core::fmt::Result1702                     fn fmt(
1703                         &self,
1704                         f: &mut core::fmt::Formatter<'_>,
1705                     ) -> core::fmt::Result {
1706                         match self {
1707                             SomeVariant::A(e) => {
1708                                 f.debug_tuple("SomeVariant::A").field(e).finish()
1709                             }
1710                             SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(),
1711                             SomeVariant::C(e) => {
1712                                 f.debug_tuple("SomeVariant::C").field(e).finish()
1713                             }
1714                             SomeVariant::D(e) => {
1715                                 f.debug_tuple("SomeVariant::D").field(e).finish()
1716                             }
1717                         }
1718                     }
1719                 }
1720                 const _: () = {
1721                     assert!(
1722                         12 == < SomeVariant as wasmtime::component::ComponentType
1723                         >::SIZE32
1724                     );
1725                     assert!(
1726                         4 == < SomeVariant as wasmtime::component::ComponentType
1727                         >::ALIGN32
1728                     );
1729                 };
1730                 pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec<
1731                     (
1732                         wasmtime::component::__internal::String,
1733                         u8,
1734                         i8,
1735                         u16,
1736                         i16,
1737                         u32,
1738                         i32,
1739                         u64,
1740                         i64,
1741                         f32,
1742                         f64,
1743                         char,
1744                     ),
1745                 >;
1746                 const _: () = {
1747                     assert!(
1748                         8 == < LoadStoreAllSizes as wasmtime::component::ComponentType
1749                         >::SIZE32
1750                     );
1751                     assert!(
1752                         4 == < LoadStoreAllSizes as wasmtime::component::ComponentType
1753                         >::ALIGN32
1754                     );
1755                 };
1756                 #[derive(Clone)]
1757                 pub struct Guest {
1758                     list_u8_param: wasmtime::component::Func,
1759                     list_u16_param: wasmtime::component::Func,
1760                     list_u32_param: wasmtime::component::Func,
1761                     list_u64_param: wasmtime::component::Func,
1762                     list_s8_param: wasmtime::component::Func,
1763                     list_s16_param: wasmtime::component::Func,
1764                     list_s32_param: wasmtime::component::Func,
1765                     list_s64_param: wasmtime::component::Func,
1766                     list_f32_param: wasmtime::component::Func,
1767                     list_f64_param: wasmtime::component::Func,
1768                     list_u8_ret: wasmtime::component::Func,
1769                     list_u16_ret: wasmtime::component::Func,
1770                     list_u32_ret: wasmtime::component::Func,
1771                     list_u64_ret: wasmtime::component::Func,
1772                     list_s8_ret: wasmtime::component::Func,
1773                     list_s16_ret: wasmtime::component::Func,
1774                     list_s32_ret: wasmtime::component::Func,
1775                     list_s64_ret: wasmtime::component::Func,
1776                     list_f32_ret: wasmtime::component::Func,
1777                     list_f64_ret: wasmtime::component::Func,
1778                     tuple_list: wasmtime::component::Func,
1779                     string_list_arg: wasmtime::component::Func,
1780                     string_list_ret: wasmtime::component::Func,
1781                     tuple_string_list: wasmtime::component::Func,
1782                     string_list: wasmtime::component::Func,
1783                     record_list: wasmtime::component::Func,
1784                     record_list_reverse: wasmtime::component::Func,
1785                     variant_list: wasmtime::component::Func,
1786                     load_store_everything: wasmtime::component::Func,
1787                 }
1788                 #[derive(Clone)]
1789                 pub struct GuestIndices {
1790                     list_u8_param: wasmtime::component::ComponentExportIndex,
1791                     list_u16_param: wasmtime::component::ComponentExportIndex,
1792                     list_u32_param: wasmtime::component::ComponentExportIndex,
1793                     list_u64_param: wasmtime::component::ComponentExportIndex,
1794                     list_s8_param: wasmtime::component::ComponentExportIndex,
1795                     list_s16_param: wasmtime::component::ComponentExportIndex,
1796                     list_s32_param: wasmtime::component::ComponentExportIndex,
1797                     list_s64_param: wasmtime::component::ComponentExportIndex,
1798                     list_f32_param: wasmtime::component::ComponentExportIndex,
1799                     list_f64_param: wasmtime::component::ComponentExportIndex,
1800                     list_u8_ret: wasmtime::component::ComponentExportIndex,
1801                     list_u16_ret: wasmtime::component::ComponentExportIndex,
1802                     list_u32_ret: wasmtime::component::ComponentExportIndex,
1803                     list_u64_ret: wasmtime::component::ComponentExportIndex,
1804                     list_s8_ret: wasmtime::component::ComponentExportIndex,
1805                     list_s16_ret: wasmtime::component::ComponentExportIndex,
1806                     list_s32_ret: wasmtime::component::ComponentExportIndex,
1807                     list_s64_ret: wasmtime::component::ComponentExportIndex,
1808                     list_f32_ret: wasmtime::component::ComponentExportIndex,
1809                     list_f64_ret: wasmtime::component::ComponentExportIndex,
1810                     tuple_list: wasmtime::component::ComponentExportIndex,
1811                     string_list_arg: wasmtime::component::ComponentExportIndex,
1812                     string_list_ret: wasmtime::component::ComponentExportIndex,
1813                     tuple_string_list: wasmtime::component::ComponentExportIndex,
1814                     string_list: wasmtime::component::ComponentExportIndex,
1815                     record_list: wasmtime::component::ComponentExportIndex,
1816                     record_list_reverse: wasmtime::component::ComponentExportIndex,
1817                     variant_list: wasmtime::component::ComponentExportIndex,
1818                     load_store_everything: wasmtime::component::ComponentExportIndex,
1819                 }
1820                 impl GuestIndices {
1821                     /// Constructor for [`GuestIndices`] which takes a
1822                     /// [`Component`](wasmtime::component::Component) as input and can be executed
1823                     /// before instantiation.
1824                     ///
1825                     /// This constructor can be used to front-load string lookups to find exports
1826                     /// within a component.
new<_T>( _instance_pre: &wasmtime::component::InstancePre<_T>, ) -> wasmtime::Result<GuestIndices>1827                     pub fn new<_T>(
1828                         _instance_pre: &wasmtime::component::InstancePre<_T>,
1829                     ) -> wasmtime::Result<GuestIndices> {
1830                         let instance = _instance_pre
1831                             .component()
1832                             .get_export_index(None, "foo:foo/lists")
1833                             .ok_or_else(|| {
1834                                 wasmtime::format_err!(
1835                                     "no exported instance named `foo:foo/lists`"
1836                                 )
1837                             })?;
1838                         let mut lookup = move |name| {
1839                             _instance_pre
1840                                 .component()
1841                                 .get_export_index(Some(&instance), name)
1842                                 .ok_or_else(|| {
1843                                     wasmtime::format_err!(
1844                                         "instance export `foo:foo/lists` does \
1845                                                                           not have export `{name}`"
1846                                     )
1847                                 })
1848                         };
1849                         let _ = &mut lookup;
1850                         let list_u8_param = lookup("list-u8-param")?;
1851                         let list_u16_param = lookup("list-u16-param")?;
1852                         let list_u32_param = lookup("list-u32-param")?;
1853                         let list_u64_param = lookup("list-u64-param")?;
1854                         let list_s8_param = lookup("list-s8-param")?;
1855                         let list_s16_param = lookup("list-s16-param")?;
1856                         let list_s32_param = lookup("list-s32-param")?;
1857                         let list_s64_param = lookup("list-s64-param")?;
1858                         let list_f32_param = lookup("list-f32-param")?;
1859                         let list_f64_param = lookup("list-f64-param")?;
1860                         let list_u8_ret = lookup("list-u8-ret")?;
1861                         let list_u16_ret = lookup("list-u16-ret")?;
1862                         let list_u32_ret = lookup("list-u32-ret")?;
1863                         let list_u64_ret = lookup("list-u64-ret")?;
1864                         let list_s8_ret = lookup("list-s8-ret")?;
1865                         let list_s16_ret = lookup("list-s16-ret")?;
1866                         let list_s32_ret = lookup("list-s32-ret")?;
1867                         let list_s64_ret = lookup("list-s64-ret")?;
1868                         let list_f32_ret = lookup("list-f32-ret")?;
1869                         let list_f64_ret = lookup("list-f64-ret")?;
1870                         let tuple_list = lookup("tuple-list")?;
1871                         let string_list_arg = lookup("string-list-arg")?;
1872                         let string_list_ret = lookup("string-list-ret")?;
1873                         let tuple_string_list = lookup("tuple-string-list")?;
1874                         let string_list = lookup("string-list")?;
1875                         let record_list = lookup("record-list")?;
1876                         let record_list_reverse = lookup("record-list-reverse")?;
1877                         let variant_list = lookup("variant-list")?;
1878                         let load_store_everything = lookup("load-store-everything")?;
1879                         Ok(GuestIndices {
1880                             list_u8_param,
1881                             list_u16_param,
1882                             list_u32_param,
1883                             list_u64_param,
1884                             list_s8_param,
1885                             list_s16_param,
1886                             list_s32_param,
1887                             list_s64_param,
1888                             list_f32_param,
1889                             list_f64_param,
1890                             list_u8_ret,
1891                             list_u16_ret,
1892                             list_u32_ret,
1893                             list_u64_ret,
1894                             list_s8_ret,
1895                             list_s16_ret,
1896                             list_s32_ret,
1897                             list_s64_ret,
1898                             list_f32_ret,
1899                             list_f64_ret,
1900                             tuple_list,
1901                             string_list_arg,
1902                             string_list_ret,
1903                             tuple_string_list,
1904                             string_list,
1905                             record_list,
1906                             record_list_reverse,
1907                             variant_list,
1908                             load_store_everything,
1909                         })
1910                     }
load( &self, mut store: impl wasmtime::AsContextMut, instance: &wasmtime::component::Instance, ) -> wasmtime::Result<Guest>1911                     pub fn load(
1912                         &self,
1913                         mut store: impl wasmtime::AsContextMut,
1914                         instance: &wasmtime::component::Instance,
1915                     ) -> wasmtime::Result<Guest> {
1916                         let _instance = instance;
1917                         let _instance_pre = _instance.instance_pre(&store);
1918                         let _instance_type = _instance_pre.instance_type();
1919                         let mut store = store.as_context_mut();
1920                         let _ = &mut store;
1921                         let list_u8_param = *_instance
1922                             .get_typed_func::<
1923                                 (&[u8],),
1924                                 (),
1925                             >(&mut store, &self.list_u8_param)?
1926                             .func();
1927                         let list_u16_param = *_instance
1928                             .get_typed_func::<
1929                                 (&[u16],),
1930                                 (),
1931                             >(&mut store, &self.list_u16_param)?
1932                             .func();
1933                         let list_u32_param = *_instance
1934                             .get_typed_func::<
1935                                 (&[u32],),
1936                                 (),
1937                             >(&mut store, &self.list_u32_param)?
1938                             .func();
1939                         let list_u64_param = *_instance
1940                             .get_typed_func::<
1941                                 (&[u64],),
1942                                 (),
1943                             >(&mut store, &self.list_u64_param)?
1944                             .func();
1945                         let list_s8_param = *_instance
1946                             .get_typed_func::<
1947                                 (&[i8],),
1948                                 (),
1949                             >(&mut store, &self.list_s8_param)?
1950                             .func();
1951                         let list_s16_param = *_instance
1952                             .get_typed_func::<
1953                                 (&[i16],),
1954                                 (),
1955                             >(&mut store, &self.list_s16_param)?
1956                             .func();
1957                         let list_s32_param = *_instance
1958                             .get_typed_func::<
1959                                 (&[i32],),
1960                                 (),
1961                             >(&mut store, &self.list_s32_param)?
1962                             .func();
1963                         let list_s64_param = *_instance
1964                             .get_typed_func::<
1965                                 (&[i64],),
1966                                 (),
1967                             >(&mut store, &self.list_s64_param)?
1968                             .func();
1969                         let list_f32_param = *_instance
1970                             .get_typed_func::<
1971                                 (&[f32],),
1972                                 (),
1973                             >(&mut store, &self.list_f32_param)?
1974                             .func();
1975                         let list_f64_param = *_instance
1976                             .get_typed_func::<
1977                                 (&[f64],),
1978                                 (),
1979                             >(&mut store, &self.list_f64_param)?
1980                             .func();
1981                         let list_u8_ret = *_instance
1982                             .get_typed_func::<
1983                                 (),
1984                                 (wasmtime::component::__internal::Vec<u8>,),
1985                             >(&mut store, &self.list_u8_ret)?
1986                             .func();
1987                         let list_u16_ret = *_instance
1988                             .get_typed_func::<
1989                                 (),
1990                                 (wasmtime::component::__internal::Vec<u16>,),
1991                             >(&mut store, &self.list_u16_ret)?
1992                             .func();
1993                         let list_u32_ret = *_instance
1994                             .get_typed_func::<
1995                                 (),
1996                                 (wasmtime::component::__internal::Vec<u32>,),
1997                             >(&mut store, &self.list_u32_ret)?
1998                             .func();
1999                         let list_u64_ret = *_instance
2000                             .get_typed_func::<
2001                                 (),
2002                                 (wasmtime::component::__internal::Vec<u64>,),
2003                             >(&mut store, &self.list_u64_ret)?
2004                             .func();
2005                         let list_s8_ret = *_instance
2006                             .get_typed_func::<
2007                                 (),
2008                                 (wasmtime::component::__internal::Vec<i8>,),
2009                             >(&mut store, &self.list_s8_ret)?
2010                             .func();
2011                         let list_s16_ret = *_instance
2012                             .get_typed_func::<
2013                                 (),
2014                                 (wasmtime::component::__internal::Vec<i16>,),
2015                             >(&mut store, &self.list_s16_ret)?
2016                             .func();
2017                         let list_s32_ret = *_instance
2018                             .get_typed_func::<
2019                                 (),
2020                                 (wasmtime::component::__internal::Vec<i32>,),
2021                             >(&mut store, &self.list_s32_ret)?
2022                             .func();
2023                         let list_s64_ret = *_instance
2024                             .get_typed_func::<
2025                                 (),
2026                                 (wasmtime::component::__internal::Vec<i64>,),
2027                             >(&mut store, &self.list_s64_ret)?
2028                             .func();
2029                         let list_f32_ret = *_instance
2030                             .get_typed_func::<
2031                                 (),
2032                                 (wasmtime::component::__internal::Vec<f32>,),
2033                             >(&mut store, &self.list_f32_ret)?
2034                             .func();
2035                         let list_f64_ret = *_instance
2036                             .get_typed_func::<
2037                                 (),
2038                                 (wasmtime::component::__internal::Vec<f64>,),
2039                             >(&mut store, &self.list_f64_ret)?
2040                             .func();
2041                         let tuple_list = *_instance
2042                             .get_typed_func::<
2043                                 (&[(u8, i8)],),
2044                                 (wasmtime::component::__internal::Vec<(i64, u32)>,),
2045                             >(&mut store, &self.tuple_list)?
2046                             .func();
2047                         let string_list_arg = *_instance
2048                             .get_typed_func::<
2049                                 (&[wasmtime::component::__internal::String],),
2050                                 (),
2051                             >(&mut store, &self.string_list_arg)?
2052                             .func();
2053                         let string_list_ret = *_instance
2054                             .get_typed_func::<
2055                                 (),
2056                                 (
2057                                     wasmtime::component::__internal::Vec<
2058                                         wasmtime::component::__internal::String,
2059                                     >,
2060                                 ),
2061                             >(&mut store, &self.string_list_ret)?
2062                             .func();
2063                         let tuple_string_list = *_instance
2064                             .get_typed_func::<
2065                                 (&[(u8, wasmtime::component::__internal::String)],),
2066                                 (
2067                                     wasmtime::component::__internal::Vec<
2068                                         (wasmtime::component::__internal::String, u8),
2069                                     >,
2070                                 ),
2071                             >(&mut store, &self.tuple_string_list)?
2072                             .func();
2073                         let string_list = *_instance
2074                             .get_typed_func::<
2075                                 (&[wasmtime::component::__internal::String],),
2076                                 (
2077                                     wasmtime::component::__internal::Vec<
2078                                         wasmtime::component::__internal::String,
2079                                     >,
2080                                 ),
2081                             >(&mut store, &self.string_list)?
2082                             .func();
2083                         let record_list = *_instance
2084                             .get_typed_func::<
2085                                 (&[SomeRecord],),
2086                                 (wasmtime::component::__internal::Vec<OtherRecord>,),
2087                             >(&mut store, &self.record_list)?
2088                             .func();
2089                         let record_list_reverse = *_instance
2090                             .get_typed_func::<
2091                                 (&[OtherRecord],),
2092                                 (wasmtime::component::__internal::Vec<SomeRecord>,),
2093                             >(&mut store, &self.record_list_reverse)?
2094                             .func();
2095                         let variant_list = *_instance
2096                             .get_typed_func::<
2097                                 (&[SomeVariant],),
2098                                 (wasmtime::component::__internal::Vec<OtherVariant>,),
2099                             >(&mut store, &self.variant_list)?
2100                             .func();
2101                         let load_store_everything = *_instance
2102                             .get_typed_func::<
2103                                 (&LoadStoreAllSizes,),
2104                                 (LoadStoreAllSizes,),
2105                             >(&mut store, &self.load_store_everything)?
2106                             .func();
2107                         Ok(Guest {
2108                             list_u8_param,
2109                             list_u16_param,
2110                             list_u32_param,
2111                             list_u64_param,
2112                             list_s8_param,
2113                             list_s16_param,
2114                             list_s32_param,
2115                             list_s64_param,
2116                             list_f32_param,
2117                             list_f64_param,
2118                             list_u8_ret,
2119                             list_u16_ret,
2120                             list_u32_ret,
2121                             list_u64_ret,
2122                             list_s8_ret,
2123                             list_s16_ret,
2124                             list_s32_ret,
2125                             list_s64_ret,
2126                             list_f32_ret,
2127                             list_f64_ret,
2128                             tuple_list,
2129                             string_list_arg,
2130                             string_list_ret,
2131                             tuple_string_list,
2132                             string_list,
2133                             record_list,
2134                             record_list_reverse,
2135                             variant_list,
2136                             load_store_everything,
2137                         })
2138                     }
2139                 }
2140                 impl Guest {
call_list_u8_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[u8], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2141                     pub async fn call_list_u8_param<S: wasmtime::AsContextMut>(
2142                         &self,
2143                         mut store: S,
2144                         arg0: &[u8],
2145                     ) -> wasmtime::Result<()>
2146                     where
2147                         <S as wasmtime::AsContext>::Data: Send,
2148                     {
2149                         use tracing::Instrument;
2150                         let span = tracing::span!(
2151                             tracing::Level::TRACE, "wit-bindgen export", module =
2152                             "foo:foo/lists", function = "list-u8-param",
2153                         );
2154                         let callee = unsafe {
2155                             wasmtime::component::TypedFunc::<
2156                                 (&[u8],),
2157                                 (),
2158                             >::new_unchecked(self.list_u8_param)
2159                         };
2160                         let () = callee
2161                             .call_async(store.as_context_mut(), (arg0,))
2162                             .instrument(span.clone())
2163                             .await?;
2164                         Ok(())
2165                     }
call_list_u16_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[u16], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2166                     pub async fn call_list_u16_param<S: wasmtime::AsContextMut>(
2167                         &self,
2168                         mut store: S,
2169                         arg0: &[u16],
2170                     ) -> wasmtime::Result<()>
2171                     where
2172                         <S as wasmtime::AsContext>::Data: Send,
2173                     {
2174                         use tracing::Instrument;
2175                         let span = tracing::span!(
2176                             tracing::Level::TRACE, "wit-bindgen export", module =
2177                             "foo:foo/lists", function = "list-u16-param",
2178                         );
2179                         let callee = unsafe {
2180                             wasmtime::component::TypedFunc::<
2181                                 (&[u16],),
2182                                 (),
2183                             >::new_unchecked(self.list_u16_param)
2184                         };
2185                         let () = callee
2186                             .call_async(store.as_context_mut(), (arg0,))
2187                             .instrument(span.clone())
2188                             .await?;
2189                         Ok(())
2190                     }
call_list_u32_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[u32], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2191                     pub async fn call_list_u32_param<S: wasmtime::AsContextMut>(
2192                         &self,
2193                         mut store: S,
2194                         arg0: &[u32],
2195                     ) -> wasmtime::Result<()>
2196                     where
2197                         <S as wasmtime::AsContext>::Data: Send,
2198                     {
2199                         use tracing::Instrument;
2200                         let span = tracing::span!(
2201                             tracing::Level::TRACE, "wit-bindgen export", module =
2202                             "foo:foo/lists", function = "list-u32-param",
2203                         );
2204                         let callee = unsafe {
2205                             wasmtime::component::TypedFunc::<
2206                                 (&[u32],),
2207                                 (),
2208                             >::new_unchecked(self.list_u32_param)
2209                         };
2210                         let () = callee
2211                             .call_async(store.as_context_mut(), (arg0,))
2212                             .instrument(span.clone())
2213                             .await?;
2214                         Ok(())
2215                     }
call_list_u64_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[u64], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2216                     pub async fn call_list_u64_param<S: wasmtime::AsContextMut>(
2217                         &self,
2218                         mut store: S,
2219                         arg0: &[u64],
2220                     ) -> wasmtime::Result<()>
2221                     where
2222                         <S as wasmtime::AsContext>::Data: Send,
2223                     {
2224                         use tracing::Instrument;
2225                         let span = tracing::span!(
2226                             tracing::Level::TRACE, "wit-bindgen export", module =
2227                             "foo:foo/lists", function = "list-u64-param",
2228                         );
2229                         let callee = unsafe {
2230                             wasmtime::component::TypedFunc::<
2231                                 (&[u64],),
2232                                 (),
2233                             >::new_unchecked(self.list_u64_param)
2234                         };
2235                         let () = callee
2236                             .call_async(store.as_context_mut(), (arg0,))
2237                             .instrument(span.clone())
2238                             .await?;
2239                         Ok(())
2240                     }
call_list_s8_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[i8], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2241                     pub async fn call_list_s8_param<S: wasmtime::AsContextMut>(
2242                         &self,
2243                         mut store: S,
2244                         arg0: &[i8],
2245                     ) -> wasmtime::Result<()>
2246                     where
2247                         <S as wasmtime::AsContext>::Data: Send,
2248                     {
2249                         use tracing::Instrument;
2250                         let span = tracing::span!(
2251                             tracing::Level::TRACE, "wit-bindgen export", module =
2252                             "foo:foo/lists", function = "list-s8-param",
2253                         );
2254                         let callee = unsafe {
2255                             wasmtime::component::TypedFunc::<
2256                                 (&[i8],),
2257                                 (),
2258                             >::new_unchecked(self.list_s8_param)
2259                         };
2260                         let () = callee
2261                             .call_async(store.as_context_mut(), (arg0,))
2262                             .instrument(span.clone())
2263                             .await?;
2264                         Ok(())
2265                     }
call_list_s16_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[i16], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2266                     pub async fn call_list_s16_param<S: wasmtime::AsContextMut>(
2267                         &self,
2268                         mut store: S,
2269                         arg0: &[i16],
2270                     ) -> wasmtime::Result<()>
2271                     where
2272                         <S as wasmtime::AsContext>::Data: Send,
2273                     {
2274                         use tracing::Instrument;
2275                         let span = tracing::span!(
2276                             tracing::Level::TRACE, "wit-bindgen export", module =
2277                             "foo:foo/lists", function = "list-s16-param",
2278                         );
2279                         let callee = unsafe {
2280                             wasmtime::component::TypedFunc::<
2281                                 (&[i16],),
2282                                 (),
2283                             >::new_unchecked(self.list_s16_param)
2284                         };
2285                         let () = callee
2286                             .call_async(store.as_context_mut(), (arg0,))
2287                             .instrument(span.clone())
2288                             .await?;
2289                         Ok(())
2290                     }
call_list_s32_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[i32], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2291                     pub async fn call_list_s32_param<S: wasmtime::AsContextMut>(
2292                         &self,
2293                         mut store: S,
2294                         arg0: &[i32],
2295                     ) -> wasmtime::Result<()>
2296                     where
2297                         <S as wasmtime::AsContext>::Data: Send,
2298                     {
2299                         use tracing::Instrument;
2300                         let span = tracing::span!(
2301                             tracing::Level::TRACE, "wit-bindgen export", module =
2302                             "foo:foo/lists", function = "list-s32-param",
2303                         );
2304                         let callee = unsafe {
2305                             wasmtime::component::TypedFunc::<
2306                                 (&[i32],),
2307                                 (),
2308                             >::new_unchecked(self.list_s32_param)
2309                         };
2310                         let () = callee
2311                             .call_async(store.as_context_mut(), (arg0,))
2312                             .instrument(span.clone())
2313                             .await?;
2314                         Ok(())
2315                     }
call_list_s64_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[i64], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2316                     pub async fn call_list_s64_param<S: wasmtime::AsContextMut>(
2317                         &self,
2318                         mut store: S,
2319                         arg0: &[i64],
2320                     ) -> wasmtime::Result<()>
2321                     where
2322                         <S as wasmtime::AsContext>::Data: Send,
2323                     {
2324                         use tracing::Instrument;
2325                         let span = tracing::span!(
2326                             tracing::Level::TRACE, "wit-bindgen export", module =
2327                             "foo:foo/lists", function = "list-s64-param",
2328                         );
2329                         let callee = unsafe {
2330                             wasmtime::component::TypedFunc::<
2331                                 (&[i64],),
2332                                 (),
2333                             >::new_unchecked(self.list_s64_param)
2334                         };
2335                         let () = callee
2336                             .call_async(store.as_context_mut(), (arg0,))
2337                             .instrument(span.clone())
2338                             .await?;
2339                         Ok(())
2340                     }
call_list_f32_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[f32], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2341                     pub async fn call_list_f32_param<S: wasmtime::AsContextMut>(
2342                         &self,
2343                         mut store: S,
2344                         arg0: &[f32],
2345                     ) -> wasmtime::Result<()>
2346                     where
2347                         <S as wasmtime::AsContext>::Data: Send,
2348                     {
2349                         use tracing::Instrument;
2350                         let span = tracing::span!(
2351                             tracing::Level::TRACE, "wit-bindgen export", module =
2352                             "foo:foo/lists", function = "list-f32-param",
2353                         );
2354                         let callee = unsafe {
2355                             wasmtime::component::TypedFunc::<
2356                                 (&[f32],),
2357                                 (),
2358                             >::new_unchecked(self.list_f32_param)
2359                         };
2360                         let () = callee
2361                             .call_async(store.as_context_mut(), (arg0,))
2362                             .instrument(span.clone())
2363                             .await?;
2364                         Ok(())
2365                     }
call_list_f64_param<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[f64], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2366                     pub async fn call_list_f64_param<S: wasmtime::AsContextMut>(
2367                         &self,
2368                         mut store: S,
2369                         arg0: &[f64],
2370                     ) -> wasmtime::Result<()>
2371                     where
2372                         <S as wasmtime::AsContext>::Data: Send,
2373                     {
2374                         use tracing::Instrument;
2375                         let span = tracing::span!(
2376                             tracing::Level::TRACE, "wit-bindgen export", module =
2377                             "foo:foo/lists", function = "list-f64-param",
2378                         );
2379                         let callee = unsafe {
2380                             wasmtime::component::TypedFunc::<
2381                                 (&[f64],),
2382                                 (),
2383                             >::new_unchecked(self.list_f64_param)
2384                         };
2385                         let () = callee
2386                             .call_async(store.as_context_mut(), (arg0,))
2387                             .instrument(span.clone())
2388                             .await?;
2389                         Ok(())
2390                     }
call_list_u8_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u8>> where <S as wasmtime::AsContext>::Data: Send,2391                     pub async fn call_list_u8_ret<S: wasmtime::AsContextMut>(
2392                         &self,
2393                         mut store: S,
2394                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u8>>
2395                     where
2396                         <S as wasmtime::AsContext>::Data: Send,
2397                     {
2398                         use tracing::Instrument;
2399                         let span = tracing::span!(
2400                             tracing::Level::TRACE, "wit-bindgen export", module =
2401                             "foo:foo/lists", function = "list-u8-ret",
2402                         );
2403                         let callee = unsafe {
2404                             wasmtime::component::TypedFunc::<
2405                                 (),
2406                                 (wasmtime::component::__internal::Vec<u8>,),
2407                             >::new_unchecked(self.list_u8_ret)
2408                         };
2409                         let (ret0,) = callee
2410                             .call_async(store.as_context_mut(), ())
2411                             .instrument(span.clone())
2412                             .await?;
2413                         Ok(ret0)
2414                     }
call_list_u16_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u16>> where <S as wasmtime::AsContext>::Data: Send,2415                     pub async fn call_list_u16_ret<S: wasmtime::AsContextMut>(
2416                         &self,
2417                         mut store: S,
2418                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u16>>
2419                     where
2420                         <S as wasmtime::AsContext>::Data: Send,
2421                     {
2422                         use tracing::Instrument;
2423                         let span = tracing::span!(
2424                             tracing::Level::TRACE, "wit-bindgen export", module =
2425                             "foo:foo/lists", function = "list-u16-ret",
2426                         );
2427                         let callee = unsafe {
2428                             wasmtime::component::TypedFunc::<
2429                                 (),
2430                                 (wasmtime::component::__internal::Vec<u16>,),
2431                             >::new_unchecked(self.list_u16_ret)
2432                         };
2433                         let (ret0,) = callee
2434                             .call_async(store.as_context_mut(), ())
2435                             .instrument(span.clone())
2436                             .await?;
2437                         Ok(ret0)
2438                     }
call_list_u32_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u32>> where <S as wasmtime::AsContext>::Data: Send,2439                     pub async fn call_list_u32_ret<S: wasmtime::AsContextMut>(
2440                         &self,
2441                         mut store: S,
2442                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u32>>
2443                     where
2444                         <S as wasmtime::AsContext>::Data: Send,
2445                     {
2446                         use tracing::Instrument;
2447                         let span = tracing::span!(
2448                             tracing::Level::TRACE, "wit-bindgen export", module =
2449                             "foo:foo/lists", function = "list-u32-ret",
2450                         );
2451                         let callee = unsafe {
2452                             wasmtime::component::TypedFunc::<
2453                                 (),
2454                                 (wasmtime::component::__internal::Vec<u32>,),
2455                             >::new_unchecked(self.list_u32_ret)
2456                         };
2457                         let (ret0,) = callee
2458                             .call_async(store.as_context_mut(), ())
2459                             .instrument(span.clone())
2460                             .await?;
2461                         Ok(ret0)
2462                     }
call_list_u64_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u64>> where <S as wasmtime::AsContext>::Data: Send,2463                     pub async fn call_list_u64_ret<S: wasmtime::AsContextMut>(
2464                         &self,
2465                         mut store: S,
2466                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u64>>
2467                     where
2468                         <S as wasmtime::AsContext>::Data: Send,
2469                     {
2470                         use tracing::Instrument;
2471                         let span = tracing::span!(
2472                             tracing::Level::TRACE, "wit-bindgen export", module =
2473                             "foo:foo/lists", function = "list-u64-ret",
2474                         );
2475                         let callee = unsafe {
2476                             wasmtime::component::TypedFunc::<
2477                                 (),
2478                                 (wasmtime::component::__internal::Vec<u64>,),
2479                             >::new_unchecked(self.list_u64_ret)
2480                         };
2481                         let (ret0,) = callee
2482                             .call_async(store.as_context_mut(), ())
2483                             .instrument(span.clone())
2484                             .await?;
2485                         Ok(ret0)
2486                     }
call_list_s8_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i8>> where <S as wasmtime::AsContext>::Data: Send,2487                     pub async fn call_list_s8_ret<S: wasmtime::AsContextMut>(
2488                         &self,
2489                         mut store: S,
2490                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i8>>
2491                     where
2492                         <S as wasmtime::AsContext>::Data: Send,
2493                     {
2494                         use tracing::Instrument;
2495                         let span = tracing::span!(
2496                             tracing::Level::TRACE, "wit-bindgen export", module =
2497                             "foo:foo/lists", function = "list-s8-ret",
2498                         );
2499                         let callee = unsafe {
2500                             wasmtime::component::TypedFunc::<
2501                                 (),
2502                                 (wasmtime::component::__internal::Vec<i8>,),
2503                             >::new_unchecked(self.list_s8_ret)
2504                         };
2505                         let (ret0,) = callee
2506                             .call_async(store.as_context_mut(), ())
2507                             .instrument(span.clone())
2508                             .await?;
2509                         Ok(ret0)
2510                     }
call_list_s16_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i16>> where <S as wasmtime::AsContext>::Data: Send,2511                     pub async fn call_list_s16_ret<S: wasmtime::AsContextMut>(
2512                         &self,
2513                         mut store: S,
2514                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i16>>
2515                     where
2516                         <S as wasmtime::AsContext>::Data: Send,
2517                     {
2518                         use tracing::Instrument;
2519                         let span = tracing::span!(
2520                             tracing::Level::TRACE, "wit-bindgen export", module =
2521                             "foo:foo/lists", function = "list-s16-ret",
2522                         );
2523                         let callee = unsafe {
2524                             wasmtime::component::TypedFunc::<
2525                                 (),
2526                                 (wasmtime::component::__internal::Vec<i16>,),
2527                             >::new_unchecked(self.list_s16_ret)
2528                         };
2529                         let (ret0,) = callee
2530                             .call_async(store.as_context_mut(), ())
2531                             .instrument(span.clone())
2532                             .await?;
2533                         Ok(ret0)
2534                     }
call_list_s32_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i32>> where <S as wasmtime::AsContext>::Data: Send,2535                     pub async fn call_list_s32_ret<S: wasmtime::AsContextMut>(
2536                         &self,
2537                         mut store: S,
2538                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i32>>
2539                     where
2540                         <S as wasmtime::AsContext>::Data: Send,
2541                     {
2542                         use tracing::Instrument;
2543                         let span = tracing::span!(
2544                             tracing::Level::TRACE, "wit-bindgen export", module =
2545                             "foo:foo/lists", function = "list-s32-ret",
2546                         );
2547                         let callee = unsafe {
2548                             wasmtime::component::TypedFunc::<
2549                                 (),
2550                                 (wasmtime::component::__internal::Vec<i32>,),
2551                             >::new_unchecked(self.list_s32_ret)
2552                         };
2553                         let (ret0,) = callee
2554                             .call_async(store.as_context_mut(), ())
2555                             .instrument(span.clone())
2556                             .await?;
2557                         Ok(ret0)
2558                     }
call_list_s64_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i64>> where <S as wasmtime::AsContext>::Data: Send,2559                     pub async fn call_list_s64_ret<S: wasmtime::AsContextMut>(
2560                         &self,
2561                         mut store: S,
2562                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i64>>
2563                     where
2564                         <S as wasmtime::AsContext>::Data: Send,
2565                     {
2566                         use tracing::Instrument;
2567                         let span = tracing::span!(
2568                             tracing::Level::TRACE, "wit-bindgen export", module =
2569                             "foo:foo/lists", function = "list-s64-ret",
2570                         );
2571                         let callee = unsafe {
2572                             wasmtime::component::TypedFunc::<
2573                                 (),
2574                                 (wasmtime::component::__internal::Vec<i64>,),
2575                             >::new_unchecked(self.list_s64_ret)
2576                         };
2577                         let (ret0,) = callee
2578                             .call_async(store.as_context_mut(), ())
2579                             .instrument(span.clone())
2580                             .await?;
2581                         Ok(ret0)
2582                     }
call_list_f32_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f32>> where <S as wasmtime::AsContext>::Data: Send,2583                     pub async fn call_list_f32_ret<S: wasmtime::AsContextMut>(
2584                         &self,
2585                         mut store: S,
2586                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f32>>
2587                     where
2588                         <S as wasmtime::AsContext>::Data: Send,
2589                     {
2590                         use tracing::Instrument;
2591                         let span = tracing::span!(
2592                             tracing::Level::TRACE, "wit-bindgen export", module =
2593                             "foo:foo/lists", function = "list-f32-ret",
2594                         );
2595                         let callee = unsafe {
2596                             wasmtime::component::TypedFunc::<
2597                                 (),
2598                                 (wasmtime::component::__internal::Vec<f32>,),
2599                             >::new_unchecked(self.list_f32_ret)
2600                         };
2601                         let (ret0,) = callee
2602                             .call_async(store.as_context_mut(), ())
2603                             .instrument(span.clone())
2604                             .await?;
2605                         Ok(ret0)
2606                     }
call_list_f64_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f64>> where <S as wasmtime::AsContext>::Data: Send,2607                     pub async fn call_list_f64_ret<S: wasmtime::AsContextMut>(
2608                         &self,
2609                         mut store: S,
2610                     ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f64>>
2611                     where
2612                         <S as wasmtime::AsContext>::Data: Send,
2613                     {
2614                         use tracing::Instrument;
2615                         let span = tracing::span!(
2616                             tracing::Level::TRACE, "wit-bindgen export", module =
2617                             "foo:foo/lists", function = "list-f64-ret",
2618                         );
2619                         let callee = unsafe {
2620                             wasmtime::component::TypedFunc::<
2621                                 (),
2622                                 (wasmtime::component::__internal::Vec<f64>,),
2623                             >::new_unchecked(self.list_f64_ret)
2624                         };
2625                         let (ret0,) = callee
2626                             .call_async(store.as_context_mut(), ())
2627                             .instrument(span.clone())
2628                             .await?;
2629                         Ok(ret0)
2630                     }
call_tuple_list<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[(u8, i8)], ) -> wasmtime::Result< wasmtime::component::__internal::Vec<(i64, u32)>, > where <S as wasmtime::AsContext>::Data: Send,2631                     pub async fn call_tuple_list<S: wasmtime::AsContextMut>(
2632                         &self,
2633                         mut store: S,
2634                         arg0: &[(u8, i8)],
2635                     ) -> wasmtime::Result<
2636                         wasmtime::component::__internal::Vec<(i64, u32)>,
2637                     >
2638                     where
2639                         <S as wasmtime::AsContext>::Data: Send,
2640                     {
2641                         use tracing::Instrument;
2642                         let span = tracing::span!(
2643                             tracing::Level::TRACE, "wit-bindgen export", module =
2644                             "foo:foo/lists", function = "tuple-list",
2645                         );
2646                         let callee = unsafe {
2647                             wasmtime::component::TypedFunc::<
2648                                 (&[(u8, i8)],),
2649                                 (wasmtime::component::__internal::Vec<(i64, u32)>,),
2650                             >::new_unchecked(self.tuple_list)
2651                         };
2652                         let (ret0,) = callee
2653                             .call_async(store.as_context_mut(), (arg0,))
2654                             .instrument(span.clone())
2655                             .await?;
2656                         Ok(ret0)
2657                     }
call_string_list_arg<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[wasmtime::component::__internal::String], ) -> wasmtime::Result<()> where <S as wasmtime::AsContext>::Data: Send,2658                     pub async fn call_string_list_arg<S: wasmtime::AsContextMut>(
2659                         &self,
2660                         mut store: S,
2661                         arg0: &[wasmtime::component::__internal::String],
2662                     ) -> wasmtime::Result<()>
2663                     where
2664                         <S as wasmtime::AsContext>::Data: Send,
2665                     {
2666                         use tracing::Instrument;
2667                         let span = tracing::span!(
2668                             tracing::Level::TRACE, "wit-bindgen export", module =
2669                             "foo:foo/lists", function = "string-list-arg",
2670                         );
2671                         let callee = unsafe {
2672                             wasmtime::component::TypedFunc::<
2673                                 (&[wasmtime::component::__internal::String],),
2674                                 (),
2675                             >::new_unchecked(self.string_list_arg)
2676                         };
2677                         let () = callee
2678                             .call_async(store.as_context_mut(), (arg0,))
2679                             .instrument(span.clone())
2680                             .await?;
2681                         Ok(())
2682                     }
call_string_list_ret<S: wasmtime::AsContextMut>( &self, mut store: S, ) -> wasmtime::Result< wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, > where <S as wasmtime::AsContext>::Data: Send,2683                     pub async fn call_string_list_ret<S: wasmtime::AsContextMut>(
2684                         &self,
2685                         mut store: S,
2686                     ) -> wasmtime::Result<
2687                         wasmtime::component::__internal::Vec<
2688                             wasmtime::component::__internal::String,
2689                         >,
2690                     >
2691                     where
2692                         <S as wasmtime::AsContext>::Data: Send,
2693                     {
2694                         use tracing::Instrument;
2695                         let span = tracing::span!(
2696                             tracing::Level::TRACE, "wit-bindgen export", module =
2697                             "foo:foo/lists", function = "string-list-ret",
2698                         );
2699                         let callee = unsafe {
2700                             wasmtime::component::TypedFunc::<
2701                                 (),
2702                                 (
2703                                     wasmtime::component::__internal::Vec<
2704                                         wasmtime::component::__internal::String,
2705                                     >,
2706                                 ),
2707                             >::new_unchecked(self.string_list_ret)
2708                         };
2709                         let (ret0,) = callee
2710                             .call_async(store.as_context_mut(), ())
2711                             .instrument(span.clone())
2712                             .await?;
2713                         Ok(ret0)
2714                     }
call_tuple_string_list<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[(u8, wasmtime::component::__internal::String)], ) -> wasmtime::Result< wasmtime::component::__internal::Vec< (wasmtime::component::__internal::String, u8), >, > where <S as wasmtime::AsContext>::Data: Send,2715                     pub async fn call_tuple_string_list<S: wasmtime::AsContextMut>(
2716                         &self,
2717                         mut store: S,
2718                         arg0: &[(u8, wasmtime::component::__internal::String)],
2719                     ) -> wasmtime::Result<
2720                         wasmtime::component::__internal::Vec<
2721                             (wasmtime::component::__internal::String, u8),
2722                         >,
2723                     >
2724                     where
2725                         <S as wasmtime::AsContext>::Data: Send,
2726                     {
2727                         use tracing::Instrument;
2728                         let span = tracing::span!(
2729                             tracing::Level::TRACE, "wit-bindgen export", module =
2730                             "foo:foo/lists", function = "tuple-string-list",
2731                         );
2732                         let callee = unsafe {
2733                             wasmtime::component::TypedFunc::<
2734                                 (&[(u8, wasmtime::component::__internal::String)],),
2735                                 (
2736                                     wasmtime::component::__internal::Vec<
2737                                         (wasmtime::component::__internal::String, u8),
2738                                     >,
2739                                 ),
2740                             >::new_unchecked(self.tuple_string_list)
2741                         };
2742                         let (ret0,) = callee
2743                             .call_async(store.as_context_mut(), (arg0,))
2744                             .instrument(span.clone())
2745                             .await?;
2746                         Ok(ret0)
2747                     }
call_string_list<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[wasmtime::component::__internal::String], ) -> wasmtime::Result< wasmtime::component::__internal::Vec< wasmtime::component::__internal::String, >, > where <S as wasmtime::AsContext>::Data: Send,2748                     pub async fn call_string_list<S: wasmtime::AsContextMut>(
2749                         &self,
2750                         mut store: S,
2751                         arg0: &[wasmtime::component::__internal::String],
2752                     ) -> wasmtime::Result<
2753                         wasmtime::component::__internal::Vec<
2754                             wasmtime::component::__internal::String,
2755                         >,
2756                     >
2757                     where
2758                         <S as wasmtime::AsContext>::Data: Send,
2759                     {
2760                         use tracing::Instrument;
2761                         let span = tracing::span!(
2762                             tracing::Level::TRACE, "wit-bindgen export", module =
2763                             "foo:foo/lists", function = "string-list",
2764                         );
2765                         let callee = unsafe {
2766                             wasmtime::component::TypedFunc::<
2767                                 (&[wasmtime::component::__internal::String],),
2768                                 (
2769                                     wasmtime::component::__internal::Vec<
2770                                         wasmtime::component::__internal::String,
2771                                     >,
2772                                 ),
2773                             >::new_unchecked(self.string_list)
2774                         };
2775                         let (ret0,) = callee
2776                             .call_async(store.as_context_mut(), (arg0,))
2777                             .instrument(span.clone())
2778                             .await?;
2779                         Ok(ret0)
2780                     }
call_record_list<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[SomeRecord], ) -> wasmtime::Result< wasmtime::component::__internal::Vec<OtherRecord>, > where <S as wasmtime::AsContext>::Data: Send,2781                     pub async fn call_record_list<S: wasmtime::AsContextMut>(
2782                         &self,
2783                         mut store: S,
2784                         arg0: &[SomeRecord],
2785                     ) -> wasmtime::Result<
2786                         wasmtime::component::__internal::Vec<OtherRecord>,
2787                     >
2788                     where
2789                         <S as wasmtime::AsContext>::Data: Send,
2790                     {
2791                         use tracing::Instrument;
2792                         let span = tracing::span!(
2793                             tracing::Level::TRACE, "wit-bindgen export", module =
2794                             "foo:foo/lists", function = "record-list",
2795                         );
2796                         let callee = unsafe {
2797                             wasmtime::component::TypedFunc::<
2798                                 (&[SomeRecord],),
2799                                 (wasmtime::component::__internal::Vec<OtherRecord>,),
2800                             >::new_unchecked(self.record_list)
2801                         };
2802                         let (ret0,) = callee
2803                             .call_async(store.as_context_mut(), (arg0,))
2804                             .instrument(span.clone())
2805                             .await?;
2806                         Ok(ret0)
2807                     }
call_record_list_reverse<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[OtherRecord], ) -> wasmtime::Result< wasmtime::component::__internal::Vec<SomeRecord>, > where <S as wasmtime::AsContext>::Data: Send,2808                     pub async fn call_record_list_reverse<S: wasmtime::AsContextMut>(
2809                         &self,
2810                         mut store: S,
2811                         arg0: &[OtherRecord],
2812                     ) -> wasmtime::Result<
2813                         wasmtime::component::__internal::Vec<SomeRecord>,
2814                     >
2815                     where
2816                         <S as wasmtime::AsContext>::Data: Send,
2817                     {
2818                         use tracing::Instrument;
2819                         let span = tracing::span!(
2820                             tracing::Level::TRACE, "wit-bindgen export", module =
2821                             "foo:foo/lists", function = "record-list-reverse",
2822                         );
2823                         let callee = unsafe {
2824                             wasmtime::component::TypedFunc::<
2825                                 (&[OtherRecord],),
2826                                 (wasmtime::component::__internal::Vec<SomeRecord>,),
2827                             >::new_unchecked(self.record_list_reverse)
2828                         };
2829                         let (ret0,) = callee
2830                             .call_async(store.as_context_mut(), (arg0,))
2831                             .instrument(span.clone())
2832                             .await?;
2833                         Ok(ret0)
2834                     }
call_variant_list<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &[SomeVariant], ) -> wasmtime::Result< wasmtime::component::__internal::Vec<OtherVariant>, > where <S as wasmtime::AsContext>::Data: Send,2835                     pub async fn call_variant_list<S: wasmtime::AsContextMut>(
2836                         &self,
2837                         mut store: S,
2838                         arg0: &[SomeVariant],
2839                     ) -> wasmtime::Result<
2840                         wasmtime::component::__internal::Vec<OtherVariant>,
2841                     >
2842                     where
2843                         <S as wasmtime::AsContext>::Data: Send,
2844                     {
2845                         use tracing::Instrument;
2846                         let span = tracing::span!(
2847                             tracing::Level::TRACE, "wit-bindgen export", module =
2848                             "foo:foo/lists", function = "variant-list",
2849                         );
2850                         let callee = unsafe {
2851                             wasmtime::component::TypedFunc::<
2852                                 (&[SomeVariant],),
2853                                 (wasmtime::component::__internal::Vec<OtherVariant>,),
2854                             >::new_unchecked(self.variant_list)
2855                         };
2856                         let (ret0,) = callee
2857                             .call_async(store.as_context_mut(), (arg0,))
2858                             .instrument(span.clone())
2859                             .await?;
2860                         Ok(ret0)
2861                     }
call_load_store_everything<S: wasmtime::AsContextMut>( &self, mut store: S, arg0: &LoadStoreAllSizes, ) -> wasmtime::Result<LoadStoreAllSizes> where <S as wasmtime::AsContext>::Data: Send,2862                     pub async fn call_load_store_everything<S: wasmtime::AsContextMut>(
2863                         &self,
2864                         mut store: S,
2865                         arg0: &LoadStoreAllSizes,
2866                     ) -> wasmtime::Result<LoadStoreAllSizes>
2867                     where
2868                         <S as wasmtime::AsContext>::Data: Send,
2869                     {
2870                         use tracing::Instrument;
2871                         let span = tracing::span!(
2872                             tracing::Level::TRACE, "wit-bindgen export", module =
2873                             "foo:foo/lists", function = "load-store-everything",
2874                         );
2875                         let callee = unsafe {
2876                             wasmtime::component::TypedFunc::<
2877                                 (&LoadStoreAllSizes,),
2878                                 (LoadStoreAllSizes,),
2879                             >::new_unchecked(self.load_store_everything)
2880                         };
2881                         let (ret0,) = callee
2882                             .call_async(store.as_context_mut(), (arg0,))
2883                             .instrument(span.clone())
2884                             .await?;
2885                         Ok(ret0)
2886                     }
2887                 }
2888             }
2889         }
2890     }
2891 }
2892