1 /// Auto-generated bindings for a pre-instantiated version of a
2 /// component which implements the world `d`.
3 ///
4 /// This structure is created through [`DPre::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 [`D`] as well.
9 pub struct DPre<T: 'static> {
10     instance_pre: wasmtime::component::InstancePre<T>,
11     indices: DIndices,
12 }
13 impl<T: 'static> Clone for DPre<T> {
14     fn clone(&self) -> Self {
15         Self {
16             instance_pre: self.instance_pre.clone(),
17             indices: self.indices.clone(),
18         }
19     }
20 }
21 impl<_T: 'static> DPre<_T> {
22     /// Creates a new copy of `DPre` bindings which can then
23     /// be used to instantiate into a particular store.
24     ///
25     /// This method may fail if the component behind `instance_pre`
26     /// does not have the required exports.
27     pub fn new(
28         instance_pre: wasmtime::component::InstancePre<_T>,
29     ) -> wasmtime::Result<Self> {
30         let indices = DIndices::new(&instance_pre)?;
31         Ok(Self { instance_pre, indices })
32     }
33     pub fn engine(&self) -> &wasmtime::Engine {
34         self.instance_pre.engine()
35     }
36     pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
37         &self.instance_pre
38     }
39     /// Instantiates a new instance of [`D`] within the
40     /// `store` provided.
41     ///
42     /// This function will use `self` as the pre-instantiated
43     /// instance to perform instantiation. Afterwards the preloaded
44     /// indices in `self` are used to lookup all exports on the
45     /// resulting instance.
46     pub fn instantiate(
47         &self,
48         mut store: impl wasmtime::AsContextMut<Data = _T>,
49     ) -> wasmtime::Result<D> {
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> DPre<_T> {
56     /// Same as [`Self::instantiate`], except with `async`.
57     pub async fn instantiate_async(
58         &self,
59         mut store: impl wasmtime::AsContextMut<Data = _T>,
60     ) -> wasmtime::Result<D> {
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 /// `d`.
68 ///
69 /// This is an implementation detail of [`DPre`] and can
70 /// be constructed if needed as well.
71 ///
72 /// For more information see [`D`] as well.
73 #[derive(Clone)]
74 pub struct DIndices {}
75 /// Auto-generated bindings for an instance a component which
76 /// implements the world `d`.
77 ///
78 /// This structure can be created through a number of means
79 /// depending on your requirements and what you have on hand:
80 ///
81 /// * The most convenient way is to use
82 ///   [`D::instantiate`] which only needs a
83 ///   [`Store`], [`Component`], and [`Linker`].
84 ///
85 /// * Alternatively you can create a [`DPre`] ahead of
86 ///   time with a [`Component`] to front-load string lookups
87 ///   of exports once instead of per-instantiation. This
88 ///   method then uses [`DPre::instantiate`] to
89 ///   create a [`D`].
90 ///
91 /// * If you've instantiated the instance yourself already
92 ///   then you can use [`D::new`].
93 ///
94 /// These methods are all equivalent to one another and move
95 /// around the tradeoff of what work is performed when.
96 ///
97 /// [`Store`]: wasmtime::Store
98 /// [`Component`]: wasmtime::component::Component
99 /// [`Linker`]: wasmtime::component::Linker
100 pub struct D {}
101 const _: () = {
102     impl DIndices {
103         /// Creates a new copy of `DIndices` bindings which can then
104         /// be used to instantiate into a particular store.
105         ///
106         /// This method may fail if the component does not have the
107         /// required exports.
108         pub fn new<_T>(
109             _instance_pre: &wasmtime::component::InstancePre<_T>,
110         ) -> wasmtime::Result<Self> {
111             let _component = _instance_pre.component();
112             let _instance_type = _instance_pre.instance_type();
113             Ok(DIndices {})
114         }
115         /// Uses the indices stored in `self` to load an instance
116         /// of [`D`] from the instance provided.
117         ///
118         /// Note that at this time this method will additionally
119         /// perform type-checks of all exports.
120         pub fn load(
121             &self,
122             mut store: impl wasmtime::AsContextMut,
123             instance: &wasmtime::component::Instance,
124         ) -> wasmtime::Result<D> {
125             let _ = &mut store;
126             let _instance = instance;
127             Ok(D {})
128         }
129     }
130     impl D {
131         /// Convenience wrapper around [`DPre::new`] and
132         /// [`DPre::instantiate`].
133         pub fn instantiate<_T>(
134             store: impl wasmtime::AsContextMut<Data = _T>,
135             component: &wasmtime::component::Component,
136             linker: &wasmtime::component::Linker<_T>,
137         ) -> wasmtime::Result<D> {
138             let pre = linker.instantiate_pre(component)?;
139             DPre::new(pre)?.instantiate(store)
140         }
141         /// Convenience wrapper around [`DIndices::new`] and
142         /// [`DIndices::load`].
143         pub fn new(
144             mut store: impl wasmtime::AsContextMut,
145             instance: &wasmtime::component::Instance,
146         ) -> wasmtime::Result<D> {
147             let indices = DIndices::new(&instance.instance_pre(&store))?;
148             indices.load(&mut store, instance)
149         }
150         /// Convenience wrapper around [`DPre::new`] and
151         /// [`DPre::instantiate_async`].
152         pub async fn instantiate_async<_T>(
153             store: impl wasmtime::AsContextMut<Data = _T>,
154             component: &wasmtime::component::Component,
155             linker: &wasmtime::component::Linker<_T>,
156         ) -> wasmtime::Result<D>
157         where
158             _T: Send,
159         {
160             let pre = linker.instantiate_pre(component)?;
161             DPre::new(pre)?.instantiate_async(store).await
162         }
163         pub fn add_to_linker<T, D>(
164             linker: &mut wasmtime::component::Linker<T>,
165             host_getter: fn(&mut T) -> D::Data<'_>,
166         ) -> wasmtime::Result<()>
167         where
168             D: foo::foo::a::HostWithStore + foo::foo::b::HostWithStore
169                 + foo::foo::c::HostWithStore + d::HostWithStore + Send,
170             for<'a> D::Data<
171                 'a,
172             >: foo::foo::a::Host + foo::foo::b::Host + foo::foo::c::Host + d::Host
173                 + Send,
174             T: 'static + Send,
175         {
176             foo::foo::a::add_to_linker::<T, D>(linker, host_getter)?;
177             foo::foo::b::add_to_linker::<T, D>(linker, host_getter)?;
178             foo::foo::c::add_to_linker::<T, D>(linker, host_getter)?;
179             d::add_to_linker::<T, D>(linker, host_getter)?;
180             Ok(())
181         }
182     }
183 };
184 pub mod foo {
185     pub mod foo {
186         #[allow(clippy::all)]
187         pub mod a {
188             #[allow(unused_imports)]
189             use wasmtime::component::__internal::Box;
190             #[derive(wasmtime::component::ComponentType)]
191             #[derive(wasmtime::component::Lift)]
192             #[derive(wasmtime::component::Lower)]
193             #[component(record)]
194             #[derive(Clone, Copy)]
195             pub struct Foo {}
196             impl core::fmt::Debug for Foo {
197                 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
198                     f.debug_struct("Foo").finish()
199                 }
200             }
201             const _: () = {
202                 assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
203                 assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
204             };
205             pub trait HostWithStore: wasmtime::component::HasData + Send {
206                 fn a<T: Send>(
207                     accessor: &wasmtime::component::Accessor<T, Self>,
208                 ) -> impl ::core::future::Future<Output = Foo> + Send;
209             }
210             pub trait Host: Send {}
211             impl<_T: Host + ?Sized + Send> Host for &mut _T {}
212             pub fn add_to_linker<T, D>(
213                 linker: &mut wasmtime::component::Linker<T>,
214                 host_getter: fn(&mut T) -> D::Data<'_>,
215             ) -> wasmtime::Result<()>
216             where
217                 D: HostWithStore,
218                 for<'a> D::Data<'a>: Host,
219                 T: 'static + Send,
220             {
221                 let mut inst = linker.instance("foo:foo/a")?;
222                 inst.func_wrap_concurrent(
223                     "a",
224                     move |caller: &wasmtime::component::Accessor<T>, (): ()| {
225                         wasmtime::component::__internal::Box::pin(async move {
226                             let host = &caller.with_getter(host_getter);
227                             let r = <D as HostWithStore>::a(host).await;
228                             Ok((r,))
229                         })
230                     },
231                 )?;
232                 Ok(())
233             }
234         }
235         #[allow(clippy::all)]
236         pub mod b {
237             #[allow(unused_imports)]
238             use wasmtime::component::__internal::Box;
239             pub type Foo = super::super::super::foo::foo::a::Foo;
240             const _: () = {
241                 assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
242                 assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
243             };
244             pub trait HostWithStore: wasmtime::component::HasData + Send {
245                 fn a<T: Send>(
246                     accessor: &wasmtime::component::Accessor<T, Self>,
247                 ) -> impl ::core::future::Future<Output = Foo> + Send;
248             }
249             pub trait Host: Send {}
250             impl<_T: Host + ?Sized + Send> Host for &mut _T {}
251             pub fn add_to_linker<T, D>(
252                 linker: &mut wasmtime::component::Linker<T>,
253                 host_getter: fn(&mut T) -> D::Data<'_>,
254             ) -> wasmtime::Result<()>
255             where
256                 D: HostWithStore,
257                 for<'a> D::Data<'a>: Host,
258                 T: 'static + Send,
259             {
260                 let mut inst = linker.instance("foo:foo/b")?;
261                 inst.func_wrap_concurrent(
262                     "a",
263                     move |caller: &wasmtime::component::Accessor<T>, (): ()| {
264                         wasmtime::component::__internal::Box::pin(async move {
265                             let host = &caller.with_getter(host_getter);
266                             let r = <D as HostWithStore>::a(host).await;
267                             Ok((r,))
268                         })
269                     },
270                 )?;
271                 Ok(())
272             }
273         }
274         #[allow(clippy::all)]
275         pub mod c {
276             #[allow(unused_imports)]
277             use wasmtime::component::__internal::Box;
278             pub type Foo = super::super::super::foo::foo::b::Foo;
279             const _: () = {
280                 assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
281                 assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
282             };
283             pub trait HostWithStore: wasmtime::component::HasData + Send {
284                 fn a<T: Send>(
285                     accessor: &wasmtime::component::Accessor<T, Self>,
286                 ) -> impl ::core::future::Future<Output = Foo> + Send;
287             }
288             pub trait Host: Send {}
289             impl<_T: Host + ?Sized + Send> Host for &mut _T {}
290             pub fn add_to_linker<T, D>(
291                 linker: &mut wasmtime::component::Linker<T>,
292                 host_getter: fn(&mut T) -> D::Data<'_>,
293             ) -> wasmtime::Result<()>
294             where
295                 D: HostWithStore,
296                 for<'a> D::Data<'a>: Host,
297                 T: 'static + Send,
298             {
299                 let mut inst = linker.instance("foo:foo/c")?;
300                 inst.func_wrap_concurrent(
301                     "a",
302                     move |caller: &wasmtime::component::Accessor<T>, (): ()| {
303                         wasmtime::component::__internal::Box::pin(async move {
304                             let host = &caller.with_getter(host_getter);
305                             let r = <D as HostWithStore>::a(host).await;
306                             Ok((r,))
307                         })
308                     },
309                 )?;
310                 Ok(())
311             }
312         }
313     }
314 }
315 #[allow(clippy::all)]
316 pub mod d {
317     #[allow(unused_imports)]
318     use wasmtime::component::__internal::Box;
319     pub type Foo = super::foo::foo::c::Foo;
320     const _: () = {
321         assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
322         assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
323     };
324     pub trait HostWithStore: wasmtime::component::HasData + Send {
325         fn b<T: Send>(
326             accessor: &wasmtime::component::Accessor<T, Self>,
327         ) -> impl ::core::future::Future<Output = Foo> + Send;
328     }
329     pub trait Host: Send {}
330     impl<_T: Host + ?Sized + Send> Host for &mut _T {}
331     pub fn add_to_linker<T, D>(
332         linker: &mut wasmtime::component::Linker<T>,
333         host_getter: fn(&mut T) -> D::Data<'_>,
334     ) -> wasmtime::Result<()>
335     where
336         D: HostWithStore,
337         for<'a> D::Data<'a>: Host,
338         T: 'static + Send,
339     {
340         let mut inst = linker.instance("d")?;
341         inst.func_wrap_concurrent(
342             "b",
343             move |caller: &wasmtime::component::Accessor<T>, (): ()| {
344                 wasmtime::component::__internal::Box::pin(async move {
345                     let host = &caller.with_getter(host_getter);
346                     let r = <D as HostWithStore>::b(host).await;
347                     Ok((r,))
348                 })
349             },
350         )?;
351         Ok(())
352     }
353 }
354