vize_l3 0.481.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
92
93
94
95
96
97

//! Static-name property decisions on the existing DOM owner frame.

use super::{DomBinding, DomBuilder, DomExpressionFacts, DomUnsupported, PropertyRole};
use crate::decision::dom::vue::policy::FileReads;
use vize_l0::id::NodeId;
use vize_l2::{
    op::{BindingOp, DynamicName, Op},
    walk::NodeRef,
};

impl<'owner, 'arena, F: DomExpressionFacts, R: FileReads<'owner, 'arena>>
    DomBuilder<'_, 'owner, 'arena, F, R>
{
    pub(in crate::decision) fn binding(&mut self, id: NodeId, binding: &'owner BindingOp<'arena>) {
        let span = NodeRef::Binding(binding).span();
        if self.in_original_for_body() {
            self.reject(id, span, DomUnsupported::ForBody);
        }
        if let BindingOp::On(on) = binding {
            self.handler_binding(id, binding, on);
            return;
        }
        let BindingOp::Bind(bind) = binding else {
            self.reject(id, span, DomUnsupported::Binding);
            return;
        };
        if !bind.modifiers.is_empty() {
            self.reject(id, span, DomUnsupported::BindingModifiers);
            return;
        }
        let Some(DynamicName::Static(name)) = bind.name else {
            self.reject(id, span, DomUnsupported::BindingName);
            return;
        };
        let role = match name {
            "class" => PropertyRole::Class,
            "style" => PropertyRole::Style,
            name if name.is_empty()
                || matches!(name, "key" | "ref" | "is")
                || name.starts_with("on") =>
            {
                self.reject(id, span, DomUnsupported::BindingName);
                return;
            }
            _ => PropertyRole::Property,
        };
        let Some((_, frame)) = self.frames.last() else {
            self.reject(id, span, DomUnsupported::Binding);
            return;
        };
        let Op::Element(element) = frame.node.op else {
            self.reject(id, span, DomUnsupported::Binding);
            return;
        };
        if frame.binding_names.contains(&name)
            || element
                .attributes
                .iter()
                .any(|attribute| attribute.name == name)
        {
            self.reject(id, span, DomUnsupported::DuplicateProperty);
            return;
        }
        let Some(expression) = bind.value else {
            self.reject(id, span, DomUnsupported::MissingValue);
            return;
        };
        let Some(value) = self.value(id, expression) else {
            return;
        };
        let Some((_, frame)) = self.frames.last_mut() else {
            self.reject(id, span, DomUnsupported::Binding);
            return;
        };
        frame.binding_names.push(name);
        frame.normalize_class |= role == PropertyRole::Class;
        frame.normalize_style |= role == PropertyRole::Style && value.is_dynamic();
        if value.is_dynamic() {
            match role {
                PropertyRole::Property | PropertyRole::Event => {
                    frame.node.changes.properties = true;
                    frame.node.dynamic_property_bindings.push(id);
                }
                PropertyRole::Class => frame.node.changes.class = true,
                PropertyRole::Style => frame.node.changes.style = true,
            }
        }
        self.facts.bindings.insert(
            id,
            DomBinding {
                binding,
                role,
                value,
            },
        );
    }
}