Skip to main content

vibe/cbor_ast/
decode.rs

1//! Decode CBOR-LD to Program.
2
3use super::codec::CborDecoder;
4use super::{DecodeError, TAG_VIBE_AST};
5use crate::ast::*;
6use crate::span::Span;
7
8/// Decodes CBOR.
9pub 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
18// ── Encode ─────────────────────────────────────────────────────────────────
19fn 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    // Decode all key-value pairs in a single pass, storing into locals.
233    // We don't know the item type until we see "type", so we buffer
234    // field values as an enum and construct the Item at the end.
235    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    // Construct the Item from the collected fields based on item_type.
246    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
539/// Buffered field value for Item construction after single-pass decode.
540enum 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            // "args" in Item context could be NamedArgs or Args — for Function/Hook
612            // budget it's NamedArgs. For Call args it's Args. But we're in decode_item_field,
613            // so this is for Item-level fields only.
614            if key == "budget" {
615                Ok(ItemField::NamedArgs(decode_named_args(dec)?))
616            } else {
617                // Skip unknown "args" — will be handled by Stmt decoding
618                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    // ExprKind is encoded as a single-key map where the key is the variant name,
704    // or as {"type": "VariantName", ...}.
705    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            // Prefixed(prefix, local)
912            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    // Skip any remaining fields
1066    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; // positive int works for both Int and UInt
1178                } else if dec.peek()? >> 5 == 1 {
1179                    value_i = dec.int()?;
1180                    value_u = value_i as u64; // negative int as two's complement
1181                } 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    // Single-pass decode: buffer field values as StmtVal, construct at end.
1283    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    // Construct the Stmt from collected fields.
1294    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
1550/// Buffered field value for Stmt construction after single-pass decode.
1551enum 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}