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 async fn instantiate_async(
47         &self,
48         mut store: impl wasmtime::AsContextMut<Data = _T>,
49     ) -> wasmtime::Result<Imports>
50     where
51         _T: Send,
52     {
53         let mut store = store.as_context_mut();
54         let instance = self.instance_pre.instantiate_async(&mut store).await?;
55         self.indices.load(&mut store, &instance)
56     }
57 }
58 /// Auto-generated bindings for index of the exports of
59 /// `imports`.
60 ///
61 /// This is an implementation detail of [`ImportsPre`] and can
62 /// be constructed if needed as well.
63 ///
64 /// For more information see [`Imports`] as well.
65 #[derive(Clone)]
66 pub struct ImportsIndices {}
67 /// Auto-generated bindings for an instance a component which
68 /// implements the world `imports`.
69 ///
70 /// This structure can be created through a number of means
71 /// depending on your requirements and what you have on hand:
72 ///
73 /// * The most convenient way is to use
74 ///   [`Imports::instantiate_async`] which only needs a
75 ///   [`Store`], [`Component`], and [`Linker`].
76 ///
77 /// * Alternatively you can create a [`ImportsPre`] ahead of
78 ///   time with a [`Component`] to front-load string lookups
79 ///   of exports once instead of per-instantiation. This
80 ///   method then uses [`ImportsPre::instantiate_async`] to
81 ///   create a [`Imports`].
82 ///
83 /// * If you've instantiated the instance yourself already
84 ///   then you can use [`Imports::new`].
85 ///
86 /// These methods are all equivalent to one another and move
87 /// around the tradeoff of what work is performed when.
88 ///
89 /// [`Store`]: wasmtime::Store
90 /// [`Component`]: wasmtime::component::Component
91 /// [`Linker`]: wasmtime::component::Linker
92 pub struct Imports {}
93 const _: () = {
94     #[allow(unused_imports)]
95     use wasmtime::component::__internal::anyhow;
96     impl ImportsIndices {
97         /// Creates a new copy of `ImportsIndices` bindings which can then
98         /// be used to instantiate into a particular store.
99         ///
100         /// This method may fail if the component does not have the
101         /// required exports.
102         pub fn new<_T>(
103             _instance_pre: &wasmtime::component::InstancePre<_T>,
104         ) -> wasmtime::Result<Self> {
105             let _component = _instance_pre.component();
106             let _instance_type = _instance_pre.instance_type();
107             Ok(ImportsIndices {})
108         }
109         /// Uses the indices stored in `self` to load an instance
110         /// of [`Imports`] from the instance provided.
111         ///
112         /// Note that at this time this method will additionally
113         /// perform type-checks of all exports.
114         pub fn load(
115             &self,
116             mut store: impl wasmtime::AsContextMut,
117             instance: &wasmtime::component::Instance,
118         ) -> wasmtime::Result<Imports> {
119             let _ = &mut store;
120             let _instance = instance;
121             Ok(Imports {})
122         }
123     }
124     impl Imports {
125         /// Convenience wrapper around [`ImportsPre::new`] and
126         /// [`ImportsPre::instantiate_async`].
127         pub async fn instantiate_async<_T>(
128             store: impl wasmtime::AsContextMut<Data = _T>,
129             component: &wasmtime::component::Component,
130             linker: &wasmtime::component::Linker<_T>,
131         ) -> wasmtime::Result<Imports>
132         where
133             _T: Send,
134         {
135             let pre = linker.instantiate_pre(component)?;
136             ImportsPre::new(pre)?.instantiate_async(store).await
137         }
138         /// Convenience wrapper around [`ImportsIndices::new`] and
139         /// [`ImportsIndices::load`].
140         pub fn new(
141             mut store: impl wasmtime::AsContextMut,
142             instance: &wasmtime::component::Instance,
143         ) -> wasmtime::Result<Imports> {
144             let indices = ImportsIndices::new(&instance.instance_pre(&store))?;
145             indices.load(&mut store, instance)
146         }
147         pub fn add_to_linker<T, D>(
148             linker: &mut wasmtime::component::Linker<T>,
149             get: fn(&mut T) -> D::Data<'_>,
150         ) -> wasmtime::Result<()>
151         where
152             D: wasmtime::component::HasData,
153             for<'a> D::Data<
154                 'a,
155             >: a::b::interface_with_live_type::Host
156                 + a::b::interface_with_dead_type::Host + Send,
157             T: Send + 'static,
158         {
159             a::b::interface_with_live_type::add_to_linker::<T, D>(linker, get)?;
160             a::b::interface_with_dead_type::add_to_linker::<T, D>(linker, get)?;
161             Ok(())
162         }
163     }
164 };
165 pub mod a {
166     pub mod b {
167         #[allow(clippy::all)]
168         pub mod interface_with_live_type {
169             #[allow(unused_imports)]
170             use wasmtime::component::__internal::{anyhow, Box};
171             #[derive(wasmtime::component::ComponentType)]
172             #[derive(wasmtime::component::Lift)]
173             #[derive(wasmtime::component::Lower)]
174             #[component(record)]
175             #[derive(Clone, Copy)]
176             pub struct LiveType {
177                 #[component(name = "a")]
178                 pub a: u32,
179             }
180             impl core::fmt::Debug for LiveType {
181                 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
182                     f.debug_struct("LiveType").field("a", &self.a).finish()
183                 }
184             }
185             const _: () = {
186                 assert!(4 == < LiveType as wasmtime::component::ComponentType >::SIZE32);
187                 assert!(
188                     4 == < LiveType as wasmtime::component::ComponentType >::ALIGN32
189                 );
190             };
191             #[wasmtime::component::__internal::trait_variant_make(::core::marker::Send)]
192             pub trait Host: Send {
193                 async fn f(&mut self) -> LiveType;
194             }
195             pub fn add_to_linker<T, D>(
196                 linker: &mut wasmtime::component::Linker<T>,
197                 host_getter: fn(&mut T) -> D::Data<'_>,
198             ) -> wasmtime::Result<()>
199             where
200                 D: wasmtime::component::HasData,
201                 for<'a> D::Data<'a>: Host + Send,
202                 T: Send + 'static,
203             {
204                 let mut inst = linker.instance("a:b/interface-with-live-type")?;
205                 inst.func_wrap_async(
206                     "f",
207                     move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
208                         use tracing::Instrument;
209                         let span = tracing::span!(
210                             tracing::Level::TRACE, "wit-bindgen import", module =
211                             "interface-with-live-type", function = "f",
212                         );
213                         wasmtime::component::__internal::Box::new(
214                             async move {
215                                 tracing::event!(tracing::Level::TRACE, "call");
216                                 let host = &mut host_getter(caller.data_mut());
217                                 let r = Host::f(host).await;
218                                 tracing::event!(
219                                     tracing::Level::TRACE, result = tracing::field::debug(& r),
220                                     "return"
221                                 );
222                                 Ok((r,))
223                             }
224                                 .instrument(span),
225                         )
226                     },
227                 )?;
228                 Ok(())
229             }
230             impl<_T: Host + ?Sized + Send> Host for &mut _T {
231                 async fn f(&mut self) -> LiveType {
232                     Host::f(*self).await
233                 }
234             }
235         }
236         #[allow(clippy::all)]
237         pub mod interface_with_dead_type {
238             #[allow(unused_imports)]
239             use wasmtime::component::__internal::{anyhow, Box};
240             pub type LiveType = super::super::super::a::b::interface_with_live_type::LiveType;
241             const _: () = {
242                 assert!(4 == < LiveType as wasmtime::component::ComponentType >::SIZE32);
243                 assert!(
244                     4 == < LiveType as wasmtime::component::ComponentType >::ALIGN32
245                 );
246             };
247             #[derive(wasmtime::component::ComponentType)]
248             #[derive(wasmtime::component::Lift)]
249             #[derive(wasmtime::component::Lower)]
250             #[component(record)]
251             #[derive(Clone, Copy)]
252             pub struct DeadType {
253                 #[component(name = "a")]
254                 pub a: u32,
255             }
256             impl core::fmt::Debug for DeadType {
257                 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
258                     f.debug_struct("DeadType").field("a", &self.a).finish()
259                 }
260             }
261             const _: () = {
262                 assert!(4 == < DeadType as wasmtime::component::ComponentType >::SIZE32);
263                 assert!(
264                     4 == < DeadType as wasmtime::component::ComponentType >::ALIGN32
265                 );
266             };
267             #[derive(wasmtime::component::ComponentType)]
268             #[derive(wasmtime::component::Lift)]
269             #[derive(wasmtime::component::Lower)]
270             #[component(variant)]
271             #[derive(Clone, Copy)]
272             pub enum V {
273                 #[component(name = "a")]
274                 A(LiveType),
275                 #[component(name = "b")]
276                 B(DeadType),
277             }
278             impl core::fmt::Debug for V {
279                 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
280                     match self {
281                         V::A(e) => f.debug_tuple("V::A").field(e).finish(),
282                         V::B(e) => f.debug_tuple("V::B").field(e).finish(),
283                     }
284                 }
285             }
286             const _: () = {
287                 assert!(8 == < V as wasmtime::component::ComponentType >::SIZE32);
288                 assert!(4 == < V as wasmtime::component::ComponentType >::ALIGN32);
289             };
290             #[wasmtime::component::__internal::trait_variant_make(::core::marker::Send)]
291             pub trait Host: Send {}
292             pub fn add_to_linker<T, D>(
293                 linker: &mut wasmtime::component::Linker<T>,
294                 host_getter: fn(&mut T) -> D::Data<'_>,
295             ) -> wasmtime::Result<()>
296             where
297                 D: wasmtime::component::HasData,
298                 for<'a> D::Data<'a>: Host + Send,
299                 T: Send + 'static,
300             {
301                 let mut inst = linker.instance("a:b/interface-with-dead-type")?;
302                 Ok(())
303             }
304             impl<_T: Host + ?Sized + Send> Host for &mut _T {}
305         }
306     }
307 }
308