Skip to main content

vibe/cbor_ast/
encode.rs

1//! Encode Program to CBOR-LD.
2
3use super::codec::CborEncoder;
4use super::TAG_VIBE_AST;
5use crate::ast::*;
6use crate::span::Span;
7
8/// Encodes CBOR.
9pub fn encode(program: &Program) -> Vec<u8> {
10    let mut enc = CborEncoder::new();
11    enc.tag(TAG_VIBE_AST);
12    encode_program(&mut enc, program);
13    enc.finish()
14}
15
16// ── Encode ─────────────────────────────────────────────────────────────────
17
18fn encode_program(enc: &mut CborEncoder, p: &Program) {
19    enc.map(8);
20    enc.str("type");
21    enc.str("Program");
22    enc.str("span");
23    encode_span(enc, p.span);
24    enc.str("module");
25    encode_opt_module(enc, &p.module);
26    enc.str("imports");
27    encode_imports(enc, &p.imports);
28    enc.str("prefixes");
29    encode_prefixes(enc, &p.prefixes);
30    enc.str("locales");
31    encode_locales(enc, &p.locales);
32    enc.str("requires");
33    encode_caps(enc, &p.requires);
34    enc.str("items");
35    encode_items(enc, &p.items);
36}
37
38fn encode_locales(enc: &mut CborEncoder, locales: &[LocaleDecl]) {
39    enc.array(locales.len() as u64);
40    for loc in locales {
41        enc.map(2);
42        enc.str("code");
43        enc.str(&loc.code);
44        enc.str("span");
45        encode_span(enc, loc.span);
46    }
47}
48
49fn encode_opt_module(enc: &mut CborEncoder, m: &Option<ModuleDecl>) {
50    match m {
51        Some(m) => {
52            enc.map(2);
53            enc.str("name");
54            encode_name(enc, &m.name);
55            enc.str("span");
56            encode_span(enc, m.span);
57        }
58        None => enc.null(),
59    }
60}
61
62fn encode_name(enc: &mut CborEncoder, n: &Name) {
63    match n {
64        Name::Ident(s) => {
65            enc.map(1);
66            enc.str("Ident");
67            enc.str(s);
68        }
69        Name::Iri(s) => {
70            enc.map(1);
71            enc.str("Iri");
72            enc.str(s);
73        }
74    }
75}
76
77fn encode_imports(enc: &mut CborEncoder, imports: &[ImportDecl]) {
78    enc.array(imports.len() as u64);
79    for imp in imports {
80        enc.map(3);
81        enc.str("path");
82        enc.str(&imp.path);
83        enc.str("alias");
84        match &imp.alias {
85            Some(a) => enc.str(a),
86            None => enc.null(),
87        };
88        enc.str("span");
89        encode_span(enc, imp.span);
90    }
91}
92
93fn encode_prefixes(enc: &mut CborEncoder, prefixes: &[PrefixDecl]) {
94    enc.array(prefixes.len() as u64);
95    for pre in prefixes {
96        enc.map(3);
97        enc.str("prefix");
98        enc.str(&pre.prefix);
99        enc.str("iri");
100        enc.str(&pre.iri);
101        enc.str("span");
102        encode_span(enc, pre.span);
103    }
104}
105
106fn encode_caps(enc: &mut CborEncoder, caps: &[CapSpec]) {
107    enc.array(caps.len() as u64);
108    for cap in caps {
109        enc.map(3);
110        enc.str("id");
111        enc.str(&cap.id);
112        enc.str("args");
113        encode_named_args(enc, &cap.args);
114        enc.str("span");
115        encode_span(enc, cap.span);
116    }
117}
118
119fn encode_named_args(enc: &mut CborEncoder, args: &[NamedArg]) {
120    enc.array(args.len() as u64);
121    for arg in args {
122        enc.map(3);
123        enc.str("name");
124        enc.str(&arg.name);
125        enc.str("value");
126        encode_expr(enc, &arg.value);
127        enc.str("span");
128        encode_span(enc, arg.span);
129    }
130}
131
132fn encode_items(enc: &mut CborEncoder, items: &[Item]) {
133    enc.array(items.len() as u64);
134    for item in items {
135        encode_item(enc, item);
136    }
137}
138fn encode_item(enc: &mut CborEncoder, item: &Item) {
139    match item {
140        Item::Function(f) => {
141            enc.map(8);
142            enc.str("type");
143            enc.str("Function");
144            enc.str("name");
145            enc.str(&f.name);
146            enc.str("effect");
147            encode_effect(enc, &f.effect);
148            enc.str("async");
149            enc.bool(f.is_async);
150            enc.str("params");
151            encode_params(enc, &f.params);
152            enc.str("budget");
153            encode_named_args(enc, &f.budget);
154            enc.str("ret");
155            match &f.ret {
156                Some(t) => encode_type_expr(enc, t),
157                None => enc.null(),
158            };
159            enc.str("body");
160            encode_block(enc, &f.body);
161        }
162        Item::Hook(h) => {
163            enc.map(7);
164            enc.str("type");
165            enc.str("Hook");
166            enc.str("span");
167            encode_span(enc, h.span);
168            enc.str("path");
169            encode_str_list(enc, &h.path);
170            enc.str("params");
171            encode_params(enc, &h.params);
172            enc.str("budget");
173            encode_named_args(enc, &h.budget);
174            enc.str("ret");
175            match &h.ret {
176                Some(t) => encode_type_expr(enc, t),
177                None => enc.null(),
178            };
179            enc.str("body");
180            encode_block(enc, &h.body);
181        }
182        Item::Const(c) => {
183            enc.map(5);
184            enc.str("type");
185            enc.str("Const");
186            enc.str("name");
187            enc.str(&c.name);
188            enc.str("ty");
189            match &c.ty {
190                Some(t) => encode_type_expr(enc, t),
191                None => enc.null(),
192            };
193            enc.str("value");
194            encode_expr(enc, &c.value);
195            enc.str("span");
196            encode_span(enc, c.span);
197        }
198        Item::Statement(s) => {
199            enc.map(2);
200            enc.str("type");
201            enc.str("Statement");
202            enc.str("stmt");
203            encode_stmt(enc, s);
204        }
205        Item::Enum(e) => {
206            enc.map(3);
207            enc.str("type");
208            enc.str("Enum");
209            enc.str("name");
210            enc.str(&e.name);
211            enc.str("variants");
212            {
213                enc.array(e.variants.len() as u64);
214                for v in &e.variants {
215                    enc.map(2);
216                    enc.str("name");
217                    enc.str(&v.name);
218                    enc.str("payload");
219                    {
220                        enc.array(v.payload.len() as u64);
221                        for t in &v.payload {
222                            encode_type_expr(enc, t);
223                        }
224                    }
225                }
226            }
227        }
228        Item::Field(f) => {
229            enc.map(6);
230            enc.str("type");
231            enc.str("Field");
232            enc.str("name");
233            enc.str(&f.name);
234            enc.str("ty");
235            encode_type_expr(enc, &f.ty);
236            enc.str("unit");
237            match &f.unit {
238                Some(u) => enc.str(u),
239                None => enc.null(),
240            };
241            enc.str("support");
242            enc.str(match f.support {
243                FieldSupport::Region => "region",
244                FieldSupport::Point => "point",
245                FieldSupport::Continuant => "continuant",
246                FieldSupport::Stream => "stream",
247            });
248            enc.str("representation");
249            enc.str(match f.representation {
250                FieldRepresentation::Grid => "grid",
251                FieldRepresentation::Mesh => "mesh",
252                FieldRepresentation::Particles => "particles",
253                FieldRepresentation::Analytic => "analytic",
254                FieldRepresentation::Sampled => "sampled",
255            });
256        }
257        Item::Material(m) => {
258            enc.map(3);
259            enc.str("type");
260            enc.str("Material");
261            enc.str("name");
262            enc.str(&m.name);
263            enc.str("properties");
264            encode_named_args(enc, &m.properties);
265        }
266        Item::Law(l) => {
267            enc.map(4);
268            enc.str("type");
269            enc.str("Law");
270            enc.str("name");
271            enc.str(&l.name);
272            enc.str("condition");
273            encode_expr(enc, &l.condition);
274            enc.str("consequence");
275            encode_expr(enc, &l.consequence);
276        }
277        Item::Cell(c) => {
278            enc.map(7);
279            enc.str("type");
280            enc.str("Cell");
281            enc.str("span");
282            encode_span(enc, c.span);
283            enc.str("effect");
284            encode_effect(enc, &c.effect);
285            enc.str("name");
286            enc.str(&c.name);
287            enc.str("params");
288            encode_params(enc, &c.params);
289            enc.str("expr");
290            encode_expr(enc, &c.expr);
291            enc.str("when");
292            match &c.when {
293                Some(w) => encode_expr(enc, w),
294                None => enc.null(),
295            };
296        }
297        Item::Present(p) => {
298            enc.map(3);
299            enc.str("type");
300            enc.str("Present");
301            enc.str("name");
302            enc.str(&p.name);
303            enc.str("properties");
304            encode_named_args(enc, &p.properties);
305        }
306        Item::Bind(b) => {
307            enc.map(7);
308            enc.str("type");
309            enc.str("Bind");
310            enc.str("left");
311            encode_expr(enc, &b.left);
312            enc.str("right");
313            encode_expr(enc, &b.right);
314            enc.str("resolve");
315            enc.str(match b.resolve {
316                crate::ast::BindResolve::Latest => "latest",
317                crate::ast::BindResolve::Left => "left",
318                crate::ast::BindResolve::Right => "right",
319            });
320            enc.str("clamp_lo");
321            match &b.clamp {
322                Some((lo, _)) => encode_expr(enc, lo),
323                None => enc.null(),
324            };
325            enc.str("clamp_hi");
326            match &b.clamp {
327                Some((_, hi)) => encode_expr(enc, hi),
328                None => enc.null(),
329            };
330        }
331    }
332}
333
334fn encode_effect(enc: &mut CborEncoder, e: &Option<EffectClass>) {
335    match e {
336        Some(ec) => {
337            let s = match ec {
338                EffectClass::Pure => "Pure",
339                EffectClass::Hot => "Hot",
340                EffectClass::Cold => "Cold",
341                EffectClass::Async => "Async",
342                EffectClass::External => "External",
343            };
344            enc.str(s);
345        }
346        None => enc.null(),
347    }
348}
349
350fn encode_params(enc: &mut CborEncoder, params: &[Param]) {
351    enc.array(params.len() as u64);
352    for p in params {
353        enc.map(3);
354        enc.str("name");
355        enc.str(&p.name);
356        enc.str("ty");
357        encode_type_expr(enc, &p.ty);
358        enc.str("span");
359        encode_span(enc, p.span);
360    }
361}
362
363fn encode_type_expr(enc: &mut CborEncoder, t: &TypeExpr) {
364    enc.map(3);
365    enc.str("name");
366    enc.str(&t.name);
367    enc.str("args");
368    {
369        enc.array(t.args.len() as u64);
370        for a in &t.args {
371            encode_type_expr(enc, a);
372        }
373    };
374    enc.str("span");
375    encode_span(enc, t.span);
376}
377
378fn encode_block(enc: &mut CborEncoder, b: &Block) {
379    enc.map(2);
380    enc.str("stmts");
381    {
382        enc.array(b.stmts.len() as u64);
383        for s in &b.stmts {
384            encode_stmt(enc, s);
385        }
386    };
387    enc.str("span");
388    encode_span(enc, b.span);
389}
390
391fn encode_stmt(enc: &mut CborEncoder, s: &Stmt) {
392    match s {
393        Stmt::Let {
394            span,
395            mutable,
396            name,
397            ty,
398            value,
399        } => {
400            enc.map(5);
401            enc.str("type");
402            enc.str("Let");
403            enc.str("name");
404            enc.str(name);
405            enc.str("mutable");
406            enc.bool(*mutable);
407            enc.str("ty");
408            match ty {
409                Some(t) => encode_type_expr(enc, t),
410                None => enc.null(),
411            };
412            enc.str("value");
413            match value {
414                Some(v) => encode_expr(enc, v),
415                None => enc.null(),
416            };
417            let _ = span;
418        }
419        Stmt::LetPat {
420            span,
421            mutable,
422            pattern,
423            ty,
424            value,
425        } => {
426            enc.map(5);
427            enc.str("type");
428            enc.str("LetPat");
429            enc.str("mutable");
430            enc.bool(*mutable);
431            enc.str("pattern");
432            encode_pattern(enc, pattern);
433            enc.str("ty");
434            match ty {
435                Some(t) => encode_type_expr(enc, t),
436                None => enc.null(),
437            };
438            enc.str("value");
439            encode_expr(enc, value);
440            let _ = span;
441        }
442        Stmt::Assign {
443            span,
444            target,
445            value,
446        } => {
447            enc.map(3);
448            enc.str("type");
449            enc.str("Assign");
450            enc.str("target");
451            encode_expr(enc, target);
452            enc.str("value");
453            encode_expr(enc, value);
454            let _ = span;
455        }
456        Stmt::If {
457            span,
458            cond,
459            then_block,
460            else_block,
461        } => {
462            enc.map(4);
463            enc.str("type");
464            enc.str("If");
465            enc.str("cond");
466            encode_expr(enc, cond);
467            enc.str("then");
468            encode_block(enc, then_block);
469            enc.str("else");
470            match else_block {
471                Some(b) => encode_stmt(enc, b),
472                None => enc.null(),
473            };
474            let _ = span;
475        }
476        Stmt::For {
477            span,
478            name,
479            iter,
480            body,
481        } => {
482            enc.map(4);
483            enc.str("type");
484            enc.str("For");
485            enc.str("name");
486            enc.str(name);
487            enc.str("iter");
488            encode_expr(enc, iter);
489            enc.str("body");
490            encode_block(enc, body);
491            let _ = span;
492        }
493        Stmt::While { span, cond, body } => {
494            enc.map(3);
495            enc.str("type");
496            enc.str("While");
497            enc.str("cond");
498            encode_expr(enc, cond);
499            enc.str("body");
500            encode_block(enc, body);
501            let _ = span;
502        }
503        Stmt::Match {
504            span,
505            scrutinee,
506            arms,
507        } => {
508            enc.map(3);
509            enc.str("type");
510            enc.str("Match");
511            enc.str("scrutinee");
512            encode_expr(enc, scrutinee);
513            enc.str("arms");
514            {
515                enc.array(arms.len() as u64);
516                for arm in arms {
517                    enc.map(3);
518                    enc.str("pattern");
519                    encode_pattern(enc, &arm.pattern);
520                    enc.str("body");
521                    encode_arm_body(enc, &arm.body);
522                    enc.str("span");
523                    encode_span(enc, arm.span);
524                }
525            };
526            let _ = span;
527        }
528        Stmt::Return { span, value } => {
529            enc.map(2);
530            enc.str("type");
531            enc.str("Return");
532            enc.str("value");
533            match value {
534                Some(v) => encode_expr(enc, v),
535                None => enc.null(),
536            };
537            let _ = span;
538        }
539        Stmt::Yield { span, value } => {
540            enc.map(2);
541            enc.str("type");
542            enc.str("Yield");
543            enc.str("value");
544            match value {
545                Some(v) => encode_expr(enc, v),
546                None => enc.null(),
547            };
548            let _ = span;
549        }
550        Stmt::Transaction { span, args, body } => {
551            enc.map(3);
552            enc.str("type");
553            enc.str("Transaction");
554            enc.str("args");
555            encode_named_args(enc, args);
556            enc.str("body");
557            encode_block(enc, body);
558            let _ = span;
559        }
560        Stmt::Effect { span, expr } => {
561            enc.map(2);
562            enc.str("type");
563            enc.str("Effect");
564            enc.str("expr");
565            encode_expr(enc, expr);
566            let _ = span;
567        }
568        Stmt::Expr { span, expr } => {
569            enc.map(2);
570            enc.str("type");
571            enc.str("Expr");
572            enc.str("expr");
573            encode_expr(enc, expr);
574            let _ = span;
575        }
576        Stmt::Block(b) => {
577            enc.map(2);
578            enc.str("type");
579            enc.str("Block");
580            enc.str("block");
581            encode_block(enc, b);
582        }
583    }
584}
585
586fn encode_pattern(enc: &mut CborEncoder, p: &Pattern) {
587    match p {
588        Pattern::Wildcard => {
589            enc.map(1);
590            enc.str("type");
591            enc.str("Wildcard");
592        }
593        Pattern::Ident(s) => {
594            enc.map(2);
595            enc.str("type");
596            enc.str("Ident");
597            enc.str("name");
598            enc.str(s);
599        }
600        Pattern::Literal(l) => {
601            enc.map(2);
602            enc.str("type");
603            enc.str("Literal");
604            enc.str("lit");
605            encode_literal(enc, l);
606        }
607        Pattern::Ok(p) => {
608            enc.map(2);
609            enc.str("type");
610            enc.str("Ok");
611            enc.str("inner");
612            encode_pattern(enc, p);
613        }
614        Pattern::Err(p) => {
615            enc.map(2);
616            enc.str("type");
617            enc.str("Err");
618            enc.str("inner");
619            encode_pattern(enc, p);
620        }
621        Pattern::Some(p) => {
622            enc.map(2);
623            enc.str("type");
624            enc.str("Some");
625            enc.str("inner");
626            encode_pattern(enc, p);
627        }
628        Pattern::None => {
629            enc.map(1);
630            enc.str("type");
631            enc.str("None");
632        }
633        Pattern::Variant {
634            enum_name,
635            variant_name,
636            args,
637        } => {
638            enc.map(4);
639            enc.str("type");
640            enc.str("Variant");
641            enc.str("enum");
642            enc.str(enum_name);
643            enc.str("variant");
644            enc.str(variant_name);
645            enc.str("args");
646            {
647                enc.array(args.len() as u64);
648                for a in args {
649                    encode_pattern(enc, a);
650                }
651            }
652        }
653        Pattern::Record(fields) => {
654            enc.map(2);
655            enc.str("type");
656            enc.str("Record");
657            enc.str("fields");
658            enc.array(fields.len() as u64);
659            for (name, pat) in fields {
660                enc.map(2);
661                enc.str("name");
662                enc.str(name);
663                enc.str("pattern");
664                encode_pattern(enc, pat);
665            }
666        }
667        Pattern::List(elements) => {
668            enc.map(2);
669            enc.str("type");
670            enc.str("List");
671            enc.str("elements");
672            enc.array(elements.len() as u64);
673            for p in elements {
674                encode_pattern(enc, p);
675            }
676        }
677        Pattern::Constructor { name, args } => {
678            enc.map(3);
679            enc.str("type");
680            enc.str("Constructor");
681            enc.str("name");
682            enc.str(name);
683            enc.str("args");
684            enc.array(args.len() as u64);
685            for a in args {
686                encode_pattern(enc, a);
687            }
688        }
689    }
690}
691
692fn encode_arm_body(enc: &mut CborEncoder, b: &ArmBody) {
693    match b {
694        ArmBody::Block(blk) => {
695            enc.map(1);
696            enc.str("Block");
697            encode_block(enc, blk);
698        }
699        ArmBody::Expr(e) => {
700            enc.map(1);
701            enc.str("Expr");
702            encode_expr(enc, e);
703        }
704    }
705}
706
707pub(crate) fn encode_expr(enc: &mut CborEncoder, e: &Expr) {
708    enc.map(2);
709    enc.str("kind");
710    encode_expr_kind(enc, &e.kind);
711    enc.str("span");
712    encode_span(enc, e.span);
713}
714
715fn encode_expr_kind(enc: &mut CborEncoder, k: &ExprKind) {
716    match k {
717        ExprKind::Literal(l) => {
718            enc.map(1);
719            enc.str("Literal");
720            encode_literal(enc, l);
721        }
722        ExprKind::Ident(s) => {
723            enc.map(1);
724            enc.str("Ident");
725            enc.str(s);
726        }
727        ExprKind::QueryVar(s) => {
728            enc.map(1);
729            enc.str("QueryVar");
730            enc.str(s);
731        }
732        ExprKind::Iri(s) => {
733            enc.map(1);
734            enc.str("Iri");
735            enc.str(s);
736        }
737        ExprKind::Prefixed(p, l) => {
738            enc.map(2);
739            enc.str("prefix");
740            enc.str(p);
741            enc.str("local");
742            enc.str(l);
743        }
744        ExprKind::Blank(s) => {
745            enc.map(1);
746            enc.str("Blank");
747            enc.str(s);
748        }
749        ExprKind::Binary { op, left, right } => {
750            enc.map(4);
751            enc.str("type");
752            enc.str("Binary");
753            enc.str("op");
754            encode_binop(enc, op);
755            enc.str("left");
756            encode_expr(enc, left);
757            enc.str("right");
758            encode_expr(enc, right);
759        }
760        ExprKind::Unary { op, expr } => {
761            enc.map(3);
762            enc.str("type");
763            enc.str("Unary");
764            enc.str("op");
765            encode_unop(enc, op);
766            enc.str("expr");
767            encode_expr(enc, expr);
768        }
769        ExprKind::Await(e) => {
770            enc.map(1);
771            enc.str("Await");
772            encode_expr(enc, e);
773        }
774        ExprKind::Member { recv, name } => {
775            enc.map(3);
776            enc.str("type");
777            enc.str("Member");
778            enc.str("recv");
779            encode_expr(enc, recv);
780            enc.str("name");
781            enc.str(name);
782        }
783        ExprKind::Call { callee, args } => {
784            enc.map(3);
785            enc.str("type");
786            enc.str("Call");
787            enc.str("callee");
788            encode_expr(enc, callee);
789            enc.str("args");
790            encode_args(enc, args);
791        }
792        ExprKind::Index { recv, index } => {
793            enc.map(3);
794            enc.str("type");
795            enc.str("Index");
796            enc.str("recv");
797            encode_expr(enc, recv);
798            enc.str("index");
799            encode_expr(enc, index);
800        }
801        ExprKind::Try(e) => {
802            enc.map(1);
803            enc.str("Try");
804            encode_expr(enc, e);
805        }
806        ExprKind::List(es) => {
807            enc.map(1);
808            enc.str("List");
809            enc.array(es.len() as u64);
810            for e in es {
811                encode_expr(enc, e);
812            }
813        }
814        ExprKind::Record(args) => {
815            enc.map(1);
816            enc.str("Record");
817            encode_named_args(enc, args);
818        }
819        ExprKind::Triple {
820            subject,
821            predicate,
822            object,
823        } => {
824            enc.map(4);
825            enc.str("type");
826            enc.str("Triple");
827            enc.str("subject");
828            encode_expr(enc, subject);
829            enc.str("predicate");
830            encode_expr(enc, predicate);
831            enc.str("object");
832            encode_expr(enc, object);
833        }
834        ExprKind::Reified {
835            subject,
836            predicate,
837            object,
838            reifier,
839        } => {
840            enc.map(5);
841            enc.str("type");
842            enc.str("Reified");
843            enc.str("subject");
844            encode_expr(enc, subject);
845            enc.str("predicate");
846            encode_expr(enc, predicate);
847            enc.str("object");
848            encode_expr(enc, object);
849            enc.str("reifier");
850            encode_expr(enc, reifier);
851        }
852        ExprKind::Pipe { left, right } => {
853            enc.map(2);
854            enc.str("left");
855            encode_expr(enc, left);
856            enc.str("right");
857            encode_expr(enc, right);
858        }
859        ExprKind::GraphQuery {
860            is_ask,
861            pattern,
862            variables,
863        } => {
864            enc.map(3);
865            enc.str("is_ask");
866            enc.bool(*is_ask);
867            enc.str("pattern");
868            enc.str(pattern);
869            enc.str("variables");
870            enc.array(variables.len() as u64);
871            for v in variables {
872                enc.str(v);
873            }
874        }
875        ExprKind::ModalLogic {
876            modality,
877            args,
878            body,
879        } => {
880            enc.map(1);
881            enc.str("ModalLogic");
882            enc.map(3);
883            enc.str("modality");
884            enc.str(match modality {
885                ModalKind::DeonticObligate => "obligate",
886                ModalKind::DeonticPermit => "permit",
887                ModalKind::DeonticForbid => "forbid",
888                ModalKind::EpistemicKnows => "knows",
889                ModalKind::EpistemicBelieves => "believes",
890                ModalKind::Paraconsistent => "paraconsistent",
891                ModalKind::LtlGlobally => "always",
892                ModalKind::LtlFinally => "eventually",
893                ModalKind::LtlUntil => "until",
894                ModalKind::DlSubsumes => "subsumes",
895                ModalKind::N3Defeasible => "defeasible_rule",
896            });
897            enc.str("args");
898            enc.array(args.len() as u64);
899            for a in args {
900                encode_expr(enc, a);
901            }
902            enc.str("body");
903            match body {
904                Some(b) => encode_expr(enc, b),
905                None => enc.null(),
906            }
907        }
908        ExprKind::Interpolate(parts) => {
909            enc.map(1);
910            enc.str("Interpolate");
911            enc.array(parts.len() as u64);
912            for p in parts {
913                encode_expr(enc, p);
914            }
915        }
916        ExprKind::Lambda { params, body } => {
917            enc.map(3);
918            enc.str("type");
919            enc.str("Lambda");
920            enc.str("params");
921            encode_str_list(enc, params);
922            enc.str("body");
923            encode_expr(enc, body);
924        }
925        ExprKind::Tween {
926            from,
927            to,
928            over,
929            ease,
930            spring,
931        } => {
932            enc.map(6);
933            enc.str("type");
934            enc.str("Tween");
935            enc.str("from");
936            encode_expr(enc, from);
937            enc.str("to");
938            encode_expr(enc, to);
939            enc.str("over");
940            encode_expr(enc, over);
941            enc.str("ease");
942            match ease {
943                Some(s) => enc.str(s),
944                None => enc.null(),
945            };
946            enc.str("spring");
947            match spring {
948                Some(args) => encode_named_args(enc, args),
949                None => enc.null(),
950            };
951        }
952        ExprKind::IfElse {
953            cond,
954            then_value,
955            else_value,
956        } => {
957            enc.map(4);
958            enc.str("type");
959            enc.str("IfElse");
960            enc.str("cond");
961            encode_expr(enc, cond);
962            enc.str("then");
963            encode_expr(enc, then_value);
964            enc.str("else");
965            encode_expr(enc, else_value);
966        }
967    }
968}
969
970fn encode_args(enc: &mut CborEncoder, args: &[Arg]) {
971    enc.array(args.len() as u64);
972    for arg in args {
973        match arg {
974            Arg::Pos(e) => {
975                enc.map(1);
976                enc.str("Pos");
977                encode_expr(enc, e);
978            }
979            Arg::Named(na) => {
980                enc.map(1);
981                enc.str("Named");
982                encode_named_arg(enc, na);
983            }
984        }
985    }
986}
987
988fn encode_named_arg(enc: &mut CborEncoder, na: &NamedArg) {
989    enc.map(3);
990    enc.str("name");
991    enc.str(&na.name);
992    enc.str("value");
993    encode_expr(enc, &na.value);
994    enc.str("span");
995    encode_span(enc, na.span);
996}
997
998fn encode_binop(enc: &mut CborEncoder, op: &BinOp) {
999    let s = match op {
1000        BinOp::Or => "Or",
1001        BinOp::And => "And",
1002        BinOp::Eq => "Eq",
1003        BinOp::Ne => "Ne",
1004        BinOp::Lt => "Lt",
1005        BinOp::Le => "Le",
1006        BinOp::Gt => "Gt",
1007        BinOp::Ge => "Ge",
1008        BinOp::Add => "Add",
1009        BinOp::Sub => "Sub",
1010        BinOp::Mul => "Mul",
1011        BinOp::Div => "Div",
1012        BinOp::Rem => "Rem",
1013    };
1014    enc.str(s);
1015}
1016
1017fn encode_unop(enc: &mut CborEncoder, op: &UnOp) {
1018    let s = match op {
1019        UnOp::Not => "Not",
1020        UnOp::Neg => "Neg",
1021        UnOp::Plus => "Plus",
1022    };
1023    enc.str(s);
1024}
1025
1026fn encode_literal(enc: &mut CborEncoder, l: &Literal) {
1027    match l {
1028        Literal::Null => {
1029            enc.map(1);
1030            enc.str("type");
1031            enc.str("Null");
1032        }
1033        Literal::Bool(b) => {
1034            enc.map(2);
1035            enc.str("type");
1036            enc.str("Bool");
1037            enc.str("value");
1038            enc.bool(*b);
1039        }
1040        Literal::Int(n) => {
1041            enc.map(2);
1042            enc.str("type");
1043            enc.str("Int");
1044            enc.str("value");
1045            enc.int(*n);
1046        }
1047        Literal::UInt(n) => {
1048            enc.map(2);
1049            enc.str("type");
1050            enc.str("UInt");
1051            enc.str("value");
1052            enc.uint(*n);
1053        }
1054        Literal::Float(bits) => {
1055            enc.map(2);
1056            enc.str("type");
1057            enc.str("Float");
1058            enc.str("bits");
1059            enc.uint(*bits);
1060        }
1061        Literal::Quantity { value, unit } => {
1062            enc.map(3);
1063            enc.str("type");
1064            enc.str("Quantity");
1065            enc.str("value");
1066            enc.uint(*value);
1067            enc.str("unit");
1068            enc.str(unit);
1069        }
1070        Literal::String(s) => {
1071            enc.map(2);
1072            enc.str("type");
1073            enc.str("String");
1074            enc.str("value");
1075            enc.str(s);
1076        }
1077        Literal::Color(c) => {
1078            enc.map(5);
1079            enc.str("type");
1080            enc.str("Color");
1081            enc.str("r");
1082            enc.uint(c.r as u64);
1083            enc.str("g");
1084            enc.uint(c.g as u64);
1085            enc.str("b");
1086            enc.uint(c.b as u64);
1087            enc.str("a");
1088            enc.uint(c.a as u64);
1089        }
1090    }
1091}
1092
1093fn encode_span(enc: &mut CborEncoder, s: Span) {
1094    enc.array(2);
1095    enc.uint(s.start as u64);
1096    enc.uint(s.end as u64);
1097}
1098
1099fn encode_str_list(enc: &mut CborEncoder, list: &[String]) {
1100    enc.array(list.len() as u64);
1101    for s in list {
1102        enc.str(s);
1103    }
1104}