CoCalc -- integers

GitHub Repository: bytecodealliance/wasmtime
Path: blob/main/crates/component-macro/tests/expanded/integers_async.rs
³⁰⁹² views
1
/// Auto-generated bindings for a pre-instantiated version of a
2
/// component which implements the world `the-world`.
3
///
4
/// This structure is created through [`TheWorldPre::new`] which
5
/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
6
/// has been created through a [`Linker`](wasmtime::component::Linker).
7
///
8
/// For more information see [`TheWorld`] as well.
9
pub struct TheWorldPre<T: 'static> {
10
    instance_pre: wasmtime::component::InstancePre<T>,
11
    indices: TheWorldIndices,
12
}
13
impl<T: 'static> Clone for TheWorldPre<T> {
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> TheWorldPre<_T> {
22
    /// Creates a new copy of `TheWorldPre` bindings which can then
23
    /// be used to instantiate into a particular store.
24
    ///
25
    /// This method may fail if the component behind `instance_pre`
26
    /// does not have the required exports.
27
    pub fn new(
28
        instance_pre: wasmtime::component::InstancePre<_T>,
29
    ) -> wasmtime::Result<Self> {
30
        let indices = TheWorldIndices::new(&instance_pre)?;
31
        Ok(Self { instance_pre, indices })
32
    }
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 [`TheWorld`] within the
40
    /// `store` provided.
41
    ///
42
    /// This function will use `self` as the pre-instantiated
43
    /// instance to perform instantiation. Afterwards the preloaded
44
    /// indices in `self` are used to lookup all exports on the
45
    /// resulting instance.
46
    pub fn instantiate(
47
        &self,
48
        mut store: impl wasmtime::AsContextMut<Data = _T>,
49
    ) -> wasmtime::Result<TheWorld> {
50
        let mut store = store.as_context_mut();
51
        let instance = self.instance_pre.instantiate(&mut store)?;
52
        self.indices.load(&mut store, &instance)
53
    }
54
}
55
impl<_T: Send + 'static> TheWorldPre<_T> {
56
    /// Same as [`Self::instantiate`], except with `async`.
57
    pub async fn instantiate_async(
58
        &self,
59
        mut store: impl wasmtime::AsContextMut<Data = _T>,
60
    ) -> wasmtime::Result<TheWorld> {
61
        let mut store = store.as_context_mut();
62
        let instance = self.instance_pre.instantiate_async(&mut store).await?;
63
        self.indices.load(&mut store, &instance)
64
    }
65
}
66
/// Auto-generated bindings for index of the exports of
67
/// `the-world`.
68
///
69
/// This is an implementation detail of [`TheWorldPre`] and can
70
/// be constructed if needed as well.
71
///
72
/// For more information see [`TheWorld`] as well.
73
#[derive(Clone)]
74
pub struct TheWorldIndices {
75
    interface0: exports::foo::foo::integers::GuestIndices,
76
}
77
/// Auto-generated bindings for an instance a component which
78
/// implements the world `the-world`.
79
///
80
/// This structure can be created through a number of means
81
/// depending on your requirements and what you have on hand:
82
///
83
/// * The most convenient way is to use
84
///   [`TheWorld::instantiate`] which only needs a
85
///   [`Store`], [`Component`], and [`Linker`].
86
///
87
/// * Alternatively you can create a [`TheWorldPre`] ahead of
88
///   time with a [`Component`] to front-load string lookups
89
///   of exports once instead of per-instantiation. This
90
///   method then uses [`TheWorldPre::instantiate`] to
91
///   create a [`TheWorld`].
92
///
93
/// * If you've instantiated the instance yourself already
94
///   then you can use [`TheWorld::new`].
95
///
96
/// These methods are all equivalent to one another and move
97
/// around the tradeoff of what work is performed when.
98
///
99
/// [`Store`]: wasmtime::Store
100
/// [`Component`]: wasmtime::component::Component
101
/// [`Linker`]: wasmtime::component::Linker
102
pub struct TheWorld {
103
    interface0: exports::foo::foo::integers::Guest,
104
}
105
const _: () = {
106
    impl TheWorldIndices {
107
        /// Creates a new copy of `TheWorldIndices` bindings which can then
108
        /// be used to instantiate into a particular store.
109
        ///
110
        /// This method may fail if the component does not have the
111
        /// required exports.
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::integers::GuestIndices::new(
118
                _instance_pre,
119
            )?;
120
            Ok(TheWorldIndices { interface0 })
121
        }
122
        /// Uses the indices stored in `self` to load an instance
123
        /// of [`TheWorld`] from the instance provided.
124
        ///
125
        /// Note that at this time this method will additionally
126
        /// perform type-checks of all exports.
127
        pub fn load(
128
            &self,
129
            mut store: impl wasmtime::AsContextMut,
130
            instance: &wasmtime::component::Instance,
131
        ) -> wasmtime::Result<TheWorld> {
132
            let _ = &mut store;
133
            let _instance = instance;
134
            let interface0 = self.interface0.load(&mut store, &_instance)?;
135
            Ok(TheWorld { interface0 })
136
        }
137
    }
