Skip to main content

vibe/cbor_ast/
mod.rs

1//! Homoiconic CBOR-LD AST Codec (Tag 4200).
2
3pub mod cbor_ld;
4mod codec;
5mod decode;
6mod encode;
7
8pub const TAG_VIBE_AST: u64 = 4200;
9
10#[derive(Debug, Clone, PartialEq)]
11pub enum DecodeError {
12    UnexpectedTag(u64),
13    UnexpectedType(&'static str),
14    MissingField(&'static str),
15    InvalidCbor(String),
16    Eof,
17}
18
19impl std::fmt::Display for DecodeError {
20    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21        match self {
22            Self::UnexpectedTag(t) => write!(f, "unexpected CBOR tag {t}"),
23            Self::UnexpectedType(t) => write!(f, "unexpected type: {t}"),
24            Self::MissingField(fld) => write!(f, "missing field: {fld}"),
25            Self::InvalidCbor(s) => write!(f, "invalid CBOR: {s}"),
26            Self::Eof => write!(f, "unexpected end of input"),
27        }
28    }
29}
30
31impl std::error::Error for DecodeError {}
32
33pub use cbor_ld::{
34    call_cbor_ld, compress_iri, decode_value_cbor_ld, derive_provider_namespace,
35    encode_value_cbor_ld, expand_term, ingest_json_with_provider_ns, DEFAULT_CONTEXT_IRI,
36    TAG_CBOR_LD_COMPRESSED, TAG_CBOR_LD_UNCOMPRESSED, TAG_VIBE_DISCLOSURE_DENIED,
37    TAG_VIBE_DURATION, TAG_VIBE_INSTANT, TAG_VIBE_IRI, TAG_VIBE_QUANTITY, TAG_VIBE_QUIN_REF,
38};
39pub use decode::decode;
40pub use encode::encode;
41
42#[cfg(test)]
43mod tests {
44    use super::codec::{CborDecoder, CborEncoder};
45    use super::*;
46    use crate::ast::*;
47    use crate::span::Span;
48
49    #[test]
50    fn encode_decode_empty_program() {
51        let prog = Program {
52            span: Span::new(0, 0),
53            module: None,
54            imports: Vec::new(),
55            prefixes: Vec::new(),
56            locales: Vec::new(),
57            requires: Vec::new(),
58            items: Vec::new(),
59        };
60        let bytes = encode(&prog);
61        assert!(!bytes.is_empty());
62        // Tag 4200 = major 6, len 4200
63        // 4200 = 0x1068, so ai=25, 2 bytes
64        assert_eq!(bytes[0], (6 << 5) | 25);
65        let decoded = decode(&bytes).unwrap();
66        assert_eq!(decoded, prog);
67    }
68
69    #[test]
70    fn encode_decode_simple_program() {
71        let prog = Program {
72            span: Span::new(0, 50),
73            module: Some(ModuleDecl {
74                span: Span::new(0, 20),
75                name: Name::Ident("test".to_string()),
76            }),
77            imports: vec![ImportDecl {
78                span: Span::new(21, 40),
79                path: "vibe:0.1/render".to_string(),
80                alias: Some("r".to_string()),
81            }],
82            prefixes: vec![PrefixDecl {
83                span: Span::new(41, 45),
84                prefix: "ex".to_string(),
85                iri: "http://example.org/".to_string(),
86            }],
87            locales: Vec::new(),
88            requires: vec![CapSpec {
89                span: Span::new(46, 48),
90                id: "capability.invoke".to_string(),
91                args: Vec::new(),
92            }],
93            items: vec![Item::Const(ConstDecl {
94                span: Span::new(49, 50),
95                name: "x".to_string(),
96                ty: None,
97                value: Expr {
98                    span: Span::new(49, 50),
99                    kind: ExprKind::Literal(Literal::Int(42)),
100                },
101            })],
102        };
103        let bytes = encode(&prog);
104        let decoded = decode(&bytes).unwrap();
105        assert_eq!(decoded, prog);
106    }
107
108    #[test]
109    fn cbor_encoder_basic() {
110        let mut enc = CborEncoder::new();
111        enc.uint(42);
112        // 42 >= 24, so CBOR uses ai=24 + 1 byte: [24, 42]
113        assert_eq!(enc.finish(), vec![24, 42]);
114
115        let mut enc = CborEncoder::new();
116        enc.uint(5);
117        // 5 < 24, so CBOR uses ai directly: [5]
118        assert_eq!(enc.finish(), vec![5]);
119
120        let mut enc = CborEncoder::new();
121        enc.str("hello");
122        let bytes = enc.finish();
123        assert_eq!(bytes[0], (3 << 5) | 5); // string, len 5
124        assert_eq!(&bytes[1..], b"hello");
125    }
126
127    #[test]
128    fn cbor_encoder_array() {
129        let mut enc = CborEncoder::new();
130        enc.array(3);
131        enc.uint(1);
132        enc.uint(2);
133        enc.uint(3);
134        assert_eq!(enc.finish(), vec![0x83, 1, 2, 3]);
135    }
136
137    #[test]
138    fn cbor_encoder_map() {
139        let mut enc = CborEncoder::new();
140        enc.map(2);
141        enc.str("a");
142        enc.uint(1);
143        enc.str("b");
144        enc.uint(2);
145        let bytes = enc.finish();
146        assert_eq!(bytes[0], (5 << 5) | 2); // map, len 2
147    }
148
149    #[test]
150    fn cbor_encoder_tag() {
151        let mut enc = CborEncoder::new();
152        enc.tag(4200);
153        let bytes = enc.finish();
154        // Tag 4200: major 6, ai=25 (2-byte len), 4200 = 0x1068
155        assert_eq!(bytes, vec![(6 << 5) | 25, 0x10, 0x68]);
156    }
157
158    #[test]
159    fn cbor_decoder_basic() {
160        // 42 >= 24, so CBOR encodes as [24, 42]
161        let mut dec = CborDecoder::new(&[24, 42]);
162        assert_eq!(dec.uint().unwrap(), 42);
163        // 5 < 24, so CBOR encodes as [5]
164        let mut dec = CborDecoder::new(&[5]);
165        assert_eq!(dec.uint().unwrap(), 5);
166    }
167
168    #[test]
169    fn cbor_decoder_string() {
170        let bytes = [(3 << 5) | 5, b'h', b'e', b'l', b'l', b'o'];
171        let mut dec = CborDecoder::new(&bytes);
172        assert_eq!(dec.str().unwrap(), "hello");
173    }
174
175    #[test]
176    fn cbor_decoder_array() {
177        let mut dec = CborDecoder::new(&[0x83, 1, 2, 3]);
178        assert_eq!(dec.array().unwrap(), 3);
179        assert_eq!(dec.uint().unwrap(), 1);
180        assert_eq!(dec.uint().unwrap(), 2);
181        assert_eq!(dec.uint().unwrap(), 3);
182    }
183
184    #[test]
185    fn cbor_decoder_tag() {
186        let bytes = [(6 << 5) | 25, 0x10, 0x68];
187        let mut dec = CborDecoder::new(&bytes);
188        assert_eq!(dec.tag().unwrap(), 4200);
189    }
190
191    #[test]
192    fn decode_wrong_tag_errors() {
193        let mut enc = CborEncoder::new();
194        enc.tag(9999);
195        enc.uint(0);
196        let bytes = enc.finish();
197        let result = decode(&bytes);
198        assert!(result.is_err());
199        match result.unwrap_err() {
200            DecodeError::UnexpectedTag(t) => assert_eq!(t, 9999),
201            _ => panic!("expected UnexpectedTag"),
202        }
203    }
204
205    #[test]
206    fn round_trip_parsed_program() {
207        use crate::parse::parse_program;
208        let src = r#"module test;
209import "vibe:0.1/render" as r;
210prefix ex: <http://example.org/>;
211requires [ capability("capability.invoke") ];
212effect fn go() {
213    let x = 42;
214    let y = "hello";
215    return x;
216}
217"#;
218        let prog = parse_program(src).unwrap();
219        let bytes = encode(&prog);
220        assert!(!bytes.is_empty());
221        // Verify tag 4200 is present.
222        assert_eq!(bytes[0], (6 << 5) | 25);
223        let decoded = decode(&bytes).unwrap();
224        // The decoded program should have the same structure.
225        // Note: spans may differ slightly due to encoding/decoding,
226        // but the structure should match.
227        assert_eq!(decoded.module, prog.module);
228        assert_eq!(decoded.imports, prog.imports);
229        assert_eq!(decoded.prefixes, prog.prefixes);
230        assert_eq!(decoded.requires, prog.requires);
231        assert_eq!(decoded.items.len(), prog.items.len());
232    }
233
234    #[test]
235    fn round_trip_function_with_body() {
236        use crate::parse::parse_program;
237        let src = r#"effect fn add(a: f32, b: f32) {
238    return a + b;
239}"#;
240        let prog = parse_program(src).unwrap();
241        let bytes = encode(&prog);
242        let decoded = decode(&bytes).unwrap();
243        assert_eq!(decoded.items.len(), 1);
244        match &decoded.items[0] {
245            Item::Function(f) => {
246                assert_eq!(f.name, "add");
247                assert_eq!(f.params.len(), 2);
248                assert_eq!(f.params[0].name, "a");
249                assert_eq!(f.params[1].name, "b");
250            }
251            _ => panic!("expected Function item"),
252        }
253    }
254
255    #[test]
256    fn round_trip_const_with_literal() {
257        use crate::parse::parse_program;
258        let src = r#"const PI = 3.14;"#;
259        let prog = parse_program(src).unwrap();
260        let bytes = encode(&prog);
261        let decoded = decode(&bytes).unwrap();
262        assert_eq!(decoded.items.len(), 1);
263        match &decoded.items[0] {
264            Item::Const(c) => {
265                assert_eq!(c.name, "PI");
266                match &c.value.kind {
267                    ExprKind::Literal(Literal::Float(bits)) => {
268                        // 3.14 as f64 bits
269                        let expected = 3.14_f64.to_bits();
270                        assert_eq!(*bits, expected);
271                    }
272                    _ => panic!("expected Float literal"),
273                }
274            }
275            _ => panic!("expected Const item"),
276        }
277    }
278
279    #[test]
280    fn round_trip_if_statement() {
281        use crate::parse::parse_program;
282        let src = r#"effect fn go() {
283    if true {
284        return 1;
285    } else {
286        return 0;
287    }
288}"#;
289        let prog = parse_program(src).unwrap();
290        let bytes = encode(&prog);
291        let decoded = decode(&bytes).unwrap();
292        assert_eq!(decoded.items.len(), 1);
293        if let Item::Function(f) = &decoded.items[0] {
294            assert_eq!(f.body.stmts.len(), 1);
295            match &f.body.stmts[0] {
296                Stmt::If {
297                    then_block,
298                    else_block,
299                    ..
300                } => {
301                    assert_eq!(then_block.stmts.len(), 1);
302                    assert!(else_block.is_some());
303                }
304                _ => panic!("expected If statement"),
305            }
306        }
307    }
308
309    #[test]
310    fn round_trip_triple_expression() {
311        use crate::parse::parse_program;
312        let src = r#"effect fn go() {
313    <<(ex:s ex:p ex:o)>>;
314}"#;
315        let prog = parse_program(src).unwrap();
316        let bytes = encode(&prog);
317        let decoded = decode(&bytes).unwrap();
318        assert_eq!(decoded.items.len(), 1);
319    }
320
321    #[test]
322    fn encode_produces_valid_cbor() {
323        let prog = Program {
324            span: Span::new(0, 0),
325            module: None,
326            imports: Vec::new(),
327            prefixes: Vec::new(),
328            locales: Vec::new(),
329            requires: Vec::new(),
330            items: Vec::new(),
331        };
332        let bytes = encode(&prog);
333        // First byte should be tag header: major 6, ai=25 (2-byte len)
334        assert_eq!(bytes[0], (6 << 5) | 25);
335        // Next 2 bytes should be 4200 = 0x1068
336        assert_eq!(bytes[1], 0x10);
337        assert_eq!(bytes[2], 0x68);
338        // After tag, should be a map (major 5)
339        assert!((bytes[3] >> 5) == 5);
340    }
341
342    // ── T31: Tag 4200 CBOR round-trip for FieldDecl/MaterialDecl/LawDecl ──
343
344    #[test]
345    fn t31_round_trip_field_decl() {
346        use crate::parse::parse_program;
347        let src = r#"module test;
348field pressure_ambient: Pressure unit: <qudt:KiloPascal> support: region representation: grid;
349"#;
350        let prog = parse_program(src).unwrap();
351        let bytes = encode(&prog);
352        assert!(!bytes.is_empty());
353        // Verify tag 4200 is present.
354        assert_eq!(bytes[0], (6 << 5) | 25);
355        let decoded = decode(&bytes).unwrap();
356        assert_eq!(decoded.items.len(), prog.items.len());
357        // Verify the Field item survived round-trip.
358        assert!(matches!(decoded.items.first(), Some(Item::Field(_))));
359        if let Some(Item::Field(f)) = decoded.items.first() {
360            assert_eq!(f.name, "pressure_ambient");
361        }
362    }
363
364    #[test]
365    fn t31_round_trip_material_decl() {
366        use crate::parse::parse_program;
367        let src = r#"module test;
368material sucrose_cube: Material yield: 50.0;
369"#;
370        let prog = parse_program(src).unwrap();
371        let bytes = encode(&prog);
372        assert!(!bytes.is_empty());
373        let decoded = decode(&bytes).unwrap();
374        assert_eq!(decoded.items.len(), prog.items.len());
375        assert!(matches!(decoded.items.first(), Some(Item::Material(_))));
376        if let Some(Item::Material(m)) = decoded.items.first() {
377            assert_eq!(m.name, "sucrose_cube");
378        }
379    }
380
381    #[test]
382    fn t31_round_trip_law_decl() {
383        use crate::parse::parse_program;
384        let src = r#"module test;
385law crush when true => 1;
386"#;
387        let prog = parse_program(src).unwrap();
388        let bytes = encode(&prog);
389        assert!(!bytes.is_empty());
390        let decoded = decode(&bytes).unwrap();
391        assert_eq!(decoded.items.len(), prog.items.len());
392        assert!(matches!(decoded.items.first(), Some(Item::Law(_))));
393        if let Some(Item::Law(l)) = decoded.items.first() {
394            assert_eq!(l.name, "crush");
395        }
396    }
397}