1 use {
2     crate::{
3         AsContextMut, ValRaw,
4         store::StoreInner,
5         vm::{VMFuncRef, VMMemoryDefinition, component::ComponentInstance},
6     },
7     anyhow::Result,
8     futures::{FutureExt, stream::FuturesUnordered},
9     std::{boxed::Box, future::Future, mem::MaybeUninit, pin::Pin},
10     wasmtime_environ::component::{
11         RuntimeComponentInstanceIndex, TypeComponentLocalErrorContextTableIndex,
12         TypeFutureTableIndex, TypeStreamTableIndex, TypeTupleIndex,
13     },
14 };
15 
16 pub(crate) use futures_and_streams::ResourcePair;
17 pub use futures_and_streams::{ErrorContext, FutureReader, StreamReader};
18 
19 mod futures_and_streams;
20 
21 /// Represents the result of a concurrent operation.
22 ///
23 /// This is similar to a [`std::future::Future`] except that it represents an
24 /// operation which requires exclusive access to a store in order to make
25 /// progress -- without monopolizing that store for the lifetime of the
26 /// operation.
27 pub struct Promise<T>(Pin<Box<dyn Future<Output = T> + Send + Sync + 'static>>);
28 
29 impl<T: 'static> Promise<T> {
30     /// Map the result of this `Promise` from one value to another.
31     pub fn map<U>(self, fun: impl FnOnce(T) -> U + Send + Sync + 'static) -> Promise<U> {
32         Promise(Box::pin(self.0.map(fun)))
33     }
34 
35     /// Convert this `Promise` to a future which may be `await`ed for its
36     /// result.
37     ///
38     /// The returned future will require exclusive use of the store until it
39     /// completes.  If you need to await more than one `Promise` concurrently,
40     /// use [`PromisesUnordered`].
41     pub async fn get<U: Send>(self, store: impl AsContextMut<Data = U>) -> Result<T> {
42         _ = store;
43         todo!()
44     }
45 
46     /// Convert this `Promise` to a future which may be `await`ed for its
47     /// result.
48     ///
49     /// Unlike [`Self::get`], this does _not_ take a store parameter, meaning
50     /// the returned future will not make progress until and unless the event
51     /// loop for the store it came from is polled.  Thus, this method should
52     /// only be used from within host functions and not from top-level embedder
53     /// code.
54     pub fn into_future(self) -> Pin<Box<dyn Future<Output = T> + Send + Sync + 'static>> {
55         self.0
56     }
57 }
58 
59 /// Represents a collection of zero or more concurrent operations.
60 ///
61 /// Similar to [`futures::stream::FuturesUnordered`], this type supports
62 /// `await`ing more than one [`Promise`]s concurrently.
63 pub struct PromisesUnordered<T>(
64     FuturesUnordered<Pin<Box<dyn Future<Output = T> + Send + Sync + 'static>>>,
65 );
66 
67 impl<T: 'static> PromisesUnordered<T> {
68     /// Create a new `PromisesUnordered` with no entries.
69     pub fn new() -> Self {
70         Self(FuturesUnordered::new())
71     }
72 
73     /// Add the specified [`Promise`] to this collection.
74     pub fn push(&mut self, promise: Promise<T>) {
75         self.0.push(promise.0)
76     }
77 
78     /// Get the next result from this collection, if any.
79     pub async fn next<U: Send>(&mut self, store: impl AsContextMut<Data = U>) -> Result<Option<T>> {
80         _ = store;
81         todo!()
82     }
83 }
84 
85 /// Trait representing component model ABI async intrinsics and fused adapter
86 /// helper functions.
87 pub unsafe trait VMComponentAsyncStore {
88     /// The `backpressure.set` intrinsic.
89     fn backpressure_set(
90         &mut self,
91         caller_instance: RuntimeComponentInstanceIndex,
92         enabled: u32,
93     ) -> Result<()>;
94 
95     /// The `task.return` intrinsic.
96     fn task_return(
97         &mut self,
98         instance: &mut ComponentInstance,
99         ty: TypeTupleIndex,
100         storage: *mut ValRaw,
101         storage_len: usize,
102     ) -> Result<()>;
103 
104     /// The `waitable-set.new` intrinsic.
105     fn waitable_set_new(
106         &mut self,
107         instance: &mut ComponentInstance,
108         caller_instance: RuntimeComponentInstanceIndex,
109     ) -> Result<u32>;
110 
111     /// The `waitable-set.wait` intrinsic.
112     fn waitable_set_wait(
113         &mut self,
114         instance: &mut ComponentInstance,
115         caller_instance: RuntimeComponentInstanceIndex,
116         set: u32,
117         async_: bool,
118         memory: *mut VMMemoryDefinition,
119         payload: u32,
120     ) -> Result<u32>;
121 
122     /// The `waitable-set.poll` intrinsic.
123     fn waitable_set_poll(
124         &mut self,
125         instance: &mut ComponentInstance,
126         caller_instance: RuntimeComponentInstanceIndex,
127         set: u32,
128         async_: bool,
129         memory: *mut VMMemoryDefinition,
130         payload: u32,
131     ) -> Result<u32>;
132 
133     /// The `waitable-set.drop` intrinsic.
134     fn waitable_set_drop(
135         &mut self,
136         instance: &mut ComponentInstance,
137         caller_instance: RuntimeComponentInstanceIndex,
138         set: u32,
139     ) -> Result<()>;
140 
141     /// The `waitable.join` intrinsic.
142     fn waitable_join(
143         &mut self,
144         instance: &mut ComponentInstance,
145         caller_instance: RuntimeComponentInstanceIndex,
146         set: u32,
147         waitable: u32,
148     ) -> Result<()>;
149 
150     /// The `yield` intrinsic.
151     fn yield_(&mut self, instance: &mut ComponentInstance, async_: bool) -> Result<()>;
152 
153     /// The `subtask.drop` intrinsic.
154     fn subtask_drop(
155         &mut self,
156         instance: &mut ComponentInstance,
157         caller_instance: RuntimeComponentInstanceIndex,
158         task_id: u32,
159     ) -> Result<()>;
160 
161     /// A helper function for fused adapter modules involving calls where the
162     /// caller is sync-lowered but the callee is async-lifted.
163     fn sync_enter(
164         &mut self,
165         start: *mut VMFuncRef,
166         return_: *mut VMFuncRef,
167         caller_instance: RuntimeComponentInstanceIndex,
168         task_return_type: TypeTupleIndex,
169         result_count: u32,
170         storage: *mut ValRaw,
171         storage_len: usize,
172     ) -> Result<()>;
173 
174     /// A helper function for fused adapter modules involving calls where the
175     /// caller is sync-lowered but the callee is async-lifted.
176     fn sync_exit(
177         &mut self,
178         instance: &mut ComponentInstance,
179         callback: *mut VMFuncRef,
180         caller_instance: RuntimeComponentInstanceIndex,
181         callee: *mut VMFuncRef,
182         callee_instance: RuntimeComponentInstanceIndex,
183         param_count: u32,
184         storage: *mut MaybeUninit<ValRaw>,
185         storage_len: usize,
186     ) -> Result<()>;
187 
188     /// A helper function for fused adapter modules involving calls where the
189     /// caller is async-lowered.
190     fn async_enter(
191         &mut self,
192         start: *mut VMFuncRef,
193         return_: *mut VMFuncRef,
194         caller_instance: RuntimeComponentInstanceIndex,
195         task_return_type: TypeTupleIndex,
196         params: u32,
197         results: u32,
198     ) -> Result<()>;
199 
200     /// A helper function for fused adapter modules involving calls where the
201     /// caller is async-lowered.
202     fn async_exit(
203         &mut self,
204         instance: &mut ComponentInstance,
205         callback: *mut VMFuncRef,
206         post_return: *mut VMFuncRef,
207         caller_instance: RuntimeComponentInstanceIndex,
208         callee: *mut VMFuncRef,
209         callee_instance: RuntimeComponentInstanceIndex,
210         param_count: u32,
211         result_count: u32,
212         flags: u32,
213     ) -> Result<u32>;
214 
215     /// The `future.new` intrinsic.
216     fn future_new(
217         &mut self,
218         instance: &mut ComponentInstance,
219         ty: TypeFutureTableIndex,
220     ) -> Result<u32>;
221 
222     /// The `future.write` intrinsic.
223     fn future_write(
224         &mut self,
225         instance: &mut ComponentInstance,
226         memory: *mut VMMemoryDefinition,
227         realloc: *mut VMFuncRef,
228         string_encoding: u8,
229         ty: TypeFutureTableIndex,
230         future: u32,
231         address: u32,
232     ) -> Result<u32>;
233 
234     /// The `future.read` intrinsic.
235     fn future_read(
236         &mut self,
237         instance: &mut ComponentInstance,
238         memory: *mut VMMemoryDefinition,
239         realloc: *mut VMFuncRef,
240         string_encoding: u8,
241         ty: TypeFutureTableIndex,
242         future: u32,
243         address: u32,
244     ) -> Result<u32>;
245 
246     /// The `future.cancel-write` intrinsic.
247     fn future_cancel_write(
248         &mut self,
249         instance: &mut ComponentInstance,
250         ty: TypeFutureTableIndex,
251         async_: bool,
252         writer: u32,
253     ) -> Result<u32>;
254 
255     /// The `future.cancel-read` intrinsic.
256     fn future_cancel_read(
257         &mut self,
258         instance: &mut ComponentInstance,
259         ty: TypeFutureTableIndex,
260         async_: bool,
261         reader: u32,
262     ) -> Result<u32>;
263 
264     /// The `future.close-writable` intrinsic.
265     fn future_close_writable(
266         &mut self,
267         instance: &mut ComponentInstance,
268         ty: TypeFutureTableIndex,
269         writer: u32,
270     ) -> Result<()>;
271 
272     /// The `future.close-readable` intrinsic.
273     fn future_close_readable(
274         &mut self,
275         instance: &mut ComponentInstance,
276         ty: TypeFutureTableIndex,
277         reader: u32,
278     ) -> Result<()>;
279 
280     /// The `stream.new` intrinsic.
281     fn stream_new(
282         &mut self,
283         instance: &mut ComponentInstance,
284         ty: TypeStreamTableIndex,
285     ) -> Result<u32>;
286 
287     /// The `stream.write` intrinsic.
288     fn stream_write(
289         &mut self,
290         instance: &mut ComponentInstance,
291         memory: *mut VMMemoryDefinition,
292         realloc: *mut VMFuncRef,
293         string_encoding: u8,
294         ty: TypeStreamTableIndex,
295         stream: u32,
296         address: u32,
297         count: u32,
298     ) -> Result<u32>;
299 
300     /// The `stream.read` intrinsic.
301     fn stream_read(
302         &mut self,
303         instance: &mut ComponentInstance,
304         memory: *mut VMMemoryDefinition,
305         realloc: *mut VMFuncRef,
306         string_encoding: u8,
307         ty: TypeStreamTableIndex,
308         stream: u32,
309         address: u32,
310         count: u32,
311     ) -> Result<u32>;
312 
313     /// The `stream.cancel-write` intrinsic.
314     fn stream_cancel_write(
315         &mut self,
316         instance: &mut ComponentInstance,
317         ty: TypeStreamTableIndex,
318         async_: bool,
319         writer: u32,
320     ) -> Result<u32>;
321 
322     /// The `stream.cancel-read` intrinsic.
323     fn stream_cancel_read(
324         &mut self,
325         instance: &mut ComponentInstance,
326         ty: TypeStreamTableIndex,
327         async_: bool,
328         reader: u32,
329     ) -> Result<u32>;
330 
331     /// The `stream.close-writable` intrinsic.
332     fn stream_close_writable(
333         &mut self,
334         instance: &mut ComponentInstance,
335         ty: TypeStreamTableIndex,
336         writer: u32,
337     ) -> Result<()>;
338 
339     /// The `stream.close-readable` intrinsic.
340     fn stream_close_readable(
341         &mut self,
342         instance: &mut ComponentInstance,
343         ty: TypeStreamTableIndex,
344         reader: u32,
345     ) -> Result<()>;
346 
347     /// The "fast-path" implementation of the `stream.write` intrinsic for
348     /// "flat" (i.e. memcpy-able) payloads.
349     fn flat_stream_write(
350         &mut self,
351         instance: &mut ComponentInstance,
352         memory: *mut VMMemoryDefinition,
353         realloc: *mut VMFuncRef,
354         ty: TypeStreamTableIndex,
355         payload_size: u32,
356         payload_align: u32,
357         stream: u32,
358         address: u32,
359         count: u32,
360     ) -> Result<u32>;
361 
362     /// The "fast-path" implementation of the `stream.read` intrinsic for "flat"
363     /// (i.e. memcpy-able) payloads.
364     fn flat_stream_read(
365         &mut self,
366         instance: &mut ComponentInstance,
367         memory: *mut VMMemoryDefinition,
368         realloc: *mut VMFuncRef,
369         ty: TypeStreamTableIndex,
370         payload_size: u32,
371         payload_align: u32,
372         stream: u32,
373         address: u32,
374         count: u32,
375     ) -> Result<u32>;
376 
377     /// The `error-context.new` intrinsic.
378     fn error_context_new(
379         &mut self,
380         instance: &mut ComponentInstance,
381         memory: *mut VMMemoryDefinition,
382         realloc: *mut VMFuncRef,
383         string_encoding: u8,
384         ty: TypeComponentLocalErrorContextTableIndex,
385         debug_msg_address: u32,
386         debug_msg_len: u32,
387     ) -> Result<u32>;
388 
389     /// The `error-context.debug-message` intrinsic.
390     fn error_context_debug_message(
391         &mut self,
392         instance: &mut ComponentInstance,
393         memory: *mut VMMemoryDefinition,
394         realloc: *mut VMFuncRef,
395         string_encoding: u8,
396         ty: TypeComponentLocalErrorContextTableIndex,
397         err_ctx_handle: u32,
398         debug_msg_address: u32,
399     ) -> Result<()>;
400 
401     /// The `error-context.drop` intrinsic.
402     fn error_context_drop(
403         &mut self,
404         instance: &mut ComponentInstance,
405         ty: TypeComponentLocalErrorContextTableIndex,
406         err_ctx_handle: u32,
407     ) -> Result<()>;
408 }
409 
410 unsafe impl<T> VMComponentAsyncStore for StoreInner<T> {
411     fn backpressure_set(
412         &mut self,
413         caller_instance: RuntimeComponentInstanceIndex,
414         enabled: u32,
415     ) -> Result<()> {
416         _ = (caller_instance, enabled);
417         todo!()
418     }
419 
420     fn task_return(
421         &mut self,
422         instance: &mut ComponentInstance,
423         ty: TypeTupleIndex,
424         storage: *mut ValRaw,
425         storage_len: usize,
426     ) -> Result<()> {
427         _ = (instance, ty, storage, storage_len);
428         todo!()
429     }
430 
431     fn waitable_set_new(
432         &mut self,
433         instance: &mut ComponentInstance,
434         caller_instance: RuntimeComponentInstanceIndex,
435     ) -> Result<u32> {
436         _ = (instance, caller_instance);
437         todo!();
438     }
439 
440     fn waitable_set_wait(
441         &mut self,
442         instance: &mut ComponentInstance,
443         caller_instance: RuntimeComponentInstanceIndex,
444         set: u32,
445         async_: bool,
446         memory: *mut VMMemoryDefinition,
447         payload: u32,
448     ) -> Result<u32> {
449         _ = (instance, caller_instance, set, async_, memory, payload);
450         todo!();
451     }
452 
453     fn waitable_set_poll(
454         &mut self,
455         instance: &mut ComponentInstance,
456         caller_instance: RuntimeComponentInstanceIndex,
457         set: u32,
458         async_: bool,
459         memory: *mut VMMemoryDefinition,
460         payload: u32,
461     ) -> Result<u32> {
462         _ = (instance, caller_instance, set, async_, memory, payload);
463         todo!();
464     }
465 
466     fn waitable_set_drop(
467         &mut self,
468         instance: &mut ComponentInstance,
469         caller_instance: RuntimeComponentInstanceIndex,
470         set: u32,
471     ) -> Result<()> {
472         _ = (instance, caller_instance, set);
473         todo!();
474     }
475 
476     fn waitable_join(
477         &mut self,
478         instance: &mut ComponentInstance,
479         caller_instance: RuntimeComponentInstanceIndex,
480         set: u32,
481         waitable: u32,
482     ) -> Result<()> {
483         _ = (instance, caller_instance, set, waitable);
484         todo!();
485     }
486 
487     fn yield_(&mut self, instance: &mut ComponentInstance, async_: bool) -> Result<()> {
488         _ = (instance, async_);
489         todo!()
490     }
491 
492     fn subtask_drop(
493         &mut self,
494         instance: &mut ComponentInstance,
495         caller_instance: RuntimeComponentInstanceIndex,
496         task_id: u32,
497     ) -> Result<()> {
498         _ = (instance, caller_instance, task_id);
499         todo!()
500     }
501 
502     fn sync_enter(
503         &mut self,
504         start: *mut VMFuncRef,
505         return_: *mut VMFuncRef,
506         caller_instance: RuntimeComponentInstanceIndex,
507         task_return_type: TypeTupleIndex,
508         result_count: u32,
509         storage: *mut ValRaw,
510         storage_len: usize,
511     ) -> Result<()> {
512         _ = (
513             start,
514             return_,
515             caller_instance,
516             task_return_type,
517             result_count,
518             storage,
519             storage_len,
520         );
521         todo!()
522     }
523 
524     fn sync_exit(
525         &mut self,
526         instance: &mut ComponentInstance,
527         callback: *mut VMFuncRef,
528         caller_instance: RuntimeComponentInstanceIndex,
529         callee: *mut VMFuncRef,
530         callee_instance: RuntimeComponentInstanceIndex,
531         param_count: u32,
532         storage: *mut MaybeUninit<ValRaw>,
533         storage_len: usize,
534     ) -> Result<()> {
535         _ = (
536             instance,
537             callback,
538             caller_instance,
539             callee,
540             callee_instance,
541             param_count,
542             storage,
543             storage_len,
544         );
545         todo!()
546     }
547 
548     fn async_enter(
549         &mut self,
550         start: *mut VMFuncRef,
551         return_: *mut VMFuncRef,
552         caller_instance: RuntimeComponentInstanceIndex,
553         task_return_type: TypeTupleIndex,
554         params: u32,
555         results: u32,
556     ) -> Result<()> {
557         _ = (
558             start,
559             return_,
560             caller_instance,
561             task_return_type,
562             params,
563             results,
564         );
565         todo!()
566     }
567 
568     fn async_exit(
569         &mut self,
570         instance: &mut ComponentInstance,
571         callback: *mut VMFuncRef,
572         post_return: *mut VMFuncRef,
573         caller_instance: RuntimeComponentInstanceIndex,
574         callee: *mut VMFuncRef,
575         callee_instance: RuntimeComponentInstanceIndex,
576         param_count: u32,
577         result_count: u32,
578         flags: u32,
579     ) -> Result<u32> {
580         _ = (
581             instance,
582             callback,
583             post_return,
584             caller_instance,
585             callee,
586             callee_instance,
587             param_count,
588             result_count,
589             flags,
590         );
591         todo!()
592     }
593 
594     fn future_new(
595         &mut self,
596         instance: &mut ComponentInstance,
597         ty: TypeFutureTableIndex,
598     ) -> Result<u32> {
599         _ = (instance, ty);
600         todo!()
601     }
602 
603     fn future_write(
604         &mut self,
605         instance: &mut ComponentInstance,
606         memory: *mut VMMemoryDefinition,
607         realloc: *mut VMFuncRef,
608         string_encoding: u8,
609         ty: TypeFutureTableIndex,
610         future: u32,
611         address: u32,
612     ) -> Result<u32> {
613         _ = (
614             instance,
615             memory,
616             realloc,
617             string_encoding,
618             ty,
619             future,
620             address,
621         );
622         todo!()
623     }
624 
625     fn future_read(
626         &mut self,
627         instance: &mut ComponentInstance,
628         memory: *mut VMMemoryDefinition,
629         realloc: *mut VMFuncRef,
630         string_encoding: u8,
631         ty: TypeFutureTableIndex,
632         future: u32,
633         address: u32,
634     ) -> Result<u32> {
635         _ = (
636             instance,
637             memory,
638             realloc,
639             string_encoding,
640             ty,
641             future,
642             address,
643         );
644         todo!()
645     }
646 
647     fn future_cancel_write(
648         &mut self,
649         instance: &mut ComponentInstance,
650         ty: TypeFutureTableIndex,
651         async_: bool,
652         writer: u32,
653     ) -> Result<u32> {
654         _ = (instance, ty, async_, writer);
655         todo!()
656     }
657 
658     fn future_cancel_read(
659         &mut self,
660         instance: &mut ComponentInstance,
661         ty: TypeFutureTableIndex,
662         async_: bool,
663         reader: u32,
664     ) -> Result<u32> {
665         _ = (instance, ty, async_, reader);
666         todo!()
667     }
668 
669     fn future_close_writable(
670         &mut self,
671         instance: &mut ComponentInstance,
672         ty: TypeFutureTableIndex,
673         writer: u32,
674     ) -> Result<()> {
675         _ = (instance, ty, writer);
676         todo!()
677     }
678 
679     fn future_close_readable(
680         &mut self,
681         instance: &mut ComponentInstance,
682         ty: TypeFutureTableIndex,
683         reader: u32,
684     ) -> Result<()> {
685         _ = (instance, ty, reader);
686         todo!()
687     }
688 
689     fn stream_new(
690         &mut self,
691         instance: &mut ComponentInstance,
692         ty: TypeStreamTableIndex,
693     ) -> Result<u32> {
694         _ = (instance, ty);
695         todo!()
696     }
697 
698     fn stream_write(
699         &mut self,
700         instance: &mut ComponentInstance,
701         memory: *mut VMMemoryDefinition,
702         realloc: *mut VMFuncRef,
703         string_encoding: u8,
704         ty: TypeStreamTableIndex,
705         stream: u32,
706         address: u32,
707         count: u32,
708     ) -> Result<u32> {
709         _ = (
710             instance,
711             memory,
712             realloc,
713             string_encoding,
714             ty,
715             stream,
716             address,
717             count,
718         );
719         todo!()
720     }
721 
722     fn stream_read(
723         &mut self,
724         instance: &mut ComponentInstance,
725         memory: *mut VMMemoryDefinition,
726         realloc: *mut VMFuncRef,
727         string_encoding: u8,
728         ty: TypeStreamTableIndex,
729         stream: u32,
730         address: u32,
731         count: u32,
732     ) -> Result<u32> {
733         _ = (
734             instance,
735             memory,
736             realloc,
737             string_encoding,
738             ty,
739             stream,
740             address,
741             count,
742         );
743         todo!()
744     }
745 
746     fn stream_cancel_write(
747         &mut self,
748         instance: &mut ComponentInstance,
749         ty: TypeStreamTableIndex,
750         async_: bool,
751         writer: u32,
752     ) -> Result<u32> {
753         _ = (instance, ty, async_, writer);
754         todo!()
755     }
756 
757     fn stream_cancel_read(
758         &mut self,
759         instance: &mut ComponentInstance,
760         ty: TypeStreamTableIndex,
761         async_: bool,
762         reader: u32,
763     ) -> Result<u32> {
764         _ = (instance, ty, async_, reader);
765         todo!()
766     }
767 
768     fn stream_close_writable(
769         &mut self,
770         instance: &mut ComponentInstance,
771         ty: TypeStreamTableIndex,
772         writer: u32,
773     ) -> Result<()> {
774         _ = (instance, ty, writer);
775         todo!()
776     }
777 
778     fn stream_close_readable(
779         &mut self,
780         instance: &mut ComponentInstance,
781         ty: TypeStreamTableIndex,
782         reader: u32,
783     ) -> Result<()> {
784         _ = (instance, ty, reader);
785         todo!()
786     }
787 
788     fn flat_stream_write(
789         &mut self,
790         instance: &mut ComponentInstance,
791         memory: *mut VMMemoryDefinition,
792         realloc: *mut VMFuncRef,
793         ty: TypeStreamTableIndex,
794         payload_size: u32,
795         payload_align: u32,
796         stream: u32,
797         address: u32,
798         count: u32,
799     ) -> Result<u32> {
800         _ = (
801             instance,
802             memory,
803             realloc,
804             ty,
805             payload_size,
806             payload_align,
807             stream,
808             address,
809             count,
810         );
811         todo!()
812     }
813 
814     fn flat_stream_read(
815         &mut self,
816         instance: &mut ComponentInstance,
817         memory: *mut VMMemoryDefinition,
818         realloc: *mut VMFuncRef,
819         ty: TypeStreamTableIndex,
820         payload_size: u32,
821         payload_align: u32,
822         stream: u32,
823         address: u32,
824         count: u32,
825     ) -> Result<u32> {
826         _ = (
827             instance,
828             memory,
829             realloc,
830             ty,
831             payload_size,
832             payload_align,
833             stream,
834             address,
835             count,
836         );
837         todo!()
838     }
839 
840     fn error_context_new(
841         &mut self,
842         instance: &mut ComponentInstance,
843         memory: *mut VMMemoryDefinition,
844         realloc: *mut VMFuncRef,
845         string_encoding: u8,
846         ty: TypeComponentLocalErrorContextTableIndex,
847         debug_msg_address: u32,
848         debug_msg_len: u32,
849     ) -> Result<u32> {
850         _ = (
851             instance,
852             memory,
853             realloc,
854             string_encoding,
855             ty,
856             debug_msg_address,
857             debug_msg_len,
858         );
859         todo!()
860     }
861 
862     fn error_context_debug_message(
863         &mut self,
864         instance: &mut ComponentInstance,
865         memory: *mut VMMemoryDefinition,
866         realloc: *mut VMFuncRef,
867         string_encoding: u8,
868         ty: TypeComponentLocalErrorContextTableIndex,
869         err_ctx_handle: u32,
870         debug_msg_address: u32,
871     ) -> Result<()> {
872         _ = (
873             instance,
874             memory,
875             realloc,
876             string_encoding,
877             ty,
878             err_ctx_handle,
879             debug_msg_address,
880         );
881         todo!()
882     }
883 
884     fn error_context_drop(
885         &mut self,
886         instance: &mut ComponentInstance,
887         ty: TypeComponentLocalErrorContextTableIndex,
888         err_ctx_handle: u32,
889     ) -> Result<()> {
890         _ = (instance, ty, err_ctx_handle);
891         todo!()
892     }
893 }
894