1use super::codec::CborEncoder;
4use super::TAG_VIBE_AST;
5use crate::ast::*;
6use crate::span::Span;
7
8pub 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
16fn 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}