vize_l3 0.431.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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Branch header accounting inside the existing DOM event frame.

use alloc::vec::Vec;
use vize_l0::{Span, id::NodeId};
use vize_l2::op::{IfOp, Namespace, Op};

use super::{
    BranchDiscriminant, ConditionalFallback, DomBlockEligibility, DomConditional,
    DomConditionalBranch,
};
use crate::decision::{DecisionBuildError, dom::ValueKind};

pub(in crate::decision::dom) struct ConditionalFrame<'owner, 'arena> {
    owner: &'owner IfOp<'arena>,
    rows: Vec<DomConditionalBranch<'owner, 'arena>>,
    cursor: usize,
    remaining: usize,
    admitted: bool,
}

#[cfg(test)]
mod tests;

impl<'owner, 'arena> ConditionalFrame<'owner, 'arena> {
    pub(in crate::decision::dom) fn new(owner: &'owner IfOp<'arena>, admitted: bool) -> Self {
        Self {
            owner,
            rows: Vec::new(),
            cursor: 0,
            remaining: owner
                .branches
                .first()
                .map_or(0, |branch| branch.region.ops.len()),
            admitted,
        }
    }

    pub(in crate::decision::dom) fn child(
        &mut self,
        id: NodeId,
        op: &'owner Op<'arena>,
        owner_span: Option<Span>,
    ) -> Result<bool, DecisionBuildError> {
        self.skip_finished();
        let branch = self
            .owner
            .branches
            .get(self.cursor)
            .ok_or(DecisionBuildError::InvalidTraversal { node: id })?;
        if owner_span != Some(branch.span) {
            return Err(DecisionBuildError::InvalidTraversal { node: id });
        }
        self.remaining = self
            .remaining
            .checked_sub(1)
            .ok_or(DecisionBuildError::InvalidTraversal { node: id })?;
        let eligible = matches!(op, Op::Element(element)
            if element.namespace == Namespace::Html && element.tag != "template"
            && !element.attributes.iter().any(|attribute|
                matches!(attribute.name, "class" | "style" | "key" | "ref")));
        if branch.region.ops.len() != 1 || !eligible {
            self.admitted = false;
        }
        if self.admitted {
            self.rows.push(DomConditionalBranch {
                owner: branch,
                discriminant: BranchDiscriminant(
                    u32::try_from(self.cursor)
                        .map_err(|_| DecisionBuildError::InvalidTraversal { node: id })?,
                ),
                root: id,
                condition: branch.condition.map(|_| ValueKind::ContextDependent),
                block: DomBlockEligibility::NativeElement,
            });
        }
        Ok(self.admitted)
    }

    pub(in crate::decision::dom) fn finish(
        mut self,
        id: NodeId,
    ) -> Result<Option<DomConditional<'owner, 'arena>>, DecisionBuildError> {
        self.skip_finished();
        if self.cursor != self.owner.branches.len() {
            return Err(DecisionBuildError::InvalidTraversal { node: id });
        }
        if !self.admitted || self.rows.len() != self.owner.branches.len() {
            return Ok(None);
        }
        Ok(Some(DomConditional {
            owner: self.owner,
            fallback: if self
                .owner
                .branches
                .last()
                .is_some_and(|branch| branch.condition.is_none())
            {
                ConditionalFallback::AuthoredElse
            } else {
                ConditionalFallback::Placeholder
            },
            branches: self.rows,
        }))
    }

    pub(in crate::decision::dom) fn closes_first_branch(&self, id: NodeId) -> bool {
        self.admitted && self.rows.first().is_some_and(|branch| branch.root == id)
    }

    fn skip_finished(&mut self) {
        while self.remaining == 0 && self.cursor < self.owner.branches.len() {
            self.cursor += 1;
            self.remaining = self
                .owner
                .branches
                .get(self.cursor)
                .map_or(0, |branch| branch.region.ops.len());
        }
    }
}