138
    impl TheWorld {
139
        /// Convenience wrapper around [`TheWorldPre::new`] and
140
        /// [`TheWorldPre::instantiate`].
141
        pub fn instantiate<_T>(
142
            store: impl wasmtime::AsContextMut<Data = _T>,
143
            component: &wasmtime::component::Component,
144
            linker: &wasmtime::component::Linker<_T>,
145
        ) -> wasmtime::Result<TheWorld> {
146
            let pre = linker.instantiate_pre(component)?;
147
            TheWorldPre::new(pre)?.instantiate(store)
148
        }
149
        /// Convenience wrapper around [`TheWorldIndices::new`] and
150
        /// [`TheWorldIndices::load`].
151
        pub fn new(
152
            mut store: impl wasmtime::AsContextMut,
153
            instance: &wasmtime::component::Instance,
154
        ) -> wasmtime::Result<TheWorld> {
155
            let indices = TheWorldIndices::new(&instance.instance_pre(&store))?;
156
            indices.load(&mut store, instance)
157
        }
158
        /// Convenience wrapper around [`TheWorldPre::new`] and
159
        /// [`TheWorldPre::instantiate_async`].
160
        pub async fn instantiate_async<_T>(
161
            store: impl wasmtime::AsContextMut<Data = _T>,
162
            component: &wasmtime::component::Component,
163
            linker: &wasmtime::component::Linker<_T>,
164
        ) -> wasmtime::Result<TheWorld>
165
        where
166
            _T: Send,
167
        {
168
            let pre = linker.instantiate_pre(component)?;
169
            TheWorldPre::new(pre)?.instantiate_async(store).await
170
        }
171
        pub fn add_to_linker<T, D>(
172
            linker: &mut wasmtime::component::Linker<T>,
173
            host_getter: fn(&mut T) -> D::Data<'_>,
174
        ) -> wasmtime::Result<()>
175
        where
176
            D: foo::foo::integers::HostWithStore + Send,
177
            for<'a> D::Data<'a>: foo::foo::integers::Host + Send,
178
            T: 'static + Send,
179
        {
180
            foo::foo::integers::add_to_linker::<T, D>(linker, host_getter)?;
181
            Ok(())
182
        }
183
        pub fn foo_foo_integers(&self) -> &exports::foo::foo::integers::Guest {
184
            &self.interface0
185
        }
186
    }
