vize_l2 0.550.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
125
126
127

use super::{
    Allocator, FileIssueKind, Parser, PositionQueryError, SourceRoot, SourceType, cstr, lower,
};

#[test]
fn self_contained_arrays_preserve_original_ts_and_tsx_profiles() {
    let arena = Allocator::default();
    for profile in [
        SourceType::ts().with_module(true),
        SourceType::tsx().with_module(true),
    ] {
        for element in [
            "bigint",
            "boolean",
            "null",
            "number",
            "string",
            "symbol",
            "undefined",
            "{}",
            "{ id:number; name:string; enabled:boolean }",
        ] {
            let source = cstr!("const items: {element}[] = [];items;");
            let observed = Parser::new(&arena, &source, profile).parse_observed();
            assert!(observed.diagnostics().is_empty(), "{source}");
            let block = SourceRoot::new(&source).unwrap().whole_block();
            let file = lower(&arena, &source, block, &observed);
            assert!(file.is_complete(), "{source}");
            assert_eq!(file.units()[0].profile.jsx, profile.is_jsx());
            assert!(file.units()[0].profile.typescript);
            assert!(file.units()[0].profile.module);
            assert_eq!(file.bindings().count(), 1);
            assert_eq!(file.references().len(), 1);
        }
    }
}

#[test]
fn named_recursive_and_nonflat_type_children_keep_whole_file_incomplete() {
    let arena = Allocator::default();
    for element in [
        "Name",
        "Imported.Name",
        "(number)",
        "number[]",
        "number | string",
        "number & string",
        "1",
        "any",
        "unknown",
        "never",
        "void",
        "object",
        "typeof value",
        "keyof Name",
        "[number]",
        "{ id:Name }",
        "{ id:number[] }",
        "{ id:{nested:number} }",
        "{ id?:number }",
        "{ readonly id:number }",
        "{ 'id':number }",
        "{ [value]:number }",
        "{ [name:string]:number }",
        "{ [K in string]:number }",
        "{ id() : number }",
        "{ () : number }",
        "{ new () : number }",
        "{ id }",
    ] {
        let source = cstr!("const value=1;const items: {element}[] = [];value;");
        let observed =
            Parser::new(&arena, &source, SourceType::ts().with_module(true)).parse_observed();
        assert!(observed.diagnostics().is_empty(), "{source}");
        let file = lower(
            &arena,
            &source,
            SourceRoot::new(&source).unwrap().whole_block(),
            &observed,
        );
        assert!(!file.is_complete(), "{source}");
        assert!(
            file.issues()
                .iter()
                .any(|issue| issue.kind == FileIssueKind::UnsupportedSyntax),
            "{source}"
        );
        assert!(matches!(
            file.binding_at_offset(source.rfind("value").unwrap() as u32),
            Err(PositionQueryError::IncompleteFile)
        ));
    }
}

#[test]
fn context_and_unsupported_siblings_cannot_borrow_array_completeness() {
    let arena = Allocator::default();
    for source in [
        "export const items:number[]=[];",
        "declare const items:number[];",
        "let items!:number[];",
        "function local(){const items:number[]=[];}",
        "function local(items:number[]){}",
        "function local():number[]{return [];}",
        "const items:Array<number>=[];",
        "const items:readonly number[]=[];",
        "import type {Item} from 'types';const items:Item[]=[];",
        "const items:number[]=[];const other:Name=1;",
        "const other:Name=1;const items:number[]=[];",
    ] {
        let observed =
            Parser::new(&arena, source, SourceType::ts().with_module(true)).parse_observed();
        assert!(observed.diagnostics().is_empty(), "{source}");
        let file = lower(
            &arena,
            source,
            SourceRoot::new(source).unwrap().whole_block(),
            &observed,
        );
        assert!(!file.is_complete(), "{source}");
        assert!(
            file.issues()
                .iter()
                .any(|issue| issue.kind == FileIssueKind::UnsupportedSyntax)
        );
    }
}