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

use super::*;

#[test]
fn missing_collection_binding_does_not_resolve_to_its_own_same_named_alias() {
    let arena = Allocator::default();
    let file = "<template><b v-for='items in items'/></template>";
    let owner = selected(&arena, file);
    let lookup = Lookup::new(&[]);
    let original = input(&owner);
    let aliases = original.aliases().as_ptr();
    let collection = original.collection() as *const _;
    let rejected = resolve_for_head(original, &lookup).unwrap_err();
    assert_eq!(
        rejected.error,
        ForResolutionError {
            part: ForHeadPart::Collection,
            span: Span::new(0, 5),
            kind: ForResolutionErrorKind::Reference(ResolutionErrorKind::MissingBinding)
        }
    );
    assert_eq!(lookup.visits.get(), 1);
    assert_eq!(rejected.input().aliases().as_ptr(), aliases);
    assert_eq!(rejected.input().collection() as *const _, collection);
    assert_eq!(
        rejected.into_input().operand().raw_value(),
        "items in items"
    );
}

#[test]
fn duplicate_unicode_alias_refuses_at_second_original_alias_without_partial_table() {
    let arena = Allocator::default();
    let file = "<template><b v-for='(α, α) in items'/></template>";
    let owner = selected(&arena, file);
    let lookup = Lookup::new(&[("items", 2)]);
    let original = input(&owner);
    let original_span = original.operand().value_span();
    let rejected = resolve_for_head(original, &lookup).unwrap_err();
    assert_eq!(
        rejected.error,
        ForResolutionError {
            part: ForHeadPart::Aliases,
            span: Span::new(4, 6),
            kind: ForResolutionErrorKind::DuplicateAlias
        }
    );
    assert_eq!(lookup.visits.get(), 1);
    assert_eq!(rejected.input().operand().value_span(), original_span);
    assert_eq!(
        rejected.into_input().operand().raw_value(),
        "(α, α) in items"
    );
}

#[test]
fn generated_helper_and_context_alias_prefixes_remain_typed_bounded_refusals() {
    let arena = Allocator::default();
    for file in [
        "<template><b v-for='_renderList in items'/></template>",
        "<template><b v-for='$setup in items'/></template>",
        "<template><b v-for='(item, _key) in items'/></template>",
    ] {
        let owner = selected(&arena, file);
        let original = input(&owner);
        let raw = original.operand().raw_value();
        let rejected = resolve_for_head(original, &Lookup::new(&[("items", 2)])).unwrap_err();
        assert_eq!(rejected.error.part, ForHeadPart::Aliases);
        assert_eq!(rejected.error.kind, ForResolutionErrorKind::ReservedAlias);
        assert_eq!(rejected.input().operand().raw_value(), raw);
    }
}

#[test]
fn missing_collection_precedes_alias_policy_and_returns_the_entire_original_input() {
    let arena = Allocator::default();
    let owner = selected(
        &arena,
        "<template><b v-for='(_value, _value) in absent'/></template>",
    );
    let rejected = resolve_for_head(input(&owner), &Lookup::new(&[])).unwrap_err();
    assert_eq!(rejected.error.part, ForHeadPart::Collection);
    assert_eq!(
        rejected.error.kind,
        ForResolutionErrorKind::Reference(ResolutionErrorKind::MissingBinding)
    );
    assert_eq!(
        rejected.input().operand().raw_value(),
        "(_value, _value) in absent"
    );
}