187
};
188
pub mod foo {
189
    pub mod foo {
190
        #[allow(clippy::all)]
191
        pub mod integers {
192
            #[allow(unused_imports)]
193
            use wasmtime::component::__internal::Box;
194
            pub trait HostWithStore: wasmtime::component::HasData + Send {}
195
            impl<_T: ?Sized> HostWithStore for _T
196
            where
197
                _T: wasmtime::component::HasData + Send,
198
            {}
199
            pub trait Host: Send {
200
                fn a1(
201
                    &mut self,
202
                    x: u8,
203
                ) -> impl ::core::future::Future<Output = ()> + Send;
204
                fn a2(
205
                    &mut self,
206
                    x: i8,
207
                ) -> impl ::core::future::Future<Output = ()> + Send;
208
                fn a3(
209
                    &mut self,
210
                    x: u16,
211
                ) -> impl ::core::future::Future<Output = ()> + Send;
212
                fn a4(
213
                    &mut self,
214
                    x: i16,
215
                ) -> impl ::core::future::Future<Output = ()> + Send;
216
                fn a5(
217
                    &mut self,
218
                    x: u32,
219
                ) -> impl ::core::future::Future<Output = ()> + Send;
220
                fn a6(
221
                    &mut self,
222
                    x: i32,
223
                ) -> impl ::core::future::Future<Output = ()> + Send;
224
                fn a7(
225
                    &mut self,
226
                    x: u64,
227
                ) -> impl ::core::future::Future<Output = ()> + Send;
228
                fn a8(
229
                    &mut self,
230
                    x: i64,
231
                ) -> impl ::core::future::Future<Output = ()> + Send;
232
                fn a9(
233
                    &mut self,
234
                    p1: u8,
235
                    p2: i8,
236
                    p3: u16,
237
                    p4: i16,
238
                    p5: u32,
239
                    p6: i32,
240
                    p7: u64,
241
                    p8: i64,
242
                ) -> impl ::core::future::Future<Output = ()> + Send;
243
                fn r1(&mut self) -> impl ::core::future::Future<Output = u8> + Send;
244
                fn r2(&mut self) -> impl ::core::future::Future<Output = i8> + Send;
245
                fn r3(&mut self) -> impl ::core::future::Future<Output = u16> + Send;
246
                fn r4(&mut self) -> impl ::core::future::Future<Output = i16> + Send;
247
                fn r5(&mut self) -> impl ::core::future::Future<Output = u32> + Send;
248
                fn r6(&mut self) -> impl ::core::future::Future<Output = i32> + Send;
249
                fn r7(&mut self) -> impl ::core::future::Future<Output = u64> + Send;
250
                fn r8(&mut self) -> impl ::core::future::Future<Output = i64> + Send;
251
                fn pair_ret(
252
                    &mut self,
253
                ) -> impl ::core::future::Future<Output = (i64, u8)> + Send;
254
            }
255
            impl<_T: Host + ?Sized + Send> Host for &mut _T {
256
                fn a1(
257
                    &mut self,
258
                    x: u8,
259
                ) -> impl ::core::future::Future<Output = ()> + Send {
260
                    async move { Host::a1(*self, x).await }
261
                }
262
                fn a2(
263
                    &mut self,
264
                    x: i8,
265
                ) -> impl ::core::future::Future<Output = ()> + Send {
266
                    async move { Host::a2(*self, x).await }
267
                }
268
                fn a3(
269
                    &mut self,
270
                    x: u16,
271
                ) -> impl ::core::future::Future<Output = ()> + Send {
272
                    async move { Host::a3(*self, x).await }
273
                }
274
                fn a4(
275
                    &mut self,
276
                    x: i16,
277
                ) -> impl ::core::future::Future<Output = ()> + Send {
278
                    async move { Host::a4(*self, x).await }
279
                }
280
                fn a5(
281
                    &mut self,
282
                    x: u32,
283
                ) -> impl ::core::future::Future<Output = ()> + Send {
284
                    async move { Host::a5(*self, x).await }
285
                }
286
                fn a6(
287
                    &mut self,
288
                    x: i32,
289
                ) -> impl ::core::future::Future<Output = ()> + Send {
290
                    async move { Host::a6(*self, x).await }
291
                }
292
                fn a7(
293
                    &mut self,
294
                    x: u64,
295
                ) -> impl ::core::future::Future<Output = ()> + Send {
296
                    async move { Host::a7(*self, x).await }
297
                }
298
                fn a8(
299
                    &mut self,
300
                    x: i64,
301
                ) -> impl ::core::future::Future<Output = ()> + Send {
302
                    async move { Host::a8(*self, x).await }
303
                }
304
                fn a9(
305
                    &mut self,
306
                    p1: u8,
307
                    p2: i8,
308
                    p3: u16,
309
                    p4: i16,
310
                    p5: u32,
311
                    p6: i32,
312
                    p7: u64,
313
                    p8: i64,
314
                ) -> impl ::core::future::Future<Output = ()> + Send {
315
                    async move { Host::a9(*self, p1, p2, p3, p4, p5, p6, p7, p8).await }
316
                }
317
                fn r1(&mut self) -> impl ::core::future::Future<Output = u8> + Send {
318
                    async move { Host::r1(*self).await }
319
                }
320
                fn r2(&mut self) -> impl ::core::future::Future<Output = i8> + Send {
321
                    async move { Host::r2(*self).await }
322
                }
323
                fn r3(&mut self) -> impl ::core::future::Future<Output = u16> + Send {
324
                    async move { Host::r3(*self).await }
325
                }
326
                fn r4(&mut self) -> impl ::core::future::Future<Output = i16> + Send {
327
                    async move { Host::r4(*self).await }
328
                }
329
                fn r5(&mut self) -> impl ::core::future::Future<Output = u32> + Send {
330
                    async move { Host::r5(*self).await }
331
                }
332
                fn r6(&mut self) -> impl ::core::future::Future<Output = i32> + Send {
333
                    async move { Host::r6(*self).await }
334
                }
335
                fn r7(&mut self) -> impl ::core::future::Future<Output = u64> + Send {
336
                    async move { Host::r7(*self).await }
337
                }
338
                fn r8(&mut self) -> impl ::core::future::Future<Output = i64> + Send {
339
                    async move { Host::r8(*self).await }
340
                }
341
                fn pair_ret(
342
                    &mut self,
343
                ) -> impl ::core::future::Future<Output = (i64, u8)> + Send {
344
                    async move { Host::pair_ret(*self).await }
345
                }
346
            }
347
            pub fn add_to_linker<T, D>(
348
                linker: &mut wasmtime::component::Linker<T>,
349
                host_getter: fn(&mut T) -> D::Data<'_>,
350
            ) -> wasmtime::Result<()>
351
            where
352
                D: HostWithStore,
353
                for<'a> D::Data<'a>: Host,
354
                T: 'static + Send,
355
            {
356
                let mut inst = linker.instance("foo:foo/integers")?;
357
                inst.func_wrap_async(
358
                    "a1",
359
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u8,)| {
360
                        wasmtime::component::__internal::Box::new(async move {
361
                            let host = &mut host_getter(caller.data_mut());
362
                            let r = Host::a1(host, arg0).await;
363
                            Ok(r)
364
                        })
365
                    },
366
                )?;
367
                inst.func_wrap_async(
368
                    "a2",
369
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i8,)| {
370
                        wasmtime::component::__internal::Box::new(async move {
371
                            let host = &mut host_getter(caller.data_mut());
372
                            let r = Host::a2(host, arg0).await;
373
                            Ok(r)
374
                        })
375
                    },
376
                )?;
377
                inst.func_wrap_async(
378
                    "a3",
379
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u16,)| {
380
                        wasmtime::component::__internal::Box::new(async move {
381
                            let host = &mut host_getter(caller.data_mut());
382
                            let r = Host::a3(host, arg0).await;
383
                            Ok(r)
384
                        })
385
                    },
386
                )?;
387
                inst.func_wrap_async(
388
                    "a4",
389
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i16,)| {
390
                        wasmtime::component::__internal::Box::new(async move {
391
                            let host = &mut host_getter(caller.data_mut());
392
                            let r = Host::a4(host, arg0).await;
393
                            Ok(r)
394
                        })
395
                    },
396
                )?;
