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

use super::{
    Allocator, DescriptorOptions, NativeHandlerInput, NativeTemplateComponent, Outer,
    ResolutionErrorKind, Vue, VueDialect, VueVersion, resolve_handler,
};
use vize_l1::embed::Lang;

#[test]
fn original_ts_profile_is_intrinsic_and_type_annotations_remain_precise_refusals() {
    let allocator = Allocator::default();
    for (source, supported) in [
        (
            "<script setup lang='ts'></script><template><b @click='let x=1;x'/></template>",
            true,
        ),
        (
            "<script setup lang='ts'></script><template><b @click='let x:number=1;x'/></template>",
            false,
        ),
    ] {
        let descriptor = Vue.observe_descriptor(
            &allocator,
            source,
            DescriptorOptions {
                version: VueVersion::V3,
                dialect: VueDialect::Vue,
                template: vize_l1::SurfaceParseOptions::default(),
            },
        );
        let selected =
            NativeTemplateComponent::parse_in(&allocator, descriptor.admitted().unwrap())
                .unwrap()
                .unwrap();
        let element = selected.children().next().unwrap().into_element().unwrap();
        let operand = selected
            .observe_attribute_handler(element.attributes().next().unwrap())
            .unwrap();
        assert_eq!(operand.syntax().grammar().lang, Lang::Ts);
        assert!(operand.syntax().source_type().is_typescript());
        let original = NativeHandlerInput::new(operand).unwrap();
        let body = original.body();
        let result = resolve_handler(original, &Outer(&[]));
        if supported {
            let resolution = result.unwrap();
            assert!(core::ptr::eq(resolution.input().body(), body));
            assert_eq!(resolution.references().len(), 1);
        } else {
            let rejected = result.unwrap_err();
            assert_eq!(rejected.error.kind, ResolutionErrorKind::UnsupportedSyntax);
            assert_eq!(
                rejected
                    .error
                    .span
                    .slice(rejected.input().operand().syntax().source().text()),
                "x:number=1"
            );
            assert!(core::ptr::eq(rejected.input().body(), body));
            assert!(
                rejected
                    .input()
                    .operand()
                    .syntax()
                    .source_type()
                    .is_typescript()
            );
        }
    }
}