1 /// Auto-generated bindings for a pre-instantiated version of a
2 /// component which implements the world `imports`.
3 ///
4 /// This structure is created through [`ImportsPre::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 [`Imports`] as well.
9 pub struct ImportsPre<T: 'static> {
10     instance_pre: wasmtime::component::InstancePre<T>,
11     indices: ImportsIndices,
12 }
13 impl<T: 'static> Clone for ImportsPre<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> ImportsPre<_T> {
22     /// Creates a new copy of `ImportsPre` 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 = ImportsIndices::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 [`Imports`] 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<Imports> {
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> ImportsPre<_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<Imports> {
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 /// `imports`.
68 ///
69 /// This is an implementation detail of [`ImportsPre`] and can
70 /// be constructed if needed as well.
71 ///
72 /// For more information see [`Imports`] as well.
73 #[derive(Clone)]
74 pub struct ImportsIndices {}
75 /// Auto-generated bindings for an instance a component which
76 /// implements the world `imports`.
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 ///   [`Imports::instantiate`] which only needs a
83 ///   [`Store`], [`Component`], and [`Linker`].
84 ///
85 /// * Alternatively you can create a [`ImportsPre`] 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 [`ImportsPre::instantiate`] to
89 ///   create a [`Imports`].
90 ///
91 /// * If you've instantiated the instance yourself already
92 ///   then you can use [`Imports::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 Imports {}
101 const _: () = {
102     #[allow(unused_imports)]
103     use wasmtime::component::__internal::anyhow;
104     impl ImportsIndices {
105         /// Creates a new copy of `ImportsIndices` bindings which can then
106         /// be used to instantiate into a particular store.
107         ///
108         /// This method may fail if the component does not have the
109         /// required exports.
110         pub fn new<_T>(
111             _instance_pre: &wasmtime::component::InstancePre<_T>,
112         ) -> wasmtime::Result<Self> {
113             let _component = _instance_pre.component();
114             let _instance_type = _instance_pre.instance_type();
115             Ok(ImportsIndices {})
116         }
117         /// Uses the indices stored in `self` to load an instance
118         /// of [`Imports`] from the instance provided.
119         ///
120         /// Note that at this time this method will additionally
121         /// perform type-checks of all exports.
122         pub fn load(
123             &self,
124             mut store: impl wasmtime::AsContextMut,
125             instance: &wasmtime::component::Instance,
126         ) -> wasmtime::Result<Imports> {
127             let _ = &mut store;
128             let _instance = instance;
129             Ok(Imports {})
130         }
131     }
132     impl Imports {
133         /// Convenience wrapper around [`ImportsPre::new`] and
134         /// [`ImportsPre::instantiate`].
135         pub fn instantiate<_T>(
136             store: impl wasmtime::AsContextMut<Data = _T>,
137             component: &wasmtime::component::Component,
138             linker: &wasmtime::component::Linker<_T>,
139         ) -> wasmtime::Result<Imports> {
140             let pre = linker.instantiate_pre(component)?;
141             ImportsPre::new(pre)?.instantiate(store)
142         }
143         /// Convenience wrapper around [`ImportsIndices::new`] and
144         /// [`ImportsIndices::load`].
145         pub fn new(
146             mut store: impl wasmtime::AsContextMut,
147             instance: &wasmtime::component::Instance,
148         ) -> wasmtime::Result<Imports> {
149             let indices = ImportsIndices::new(&instance.instance_pre(&store))?;
150             indices.load(&mut store, instance)
151         }
152         /// Convenience wrapper around [`ImportsPre::new`] and
153         /// [`ImportsPre::instantiate_async`].
154         pub async fn instantiate_async<_T>(
155             store: impl wasmtime::AsContextMut<Data = _T>,
156             component: &wasmtime::component::Component,
157             linker: &wasmtime::component::Linker<_T>,
158         ) -> wasmtime::Result<Imports>
159         where
160             _T: Send,
161         {
162             let pre = linker.instantiate_pre(component)?;
163             ImportsPre::new(pre)?.instantiate_async(store).await
164         }
165         pub fn add_to_linker<T, D>(
166             linker: &mut wasmtime::component::Linker<T>,
167             host_getter: fn(&mut T) -> D::Data<'_>,
168         ) -> wasmtime::Result<()>
169         where
170             D: a::b::interface_with_live_type::HostWithStore
171                 + a::b::interface_with_dead_type::HostWithStore,
172             for<'a> D::Data<
173                 'a,
174             >: a::b::interface_with_live_type::Host
175                 + a::b::interface_with_dead_type::Host,
176             T: 'static,
177         {
178             a::b::interface_with_live_type::add_to_linker::<T, D>(linker, host_getter)?;
179             a::b::interface_with_dead_type::add_to_linker::<T, D>(linker, host_getter)?;
180             Ok(())
181         }
182     }
183 };
184 pub mod a {
185     pub mod b {
186         #[allow(clippy::all)]
187         pub mod interface_with_live_type {
188             #[allow(unused_imports)]
189             use wasmtime::component::__internal::{anyhow, 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 LiveType {
196                 #[component(name = "a")]
197                 pub a: u32,
198             }
199             impl core::fmt::Debug for LiveType {
200                 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
201                     f.debug_struct("LiveType").field("a", &self.a).finish()
202                 }
203             }
204             const _: () = {
205                 assert!(4 == < LiveType as wasmtime::component::ComponentType >::SIZE32);
206                 assert!(
207                     4 == < LiveType as wasmtime::component::ComponentType >::ALIGN32
208                 );
209             };
210             pub trait HostWithStore: wasmtime::component::HasData {}
211             impl<_T: ?Sized> HostWithStore for _T
212             where
213                 _T: wasmtime::component::HasData,
214             {}
215             pub trait Host {
216                 fn f(&mut self) -> LiveType;
217             }
218             impl<_T: Host + ?Sized> Host for &mut _T {
219                 fn f(&mut self) -> LiveType {
220                     Host::f(*self)
221                 }
222             }
223             pub fn add_to_linker<T, D>(
224                 linker: &mut wasmtime::component::Linker<T>,
225                 host_getter: fn(&mut T) -> D::Data<'_>,
226             ) -> wasmtime::Result<()>
227             where
228                 D: HostWithStore,
229                 for<'a> D::Data<'a>: Host,
230                 T: 'static,
231             {
232                 let mut inst = linker.instance("a:b/interface-with-live-type")?;
233                 inst.func_wrap(
234                     "f",
235                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
236                         let host = &mut host_getter(caller.data_mut());
237                         let r = Host::f(host);
238                         Ok((r,))
239                     },
240                 )?;
241                 Ok(())
242             }
243         }
244         #[allow(clippy::all)]
245         pub mod interface_with_dead_type {
246             #[allow(unused_imports)]
247             use wasmtime::component::__internal::{anyhow, Box};
248             pub type LiveType = super::super::super::a::b::interface_with_live_type::LiveType;
249             const _: () = {
250                 assert!(4 == < LiveType as wasmtime::component::ComponentType >::SIZE32);
251                 assert!(
252                     4 == < LiveType as wasmtime::component::ComponentType >::ALIGN32
253                 );
254             };
255             #[derive(wasmtime::component::ComponentType)]
256             #[derive(wasmtime::component::Lift)]
257             #[derive(wasmtime::component::Lower)]
258             #[component(record)]
259             #[derive(Clone, Copy)]
260             pub struct DeadType {
261                 #[component(name = "a")]
262                 pub a: u32,
263             }
264             impl core::fmt::Debug for DeadType {
265                 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
266                     f.debug_struct("DeadType").field("a", &self.a).finish()
267                 }
268             }
269             const _: () = {
270                 assert!(4 == < DeadType as wasmtime::component::ComponentType >::SIZE32);
271                 assert!(
272                     4 == < DeadType as wasmtime::component::ComponentType >::ALIGN32
273                 );
274             };
275             #[derive(wasmtime::component::ComponentType)]
276             #[derive(wasmtime::component::Lift)]
277             #[derive(wasmtime::component::Lower)]
278             #[component(variant)]
279             #[derive(Clone, Copy)]
280             pub enum V {
281                 #[component(name = "a")]
282                 A(LiveType),
283                 #[component(name = "b")]
284                 B(DeadType),
285             }
286             impl core::fmt::Debug for V {
287                 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
288                     match self {
289                         V::A(e) => f.debug_tuple("V::A").field(e).finish(),
290                         V::B(e) => f.debug_tuple("V::B").field(e).finish(),
291                     }
292                 }
293             }
294             const _: () = {
295                 assert!(8 == < V as wasmtime::component::ComponentType >::SIZE32);
296                 assert!(4 == < V as wasmtime::component::ComponentType >::ALIGN32);
297             };
298             pub trait HostWithStore: wasmtime::component::HasData {}
299             impl<_T: ?Sized> HostWithStore for _T
300             where
301                 _T: wasmtime::component::HasData,
302             {}
303             pub trait Host {}
304             impl<_T: Host + ?Sized> Host for &mut _T {}
305             pub fn add_to_linker<T, D>(
306                 linker: &mut wasmtime::component::Linker<T>,
307                 host_getter: fn(&mut T) -> D::Data<'_>,
308             ) -> wasmtime::Result<()>
309             where
310                 D: HostWithStore,
311                 for<'a> D::Data<'a>: Host,
312                 T: 'static,
313             {
314                 let mut inst = linker.instance("a:b/interface-with-dead-type")?;
315                 Ok(())
316             }
317         }
318     }
319 }
320