397
                inst.func_wrap_async(
398
                    "a5",
399
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u32,)| {
400
                        wasmtime::component::__internal::Box::new(async move {
401
                            let host = &mut host_getter(caller.data_mut());
402
                            let r = Host::a5(host, arg0).await;
403
                            Ok(r)
404
                        })
405
                    },
406
                )?;
407
                inst.func_wrap_async(
408
                    "a6",
409
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i32,)| {
410
                        wasmtime::component::__internal::Box::new(async move {
411
                            let host = &mut host_getter(caller.data_mut());
412
                            let r = Host::a6(host, arg0).await;
413
                            Ok(r)
414
                        })
415
                    },
416
                )?;
417
                inst.func_wrap_async(
418
                    "a7",
419
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u64,)| {
420
                        wasmtime::component::__internal::Box::new(async move {
421
                            let host = &mut host_getter(caller.data_mut());
422
                            let r = Host::a7(host, arg0).await;
423
                            Ok(r)
424
                        })
425
                    },
426
                )?;
427
                inst.func_wrap_async(
428
                    "a8",
429
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i64,)| {
430
                        wasmtime::component::__internal::Box::new(async move {
431
                            let host = &mut host_getter(caller.data_mut());
432
                            let r = Host::a8(host, arg0).await;
433
                            Ok(r)
434
                        })
435
                    },
436
                )?;
437
                inst.func_wrap_async(
438
                    "a9",
439
                    move |
440
                        mut caller: wasmtime::StoreContextMut<'_, T>,
441
                        (
442
                            arg0,
443
                            arg1,
444
                            arg2,
445
                            arg3,
446
                            arg4,
447
                            arg5,
448
                            arg6,
449
                            arg7,
450
                        ): (u8, i8, u16, i16, u32, i32, u64, i64)|
451
                    {
452
                        wasmtime::component::__internal::Box::new(async move {
453
                            let host = &mut host_getter(caller.data_mut());
454
                            let r = Host::a9(
455
                                    host,
456
                                    arg0,
457
                                    arg1,
458
                                    arg2,
459
                                    arg3,
460
                                    arg4,
461
                                    arg5,
462
                                    arg6,
463
                                    arg7,
464
                                )
465
                                .await;
466
                            Ok(r)
467
                        })
468
                    },
469
                )?;
470
                inst.func_wrap_async(
471
                    "r1",
472
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
473
                        wasmtime::component::__internal::Box::new(async move {
474
                            let host = &mut host_getter(caller.data_mut());
475
                            let r = Host::r1(host).await;
476
                            Ok((r,))
477
                        })
478
                    },
479
                )?;
480
                inst.func_wrap_async(
481
                    "r2",
482
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
483
                        wasmtime::component::__internal::Box::new(async move {
484
                            let host = &mut host_getter(caller.data_mut());
485
                            let r = Host::r2(host).await;
486
                            Ok((r,))
487
                        })
488
                    },
489
                )?;
490
                inst.func_wrap_async(
491
                    "r3",
492
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
493
                        wasmtime::component::__internal::Box::new(async move {
494
                            let host = &mut host_getter(caller.data_mut());
495
                            let r = Host::r3(host).await;
496
                            Ok((r,))
497
                        })
498
                    },
499
                )?;
500
                inst.func_wrap_async(
501
                    "r4",
502
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
503
                        wasmtime::component::__internal::Box::new(async move {
504
                            let host = &mut host_getter(caller.data_mut());
505
                            let r = Host::r4(host).await;
506
                            Ok((r,))
507
                        })
508
                    },
509
                )?;
510
                inst.func_wrap_async(
511
                    "r5",
512
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
513
                        wasmtime::component::__internal::Box::new(async move {
514
                            let host = &mut host_getter(caller.data_mut());
515
                            let r = Host::r5(host).await;
516
                            Ok((r,))
517
                        })
518
                    },
519
                )?;
520
                inst.func_wrap_async(
521
                    "r6",
522
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
523
                        wasmtime::component::__internal::Box::new(async move {
524
                            let host = &mut host_getter(caller.data_mut());
525
                            let r = Host::r6(host).await;
526
                            Ok((r,))
527
                        })
528
                    },
529
                )?;
530
                inst.func_wrap_async(
531
                    "r7",
532
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
533
                        wasmtime::component::__internal::Box::new(async move {
534
                            let host = &mut host_getter(caller.data_mut());
535
                            let r = Host::r7(host).await;
536
                            Ok((r,))
537
                        })
538
                    },
539
                )?;
540
                inst.func_wrap_async(
541
                    "r8",
542
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
543
                        wasmtime::component::__internal::Box::new(async move {
544
                            let host = &mut host_getter(caller.data_mut());
545
                            let r = Host::r8(host).await;
546
                            Ok((r,))
547
                        })
548
                    },
549
                )?;
550
                inst.func_wrap_async(
551
                    "pair-ret",
552
                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
553
                        wasmtime::component::__internal::Box::new(async move {
554
                            let host = &mut host_getter(caller.data_mut());
555
                            let r = Host::pair_ret(host).await;
556
                            Ok((r,))
557
                        })
558
                    },
