vize_l2 0.549.0

L2 - the Davinci semantic IR (codename Disegno): the neutral op family every input dialect lowers into
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! TS-16 for `vue.html` (P2-11): Vue's `v-html` raw-HTML surface as a
//! dialect binding, parseable and mirrorable like the other L2 ops.

use vize_l0::dump::{Dump, Mode as DumpMode};
use vize_l0::{Allocator, Box, Span, String, Vec as ArenaVec};
use vize_l2::dump::{
    Binding as DumpBinding, Element as DumpElement, Expr as DumpExpr, Op as DumpOp, Page as L2Page,
    VueHtml as DumpVueHtml,
};
use vize_l2::expr::{ExprRef, JsExpr};
use vize_l2::op::{BindingOp, ElementOp, Namespace, Op, Region, VueHtmlOp};

const CANONICAL: &str = "\
[l2-dump-v2]
ops=2

[l2-dump-v2.ops]
ui.element div @0:24
  vue.html value=js(\"raw\" @13:16) @5:17

";

const VALUE_LESS: &str = "\
[l2-dump-v2]
ops=2

[l2-dump-v2.ops]
ui.element div @0:16
  vue.html @5:11

";

fn hand_built() -> L2Page {
    L2Page {
        ops: vec![DumpOp::Element(DumpElement {
            tag: String::from("div"),
            namespace: Namespace::Html,
            attributes: vec![],
            bindings: vec![DumpBinding::VueHtml(DumpVueHtml {
                value: Some(DumpExpr::Js {
                    source: String::from("raw"),
                    span: Span::new(13, 16),
                }),
                span: Span::new(5, 17),
            })],
            children: vec![],
            span: Span::new(0, 24),
        })],
    }
}

fn hand_built_value_less() -> L2Page {
    L2Page {
        ops: vec![DumpOp::Element(DumpElement {
            tag: String::from("div"),
            namespace: Namespace::Html,
            attributes: vec![],
            bindings: vec![DumpBinding::VueHtml(DumpVueHtml {
                value: None,
                span: Span::new(5, 11),
            })],
            children: vec![],
            span: Span::new(0, 16),
        })],
    }
}

#[test]
fn the_html_op_round_trips() {
    let value = hand_built();
    assert_eq!(value.op_count(), 2);
    assert_eq!(value.print_to_string(DumpMode::Full).as_str(), CANONICAL);
    assert_eq!(
        L2Page::parse(CANONICAL).expect("canonical text parses"),
        value
    );
}

#[test]
fn the_value_less_html_op_round_trips() {
    let value = hand_built_value_less();
    assert_eq!(value.op_count(), 2);
    assert_eq!(value.print_to_string(DumpMode::Full).as_str(), VALUE_LESS);
    assert_eq!(
        L2Page::parse(VALUE_LESS).expect("value-less text parses"),
        value
    );
}

#[test]
fn an_arena_tree_mirrors_the_html_op() {
    let arena = Allocator::default();
    let allocator = &arena;
    let raw = ExprRef::Js(JsExpr::parse_in(allocator, "raw", Span::new(13, 16)).expect("admitted"));
    let ops = ArenaVec::from_iter_in(
        [Op::Element(Box::new_in(
            ElementOp {
                tag: "div",
                namespace: Namespace::Html,
                attributes: ArenaVec::new_in(&allocator),
                bindings: ArenaVec::from_iter_in(
                    [BindingOp::VueHtml(Box::new_in(
                        VueHtmlOp {
                            value: Some(raw),
                            span: Span::new(5, 17),
                        },
                        &allocator,
                    ))],
                    &allocator,
                ),
                children: Region {
                    ops: ArenaVec::new_in(&allocator),
                },
                span: Span::new(0, 24),
            },
            &allocator,
        ))],
        &allocator,
    );
    assert_eq!(
        L2Page::of(&ops).print_to_string(DumpMode::Full).as_str(),
        CANONICAL
    );
}