vize_l3 0.483.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

use super::{
    Builder, ControlRegion, DecisionBuildError, NodeDecision, NodeId, SideTable, TargetPolicy,
};
use crate::decision::{ControlKind, StaticLevel};
use crate::placement::Placement;

fn id(index: u32) -> NodeId {
    NodeId::from_index(index).unwrap()
}

fn builder(
    node_count: u32,
) -> Builder<'static, 'static, 'static, super::LiteralExpressions, super::NoReads> {
    Builder {
        policy: TargetPolicy::Ssr,
        original_attributes: None,
        node_count,
        frames: Default::default(),
        nodes: SideTable::new(),
        controls: SideTable::new(),
        dom: None,
        ssr: None,
        vapor: None,
    }
}

fn row() -> NodeDecision {
    NodeDecision {
        static_level: StaticLevel::Static,
        output_level: StaticLevel::Static,
        dynamic_bindings: Default::default(),
        placement: Placement::Inline,
        control: None,
    }
}

#[test]
fn insertion_rejects_out_of_owner_keys_and_duplicate_nodes() {
    let mut builder = builder(2);
    assert_eq!(
        builder.insert_node(id(2), row()),
        Err(DecisionBuildError::InvalidNode { node: id(2) })
    );
    assert!(builder.nodes.is_empty());
    builder.insert_node(id(1), row()).unwrap();
    assert_eq!(
        builder.insert_node(id(1), row()),
        Err(DecisionBuildError::DuplicateNode { node: id(1) })
    );
    assert_eq!(builder.nodes.len(), 1);
}

#[test]
fn finish_requires_every_unique_key_in_the_owner_range() {
    let mut builder = builder(2);
    builder.insert_node(id(1), row()).unwrap();
    assert_eq!(
        builder.finish(),
        Err(DecisionBuildError::NodeCountMismatch {
            expected: 2,
            actual: 1
        })
    );
    let mut builder = self::builder(2);
    builder.insert_node(id(1), row()).unwrap();
    builder.insert_node(id(0), row()).unwrap();
    let complete = builder.finish().unwrap();
    assert_eq!(complete.nodes.len(), 2);
    assert_eq!(complete.policy, TargetPolicy::Ssr);
}

#[test]
fn control_insertion_rejects_out_of_owner_keys_and_repeated_owners() {
    let mut builder = builder(1);
    let control = ControlRegion {
        kind: ControlKind::Loop,
        parent: None,
    };
    assert_eq!(
        builder.insert_control(id(1), control),
        Err(DecisionBuildError::InvalidNode { node: id(1) })
    );
    assert!(builder.controls.is_empty());
    builder.insert_control(id(0), control).unwrap();
    assert_eq!(
        builder.insert_control(id(0), control),
        Err(DecisionBuildError::DuplicateControl { node: id(0) })
    );
}

mod prepared_text;