559
                )?;
560
                Ok(())
561
            }
562
        }
563
    }
564
}
565
pub mod exports {
566
    pub mod foo {
567
        pub mod foo {
568
            #[allow(clippy::all)]
569
            pub mod integers {
570
                #[allow(unused_imports)]
571
                use wasmtime::component::__internal::Box;
572
                #[derive(Clone)]
573
                pub struct Guest {
574
                    a1: wasmtime::component::Func,
575
                    a2: wasmtime::component::Func,
576
                    a3: wasmtime::component::Func,
577
                    a4: wasmtime::component::Func,
578
                    a5: wasmtime::component::Func,
579
                    a6: wasmtime::component::Func,
580
                    a7: wasmtime::component::Func,
581
                    a8: wasmtime::component::Func,
582
                    a9: wasmtime::component::Func,
583
                    r1: wasmtime::component::Func,
584
                    r2: wasmtime::component::Func,
585
                    r3: wasmtime::component::Func,
586
                    r4: wasmtime::component::Func,
587
                    r5: wasmtime::component::Func,
588
                    r6: wasmtime::component::Func,
589
                    r7: wasmtime::component::Func,
590
                    r8: wasmtime::component::Func,
591
                    pair_ret: wasmtime::component::Func,
592
                }
593
                #[derive(Clone)]
594
                pub struct GuestIndices {
595
                    a1: wasmtime::component::ComponentExportIndex,
596
                    a2: wasmtime::component::ComponentExportIndex,
597
                    a3: wasmtime::component::ComponentExportIndex,
598
                    a4: wasmtime::component::ComponentExportIndex,
599
                    a5: wasmtime::component::ComponentExportIndex,
600
                    a6: wasmtime::component::ComponentExportIndex,
601
                    a7: wasmtime::component::ComponentExportIndex,
602
                    a8: wasmtime::component::ComponentExportIndex,
603
                    a9: wasmtime::component::ComponentExportIndex,
604
                    r1: wasmtime::component::ComponentExportIndex,
605
                    r2: wasmtime::component::ComponentExportIndex,
606
                    r3: wasmtime::component::ComponentExportIndex,
607
                    r4: wasmtime::component::ComponentExportIndex,
608
                    r5: wasmtime::component::ComponentExportIndex,
609
                    r6: wasmtime::component::ComponentExportIndex,
610
                    r7: wasmtime::component::ComponentExportIndex,
611
                    r8: wasmtime::component::ComponentExportIndex,
612
                    pair_ret: wasmtime::component::ComponentExportIndex,
613
                }
614
                impl GuestIndices {
615
                    /// Constructor for [`GuestIndices`] which takes a
616
                    /// [`Component`](wasmtime::component::Component) as input and can be executed
617
                    /// before instantiation.
618
                    ///
619
                    /// This constructor can be used to front-load string lookups to find exports
620
                    /// within a component.
621
                    pub fn new<_T>(
622
                        _instance_pre: &wasmtime::component::InstancePre<_T>,
623
                    ) -> wasmtime::Result<GuestIndices> {
624
                        let instance = _instance_pre
625
                            .component()
626
                            .get_export_index(None, "foo:foo/integers")
627
                            .ok_or_else(|| {
628
                                wasmtime::format_err!(
629
                                    "no exported instance named `foo:foo/integers`"
630
                                )
631
                            })?;
632
                        let mut lookup = move |name| {
633
                            _instance_pre
634
                                .component()
635
                                .get_export_index(Some(&instance), name)
636
                                .ok_or_else(|| {
637
                                    wasmtime::format_err!(
638
                                        "instance export `foo:foo/integers` does \
639
                                                    not have export `{name}`"
640
                                    )
641
                                })
642
                        };
643
                        let _ = &mut lookup;
644
                        let a1 = lookup("a1")?;
645
                        let a2 = lookup("a2")?;
646
                        let a3 = lookup("a3")?;
647
                        let a4 = lookup("a4")?;
648
                        let a5 = lookup("a5")?;
649
                        let a6 = lookup("a6")?;
650
                        let a7 = lookup("a7")?;
651
                        let a8 = lookup("a8")?;
652
                        let a9 = lookup("a9")?;
653
                        let r1 = lookup("r1")?;
654
                        let r2 = lookup("r2")?;
655
                        let r3 = lookup("r3")?;
656
                        let r4 = lookup("r4")?;
657
                        let r5 = lookup("r5")?;
658
                        let r6 = lookup("r6")?;
659
                        let r7 = lookup("r7")?;
660
                        let r8 = lookup("r8")?;
661
                        let pair_ret = lookup("pair-ret")?;
662
                        Ok(GuestIndices {
663
                            a1,
664
                            a2,
665
                            a3,
666
                            a4,
667
                            a5,
668
                            a6,
669
                            a7,
670
                            a8,
671
                            a9,
672
                            r1,
673
                            r2,
674
                            r3,
675
                            r4,
676
                            r5,
677
                            r6,
678
                            r7,
679
                            r8,
680
                            pair_ret,
681
                        })
682
                    }
683
                    pub fn load(
684
                        &self,
685
                        mut store: impl wasmtime::AsContextMut,
686
                        instance: &wasmtime::component::Instance,
687
                    ) -> wasmtime::Result<Guest> {
688
                        let _instance = instance;
689
                        let _instance_pre = _instance.instance_pre(&store);
690
                        let _instance_type = _instance_pre.instance_type();
691
                        let mut store = store.as_context_mut();
692
                        let _ = &mut store;
693
                        let a1 = *_instance
694
                            .get_typed_func::<(u8,), ()>(&mut store, &self.a1)?
695
                            .func();
696
                        let a2 = *_instance
697
                            .get_typed_func::<(i8,), ()>(&mut store, &self.a2)?
698
                            .func();
699
                        let a3 = *_instance
700
                            .get_typed_func::<(u16,), ()>(&mut store, &self.a3)?
701
                            .func();
702
                        let a4 = *_instance
703
                            .get_typed_func::<(i16,), ()>(&mut store, &self.a4)?
704
                            .func();
705
                        let a5 = *_instance
706
                            .get_typed_func::<(u32,), ()>(&mut store, &self.a5)?
707
                            .func();
708
                        let a6 = *_instance
709
                            .get_typed_func::<(i32,), ()>(&mut store, &self.a6)?
710
                            .func();
711
                        let a7 = *_instance
712
                            .get_typed_func::<(u64,), ()>(&mut store, &self.a7)?
713
                            .func();
714
                        let a8 = *_instance
715
                            .get_typed_func::<(i64,), ()>(&mut store, &self.a8)?
716
                            .func();
717
                        let a9 = *_instance
718
                            .get_typed_func::<
719
                                (u8, i8, u16, i16, u32, i32, u64, i64),
720
                                (),
721
                            >(&mut store, &self.a9)?
722
                            .func();
723
                        let r1 = *_instance
724
                            .get_typed_func::<(), (u8,)>(&mut store, &self.r1)?
725
                            .func();
726
                        let r2 = *_instance
727
                            .get_typed_func::<(), (i8,)>(&mut store, &self.r2)?
728
                            .func();
729
                        let r3 = *_instance
730
                            .get_typed_func::<(), (u16,)>(&mut store, &self.r3)?
731
                            .func();
732
                        let r4 = *_instance
733
                            .get_typed_func::<(), (i16,)>(&mut store, &self.r4)?
734
                            .func();
735
                        let r5 = *_instance
736
                            .get_typed_func::<(), (u32,)>(&mut store, &self.r5)?
737
                            .func();
738
                        let r6 = *_instance
739
                            .get_typed_func::<(), (i32,)>(&mut store, &self.r6)?
740
                            .func();
741
                        let r7 = *_instance
742
                            .get_typed_func::<(), (u64,)>(&mut store, &self.r7)?
743
                            .func();
744
                        let r8 = *_instance
745
                            .get_typed_func::<(), (i64,)>(&mut store, &self.r8)?
746
                            .func();
747
                        let pair_ret = *_instance
748
                            .get_typed_func::<
749
                                (),
750
                                ((i64, u8),),
751
                            >(&mut store, &self.pair_ret)?
752
                            .func();
753
                        Ok(Guest {
754
                            a1,
755
                            a2,
756
                            a3,
757
                            a4,
758
                            a5,
759
                            a6,
760
                            a7,
761
                            a8,
762
                            a9,
763
                            r1,
764
                            r2,
765
                            r3,
766
                            r4,
767
                            r5,
768
                            r6,
769
                            r7,
770
                            r8,
771
                            pair_ret,
772
                        })
773
                    }
774
                }
775
                impl Guest {
776
                    pub async fn call_a1<S: wasmtime::AsContextMut>(
777
                        &self,
778
                        mut store: S,
779
                        arg0: u8,
780
                    ) -> wasmtime::Result<()>
781
                    where
782
                        <S as wasmtime::AsContext>::Data: Send,
783
                    {
784
                        let callee = unsafe {
785
                            wasmtime::component::TypedFunc::<
786
                                (u8,),
787
                                (),
788
                            >::new_unchecked(self.a1)
789
                        };
790
                        let () = callee
791
                            .call_async(store.as_context_mut(), (arg0,))
792
                            .await?;
793
                        Ok(())
794
                    }
795
                    pub async fn call_a2<S: wasmtime::AsContextMut>(
796
                        &self,
797
                        mut store: S,
798
                        arg0: i8,
799
                    ) -> wasmtime::Result<()>
800
                    where
801
                        <S as wasmtime::AsContext>::Data: Send,
802
                    {
803
                        let callee = unsafe {
804
                            wasmtime::component::TypedFunc::<
805
                                (i8,),
806
                                (),
807
                            >::new_unchecked(self.a2)
808
                        };
809
                        let () = callee
810
                            .call_async(store.as_context_mut(), (arg0,))
811
                            .await?;
812
                        Ok(())
813
                    }
814
                    pub async fn call_a3<S: wasmtime::AsContextMut>(
815
                        &self,
816
                        mut store: S,
817
                        arg0: u16,
818
                    ) -> wasmtime::Result<()>
819
                    where
820
                        <S as wasmtime::AsContext>::Data: Send,
821
                    {
822
                        let callee = unsafe {
823
                            wasmtime::component::TypedFunc::<
824
                                (u16,),
825
                                (),
826
                            >::new_unchecked(self.a3)
827
                        };
828
                        let () = callee
829
                            .call_async(store.as_context_mut(), (arg0,))
830
                            .await?;
831
                        Ok(())
832
                    }
833
                    pub async fn call_a4<S: wasmtime::AsContextMut>(
834
                        &self,
835
                        mut store: S,
836
                        arg0: i16,
837
                    ) -> wasmtime::Result<()>
838
                    where
839
                        <S as wasmtime::AsContext>::Data: Send,
840
                    {
841
                        let callee = unsafe {
842
                            wasmtime::component::TypedFunc::<
843
                                (i16,),
844
                                (),
845
                            >::new_unchecked(self.a4)
846
                        };
847
                        let () = callee
848
                            .call_async(store.as_context_mut(), (arg0,))
849
                            .await?;
850
                        Ok(())
851
                    }
852
                    pub async fn call_a5<S: wasmtime::AsContextMut>(
853
                        &self,
854
                        mut store: S,
855
                        arg0: u32,
856
                    ) -> wasmtime::Result<()>
857
                    where
858
                        <S as wasmtime::AsContext>::Data: Send,
859
                    {
860
                        let callee = unsafe {
861
                            wasmtime::component::TypedFunc::<
862
                                (u32,),
863
                                (),
864
                            >::new_unchecked(self.a5)
865
                        };
866
                        let () = callee
867
                            .call_async(store.as_context_mut(), (arg0,))
868
                            .await?;
869
                        Ok(())
870
                    }
871
                    pub async fn call_a6<S: wasmtime::AsContextMut>(
872
                        &self,
873
                        mut store: S,
874
                        arg0: i32,
875
                    ) -> wasmtime::Result<()>
876
                    where
877
                        <S as wasmtime::AsContext>::Data: Send,
878
                    {
879
                        let callee = unsafe {
880
                            wasmtime::component::TypedFunc::<
881
                                (i32,),
882
                                (),
883
                            >::new_unchecked(self.a6)
884
                        };
885
                        let () = callee
886
                            .call_async(store.as_context_mut(), (arg0,))
887
                            .await?;
888
                        Ok(())
889
                    }
890
                    pub async fn call_a7<S: wasmtime::AsContextMut>(
891
                        &self,
892
                        mut store: S,
893
                        arg0: u64,
894
                    ) -> wasmtime::Result<()>
895
                    where
896
                        <S as wasmtime::AsContext>::Data: Send,
897
                    {
898
                        let callee = unsafe {
899
                            wasmtime::component::TypedFunc::<
900
                                (u64,),
901
                                (),
902
                            >::new_unchecked(self.a7)
903
                        };
904
                        let () = callee
905
                            .call_async(store.as_context_mut(), (arg0,))
906
                            .await?;
907
                        Ok(())
908
                    }
909
                    pub async fn call_a8<S: wasmtime::AsContextMut>(
910
                        &self,
911
                        mut store: S,
912
                        arg0: i64,
913
                    ) -> wasmtime::Result<()>
914
                    where
915
                        <S as wasmtime::AsContext>::Data: Send,
916
                    {
917
                        let callee = unsafe {
918
                            wasmtime::component::TypedFunc::<
919
                                (i64,),
920
                                (),
921
                            >::new_unchecked(self.a8)
922
                        };
923
                        let () = callee
924
                            .call_async(store.as_context_mut(), (arg0,))
925
                            .await?;
926
                        Ok(())
927
                    }
928
                    pub async fn call_a9<S: wasmtime::AsContextMut>(
929
                        &self,
930
                        mut store: S,
931
                        arg0: u8,
932
                        arg1: i8,
933
                        arg2: u16,
934
                        arg3: i16,
935
                        arg4: u32,
936
                        arg5: i32,
937
                        arg6: u64,
938
                        arg7: i64,
939
                    ) -> wasmtime::Result<()>
940
                    where
941
                        <S as wasmtime::AsContext>::Data: Send,
942
                    {
943
                        let callee = unsafe {
944
                            wasmtime::component::TypedFunc::<
945
                                (u8, i8, u16, i16, u32, i32, u64, i64),
946
                                (),
947
                            >::new_unchecked(self.a9)
948
                        };
949
                        let () = callee
950
                            .call_async(
951
                                store.as_context_mut(),
952
                                (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7),
953
                            )
954
                            .await?;
955
                        Ok(())
956
                    }
957
                    pub async fn call_r1<S: wasmtime::AsContextMut>(
958
                        &self,
959
                        mut store: S,
960
                    ) -> wasmtime::Result<u8>
961
                    where
962
                        <S as wasmtime::AsContext>::Data: Send,
963
                    {
964
                        let callee = unsafe {
965
                            wasmtime::component::TypedFunc::<
966
                                (),
967
                                (u8,),
968
                            >::new_unchecked(self.r1)
969
                        };
970
                        let (ret0,) = callee
971
                            .call_async(store.as_context_mut(), ())
972
                            .await?;
973
                        Ok(ret0)
974
                    }
975
                    pub async fn call_r2<S: wasmtime::AsContextMut>(
976
                        &self,
977
                        mut store: S,
978
                    ) -> wasmtime::Result<i8>
979
                    where
980
                        <S as wasmtime::AsContext>::Data: Send,
981
                    {
982
                        let callee = unsafe {
983
                            wasmtime::component::TypedFunc::<
984
                                (),
985
                                (i8,),
986
                            >::new_unchecked(self.r2)
987
                        };
988
                        let (ret0,) = callee
989
                            .call_async(store.as_context_mut(), ())
990
                            .await?;
991
                        Ok(ret0)
992
                    }
993
                    pub async fn call_r3<S: wasmtime::AsContextMut>(
994
                        &self,
995
                        mut store: S,
996
                    ) -> wasmtime::Result<u16>
997
                    where
998
                        <S as wasmtime::AsContext>::Data: Send,
999
                    {
1000
                        let callee = unsafe {
1001
                            wasmtime::component::TypedFunc::<
1002
                                (),
1003
                                (u16,),
1004
                            >::new_unchecked(self.r3)
1005
                        };
1006
                        let (ret0,) = callee
1007
                            .call_async(store.as_context_mut(), ())
1008
                            .await?;
1009
                        Ok(ret0)
1010
                    }
1011
                    pub async fn call_r4<S: wasmtime::AsContextMut>(
1012
                        &self,
1013
                        mut store: S,
1014
                    ) -> wasmtime::Result<i16>
1015
                    where
1016
                        <S as wasmtime::AsContext>::Data: Send,
1017
                    {
1018
                        let callee = unsafe {
1019
                            wasmtime::component::TypedFunc::<
1020
                                (),
1021
                                (i16,),
1022
                            >::new_unchecked(self.r4)
1023
                        };
1024
                        let (ret0,) = callee
1025
                            .call_async(store.as_context_mut(), ())
1026
                            .await?;
1027
                        Ok(ret0)
1028
                    }
1029
                    pub async fn call_r5<S: wasmtime::AsContextMut>(
1030
                        &self,
1031
                        mut store: S,
1032
                    ) -> wasmtime::Result<u32>
1033
                    where
1034
                        <S as wasmtime::AsContext>::Data: Send,
1035
                    {
1036
                        let callee = unsafe {
1037
                            wasmtime::component::TypedFunc::<
1038
                                (),
1039
                                (u32,),
1040
                            >::new_unchecked(self.r5)
1041
                        };
1042
                        let (ret0,) = callee
1043
                            .call_async(store.as_context_mut(), ())
1044
                            .await?;
1045
                        Ok(ret0)
1046
                    }
1047
                    pub async fn call_r6<S: wasmtime::AsContextMut>(
1048
                        &self,
1049
                        mut store: S,
1050
                    ) -> wasmtime::Result<i32>
1051
                    where
1052
                        <S as wasmtime::AsContext>::Data: Send,
1053
                    {
1054
                        let callee = unsafe {
1055
                            wasmtime::component::TypedFunc::<
1056
                                (),
1057
                                (i32,),
1058
                            >::new_unchecked(self.r6)
1059
                        };
1060
                        let (ret0,) = callee
1061
                            .call_async(store.as_context_mut(), ())
1062
                            .await?;
1063
                        Ok(ret0)
1064
                    }
1065
                    pub async fn call_r7<S: wasmtime::AsContextMut>(
1066
                        &self,
1067
                        mut store: S,
1068
                    ) -> wasmtime::Result<u64>
1069
                    where
1070
                        <S as wasmtime::AsContext>::Data: Send,
1071
                    {
1072
                        let callee = unsafe {
1073
                            wasmtime::component::TypedFunc::<
1074
                                (),
1075
                                (u64,),
1076
                            >::new_unchecked(self.r7)
1077
                        };
1078
                        let (ret0,) = callee
1079
                            .call_async(store.as_context_mut(), ())
1080
                            .await?;
1081
                        Ok(ret0)
1082
                    }
1083
                    pub async fn call_r8<S: wasmtime::AsContextMut>(
1084
                        &self,
1085
                        mut store: S,
1086
                    ) -> wasmtime::Result<i64>
1087
                    where
1088
                        <S as wasmtime::AsContext>::Data: Send,
1089
                    {
1090
                        let callee = unsafe {
1091
                            wasmtime::component::TypedFunc::<
1092
                                (),
1093
                                (i64,),
1094
                            >::new_unchecked(self.r8)
1095
                        };
1096
                        let (ret0,) = callee
1097
                            .call_async(store.as_context_mut(), ())
1098
                            .await?;
1099
                        Ok(ret0)
1100
                    }
1101
                    pub async fn call_pair_ret<S: wasmtime::AsContextMut>(
1102
                        &self,
1103
                        mut store: S,
1104
                    ) -> wasmtime::Result<(i64, u8)>
1105
                    where
1106
                        <S as wasmtime::AsContext>::Data: Send,
1107
                    {
1108
                        let callee = unsafe {
1109
                            wasmtime::component::TypedFunc::<
1110
                                (),
1111
                                ((i64, u8),),
1112
                            >::new_unchecked(self.pair_ret)
1113
                        };
1114
                        let (ret0,) = callee
1115
                            .call_async(store.as_context_mut(), ())
1116
                            .await?;
1117
                        Ok(ret0)
1118
                    }
1119
                }
1120
            }
1121
        }
1122
    }
1123
}
1124

1125
Product

Resources

Company
