1use super::codec::CborDecoder;
4use super::{DecodeError, TAG_VIBE_AST};
5use crate::ast::*;
6use crate::span::Span;
7
8pub fn decode(bytes: &[u8]) -> Result<Program, DecodeError> {
10 let mut dec = CborDecoder::new(bytes);
11 let tag = dec.tag()?;
12 if tag != TAG_VIBE_AST {
13 return Err(DecodeError::UnexpectedTag(tag));
14 }
15 decode_program(&mut dec)
16}
17
18fn decode_program(dec: &mut CborDecoder) -> Result<Program, DecodeError> {
20 let map_len = dec.map()?;
21 let mut module = None;
22 let mut imports = Vec::new();
23 let mut prefixes = Vec::new();
24 let mut locales = Vec::new();
25 let mut requires = Vec::new();
26 let mut items = Vec::new();
27 let mut span = Span::new(0, 0);
28 for _ in 0..map_len {
29 let key = dec.str()?;
30 match key.as_str() {
31 "type" => {
32 let _ = dec.str()?;
33 }
34 "span" => span = decode_span(dec)?,
35 "module" => module = decode_opt_module(dec)?,
36 "imports" => imports = decode_imports(dec)?,
37 "prefixes" => prefixes = decode_prefixes(dec)?,
38 "locales" => locales = decode_locales(dec)?,
39 "requires" => requires = decode_caps(dec)?,
40 "items" => items = decode_items(dec)?,
41 _ => dec.skip()?,
42 }
43 }
44 Ok(Program {
45 span,
46 module,
47 imports,
48 prefixes,
49 locales,
50 requires,
51 items,
52 })
53}
54
55fn decode_locales(dec: &mut CborDecoder) -> Result<Vec<LocaleDecl>, DecodeError> {
56 let n = dec.array()?;
57 let mut out = Vec::with_capacity(n as usize);
58 for _ in 0..n {
59 let map_len = dec.map()?;
60 let mut code = String::new();
61 let mut span = Span::new(0, 0);
62 for _ in 0..map_len {
63 let key = dec.str()?;
64 match key.as_str() {
65 "code" => code = dec.str()?,
66 "span" => span = decode_span(dec)?,
67 _ => dec.skip()?,
68 }
69 }
70 out.push(LocaleDecl { span, code });
71 }
72 Ok(out)
73}
74
75fn decode_opt_module(dec: &mut CborDecoder) -> Result<Option<ModuleDecl>, DecodeError> {
76 if dec.is_null()? {
77 dec.skip()?;
78 return Ok(None);
79 }
80 let map_len = dec.map()?;
81 let mut name = Name::Ident(String::new());
82 let mut span = Span::new(0, 0);
83 for _ in 0..map_len {
84 let key = dec.str()?;
85 match key.as_str() {
86 "name" => name = decode_name(dec)?,
87 "span" => span = decode_span(dec)?,
88 _ => dec.skip()?,
89 }
90 }
91 Ok(Some(ModuleDecl { span, name }))
92}
93
94fn decode_name(dec: &mut CborDecoder) -> Result<Name, DecodeError> {
95 let map_len = dec.map()?;
96 if map_len < 1 {
97 return Err(DecodeError::InvalidCbor("empty Name map".into()));
98 }
99 let key = dec.str()?;
100 let val = dec.str()?;
101 if map_len > 1 {
102 for _ in 1..map_len {
103 dec.skip()?;
104 }
105 }
106 match key.as_str() {
107 "Ident" => Ok(Name::Ident(val)),
108 "Iri" => Ok(Name::Iri(val)),
109 _ => Err(DecodeError::UnexpectedType("Name")),
110 }
111}
112
113fn decode_imports(dec: &mut CborDecoder) -> Result<Vec<ImportDecl>, DecodeError> {
114 let n = dec.array()?;
115 let mut out = Vec::with_capacity(n as usize);
116 for _ in 0..n {
117 let map_len = dec.map()?;
118 let mut path = String::new();
119 let mut alias = None;
120 let mut span = Span::new(0, 0);
121 for _ in 0..map_len {
122 let key = dec.str()?;
123 match key.as_str() {
124 "path" => path = dec.str()?,
125 "alias" => {
126 if dec.is_null()? {
127 dec.skip()?;
128 alias = None;
129 } else {
130 alias = Some(dec.str()?);
131 }
132 }
133 "span" => span = decode_span(dec)?,
134 _ => dec.skip()?,
135 }
136 }
137 out.push(ImportDecl { span, path, alias });
138 }
139 Ok(out)
140}
141
142fn decode_prefixes(dec: &mut CborDecoder) -> Result<Vec<PrefixDecl>, DecodeError> {
143 let n = dec.array()?;
144 let mut out = Vec::with_capacity(n as usize);
145 for _ in 0..n {
146 let map_len = dec.map()?;
147 let mut prefix = String::new();
148 let mut iri = String::new();
149 let mut span = Span::new(0, 0);
150 for _ in 0..map_len {
151 let key = dec.str()?;
152 match key.as_str() {
153 "prefix" => prefix = dec.str()?,
154 "iri" => iri = dec.str()?,
155 "span" => span = decode_span(dec)?,
156 _ => dec.skip()?,
157 }
158 }
159 out.push(PrefixDecl { span, prefix, iri });
160 }
161 Ok(out)
162}
163
164fn decode_caps(dec: &mut CborDecoder) -> Result<Vec<CapSpec>, DecodeError> {
165 let n = dec.array()?;
166 let mut out = Vec::with_capacity(n as usize);
167 for _ in 0..n {
168 let map_len = dec.map()?;
169 let mut id = String::new();
170 let mut args = Vec::new();
171 let mut span = Span::new(0, 0);
172 for _ in 0..map_len {
173 let key = dec.str()?;
174 match key.as_str() {
175 "id" => id = dec.str()?,
176 "args" => args = decode_named_args(dec)?,
177 "span" => span = decode_span(dec)?,
178 _ => dec.skip()?,
179 }
180 }
181 out.push(CapSpec { span, id, args });
182 }
183 Ok(out)
184}
185
186fn decode_str_list(dec: &mut CborDecoder) -> Result<Vec<String>, DecodeError> {
187 let n = dec.array()?;
188 let mut out = Vec::with_capacity(n as usize);
189 for _ in 0..n {
190 out.push(dec.str()?);
191 }
192 Ok(out)
193}
194
195fn decode_named_args(dec: &mut CborDecoder) -> Result<Vec<NamedArg>, DecodeError> {
196 let n = dec.array()?;
197 let mut out = Vec::with_capacity(n as usize);
198 for _ in 0..n {
199 let map_len = dec.map()?;
200 let mut name = String::new();
201 let mut value = Expr {
202 span: Span::new(0, 0),
203 kind: ExprKind::Literal(Literal::Null),
204 };
205 let mut span = Span::new(0, 0);
206 for _ in 0..map_len {
207 let key = dec.str()?;
208 match key.as_str() {
209 "name" => name = dec.str()?,
210 "value" => value = decode_expr(dec)?,
211 "span" => span = decode_span(dec)?,
212 _ => dec.skip()?,
213 }
214 }
215 out.push(NamedArg { span, name, value });
216 }
217 Ok(out)
218}
219
220fn decode_items(dec: &mut CborDecoder) -> Result<Vec<Item>, DecodeError> {
221 let n = dec.array()?;
222 let mut out = Vec::with_capacity(n as usize);
223 for _ in 0..n {
224 out.push(decode_item(dec)?);
225 }
226 Ok(out)
227}
228
229fn decode_item(dec: &mut CborDecoder) -> Result<Item, DecodeError> {
230 let map_len = dec.map()?;
231 let mut item_type = String::new();
232 let mut fields: Vec<(String, ItemField)> = Vec::with_capacity(map_len as usize);
236 for _ in 0..map_len {
237 let key = dec.str()?;
238 if key == "type" {
239 item_type = dec.str()?;
240 } else {
241 let val = decode_item_field(&key, dec)?;
242 fields.push((key, val));
243 }
244 }
245 match item_type.as_str() {
247 "Function" => {
248 let mut name = String::new();
249 let mut effect = None;
250 let mut is_async = false;
251 let mut params = Vec::new();
252 let mut budget = Vec::new();
253 let mut ret = None;
254 let mut body = Block {
255 span: Span::new(0, 0),
256 stmts: Vec::new(),
257 };
258 for (k, v) in fields {
259 match (k.as_str(), v) {
260 ("name", ItemField::Str(s)) => name = s,
261 ("effect", ItemField::Effect(e)) => effect = e,
262 ("async", ItemField::Bool(b)) => is_async = b,
263 ("params", ItemField::Params(p)) => params = p,
264 ("budget", ItemField::NamedArgs(na)) => budget = na,
265 ("ret", ItemField::TypeExpr(t)) => ret = t,
266 ("body", ItemField::Block(b)) => body = b,
267 _ => {}
268 }
269 }
270 Ok(Item::Function(FunctionDecl {
271 span: Span::new(0, 0),
272 effect,
273 is_async,
274 name,
275 params,
276 budget,
277 ret,
278 body,
279 }))
280 }
281 "Hook" => {
282 let mut span = Span::new(0, 0);
283 let mut path = Vec::new();
284 let mut params = Vec::new();
285 let mut budget = Vec::new();
286 let mut ret = None;
287 let mut body = Block {
288 span: Span::new(0, 0),
289 stmts: Vec::new(),
290 };
291 for (k, v) in fields {
292 match (k.as_str(), v) {
293 ("span", ItemField::Span(s)) => span = s,
294 ("path", ItemField::StrList(s)) => path = s,
295 ("params", ItemField::Params(p)) => params = p,
296 ("budget", ItemField::NamedArgs(na)) => budget = na,
297 ("ret", ItemField::TypeExpr(t)) => ret = t,
298 ("body", ItemField::Block(b)) => body = b,
299 _ => {}
300 }
301 }
302 Ok(Item::Hook(HookDecl {
303 span,
304 path,
305 params,
306 budget,
307 ret,
308 body,
309 }))
310 }
311 "Const" => {
312 let mut name = String::new();
313 let mut ty = None;
314 let mut value = Expr {
315 span: Span::new(0, 0),
316 kind: ExprKind::Literal(Literal::Null),
317 };
318 let mut span = Span::new(0, 0);
319 for (k, v) in fields {
320 match (k.as_str(), v) {
321 ("name", ItemField::Str(s)) => name = s,
322 ("ty", ItemField::TypeExpr(t)) => ty = t,
323 ("value", ItemField::Expr(e)) => value = e,
324 ("span", ItemField::Span(s)) => span = s,
325 _ => {}
326 }
327 }
328 Ok(Item::Const(ConstDecl {
329 span,
330 name,
331 ty,
332 value,
333 }))
334 }
335 "Statement" => {
336 for (k, v) in fields {
337 if k == "stmt" {
338 if let ItemField::Stmt(s) = v {
339 return Ok(Item::Statement(s));
340 }
341 }
342 }
343 Err(DecodeError::MissingField("stmt"))
344 }
345 "Enum" => {
346 let mut name = String::new();
347 let mut variants = Vec::new();
348 for (k, v) in fields {
349 match (k.as_str(), v) {
350 ("name", ItemField::Str(s)) => name = s,
351 ("variants", ItemField::VariantList(v)) => variants = v,
352 _ => {}
353 }
354 }
355 Ok(Item::Enum(EnumDecl {
356 span: Span::new(0, 0),
357 name,
358 variants,
359 }))
360 }
361 "Field" => {
362 let mut name = String::new();
363 let mut ty = TypeExpr {
364 span: Span::new(0, 0),
365 name: String::new(),
366 args: Vec::new(),
367 };
368 let mut unit = None;
369 let mut support = FieldSupport::Region;
370 let mut representation = FieldRepresentation::Grid;
371 for (k, v) in fields {
372 match (k.as_str(), v) {
373 ("name", ItemField::Str(s)) => name = s,
374 ("ty", ItemField::TypeExpr(t)) => {
375 if let Some(t) = t {
376 ty = t;
377 }
378 }
379 ("unit", ItemField::Str(s)) => unit = Some(s),
380 ("support", ItemField::Str(s)) => {
381 support = match s.as_str() {
382 "region" => FieldSupport::Region,
383 "point" => FieldSupport::Point,
384 "continuant" => FieldSupport::Continuant,
385 "stream" => FieldSupport::Stream,
386 _ => FieldSupport::Region,
387 };
388 }
389 ("representation", ItemField::Str(s)) => {
390 representation = match s.as_str() {
391 "grid" => FieldRepresentation::Grid,
392 "mesh" => FieldRepresentation::Mesh,
393 "particles" => FieldRepresentation::Particles,
394 "analytic" => FieldRepresentation::Analytic,
395 "sampled" => FieldRepresentation::Sampled,
396 _ => FieldRepresentation::Grid,
397 };
398 }
399 _ => {}
400 }
401 }
402 Ok(Item::Field(FieldDecl {
403 span: Span::new(0, 0),
404 name,
405 ty,
406 unit,
407 support,
408 representation,
409 }))
410 }
411 "Material" => {
412 let mut name = String::new();
413 let mut properties = Vec::new();
414 for (k, v) in fields {
415 match (k.as_str(), v) {
416 ("name", ItemField::Str(s)) => name = s,
417 ("properties", ItemField::NamedArgs(na)) => properties = na,
418 _ => {}
419 }
420 }
421 Ok(Item::Material(MaterialDecl {
422 span: Span::new(0, 0),
423 name,
424 properties,
425 }))
426 }
427 "Law" => {
428 let mut name = String::new();
429 let mut condition = Expr {
430 span: Span::new(0, 0),
431 kind: ExprKind::Literal(Literal::Null),
432 };
433 let mut consequence = Expr {
434 span: Span::new(0, 0),
435 kind: ExprKind::Literal(Literal::Null),
436 };
437 for (k, v) in fields {
438 match (k.as_str(), v) {
439 ("name", ItemField::Str(s)) => name = s,
440 ("condition", ItemField::Expr(e)) => condition = e,
441 ("consequence", ItemField::Expr(e)) => consequence = e,
442 _ => {}
443 }
444 }
445 Ok(Item::Law(LawDecl {
446 span: Span::new(0, 0),
447 name,
448 condition,
449 consequence,
450 }))
451 }
452 "Cell" => {
453 let mut name = String::new();
454 let mut span = Span::new(0, 0);
455 let mut effect = None;
456 let mut params = Vec::new();
457 let mut expr = Expr {
458 span: Span::new(0, 0),
459 kind: ExprKind::Literal(Literal::Null),
460 };
461 let mut when = None;
462 for (k, v) in fields {
463 match (k.as_str(), v) {
464 ("name", ItemField::Str(s)) => name = s,
465 ("span", ItemField::Span(sp)) => span = sp,
466 ("effect", ItemField::Effect(eff)) => effect = eff,
467 ("params", ItemField::Params(ps)) => params = ps,
468 ("expr", ItemField::Expr(e)) => expr = e,
469 ("when", ItemField::Expr(e)) => when = Some(e),
470 _ => {}
471 }
472 }
473 Ok(Item::Cell(CellDecl {
474 span,
475 effect,
476 name,
477 params,
478 expr,
479 when,
480 }))
481 }
482 "Present" => {
483 let mut name = String::new();
484 let mut properties = Vec::new();
485 for (k, v) in fields {
486 match (k.as_str(), v) {
487 ("name", ItemField::Str(s)) => name = s,
488 ("properties", ItemField::NamedArgs(ps)) => properties = ps,
489 _ => {}
490 }
491 }
492 Ok(Item::Present(crate::ast::PresentDecl {
493 span: Span::new(0, 0),
494 name,
495 properties,
496 }))
497 }
498 "Bind" => {
499 let mut left = Expr {
500 span: Span::new(0, 0),
501 kind: ExprKind::Literal(Literal::Null),
502 };
503 let mut right = left.clone();
504 let mut resolve = crate::ast::BindResolve::Latest;
505 let mut clamp_lo = None;
506 let mut clamp_hi = None;
507 for (k, v) in fields {
508 match (k.as_str(), v) {
509 ("left", ItemField::Expr(e)) => left = e,
510 ("right", ItemField::Expr(e)) => right = e,
511 ("resolve", ItemField::Str(s)) => {
512 resolve = match s.as_str() {
513 "left" => crate::ast::BindResolve::Left,
514 "right" => crate::ast::BindResolve::Right,
515 _ => crate::ast::BindResolve::Latest,
516 };
517 }
518 ("clamp_lo", ItemField::Expr(e)) => clamp_lo = Some(e),
519 ("clamp_hi", ItemField::Expr(e)) => clamp_hi = Some(e),
520 _ => {}
521 }
522 }
523 let clamp = match (clamp_lo, clamp_hi) {
524 (Some(lo), Some(hi)) => Some((lo, hi)),
525 _ => None,
526 };
527 Ok(Item::Bind(crate::ast::BindDecl {
528 span: Span::new(0, 0),
529 left,
530 right,
531 clamp,
532 resolve,
533 }))
534 }
535 _ => Err(DecodeError::UnexpectedType("Item")),
536 }
537}
538
539enum ItemField {
541 Str(String),
542 StrList(Vec<String>),
543 Bool(bool),
544 Expr(Expr),
545 Block(Block),
546 Params(Vec<Param>),
547 NamedArgs(Vec<NamedArg>),
548 Effect(Option<EffectClass>),
549 Span(Span),
550 Stmt(Stmt),
551 VariantList(Vec<EnumVariant>),
552 TypeExpr(Option<TypeExpr>),
553}
554
555fn decode_item_field(key: &str, dec: &mut CborDecoder) -> Result<ItemField, DecodeError> {
556 match key {
557 "name" => Ok(ItemField::Str(dec.str()?)),
558 "path" => {
559 if (dec.peek()? >> 5) == 4 {
560 let n = dec.array()?;
561 let mut parts = Vec::new();
562 for _ in 0..n {
563 parts.push(dec.str()?);
564 }
565 Ok(ItemField::StrList(parts))
566 } else {
567 Ok(ItemField::Str(dec.str()?))
568 }
569 }
570 "async" => Ok(ItemField::Bool(dec.bool()?)),
571 "effect" => {
572 if dec.is_null()? {
573 dec.skip()?;
574 Ok(ItemField::Effect(None))
575 } else {
576 let s = dec.str()?;
577 let e = match s.as_str() {
578 "Pure" => EffectClass::Pure,
579 "Hot" => EffectClass::Hot,
580 "Cold" => EffectClass::Cold,
581 "Async" => EffectClass::Async,
582 "External" => EffectClass::External,
583 _ => return Err(DecodeError::UnexpectedType("EffectClass")),
584 };
585 Ok(ItemField::Effect(Some(e)))
586 }
587 }
588 "ret" | "ty" => {
589 if dec.is_null()? {
590 dec.skip()?;
591 Ok(ItemField::TypeExpr(None))
592 } else {
593 Ok(ItemField::TypeExpr(Some(decode_type_expr(dec)?)))
594 }
595 }
596 "value" | "expr" | "condition" | "consequence" | "when" => {
597 if dec.is_null()? {
598 dec.skip()?;
599 Ok(ItemField::Expr(Expr {
600 span: Span::new(0, 0),
601 kind: ExprKind::Literal(Literal::Null),
602 }))
603 } else {
604 Ok(ItemField::Expr(decode_expr(dec)?))
605 }
606 }
607 "body" | "then" | "block" => Ok(ItemField::Block(decode_block(dec)?)),
608 "params" => Ok(ItemField::Params(decode_params(dec)?)),
609 "properties" => Ok(ItemField::NamedArgs(decode_named_args(dec)?)),
610 "budget" | "args" => {
611 if key == "budget" {
615 Ok(ItemField::NamedArgs(decode_named_args(dec)?))
616 } else {
617 dec.skip()?;
619 Ok(ItemField::Str(String::new()))
620 }
621 }
622 "span" => Ok(ItemField::Span(decode_span(dec)?)),
623 "stmt" => Ok(ItemField::Stmt(decode_stmt(dec)?)),
624 "variants" => {
625 let n = dec.array()?;
626 let mut vs = Vec::new();
627 for _ in 0..n {
628 let m = dec.map()?;
629 let mut vname = String::new();
630 let mut payload = Vec::new();
631 for _ in 0..m {
632 match dec.str()?.as_str() {
633 "name" => vname = dec.str()?,
634 "payload" => {
635 let pn = dec.array()?;
636 for _ in 0..pn {
637 payload.push(decode_type_expr(dec)?);
638 }
639 }
640 _ => dec.skip()?,
641 }
642 }
643 vs.push(EnumVariant {
644 span: Span::new(0, 0),
645 name: vname,
646 payload,
647 });
648 }
649 Ok(ItemField::VariantList(vs))
650 }
651 "unit" => {
652 if dec.is_null()? {
653 dec.skip()?;
654 Ok(ItemField::Str(String::new()))
655 } else {
656 Ok(ItemField::Str(dec.str()?))
657 }
658 }
659 "support" | "representation" | "resolve" => Ok(ItemField::Str(dec.str()?)),
660 "left" | "right" | "clamp_lo" | "clamp_hi" => {
661 if dec.is_null()? {
662 dec.skip()?;
663 Ok(ItemField::Str(String::new()))
664 } else {
665 Ok(ItemField::Expr(decode_expr(dec)?))
666 }
667 }
668 _ => {
669 dec.skip()?;
670 Ok(ItemField::Str(String::new()))
671 }
672 }
673}
674fn decode_span(dec: &mut CborDecoder) -> Result<Span, DecodeError> {
675 let n = dec.array()?;
676 if n < 2 {
677 return Err(DecodeError::InvalidCbor("span needs 2 elements".into()));
678 }
679 let start = dec.uint()? as u32;
680 let end = dec.uint()? as u32;
681 for _ in 2..n {
682 dec.skip()?;
683 }
684 Ok(Span::new(start, end))
685}
686
687pub(crate) fn decode_expr(dec: &mut CborDecoder) -> Result<Expr, DecodeError> {
688 let map_len = dec.map()?;
689 let mut span = Span::new(0, 0);
690 let mut kind = ExprKind::Literal(Literal::Null);
691 for _ in 0..map_len {
692 let key = dec.str()?;
693 match key.as_str() {
694 "kind" => kind = decode_expr_kind(dec)?,
695 "span" => span = decode_span(dec)?,
696 _ => dec.skip()?,
697 }
698 }
699 Ok(Expr { span, kind })
700}
701
702fn decode_expr_kind(dec: &mut CborDecoder) -> Result<ExprKind, DecodeError> {
703 let map_len = dec.map()?;
706 if map_len < 1 {
707 return Err(DecodeError::InvalidCbor("empty ExprKind map".into()));
708 }
709 let first_key = dec.str()?;
710 let (variant, remaining_pairs) = if first_key == "type" {
711 (dec.str()?, map_len - 1)
712 } else {
713 (first_key, map_len - 1)
714 };
715 let kind = match variant.as_str() {
716 "Literal" => ExprKind::Literal(decode_literal(dec)?),
717 "Ident" => ExprKind::Ident(dec.str()?),
718 "QueryVar" => ExprKind::QueryVar(dec.str()?),
719 "Iri" => ExprKind::Iri(dec.str()?),
720 "Blank" => ExprKind::Blank(dec.str()?),
721 "Binary" => {
722 let mut op = BinOp::Add;
723 let mut left = Expr {
724 span: Span::new(0, 0),
725 kind: ExprKind::Literal(Literal::Null),
726 };
727 let mut right = Expr {
728 span: Span::new(0, 0),
729 kind: ExprKind::Literal(Literal::Null),
730 };
731 for _ in 0..remaining_pairs {
732 let k = dec.str()?;
733 match k.as_str() {
734 "op" => op = decode_binop(dec)?,
735 "left" => left = decode_expr(dec)?,
736 "right" => right = decode_expr(dec)?,
737 _ => dec.skip()?,
738 }
739 }
740 ExprKind::Binary {
741 op,
742 left: Box::new(left),
743 right: Box::new(right),
744 }
745 }
746 "Unary" => {
747 let mut op = UnOp::Not;
748 let mut expr = Expr {
749 span: Span::new(0, 0),
750 kind: ExprKind::Literal(Literal::Null),
751 };
752 for _ in 0..remaining_pairs {
753 let k = dec.str()?;
754 match k.as_str() {
755 "op" => op = decode_unop(dec)?,
756 "expr" => expr = decode_expr(dec)?,
757 _ => dec.skip()?,
758 }
759 }
760 ExprKind::Unary {
761 op,
762 expr: Box::new(expr),
763 }
764 }
765 "Await" => {
766 let e = decode_expr(dec)?;
767 for _ in 0..remaining_pairs {
768 dec.skip()?;
769 }
770 ExprKind::Await(Box::new(e))
771 }
772 "Member" => {
773 let mut recv = Expr {
774 span: Span::new(0, 0),
775 kind: ExprKind::Literal(Literal::Null),
776 };
777 let mut name = String::new();
778 for _ in 0..remaining_pairs {
779 let k = dec.str()?;
780 match k.as_str() {
781 "recv" => recv = decode_expr(dec)?,
782 "name" => name = dec.str()?,
783 _ => dec.skip()?,
784 }
785 }
786 ExprKind::Member {
787 recv: Box::new(recv),
788 name,
789 }
790 }
791 "Call" => {
792 let mut callee = Expr {
793 span: Span::new(0, 0),
794 kind: ExprKind::Literal(Literal::Null),
795 };
796 let mut args = Vec::new();
797 for _ in 0..remaining_pairs {
798 let k = dec.str()?;
799 match k.as_str() {
800 "callee" => callee = decode_expr(dec)?,
801 "args" => args = decode_args(dec)?,
802 _ => dec.skip()?,
803 }
804 }
805 ExprKind::Call {
806 callee: Box::new(callee),
807 args,
808 }
809 }
810 "Index" => {
811 let mut recv = Expr {
812 span: Span::new(0, 0),
813 kind: ExprKind::Literal(Literal::Null),
814 };
815 let mut index = Expr {
816 span: Span::new(0, 0),
817 kind: ExprKind::Literal(Literal::Null),
818 };
819 for _ in 0..remaining_pairs {
820 let k = dec.str()?;
821 match k.as_str() {
822 "recv" => recv = decode_expr(dec)?,
823 "index" => index = decode_expr(dec)?,
824 _ => dec.skip()?,
825 }
826 }
827 ExprKind::Index {
828 recv: Box::new(recv),
829 index: Box::new(index),
830 }
831 }
832 "Try" => {
833 let e = decode_expr(dec)?;
834 for _ in 0..remaining_pairs {
835 dec.skip()?;
836 }
837 ExprKind::Try(Box::new(e))
838 }
839 "List" => {
840 let n = dec.array()?;
841 let mut es = Vec::with_capacity(n as usize);
842 for _ in 0..n {
843 es.push(decode_expr(dec)?);
844 }
845 ExprKind::List(es)
846 }
847 "Record" => ExprKind::Record(decode_named_args(dec)?),
848 "Triple" => {
849 let mut subject = Expr {
850 span: Span::new(0, 0),
851 kind: ExprKind::Literal(Literal::Null),
852 };
853 let mut predicate = Expr {
854 span: Span::new(0, 0),
855 kind: ExprKind::Literal(Literal::Null),
856 };
857 let mut object = Expr {
858 span: Span::new(0, 0),
859 kind: ExprKind::Literal(Literal::Null),
860 };
861 for _ in 0..remaining_pairs {
862 let k = dec.str()?;
863 match k.as_str() {
864 "subject" => subject = decode_expr(dec)?,
865 "predicate" => predicate = decode_expr(dec)?,
866 "object" => object = decode_expr(dec)?,
867 _ => dec.skip()?,
868 }
869 }
870 ExprKind::Triple {
871 subject: Box::new(subject),
872 predicate: Box::new(predicate),
873 object: Box::new(object),
874 }
875 }
876 "Reified" => {
877 let mut subject = Expr {
878 span: Span::new(0, 0),
879 kind: ExprKind::Literal(Literal::Null),
880 };
881 let mut predicate = Expr {
882 span: Span::new(0, 0),
883 kind: ExprKind::Literal(Literal::Null),
884 };
885 let mut object = Expr {
886 span: Span::new(0, 0),
887 kind: ExprKind::Literal(Literal::Null),
888 };
889 let mut reifier = Expr {
890 span: Span::new(0, 0),
891 kind: ExprKind::Literal(Literal::Null),
892 };
893 for _ in 0..remaining_pairs {
894 let k = dec.str()?;
895 match k.as_str() {
896 "subject" => subject = decode_expr(dec)?,
897 "predicate" => predicate = decode_expr(dec)?,
898 "object" => object = decode_expr(dec)?,
899 "reifier" => reifier = decode_expr(dec)?,
900 _ => dec.skip()?,
901 }
902 }
903 ExprKind::Reified {
904 subject: Box::new(subject),
905 predicate: Box::new(predicate),
906 object: Box::new(object),
907 reifier: Box::new(reifier),
908 }
909 }
910 "prefix" => {
911 let prefix = dec.str()?;
913 let local = dec.str()?;
914 for _ in 0..remaining_pairs {
915 dec.skip()?;
916 }
917 ExprKind::Prefixed(prefix, local)
918 }
919 "Interpolate" => {
920 let n = dec.array()?;
921 let mut parts = Vec::with_capacity(n as usize);
922 for _ in 0..n {
923 parts.push(decode_expr(dec)?);
924 }
925 ExprKind::Interpolate(parts)
926 }
927 "Lambda" => {
928 let mut params = Vec::new();
929 let mut body = Expr {
930 span: Span::new(0, 0),
931 kind: ExprKind::Literal(Literal::Null),
932 };
933 for _ in 0..remaining_pairs {
934 let k = dec.str()?;
935 match k.as_str() {
936 "params" => params = decode_str_list(dec)?,
937 "body" => body = decode_expr(dec)?,
938 _ => dec.skip()?,
939 }
940 }
941 ExprKind::Lambda {
942 params,
943 body: Box::new(body),
944 }
945 }
946 "Tween" => {
947 let mut from = Expr {
948 span: Span::new(0, 0),
949 kind: ExprKind::Literal(Literal::Null),
950 };
951 let mut to = from.clone();
952 let mut over = from.clone();
953 let mut ease = None;
954 let mut spring = None;
955 for _ in 0..remaining_pairs {
956 let k = dec.str()?;
957 match k.as_str() {
958 "from" => from = decode_expr(dec)?,
959 "to" => to = decode_expr(dec)?,
960 "over" => over = decode_expr(dec)?,
961 "ease" => {
962 if dec.is_null()? {
963 dec.skip()?;
964 } else {
965 ease = Some(dec.str()?);
966 }
967 }
968 "spring" => {
969 if dec.is_null()? {
970 dec.skip()?;
971 } else {
972 spring = Some(decode_named_args(dec)?);
973 }
974 }
975 _ => dec.skip()?,
976 }
977 }
978 ExprKind::Tween {
979 from: Box::new(from),
980 to: Box::new(to),
981 over: Box::new(over),
982 ease,
983 spring,
984 }
985 }
986 "IfElse" => {
987 let mut cond = None;
988 let mut then_value = None;
989 let mut else_value = None;
990 for _ in 0..remaining_pairs {
991 let k = dec.str()?;
992 match k.as_str() {
993 "cond" => cond = Some(decode_expr(dec)?),
994 "then" => then_value = Some(decode_expr(dec)?),
995 "else" => else_value = Some(decode_expr(dec)?),
996 _ => dec.skip()?,
997 }
998 }
999 ExprKind::IfElse {
1000 cond: Box::new(cond.ok_or(DecodeError::MissingField("cond"))?),
1001 then_value: Box::new(then_value.ok_or(DecodeError::MissingField("then"))?),
1002 else_value: Box::new(else_value.ok_or(DecodeError::MissingField("else"))?),
1003 }
1004 }
1005 "ModalLogic" => {
1006 let n = dec.map()?;
1007 let mut modality = ModalKind::DeonticObligate;
1008 let mut args = Vec::new();
1009 let mut body = None;
1010 for _ in 0..n {
1011 let k = dec.str()?;
1012 match k.as_str() {
1013 "modality" => {
1014 let m = dec.str()?;
1015 modality = match m.as_str() {
1016 "obligate" => ModalKind::DeonticObligate,
1017 "permit" => ModalKind::DeonticPermit,
1018 "forbid" => ModalKind::DeonticForbid,
1019 "knows" => ModalKind::EpistemicKnows,
1020 "believes" => ModalKind::EpistemicBelieves,
1021 "paraconsistent" => ModalKind::Paraconsistent,
1022 "always" => ModalKind::LtlGlobally,
1023 "eventually" => ModalKind::LtlFinally,
1024 "until" => ModalKind::LtlUntil,
1025 "subsumes" => ModalKind::DlSubsumes,
1026 "defeasible_rule" => ModalKind::N3Defeasible,
1027 _ => {
1028 return Err(DecodeError::InvalidCbor(format!(
1029 "unknown modality '{m}'"
1030 )))
1031 }
1032 };
1033 }
1034 "args" => {
1035 let count = dec.array()?;
1036 args = Vec::with_capacity(count as usize);
1037 for _ in 0..count {
1038 args.push(decode_expr(dec)?);
1039 }
1040 }
1041 "body" => {
1042 if dec.is_null()? {
1043 dec.null()?;
1044 body = None;
1045 } else {
1046 body = Some(Box::new(decode_expr(dec)?));
1047 }
1048 }
1049 _ => dec.skip()?,
1050 }
1051 }
1052 ExprKind::ModalLogic {
1053 modality,
1054 args,
1055 body,
1056 }
1057 }
1058 _ => {
1059 for _ in 0..remaining_pairs {
1060 dec.skip()?;
1061 }
1062 ExprKind::Ident(variant)
1063 }
1064 };
1065 Ok(kind)
1067}
1068
1069fn decode_args(dec: &mut CborDecoder) -> Result<Vec<Arg>, DecodeError> {
1070 let n = dec.array()?;
1071 let mut out = Vec::with_capacity(n as usize);
1072 for _ in 0..n {
1073 let map_len = dec.map()?;
1074 if map_len < 1 {
1075 return Err(DecodeError::InvalidCbor("empty Arg map".into()));
1076 }
1077 let key = dec.str()?;
1078 match key.as_str() {
1079 "Pos" => {
1080 let e = decode_expr(dec)?;
1081 for _ in 1..map_len {
1082 dec.skip()?;
1083 }
1084 out.push(Arg::Pos(e));
1085 }
1086 "Named" => {
1087 let na = decode_named_arg(dec)?;
1088 for _ in 1..map_len {
1089 dec.skip()?;
1090 }
1091 out.push(Arg::Named(na));
1092 }
1093 _ => {
1094 for _ in 0..map_len - 1 {
1095 dec.skip()?;
1096 }
1097 }
1098 }
1099 }
1100 Ok(out)
1101}
1102
1103fn decode_named_arg(dec: &mut CborDecoder) -> Result<NamedArg, DecodeError> {
1104 let map_len = dec.map()?;
1105 let mut name = String::new();
1106 let mut value = Expr {
1107 span: Span::new(0, 0),
1108 kind: ExprKind::Literal(Literal::Null),
1109 };
1110 let mut span = Span::new(0, 0);
1111 for _ in 0..map_len {
1112 let key = dec.str()?;
1113 match key.as_str() {
1114 "name" => name = dec.str()?,
1115 "value" => value = decode_expr(dec)?,
1116 "span" => span = decode_span(dec)?,
1117 _ => dec.skip()?,
1118 }
1119 }
1120 Ok(NamedArg { span, name, value })
1121}
1122
1123fn decode_binop(dec: &mut CborDecoder) -> Result<BinOp, DecodeError> {
1124 let s = dec.str()?;
1125 match s.as_str() {
1126 "Or" => Ok(BinOp::Or),
1127 "And" => Ok(BinOp::And),
1128 "Eq" => Ok(BinOp::Eq),
1129 "Ne" => Ok(BinOp::Ne),
1130 "Lt" => Ok(BinOp::Lt),
1131 "Le" => Ok(BinOp::Le),
1132 "Gt" => Ok(BinOp::Gt),
1133 "Ge" => Ok(BinOp::Ge),
1134 "Add" => Ok(BinOp::Add),
1135 "Sub" => Ok(BinOp::Sub),
1136 "Mul" => Ok(BinOp::Mul),
1137 "Div" => Ok(BinOp::Div),
1138 "Rem" => Ok(BinOp::Rem),
1139 _ => Err(DecodeError::UnexpectedType("BinOp")),
1140 }
1141}
1142
1143fn decode_unop(dec: &mut CborDecoder) -> Result<UnOp, DecodeError> {
1144 let s = dec.str()?;
1145 match s.as_str() {
1146 "Not" => Ok(UnOp::Not),
1147 "Neg" => Ok(UnOp::Neg),
1148 "Plus" => Ok(UnOp::Plus),
1149 _ => Err(DecodeError::UnexpectedType("UnOp")),
1150 }
1151}
1152
1153fn decode_literal(dec: &mut CborDecoder) -> Result<Literal, DecodeError> {
1154 let map_len = dec.map()?;
1155 let mut lit_type = String::new();
1156 let mut value_u = 0u64;
1157 let mut value_i = 0i64;
1158 let mut value_b = false;
1159 let mut value_s = String::new();
1160 let mut r = 0u64;
1161 let mut g = 0u64;
1162 let mut b = 0u64;
1163 let mut a = 255u64;
1164 for _ in 0..map_len {
1165 let key = dec.str()?;
1166 match key.as_str() {
1167 "type" => lit_type = dec.str()?,
1168 "r" => r = dec.uint()?,
1169 "g" => g = dec.uint()?,
1170 "b" => b = dec.uint()?,
1171 "a" => a = dec.uint()?,
1172 "value" => {
1173 if dec.peek()? == 0xF5 || dec.peek()? == 0xF4 {
1174 value_b = dec.bool()?;
1175 } else if dec.peek()? >> 5 == 0 {
1176 value_u = dec.uint()?;
1177 value_i = value_u as i64; } else if dec.peek()? >> 5 == 1 {
1179 value_i = dec.int()?;
1180 value_u = value_i as u64; } else {
1182 value_s = dec.str()?;
1183 }
1184 }
1185 "bits" => value_u = dec.uint()?,
1186 _ => dec.skip()?,
1187 }
1188 }
1189 match lit_type.as_str() {
1190 "Null" => Ok(Literal::Null),
1191 "Bool" => Ok(Literal::Bool(value_b)),
1192 "Int" => Ok(Literal::Int(value_i)),
1193 "UInt" => Ok(Literal::UInt(value_u)),
1194 "Float" => Ok(Literal::Float(value_u)),
1195 "String" => Ok(Literal::String(value_s)),
1196 "Color" => Ok(Literal::Color(crate::ast::ColorLit {
1197 r: r as u8,
1198 g: g as u8,
1199 b: b as u8,
1200 a: a as u8,
1201 })),
1202 _ => Err(DecodeError::UnexpectedType("Literal")),
1203 }
1204}
1205
1206fn decode_params(dec: &mut CborDecoder) -> Result<Vec<Param>, DecodeError> {
1207 let n = dec.array()?;
1208 let mut out = Vec::with_capacity(n as usize);
1209 for _ in 0..n {
1210 let map_len = dec.map()?;
1211 let mut name = String::new();
1212 let mut ty = TypeExpr {
1213 span: Span::new(0, 0),
1214 name: String::new(),
1215 args: Vec::new(),
1216 };
1217 let mut span = Span::new(0, 0);
1218 for _ in 0..map_len {
1219 let key = dec.str()?;
1220 match key.as_str() {
1221 "name" => name = dec.str()?,
1222 "ty" => ty = decode_type_expr(dec)?,
1223 "span" => span = decode_span(dec)?,
1224 _ => dec.skip()?,
1225 }
1226 }
1227 out.push(Param { span, name, ty });
1228 }
1229 Ok(out)
1230}
1231
1232fn decode_type_expr(dec: &mut CborDecoder) -> Result<TypeExpr, DecodeError> {
1233 let map_len = dec.map()?;
1234 let mut name = String::new();
1235 let mut args = Vec::new();
1236 let mut span = Span::new(0, 0);
1237 for _ in 0..map_len {
1238 let key = dec.str()?;
1239 match key.as_str() {
1240 "name" => name = dec.str()?,
1241 "args" => {
1242 let n = dec.array()?;
1243 args = Vec::with_capacity(n as usize);
1244 for _ in 0..n {
1245 args.push(decode_type_expr(dec)?);
1246 }
1247 }
1248 "span" => span = decode_span(dec)?,
1249 _ => dec.skip()?,
1250 }
1251 }
1252 Ok(TypeExpr { span, name, args })
1253}
1254
1255fn decode_block(dec: &mut CborDecoder) -> Result<Block, DecodeError> {
1256 let map_len = dec.map()?;
1257 let mut stmts = Vec::new();
1258 let mut span = Span::new(0, 0);
1259 for _ in 0..map_len {
1260 let key = dec.str()?;
1261 match key.as_str() {
1262 "stmts" => {
1263 let n = dec.array()?;
1264 stmts = Vec::with_capacity(n as usize);
1265 for _ in 0..n {
1266 stmts.push(decode_stmt(dec)?);
1267 }
1268 }
1269 "span" => span = decode_span(dec)?,
1270 _ => dec.skip()?,
1271 }
1272 }
1273 Ok(Block { span, stmts })
1274}
1275
1276fn decode_stmt(dec: &mut CborDecoder) -> Result<Stmt, DecodeError> {
1277 let map_len = dec.map()?;
1278 if map_len < 1 {
1279 return Err(DecodeError::InvalidCbor("empty Stmt map".into()));
1280 }
1281 let mut stmt_type = String::new();
1282 let mut fields: Vec<(String, StmtVal)> = Vec::with_capacity(map_len as usize);
1284 for _ in 0..map_len {
1285 let key = dec.str()?;
1286 if key == "type" {
1287 stmt_type = dec.str()?;
1288 } else {
1289 let val = decode_stmt_field(&key, dec)?;
1290 fields.push((key, val));
1291 }
1292 }
1293 match stmt_type.as_str() {
1295 "Let" => {
1296 let mut name = String::new();
1297 let mut mutable = false;
1298 let mut ty = None;
1299 let mut value = None;
1300 for (k, v) in fields {
1301 match (k.as_str(), v) {
1302 ("name", StmtVal::Str(s)) => name = s,
1303 ("mutable", StmtVal::Bool(b)) => mutable = b,
1304 ("ty", StmtVal::TypeExpr(t)) => ty = t,
1305 ("value", StmtVal::Expr(e)) => value = Some(e),
1306 _ => {}
1307 }
1308 }
1309 Ok(Stmt::Let {
1310 span: Span::new(0, 0),
1311 mutable,
1312 name,
1313 ty,
1314 value,
1315 })
1316 }
1317 "Assign" => {
1318 let mut target = Expr {
1319 span: Span::new(0, 0),
1320 kind: ExprKind::Literal(Literal::Null),
1321 };
1322 let mut value = Expr {
1323 span: Span::new(0, 0),
1324 kind: ExprKind::Literal(Literal::Null),
1325 };
1326 for (k, v) in fields {
1327 match (k.as_str(), v) {
1328 ("target", StmtVal::Expr(e)) => target = e,
1329 ("value", StmtVal::Expr(e)) => value = e,
1330 _ => {}
1331 }
1332 }
1333 Ok(Stmt::Assign {
1334 span: Span::new(0, 0),
1335 target,
1336 value,
1337 })
1338 }
1339 "If" => {
1340 let mut cond = Expr {
1341 span: Span::new(0, 0),
1342 kind: ExprKind::Literal(Literal::Null),
1343 };
1344 let mut then_block = Block {
1345 span: Span::new(0, 0),
1346 stmts: Vec::new(),
1347 };
1348 let mut else_block = None;
1349 for (k, v) in fields {
1350 match (k.as_str(), v) {
1351 ("cond", StmtVal::Expr(e)) => cond = e,
1352 ("then", StmtVal::Block(b)) => then_block = b,
1353 ("else", StmtVal::Stmt(s)) => else_block = Some(Box::new(s)),
1354 _ => {}
1355 }
1356 }
1357 Ok(Stmt::If {
1358 span: Span::new(0, 0),
1359 cond,
1360 then_block,
1361 else_block,
1362 })
1363 }
1364 "For" => {
1365 let mut name = String::new();
1366 let mut iter = Expr {
1367 span: Span::new(0, 0),
1368 kind: ExprKind::Literal(Literal::Null),
1369 };
1370 let mut body = Block {
1371 span: Span::new(0, 0),
1372 stmts: Vec::new(),
1373 };
1374 for (k, v) in fields {
1375 match (k.as_str(), v) {
1376 ("name", StmtVal::Str(s)) => name = s,
1377 ("iter", StmtVal::Expr(e)) => iter = e,
1378 ("body", StmtVal::Block(b)) => body = b,
1379 _ => {}
1380 }
1381 }
1382 Ok(Stmt::For {
1383 span: Span::new(0, 0),
1384 name,
1385 iter,
1386 body,
1387 })
1388 }
1389 "While" => {
1390 let mut cond = Expr {
1391 span: Span::new(0, 0),
1392 kind: ExprKind::Literal(Literal::Null),
1393 };
1394 let mut body = Block {
1395 span: Span::new(0, 0),
1396 stmts: Vec::new(),
1397 };
1398 for (k, v) in fields {
1399 match (k.as_str(), v) {
1400 ("cond", StmtVal::Expr(e)) => cond = e,
1401 ("body", StmtVal::Block(b)) => body = b,
1402 _ => {}
1403 }
1404 }
1405 Ok(Stmt::While {
1406 span: Span::new(0, 0),
1407 cond,
1408 body,
1409 })
1410 }
1411 "Match" => {
1412 let mut scrutinee = Expr {
1413 span: Span::new(0, 0),
1414 kind: ExprKind::Literal(Literal::Null),
1415 };
1416 let mut arms = Vec::new();
1417 for (k, v) in fields {
1418 match (k.as_str(), v) {
1419 ("scrutinee", StmtVal::Expr(e)) => scrutinee = e,
1420 ("arms", StmtVal::Arms(a)) => arms = a,
1421 _ => {}
1422 }
1423 }
1424 Ok(Stmt::Match {
1425 span: Span::new(0, 0),
1426 scrutinee,
1427 arms,
1428 })
1429 }
1430 "Return" => {
1431 let mut value = None;
1432 for (k, v) in fields {
1433 if k == "value" {
1434 if let StmtVal::Expr(e) = v {
1435 value = Some(e);
1436 }
1437 }
1438 }
1439 Ok(Stmt::Return {
1440 span: Span::new(0, 0),
1441 value,
1442 })
1443 }
1444 "Yield" => {
1445 let mut value = None;
1446 for (k, v) in fields {
1447 if k == "value" {
1448 if let StmtVal::Expr(e) = v {
1449 value = Some(e);
1450 }
1451 }
1452 }
1453 Ok(Stmt::Yield {
1454 span: Span::new(0, 0),
1455 value,
1456 })
1457 }
1458 "Transaction" => {
1459 let mut args = Vec::new();
1460 let mut body = Block {
1461 span: Span::new(0, 0),
1462 stmts: Vec::new(),
1463 };
1464 for (k, v) in fields {
1465 match (k.as_str(), v) {
1466 ("args", StmtVal::NamedArgs(na)) => args = na,
1467 ("body", StmtVal::Block(b)) => body = b,
1468 _ => {}
1469 }
1470 }
1471 Ok(Stmt::Transaction {
1472 span: Span::new(0, 0),
1473 args,
1474 body,
1475 })
1476 }
1477 "Effect" => {
1478 let mut expr = Expr {
1479 span: Span::new(0, 0),
1480 kind: ExprKind::Literal(Literal::Null),
1481 };
1482 for (k, v) in fields {
1483 if k == "expr" {
1484 if let StmtVal::Expr(e) = v {
1485 expr = e;
1486 }
1487 }
1488 }
1489 Ok(Stmt::Effect {
1490 span: Span::new(0, 0),
1491 expr,
1492 })
1493 }
1494 "Expr" => {
1495 let mut expr = Expr {
1496 span: Span::new(0, 0),
1497 kind: ExprKind::Literal(Literal::Null),
1498 };
1499 for (k, v) in fields {
1500 if k == "expr" {
1501 if let StmtVal::Expr(e) = v {
1502 expr = e;
1503 }
1504 }
1505 }
1506 Ok(Stmt::Expr {
1507 span: Span::new(0, 0),
1508 expr,
1509 })
1510 }
1511 "LetPat" => {
1512 let mut pattern = Pattern::Wildcard;
1513 let mut mutable = false;
1514 let mut ty = None;
1515 let mut value = Expr {
1516 span: Span::new(0, 0),
1517 kind: ExprKind::Literal(Literal::Null),
1518 };
1519 for (k, v) in fields {
1520 match (k.as_str(), v) {
1521 ("pattern", StmtVal::Pattern(p)) => pattern = p,
1522 ("mutable", StmtVal::Bool(b)) => mutable = b,
1523 ("ty", StmtVal::TypeExpr(t)) => ty = t,
1524 ("value", StmtVal::Expr(e)) => value = e,
1525 _ => {}
1526 }
1527 }
1528 Ok(Stmt::LetPat {
1529 span: Span::new(0, 0),
1530 mutable,
1531 pattern,
1532 ty,
1533 value,
1534 })
1535 }
1536 "Block" => {
1537 for (k, v) in fields {
1538 if k == "block" {
1539 if let StmtVal::Block(b) = v {
1540 return Ok(Stmt::Block(b));
1541 }
1542 }
1543 }
1544 Err(DecodeError::MissingField("block"))
1545 }
1546 _ => Err(DecodeError::UnexpectedType("Stmt")),
1547 }
1548}
1549
1550enum StmtVal {
1552 Str(String),
1553 Bool(bool),
1554 Expr(Expr),
1555 Block(Block),
1556 Stmt(Stmt),
1557 Pattern(Pattern),
1558 TypeExpr(Option<TypeExpr>),
1559 NamedArgs(Vec<NamedArg>),
1560 Arms(Vec<MatchArm>),
1561}
1562
1563fn decode_stmt_field(key: &str, dec: &mut CborDecoder) -> Result<StmtVal, DecodeError> {
1564 match key {
1565 "name" => Ok(StmtVal::Str(dec.str()?)),
1566 "mutable" => Ok(StmtVal::Bool(dec.bool()?)),
1567 "pattern" => Ok(StmtVal::Pattern(decode_pattern(dec)?)),
1568 "ty" => {
1569 if dec.is_null()? {
1570 dec.skip()?;
1571 Ok(StmtVal::TypeExpr(None))
1572 } else {
1573 Ok(StmtVal::TypeExpr(Some(decode_type_expr(dec)?)))
1574 }
1575 }
1576 "cond" | "target" | "iter" | "scrutinee" | "expr" | "value" => {
1577 if dec.is_null()? {
1578 dec.skip()?;
1579 Ok(StmtVal::Expr(Expr {
1580 span: Span::new(0, 0),
1581 kind: ExprKind::Literal(Literal::Null),
1582 }))
1583 } else {
1584 Ok(StmtVal::Expr(decode_expr(dec)?))
1585 }
1586 }
1587 "then" | "body" | "block" => Ok(StmtVal::Block(decode_block(dec)?)),
1588 "else" => {
1589 if dec.is_null()? {
1590 dec.skip()?;
1591 Ok(StmtVal::Expr(Expr {
1592 span: Span::new(0, 0),
1593 kind: ExprKind::Literal(Literal::Null),
1594 }))
1595 } else {
1596 Ok(StmtVal::Stmt(decode_stmt(dec)?))
1597 }
1598 }
1599 "args" => Ok(StmtVal::NamedArgs(decode_named_args(dec)?)),
1600 "arms" => {
1601 let n = dec.array()?;
1602 let mut arms = Vec::with_capacity(n as usize);
1603 for _ in 0..n {
1604 let m = dec.map()?;
1605 let mut pattern = Pattern::Wildcard;
1606 let mut body = ArmBody::Expr(Expr {
1607 span: Span::new(0, 0),
1608 kind: ExprKind::Literal(Literal::Null),
1609 });
1610 for _ in 0..m {
1611 let k = dec.str()?;
1612 match k.as_str() {
1613 "pattern" => pattern = decode_pattern(dec)?,
1614 "body" => body = decode_arm_body(dec)?,
1615 "span" => {
1616 let _ = decode_span(dec)?;
1617 }
1618 _ => dec.skip()?,
1619 }
1620 }
1621 arms.push(MatchArm {
1622 span: Span::new(0, 0),
1623 pattern,
1624 body,
1625 });
1626 }
1627 Ok(StmtVal::Arms(arms))
1628 }
1629 _ => {
1630 dec.skip()?;
1631 Ok(StmtVal::Str(String::new()))
1632 }
1633 }
1634}
1635
1636fn decode_pattern(dec: &mut CborDecoder) -> Result<Pattern, DecodeError> {
1637 let map_len = dec.map()?;
1638 if map_len < 1 {
1639 return Err(DecodeError::InvalidCbor("empty Pattern map".into()));
1640 }
1641 let mut pat_type = String::new();
1642 let mut name = String::new();
1643 let mut enum_name = String::new();
1644 let mut variant_name = String::new();
1645 let mut lit = None;
1646 let mut inner = None;
1647 let mut fields = Vec::new();
1648 let mut elements = Vec::new();
1649 let mut args = Vec::new();
1650
1651 for _ in 0..map_len {
1652 let key = dec.str()?;
1653 match key.as_str() {
1654 "type" => pat_type = dec.str()?,
1655 "name" => name = dec.str()?,
1656 "enum" => enum_name = dec.str()?,
1657 "variant" => variant_name = dec.str()?,
1658 "lit" => lit = Some(decode_literal(dec)?),
1659 "inner" => inner = Some(Box::new(decode_pattern(dec)?)),
1660 "fields" => {
1661 let n = dec.array()?;
1662 for _ in 0..n {
1663 let field_map = dec.map()?;
1664 let mut fname = String::new();
1665 let mut fpat = Pattern::Wildcard;
1666 for _ in 0..field_map {
1667 match dec.str()?.as_str() {
1668 "name" => fname = dec.str()?,
1669 "pattern" => fpat = decode_pattern(dec)?,
1670 _ => dec.skip()?,
1671 }
1672 }
1673 fields.push((fname, fpat));
1674 }
1675 }
1676 "elements" => {
1677 let n = dec.array()?;
1678 for _ in 0..n {
1679 elements.push(decode_pattern(dec)?);
1680 }
1681 }
1682 "args" => {
1683 let n = dec.array()?;
1684 for _ in 0..n {
1685 args.push(decode_pattern(dec)?);
1686 }
1687 }
1688 _ => dec.skip()?,
1689 }
1690 }
1691
1692 match pat_type.as_str() {
1693 "Wildcard" => Ok(Pattern::Wildcard),
1694 "None" => Ok(Pattern::None),
1695 "Ident" => Ok(Pattern::Ident(name)),
1696 "Literal" => Ok(Pattern::Literal(lit.unwrap_or(Literal::Null))),
1697 "Ok" => Ok(Pattern::Ok(
1698 inner.unwrap_or_else(|| Box::new(Pattern::Wildcard)),
1699 )),
1700 "Err" => Ok(Pattern::Err(
1701 inner.unwrap_or_else(|| Box::new(Pattern::Wildcard)),
1702 )),
1703 "Some" => Ok(Pattern::Some(
1704 inner.unwrap_or_else(|| Box::new(Pattern::Wildcard)),
1705 )),
1706 "Record" => Ok(Pattern::Record(fields)),
1707 "List" => Ok(Pattern::List(elements)),
1708 "Constructor" => Ok(Pattern::Constructor { name, args }),
1709 "Variant" => Ok(Pattern::Variant {
1710 enum_name,
1711 variant_name,
1712 args,
1713 }),
1714 _ => Err(DecodeError::UnexpectedType("Pattern")),
1715 }
1716}
1717
1718fn decode_arm_body(dec: &mut CborDecoder) -> Result<ArmBody, DecodeError> {
1719 let map_len = dec.map()?;
1720 if map_len < 1 {
1721 return Err(DecodeError::InvalidCbor("empty ArmBody map".into()));
1722 }
1723 let key = dec.str()?;
1724 let body = match key.as_str() {
1725 "Block" => ArmBody::Block(decode_block(dec)?),
1726 "Expr" => ArmBody::Expr(decode_expr(dec)?),
1727 _ => return Err(DecodeError::UnexpectedType("ArmBody")),
1728 };
1729 for _ in 1..map_len {
1730 dec.skip()?;
1731 }
1732 Ok(body)
1733}