vize_l2 0.442.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

use super::{Allocator, ForHeadInput, Lang, NativeForRefusal, observe};

#[test]
fn unsupported_native_families_preserve_the_whole_head_and_both_owners() {
    let arena = Allocator::default();
    for (text, kind) in [
        ("(item,key,index) in items", NativeForRefusal::AliasCount(3)),
        ("item in items.values", NativeForRefusal::CollectionShape),
        ("item in /*kept*/items", NativeForRefusal::Comment),
        ("item in _ctx", NativeForRefusal::RenderContextName),
        (r"\u0061 in items", NativeForRefusal::EscapedSpelling),
        ("item in items", NativeForRefusal::EntityOutput),
    ] {
        let syntax = observe(&arena, text, Lang::Js);
        assert_eq!(syntax.native_refusal(), Some(kind), "{text}");
        let aliases = syntax
            .aliases()
            .unwrap()
            .unwrap()
            .parameters()
            .unwrap()
            .as_ptr();
        let collection = syntax.collection().unwrap().unwrap().expression().unwrap() as *const _;
        let map = syntax
            .source()
            .decode_map()
            .map(|map| map.segments().as_ptr());
        let comments = syntax.comments().count();
        let rejected = ForHeadInput::new(syntax).unwrap_err();
        assert_eq!(rejected.kind, kind);
        assert_eq!(
            rejected
                .syntax()
                .aliases()
                .unwrap()
                .unwrap()
                .parameters()
                .unwrap()
                .as_ptr(),
            aliases
        );
        assert_eq!(
            rejected
                .syntax()
                .collection()
                .unwrap()
                .unwrap()
                .expression()
                .unwrap() as *const _,
            collection
        );
        assert_eq!(
            rejected
                .syntax()
                .source()
                .decode_map()
                .map(|map| map.segments().as_ptr()),
            map
        );
        assert_eq!(rejected.syntax().comments().count(), comments);
        assert_eq!(rejected.into_syntax().native_refusal(), Some(kind));
    }
}

#[test]
fn original_diagnostics_and_comments_are_retained_on_syntax_refusal() {
    let arena = Allocator::default();
    let text = "item in /x/uv /*kept*/";
    let syntax = observe(&arena, text, Lang::Js);
    let kind = syntax.native_refusal().unwrap();
    let before: alloc::vec::Vec<_> = syntax
        .diagnostics()
        .map(|(part, diagnostic)| {
            (
                part,
                diagnostic.message().as_ptr(),
                diagnostic.message().len(),
                diagnostic.severity(),
            )
        })
        .collect();
    assert!(!before.is_empty());
    let comments: alloc::vec::Vec<_> = syntax
        .comments()
        .map(|(part, comment)| {
            (
                part,
                comment.text().unwrap().as_ptr(),
                comment.text().unwrap().len(),
            )
        })
        .collect();
    let rejected = ForHeadInput::new(syntax).unwrap_err();
    assert_eq!(rejected.kind, kind);
    let after: alloc::vec::Vec<_> = rejected
        .syntax()
        .diagnostics()
        .map(|(part, diagnostic)| {
            (
                part,
                diagnostic.message().as_ptr(),
                diagnostic.message().len(),
                diagnostic.severity(),
            )
        })
        .collect();
    assert_eq!(after, before);
    let after: alloc::vec::Vec<_> = rejected
        .syntax()
        .comments()
        .map(|(part, comment)| {
            (
                part,
                comment.text().unwrap().as_ptr(),
                comment.text().unwrap().len(),
            )
        })
        .collect();
    assert_eq!(after, comments);
    assert_eq!(rejected.into_syntax().source().text(), text);
}