vize_l3 0.554.0

L3 - the Davinci reactivity IR (codename Impeto): flat scheduled ops with explicit state and effect edges
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use vize_l0::{Allocator, Span, String, cstr};
use vize_l3::op::{
    EdgeKind, EffectId, EffectScope, Op, OpId, OpKind, Phase, Program, Region, RegionId, StateEdge,
};
use vize_l3::verify::verify;

fn base<'a>(allocator: &'a Allocator, phase: Phase) -> Program<'a> {
    let mut program = Program::new(allocator, phase);
    program.push_region(Region::root(Span::new(0, 100)));
    program.push_op(Op::new(
        OpId::new(0),
        OpKind::If,
        RegionId::ROOT,
        Span::new(0, 100),
    ));
    program.push_region(Region::child(
        RegionId::new(1),
        RegionId::ROOT,
        OpId::new(0),
        Span::new(10, 90),
    ));
    program.push_effect(EffectScope {
        id: EffectId::new(0),
        owner: OpId::new(1),
        region: RegionId::new(1),
        span: Span::new(20, 60),
    });
    program.push_op(
        Op::new(
            OpId::new(1),
            OpKind::SetText,
            RegionId::new(1),
            Span::new(20, 30),
        )
        .with_effect(EffectId::new(0)),
    );
    program.push_op(
        Op::new(
            OpId::new(2),
            OpKind::SetProp,
            RegionId::new(1),
            Span::new(31, 40),
        )
        .with_effect(EffectId::new(0)),
    );
    program.push_edge(StateEdge::scoped(
        OpId::new(1),
        OpId::new(2),
        EdgeKind::EffectOrder,
        EffectId::new(0),
    ));
    program
}

fn messages(program: &Program<'_>) -> Vec<String> {
    verify(program)
        .into_iter()
        .map(|violation| cstr!("{violation}"))
        .collect()
}

#[test]
fn valid_program_has_no_phase_violations() {
    let arena = Allocator::default();
    assert_eq!(verify(&base(&arena, Phase::Built)), []);
    assert_eq!(verify(&base(&arena, Phase::Partitioned)), []);
    assert_eq!(verify(&base(&arena, Phase::Scheduled)), []);
}

#[test]
fn unresolved_state_edges_fail_exactly() {
    let arena = Allocator::default();
    let mut program = base(&arena, Phase::Built);
    program.push_edge(StateEdge::new(
        OpId::new(42),
        OpId::new(99),
        EdgeKind::DomOrder,
    ));

    assert_eq!(
        messages(&program),
        [
            "L3V004 @0:0 state edge source op#42 does not resolve",
            "L3V004 @0:0 state edge target op#99 does not resolve",
        ]
    );
}

#[test]
fn region_nesting_failures_name_the_parent_or_owner() {
    let arena = Allocator::default();
    let mut program = base(&arena, Phase::Built);
    program.push_region(Region::child(
        RegionId::new(2),
        RegionId::new(1),
        OpId::new(0),
        Span::new(80, 99),
    ));

    assert_eq!(
        messages(&program),
        [
            "L3V006 @80:99 region r#2 escapes parent region r#1",
            "L3V006 @80:99 region r#2 is owned by op#0, but the owner lives in r#0",
        ]
    );
}

#[test]
fn effect_scopes_must_contain_their_edges() {
    let arena = Allocator::default();
    let mut program = base(&arena, Phase::Built);
    program.push_op(Op::new(
        OpId::new(3),
        OpKind::SetHtml,
        RegionId::ROOT,
        Span::new(1, 2),
    ));
    program.push_edge(StateEdge::scoped(
        OpId::new(1),
        OpId::new(3),
        EdgeKind::EffectOrder,
        EffectId::new(0),
    ));

    assert_eq!(
        messages(&program),
        ["L3V007 @20:60 edge op#1 -> op#3 leaves effect scope fx#0"]
    );
}

#[test]
fn scheduled_phase_rejects_back_edges() {
    let arena = Allocator::default();
    let mut program = base(&arena, Phase::Scheduled);
    program.push_edge(StateEdge::new(
        OpId::new(2),
        OpId::new(1),
        EdgeKind::DomOrder,
    ));

    assert_eq!(
        messages(&program),
        ["L3V008 @0:0 scheduled edge op#2 -> op#1 points backward or to itself"]
    );
}