golem_wasm/
builder.rs

1// Copyright 2024-2025 Golem Cloud
2//
3// Licensed under the Golem Source License v1.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://license.golem.cloud/LICENSE
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use crate::{NodeIndex, Uri, WitNode, WitValue};
16
17pub trait WitValueBuilderExtensions {
18    fn builder() -> WitValueBuilder;
19}
20
21impl WitValueBuilderExtensions for WitValue {
22    fn builder() -> WitValueBuilder {
23        WitValueBuilder::new()
24    }
25}
26
27pub trait NodeBuilder: Sized {
28    type Result;
29
30    fn parent_builder(&mut self) -> &mut WitValueBuilder;
31
32    fn u8(self, value: u8) -> Self::Result;
33    fn u16(self, value: u16) -> Self::Result;
34    fn u32(self, value: u32) -> Self::Result;
35    fn u64(self, value: u64) -> Self::Result;
36
37    fn s8(self, value: i8) -> Self::Result;
38    fn s16(self, value: i16) -> Self::Result;
39    fn s32(self, value: i32) -> Self::Result;
40    fn s64(self, value: i64) -> Self::Result;
41
42    fn f32(self, value: f32) -> Self::Result;
43    fn f64(self, value: f64) -> Self::Result;
44
45    fn char(self, value: char) -> Self::Result;
46    fn bool(self, value: bool) -> Self::Result;
47    fn string(self, value: &str) -> Self::Result;
48    fn enum_value(self, value: u32) -> Self::Result;
49    fn flags(self, values: Vec<bool>) -> Self::Result;
50
51    fn record(self) -> WitValueChildItemsBuilder<Self>;
52    fn variant(self, case_idx: u32) -> WitValueChildBuilder<Self>;
53    fn variant_unit(self, case_idx: u32) -> Self::Result;
54
55    /// An alternative to `variant` and `variant_unit`, easier to use in generated code
56    fn variant_fn(
57        self,
58        case_idx: u32,
59        is_unit: bool,
60        f: impl FnOnce(WitValueChildBuilder<Self>) -> Self,
61    ) -> Self::Result {
62        if is_unit {
63            self.variant_unit(case_idx)
64        } else {
65            f(self.variant(case_idx)).finish()
66        }
67    }
68
69    fn tuple(self) -> WitValueChildItemsBuilder<Self>;
70    fn list(self) -> WitValueChildItemsBuilder<Self>;
71
72    fn list_fn<T>(
73        self,
74        items: &[T],
75        f: impl Fn(&T, WitValueItemBuilder<Self>) -> WitValueChildItemsBuilder<Self>,
76    ) -> Self::Result {
77        let mut builder = self.list();
78        for item in items {
79            builder = f(item, builder.item());
80        }
81        builder.finish()
82    }
83
84    fn option_some(self) -> WitValueChildBuilder<Self>;
85    fn option_none(self) -> Self::Result;
86
87    /// An alternative to `option_some` and `option_none`, easier to use in generated code
88    fn option_fn(
89        self,
90        is_some: bool,
91        f: impl FnOnce(WitValueChildBuilder<Self>) -> Self,
92    ) -> Self::Result {
93        if is_some {
94            f(self.option_some()).finish()
95        } else {
96            self.option_none()
97        }
98    }
99
100    fn result_ok(self) -> WitValueChildBuilder<Self>;
101    fn result_ok_unit(self) -> Self::Result;
102    fn result_err(self) -> WitValueChildBuilder<Self>;
103    fn result_err_unit(self) -> Self::Result;
104
105    /// An alternative to `result_ok`, `result_ok_unit`, `result_err` and `result_err_unit`, easier to use in generated code
106    fn result_fn(
107        self,
108        is_ok: bool,
109        has_ok: bool,
110        has_err: bool,
111        f: impl FnOnce(WitValueChildBuilder<Self>) -> Self,
112    ) -> Self::Result {
113        if is_ok {
114            if has_ok {
115                f(self.result_ok()).finish()
116            } else {
117                self.result_ok_unit()
118            }
119        } else if has_err {
120            f(self.result_err()).finish()
121        } else {
122            self.result_err_unit()
123        }
124    }
125
126    fn handle(self, uri: Uri, handle_value: u64) -> Self::Result;
127
128    fn finish(self) -> Self::Result;
129}
130
131pub struct WitValueBuilder {
132    nodes: Vec<WitNode>,
133}
134
135impl WitValueBuilder {
136    pub(crate) fn new() -> Self {
137        WitValueBuilder { nodes: Vec::new() }
138    }
139
140    fn add(&mut self, node: WitNode) -> NodeIndex {
141        self.nodes.push(node);
142        self.nodes.len() as NodeIndex - 1
143    }
144
145    pub(crate) fn add_u8(&mut self, value: u8) -> NodeIndex {
146        self.add(WitNode::PrimU8(value))
147    }
148
149    pub(crate) fn add_u16(&mut self, value: u16) -> NodeIndex {
150        self.add(WitNode::PrimU16(value))
151    }
152
153    pub(crate) fn add_u32(&mut self, value: u32) -> NodeIndex {
154        self.add(WitNode::PrimU32(value))
155    }
156
157    pub(crate) fn add_u64(&mut self, value: u64) -> NodeIndex {
158        self.add(WitNode::PrimU64(value))
159    }
160
161    pub(crate) fn add_s8(&mut self, value: i8) -> NodeIndex {
162        self.add(WitNode::PrimS8(value))
163    }
164
165    pub(crate) fn add_s16(&mut self, value: i16) -> NodeIndex {
166        self.add(WitNode::PrimS16(value))
167    }
168
169    pub(crate) fn add_s32(&mut self, value: i32) -> NodeIndex {
170        self.add(WitNode::PrimS32(value))
171    }
172
173    pub(crate) fn add_s64(&mut self, value: i64) -> NodeIndex {
174        self.add(WitNode::PrimS64(value))
175    }
176
177    pub(crate) fn add_f32(&mut self, value: f32) -> NodeIndex {
178        self.add(WitNode::PrimFloat32(value))
179    }
180
181    pub(crate) fn add_f64(&mut self, value: f64) -> NodeIndex {
182        self.add(WitNode::PrimFloat64(value))
183    }
184
185    pub(crate) fn add_char(&mut self, value: char) -> NodeIndex {
186        self.add(WitNode::PrimChar(value))
187    }
188
189    pub(crate) fn add_bool(&mut self, value: bool) -> NodeIndex {
190        self.add(WitNode::PrimBool(value))
191    }
192
193    pub(crate) fn add_string(&mut self, value: &str) -> NodeIndex {
194        self.add(WitNode::PrimString(value.to_string()))
195    }
196
197    pub(crate) fn add_record(&mut self) -> NodeIndex {
198        self.add(WitNode::RecordValue(Vec::new()))
199    }
200
201    pub(crate) fn add_variant(&mut self, idx: u32, target_idx: NodeIndex) -> NodeIndex {
202        self.add(WitNode::VariantValue((idx, Some(target_idx))))
203    }
204
205    pub(crate) fn add_variant_unit(&mut self, idx: u32) -> NodeIndex {
206        self.add(WitNode::VariantValue((idx, None)))
207    }
208
209    pub(crate) fn add_enum_value(&mut self, value: u32) -> NodeIndex {
210        self.add(WitNode::EnumValue(value))
211    }
212
213    pub(crate) fn add_flags(&mut self, values: Vec<bool>) -> NodeIndex {
214        self.add(WitNode::FlagsValue(values))
215    }
216
217    pub(crate) fn add_tuple(&mut self) -> NodeIndex {
218        self.add(WitNode::TupleValue(Vec::new()))
219    }
220
221    pub(crate) fn add_list(&mut self) -> NodeIndex {
222        self.add(WitNode::ListValue(Vec::new()))
223    }
224
225    pub(crate) fn add_option_none(&mut self) -> NodeIndex {
226        self.add(WitNode::OptionValue(None))
227    }
228
229    pub(crate) fn add_option_some(&mut self) -> NodeIndex {
230        self.add(WitNode::OptionValue(Some(-1)))
231    }
232
233    pub(crate) fn add_result_ok(&mut self) -> NodeIndex {
234        self.add(WitNode::ResultValue(Ok(Some(-1))))
235    }
236
237    pub(crate) fn add_result_ok_unit(&mut self) -> NodeIndex {
238        self.add(WitNode::ResultValue(Ok(None)))
239    }
240
241    pub(crate) fn add_result_err(&mut self) -> NodeIndex {
242        self.add(WitNode::ResultValue(Err(Some(-1))))
243    }
244
245    pub(crate) fn add_result_err_unit(&mut self) -> NodeIndex {
246        self.add(WitNode::ResultValue(Err(None)))
247    }
248
249    pub(crate) fn add_handle(&mut self, uri: Uri, handle_value: u64) -> NodeIndex {
250        self.add(WitNode::Handle((uri, handle_value)))
251    }
252
253    pub(crate) fn finish_child(&mut self, child: NodeIndex, target_idx: NodeIndex) {
254        match &mut self.nodes[target_idx as usize] {
255            WitNode::OptionValue(ref mut result_item) => match result_item {
256                Some(idx) => *idx = child,
257                None => panic!("finish_child called on None option"),
258            },
259            WitNode::ResultValue(ref mut result_item) => match result_item {
260                Ok(Some(idx)) => *idx = child,
261                Ok(None) => panic!("finish_child called on Ok(None) result"),
262                Err(Some(idx)) => *idx = child,
263                Err(None) => panic!("finish_child called on Err(None) result"),
264            },
265            WitNode::VariantValue((_, ref mut result_item)) => match result_item {
266                Some(idx) => *idx = child,
267                None => panic!("finish_child called on variant with no inner value"),
268            },
269            _ => {
270                panic!(
271                    "finish_child called on a node that is neither an option, result or variant"
272                );
273            }
274        }
275    }
276
277    pub(crate) fn finish_seq(&mut self, items: Vec<NodeIndex>, target_idx: NodeIndex) {
278        match &mut self.nodes[target_idx as usize] {
279            WitNode::RecordValue(ref mut result_items) => {
280                *result_items = items;
281            }
282            WitNode::TupleValue(ref mut result_items) => {
283                *result_items = items;
284            }
285            WitNode::ListValue(ref mut result_items) => {
286                *result_items = items;
287            }
288            _ => {
289                panic!("finish_seq called on a node that is neither a record, list, or tuple");
290            }
291        }
292    }
293
294    pub(crate) fn build(self) -> WitValue {
295        WitValue { nodes: self.nodes }
296    }
297}
298
299impl NodeBuilder for WitValueBuilder {
300    type Result = WitValue;
301
302    fn parent_builder(&mut self) -> &mut WitValueBuilder {
303        self
304    }
305
306    fn u8(mut self, value: u8) -> Self::Result {
307        let _ = self.add_u8(value);
308        self.build()
309    }
310
311    fn u16(mut self, value: u16) -> Self::Result {
312        let _ = self.add_u16(value);
313        self.build()
314    }
315
316    fn u32(mut self, value: u32) -> Self::Result {
317        let _ = self.add_u32(value);
318        self.build()
319    }
320
321    fn u64(mut self, value: u64) -> Self::Result {
322        let _ = self.add_u64(value);
323        self.build()
324    }
325
326    fn s8(mut self, value: i8) -> Self::Result {
327        let _ = self.add_s8(value);
328        self.build()
329    }
330
331    fn s16(mut self, value: i16) -> Self::Result {
332        let _ = self.add_s16(value);
333        self.build()
334    }
335
336    fn s32(mut self, value: i32) -> Self::Result {
337        let _ = self.add_s32(value);
338        self.build()
339    }
340
341    fn s64(mut self, value: i64) -> Self::Result {
342        let _ = self.add_s64(value);
343        self.build()
344    }
345
346    fn f32(mut self, value: f32) -> Self::Result {
347        let _ = self.add_f32(value);
348        self.build()
349    }
350
351    fn f64(mut self, value: f64) -> Self::Result {
352        let _ = self.add_f64(value);
353        self.build()
354    }
355
356    fn char(mut self, value: char) -> Self::Result {
357        let _ = self.add_char(value);
358        self.build()
359    }
360
361    fn bool(mut self, value: bool) -> Self::Result {
362        let _ = self.add_bool(value);
363        self.build()
364    }
365
366    fn string(mut self, value: &str) -> Self::Result {
367        let _ = self.add_string(value);
368        self.build()
369    }
370
371    fn enum_value(mut self, value: u32) -> Self::Result {
372        let _ = self.add_enum_value(value);
373        self.build()
374    }
375
376    fn flags(mut self, values: Vec<bool>) -> Self::Result {
377        let _ = self.add_flags(values);
378        self.build()
379    }
380
381    fn record(mut self) -> WitValueChildItemsBuilder<WitValueBuilder> {
382        let idx = self.add_record();
383        WitValueChildItemsBuilder::new(self, idx)
384    }
385
386    fn variant(mut self, case_idx: u32) -> WitValueChildBuilder<WitValueBuilder> {
387        let variant_idx = self.add_variant(case_idx, -1);
388        WitValueChildBuilder {
389            builder: self,
390            target_idx: variant_idx,
391        }
392    }
393
394    fn variant_unit(mut self, case_idx: u32) -> Self::Result {
395        let _ = self.add_variant_unit(case_idx);
396        self.build()
397    }
398
399    fn tuple(mut self) -> WitValueChildItemsBuilder<WitValueBuilder> {
400        let tuple_idx = self.add_tuple();
401        WitValueChildItemsBuilder::new(self, tuple_idx)
402    }
403
404    fn list(mut self) -> WitValueChildItemsBuilder<WitValueBuilder> {
405        let tuple_idx = self.add_list();
406        WitValueChildItemsBuilder::new(self, tuple_idx)
407    }
408
409    fn option_some(mut self) -> WitValueChildBuilder<Self> {
410        let option_idx = self.add_option_some();
411        WitValueChildBuilder {
412            builder: self,
413            target_idx: option_idx,
414        }
415    }
416
417    fn option_none(mut self) -> Self::Result {
418        let _ = self.add_option_none();
419        self.build()
420    }
421
422    fn result_ok(mut self) -> WitValueChildBuilder<Self> {
423        let result_idx = self.add_result_ok();
424        WitValueChildBuilder {
425            builder: self,
426            target_idx: result_idx,
427        }
428    }
429
430    fn result_ok_unit(mut self) -> Self::Result {
431        let _ = self.add_result_ok_unit();
432        self.build()
433    }
434
435    fn result_err(mut self) -> WitValueChildBuilder<Self> {
436        let result_idx = self.add_result_err();
437        WitValueChildBuilder {
438            builder: self,
439            target_idx: result_idx,
440        }
441    }
442
443    fn result_err_unit(mut self) -> Self::Result {
444        let _ = self.add_result_err_unit();
445        self.build()
446    }
447
448    fn handle(mut self, uri: Uri, handle_value: u64) -> Self::Result {
449        let _ = self.add_handle(uri, handle_value);
450        self.build()
451    }
452
453    fn finish(self) -> Self::Result {
454        self.build()
455    }
456}
457
458pub struct WitValueChildItemsBuilder<ParentBuilder: NodeBuilder> {
459    builder: ParentBuilder,
460    target_idx: NodeIndex,
461    items: Vec<NodeIndex>,
462}
463
464impl<ParentBuilder: NodeBuilder> WitValueChildItemsBuilder<ParentBuilder> {
465    fn new(builder: ParentBuilder, target_idx: NodeIndex) -> Self {
466        Self {
467            builder,
468            target_idx,
469            items: Vec::new(),
470        }
471    }
472
473    fn add_item(&mut self, item_type_index: i32) {
474        self.items.push(item_type_index);
475    }
476
477    pub fn item(self) -> WitValueItemBuilder<ParentBuilder> {
478        WitValueItemBuilder {
479            child_items_builder: self,
480        }
481    }
482
483    pub fn finish(mut self) -> ParentBuilder::Result {
484        self.builder
485            .parent_builder()
486            .finish_seq(self.items, self.target_idx);
487        self.builder.finish()
488    }
489}
490
491pub struct WitValueItemBuilder<ParentBuilder: NodeBuilder> {
492    child_items_builder: WitValueChildItemsBuilder<ParentBuilder>,
493}
494
495impl<ParentBuilder: NodeBuilder> NodeBuilder for WitValueItemBuilder<ParentBuilder> {
496    type Result = WitValueChildItemsBuilder<ParentBuilder>;
497
498    fn parent_builder(&mut self) -> &mut WitValueBuilder {
499        self.child_items_builder.builder.parent_builder()
500    }
501
502    fn u8(mut self, value: u8) -> Self::Result {
503        let item_type_index = self.parent_builder().add_u8(value);
504        self.child_items_builder.add_item(item_type_index);
505        self.child_items_builder
506    }
507
508    fn u16(mut self, value: u16) -> Self::Result {
509        let item_type_index = self.parent_builder().add_u16(value);
510        self.child_items_builder.add_item(item_type_index);
511        self.child_items_builder
512    }
513
514    fn u32(mut self, value: u32) -> Self::Result {
515        let item_type_index = self.parent_builder().add_u32(value);
516        self.child_items_builder.add_item(item_type_index);
517        self.child_items_builder
518    }
519
520    fn u64(mut self, value: u64) -> Self::Result {
521        let item_type_index = self.parent_builder().add_u64(value);
522        self.child_items_builder.add_item(item_type_index);
523        self.child_items_builder
524    }
525
526    fn s8(mut self, value: i8) -> Self::Result {
527        let item_type_index = self.parent_builder().add_s8(value);
528        self.child_items_builder.add_item(item_type_index);
529        self.child_items_builder
530    }
531
532    fn s16(mut self, value: i16) -> Self::Result {
533        let item_type_index = self.parent_builder().add_s16(value);
534        self.child_items_builder.add_item(item_type_index);
535        self.child_items_builder
536    }
537
538    fn s32(mut self, value: i32) -> Self::Result {
539        let item_type_index = self.parent_builder().add_s32(value);
540        self.child_items_builder.add_item(item_type_index);
541        self.child_items_builder
542    }
543
544    fn s64(mut self, value: i64) -> Self::Result {
545        let item_type_index = self.parent_builder().add_s64(value);
546        self.child_items_builder.add_item(item_type_index);
547        self.child_items_builder
548    }
549
550    fn f32(mut self, value: f32) -> Self::Result {
551        let item_type_index = self.parent_builder().add_f32(value);
552        self.child_items_builder.add_item(item_type_index);
553        self.child_items_builder
554    }
555
556    fn f64(mut self, value: f64) -> Self::Result {
557        let item_type_index = self.parent_builder().add_f64(value);
558        self.child_items_builder.add_item(item_type_index);
559        self.child_items_builder
560    }
561
562    fn char(mut self, value: char) -> Self::Result {
563        let item_type_index = self.parent_builder().add_char(value);
564        self.child_items_builder.add_item(item_type_index);
565        self.child_items_builder
566    }
567
568    fn bool(mut self, value: bool) -> Self::Result {
569        let item_type_index = self.parent_builder().add_bool(value);
570        self.child_items_builder.add_item(item_type_index);
571        self.child_items_builder
572    }
573
574    fn string(mut self, value: &str) -> Self::Result {
575        let item_type_index = self.parent_builder().add_string(value);
576        self.child_items_builder.add_item(item_type_index);
577        self.child_items_builder
578    }
579
580    fn enum_value(mut self, value: u32) -> Self::Result {
581        let item_type_index = self.parent_builder().add_enum_value(value);
582        self.child_items_builder.add_item(item_type_index);
583        self.child_items_builder
584    }
585
586    fn flags(mut self, values: Vec<bool>) -> Self::Result {
587        let item_type_index = self.parent_builder().add_flags(values);
588        self.child_items_builder.add_item(item_type_index);
589        self.child_items_builder
590    }
591
592    fn record(mut self) -> WitValueChildItemsBuilder<WitValueItemBuilder<ParentBuilder>> {
593        let target_idx = self.parent_builder().add_record();
594        self.child_items_builder.add_item(target_idx);
595        WitValueChildItemsBuilder::new(self, target_idx)
596    }
597
598    fn variant(
599        mut self,
600        case_idx: u32,
601    ) -> WitValueChildBuilder<WitValueItemBuilder<ParentBuilder>> {
602        let variant_idx = self.parent_builder().add_variant(case_idx, -1);
603        self.child_items_builder.add_item(variant_idx);
604        WitValueChildBuilder {
605            builder: self,
606            target_idx: variant_idx,
607        }
608    }
609
610    fn variant_unit(mut self, case_idx: u32) -> Self::Result {
611        let variant_idx = self.parent_builder().add_variant_unit(case_idx);
612        self.child_items_builder.add_item(variant_idx);
613        self.child_items_builder
614    }
615
616    fn tuple(mut self) -> WitValueChildItemsBuilder<Self> {
617        let target_idx = self.parent_builder().add_tuple();
618        self.child_items_builder.add_item(target_idx);
619        WitValueChildItemsBuilder::new(self, target_idx)
620    }
621
622    fn list(mut self) -> WitValueChildItemsBuilder<Self> {
623        let target_idx = self.parent_builder().add_list();
624        self.child_items_builder.add_item(target_idx);
625        WitValueChildItemsBuilder::new(self, target_idx)
626    }
627
628    fn option_some(mut self) -> WitValueChildBuilder<Self> {
629        let option_idx = self.parent_builder().add_option_some();
630        self.child_items_builder.add_item(option_idx);
631        WitValueChildBuilder {
632            builder: self,
633            target_idx: option_idx,
634        }
635    }
636
637    fn option_none(mut self) -> Self::Result {
638        let option_idx = self.parent_builder().add_option_none();
639        self.child_items_builder.add_item(option_idx);
640        self.child_items_builder
641    }
642
643    fn result_ok(mut self) -> WitValueChildBuilder<Self> {
644        let result_idx = self.parent_builder().add_result_ok();
645        self.child_items_builder.add_item(result_idx);
646        WitValueChildBuilder {
647            builder: self,
648            target_idx: result_idx,
649        }
650    }
651
652    fn result_ok_unit(mut self) -> Self::Result {
653        let result_idx = self.parent_builder().add_result_ok_unit();
654        self.child_items_builder.add_item(result_idx);
655        self.child_items_builder
656    }
657
658    fn result_err(mut self) -> WitValueChildBuilder<Self> {
659        let result_idx = self.parent_builder().add_result_err();
660        self.child_items_builder.add_item(result_idx);
661        WitValueChildBuilder {
662            builder: self,
663            target_idx: result_idx,
664        }
665    }
666
667    fn result_err_unit(mut self) -> Self::Result {
668        let result_idx = self.parent_builder().add_result_err_unit();
669        self.child_items_builder.add_item(result_idx);
670        self.child_items_builder
671    }
672
673    fn handle(mut self, uri: Uri, handle_value: u64) -> Self::Result {
674        let item_type_index = self.parent_builder().add_handle(uri, handle_value);
675        self.child_items_builder.add_item(item_type_index);
676        self.child_items_builder
677    }
678
679    fn finish(self) -> Self::Result {
680        self.child_items_builder
681    }
682}
683
684pub struct WitValueChildBuilder<ParentBuilder: NodeBuilder> {
685    builder: ParentBuilder,
686    target_idx: NodeIndex,
687}
688
689impl<ParentBuilder: NodeBuilder> NodeBuilder for WitValueChildBuilder<ParentBuilder> {
690    type Result = ParentBuilder;
691
692    fn parent_builder(&mut self) -> &mut WitValueBuilder {
693        self.builder.parent_builder()
694    }
695
696    fn u8(mut self, value: u8) -> Self::Result {
697        let child_index = self.parent_builder().add_u8(value);
698        let target_idx = self.target_idx;
699        self.parent_builder().finish_child(child_index, target_idx);
700        self.builder
701    }
702
703    fn u16(mut self, value: u16) -> Self::Result {
704        let child_index = self.parent_builder().add_u16(value);
705        let target_idx = self.target_idx;
706        self.parent_builder().finish_child(child_index, target_idx);
707        self.builder
708    }
709
710    fn u32(mut self, value: u32) -> Self::Result {
711        let child_index = self.parent_builder().add_u32(value);
712        let target_idx = self.target_idx;
713        self.parent_builder().finish_child(child_index, target_idx);
714        self.builder
715    }
716
717    fn u64(mut self, value: u64) -> Self::Result {
718        let child_index = self.parent_builder().add_u64(value);
719        let target_idx = self.target_idx;
720        self.parent_builder().finish_child(child_index, target_idx);
721        self.builder
722    }
723
724    fn s8(mut self, value: i8) -> Self::Result {
725        let child_index = self.parent_builder().add_s8(value);
726        let target_idx = self.target_idx;
727        self.parent_builder().finish_child(child_index, target_idx);
728        self.builder
729    }
730
731    fn s16(mut self, value: i16) -> Self::Result {
732        let child_index = self.parent_builder().add_s16(value);
733        let target_idx = self.target_idx;
734        self.parent_builder().finish_child(child_index, target_idx);
735        self.builder
736    }
737
738    fn s32(mut self, value: i32) -> Self::Result {
739        let child_index = self.parent_builder().add_s32(value);
740        let target_idx = self.target_idx;
741        self.parent_builder().finish_child(child_index, target_idx);
742        self.builder
743    }
744
745    fn s64(mut self, value: i64) -> Self::Result {
746        let child_index = self.parent_builder().add_s64(value);
747        let target_idx = self.target_idx;
748        self.parent_builder().finish_child(child_index, target_idx);
749        self.builder
750    }
751
752    fn f32(mut self, value: f32) -> Self::Result {
753        let child_index = self.parent_builder().add_f32(value);
754        let target_idx = self.target_idx;
755        self.parent_builder().finish_child(child_index, target_idx);
756        self.builder
757    }
758
759    fn f64(mut self, value: f64) -> Self::Result {
760        let child_index = self.parent_builder().add_f64(value);
761        let target_idx = self.target_idx;
762        self.parent_builder().finish_child(child_index, target_idx);
763        self.builder
764    }
765
766    fn char(mut self, value: char) -> Self::Result {
767        let child_index = self.parent_builder().add_char(value);
768        let target_idx = self.target_idx;
769        self.parent_builder().finish_child(child_index, target_idx);
770        self.builder
771    }
772
773    fn bool(mut self, value: bool) -> Self::Result {
774        let child_index = self.parent_builder().add_bool(value);
775        let target_idx = self.target_idx;
776        self.parent_builder().finish_child(child_index, target_idx);
777        self.builder
778    }
779
780    fn string(mut self, value: &str) -> Self::Result {
781        let child_index = self.parent_builder().add_string(value);
782        let target_idx = self.target_idx;
783        self.parent_builder().finish_child(child_index, target_idx);
784        self.builder
785    }
786
787    fn enum_value(mut self, value: u32) -> Self::Result {
788        let child_index = self.parent_builder().add_enum_value(value);
789        let target_idx = self.target_idx;
790        self.parent_builder().finish_child(child_index, target_idx);
791        self.builder
792    }
793
794    fn flags(mut self, values: Vec<bool>) -> Self::Result {
795        let child_index = self.parent_builder().add_flags(values);
796        let target_idx = self.target_idx;
797        self.parent_builder().finish_child(child_index, target_idx);
798        self.builder
799    }
800
801    fn record(mut self) -> WitValueChildItemsBuilder<Self> {
802        let child_index = self.parent_builder().add_record();
803        let target_idx = self.target_idx;
804        self.parent_builder().finish_child(child_index, target_idx);
805        WitValueChildItemsBuilder::new(self, child_index)
806    }
807
808    fn variant(mut self, case_idx: u32) -> WitValueChildBuilder<Self> {
809        let variant_idx = self.parent_builder().add_variant(case_idx, -1);
810        let target_idx = self.target_idx;
811        self.parent_builder().finish_child(variant_idx, target_idx);
812        WitValueChildBuilder {
813            builder: self,
814            target_idx: variant_idx,
815        }
816    }
817
818    fn variant_unit(mut self, case_idx: u32) -> Self::Result {
819        let variant_idx = self.parent_builder().add_variant_unit(case_idx);
820        let target_idx = self.target_idx;
821        self.parent_builder().finish_child(variant_idx, target_idx);
822        self.builder
823    }
824
825    fn tuple(mut self) -> WitValueChildItemsBuilder<Self> {
826        let tuple_idx = self.parent_builder().add_tuple();
827        let target_idx = self.target_idx;
828        self.parent_builder().finish_child(tuple_idx, target_idx);
829        WitValueChildItemsBuilder::new(self, tuple_idx)
830    }
831
832    fn list(mut self) -> WitValueChildItemsBuilder<Self> {
833        let list_idx = self.parent_builder().add_list();
834        let target_idx = self.target_idx;
835        self.parent_builder().finish_child(list_idx, target_idx);
836        WitValueChildItemsBuilder::new(self, list_idx)
837    }
838
839    fn option_some(mut self) -> WitValueChildBuilder<Self> {
840        let option_idx = self.parent_builder().add_option_some();
841        let target_idx = self.target_idx;
842        self.parent_builder().finish_child(option_idx, target_idx);
843        WitValueChildBuilder {
844            builder: self,
845            target_idx: option_idx,
846        }
847    }
848
849    fn option_none(mut self) -> Self::Result {
850        let option_idx = self.parent_builder().add_option_none();
851        let target_idx = self.target_idx;
852        self.parent_builder().finish_child(option_idx, target_idx);
853        self.builder
854    }
855
856    fn result_ok(mut self) -> WitValueChildBuilder<Self> {
857        let result_idx = self.parent_builder().add_result_ok();
858        let target_idx = self.target_idx;
859        self.parent_builder().finish_child(result_idx, target_idx);
860        WitValueChildBuilder {
861            builder: self,
862            target_idx: result_idx,
863        }
864    }
865
866    fn result_ok_unit(mut self) -> Self::Result {
867        let result_idx = self.parent_builder().add_result_ok_unit();
868        let target_idx = self.target_idx;
869        self.parent_builder().finish_child(result_idx, target_idx);
870        self.builder
871    }
872
873    fn result_err(mut self) -> WitValueChildBuilder<Self> {
874        let result_idx = self.parent_builder().add_result_err();
875        let target_idx = self.target_idx;
876        self.parent_builder().finish_child(result_idx, target_idx);
877        WitValueChildBuilder {
878            builder: self,
879            target_idx: result_idx,
880        }
881    }
882
883    fn result_err_unit(mut self) -> Self::Result {
884        let result_idx = self.parent_builder().add_result_err_unit();
885        let target_idx = self.target_idx;
886        self.parent_builder().finish_child(result_idx, target_idx);
887        self.builder
888    }
889
890    fn handle(mut self, uri: Uri, handle_value: u64) -> Self::Result {
891        let child_index = self.parent_builder().add_handle(uri, handle_value);
892        let target_idx = self.target_idx;
893        self.parent_builder().finish_child(child_index, target_idx);
894        self.builder
895    }
896
897    fn finish(self) -> Self::Result {
898        self.builder
899    }
900}
901
902#[cfg(test)]
903mod tests {
904    use test_r::test;
905
906    use crate::{NodeBuilder, Value, WitValue, WitValueBuilderExtensions};
907
908    #[test]
909    fn primitive() {
910        let wit_value = WitValue::builder().u64(11);
911        let value: Value = wit_value.into();
912        assert_eq!(value, Value::U64(11));
913    }
914
915    #[test]
916    fn single_record() {
917        let wit_value = WitValue::builder()
918            .record()
919            .item()
920            .u8(1)
921            .item()
922            .enum_value(2)
923            .item()
924            .flags(vec![true, false, true])
925            .finish();
926        let value: Value = wit_value.into();
927        assert_eq!(
928            value,
929            Value::Record(vec![
930                Value::U8(1),
931                Value::Enum(2),
932                Value::Flags(vec![true, false, true]),
933            ])
934        );
935    }
936
937    #[test]
938    fn deep_record() {
939        let wit_value = WitValue::builder()
940            .record()
941            .item()
942            .list()
943            .item()
944            .record()
945            .item()
946            .s32(10)
947            .item()
948            .s32(-11)
949            .finish()
950            .item()
951            .record()
952            .item()
953            .s32(100)
954            .item()
955            .s32(200)
956            .finish()
957            .finish()
958            .finish();
959        let value: Value = wit_value.into();
960        assert_eq!(
961            value,
962            Value::Record(vec![Value::List(vec![
963                Value::Record(vec![Value::S32(10), Value::S32(-11)]),
964                Value::Record(vec![Value::S32(100), Value::S32(200)]),
965            ]),])
966        );
967    }
968
969    #[test]
970    fn option() {
971        let wit_value = WitValue::builder()
972            .option_some()
973            .option_some()
974            .option_none()
975            .finish()
976            .finish();
977        let value: Value = wit_value.into();
978        assert_eq!(
979            value,
980            Value::Option(Some(Box::new(Value::Option(Some(Box::new(
981                Value::Option(None)
982            ))))))
983        );
984    }
985}
golem_wasm/builder.rs

golem_wasm/
builder.rs
