vize_l3 0.620.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

//! Conditional admission without revisiting any branch body.

use super::{DomBuilder, DomExpressionFacts, DomUnsupported, ValueKind};
use crate::decision::dom::vue::policy::FileReads;
use crate::decision::{DecisionBuildError, dom::control::build::ConditionalFrame};
use vize_l0::{Span, id::NodeId};
use vize_l2::{
    expr::ExprRef,
    op::{IfOp, Op},
    resolution::Usage,
};

impl<'owner, 'arena, F: DomExpressionFacts, R: FileReads<'owner, 'arena>>
    DomBuilder<'_, 'owner, 'arena, F, R>
{
    pub(super) fn prepare_conditional(
        &mut self,
        id: NodeId,
        op: &'owner Op<'arena>,
    ) -> Option<ConditionalFrame<'owner, 'arena>> {
        let Op::If(owner) = op else { return None };
        let mut admitted = self.frames.is_empty() && self.root_count == 1;
        if !admitted {
            self.reject(id, owner.span, DomUnsupported::ConditionalRoot);
        }
        let shape = matches!(owner.branches.as_slice(), [first] if first.condition.is_some())
            || matches!(owner.branches.as_slice(), [first, last]
                if first.condition.is_some() && last.condition.is_none());
        if !shape {
            admitted = false;
            self.reject(id, owner.span, DomUnsupported::ConditionalShape);
        }
        let mut first_condition = ValueKind::ContextDependent;
        for (index, branch) in owner.branches.iter().enumerate() {
            if branch.region.ops.len() != 1 {
                admitted = false;
                self.reject(id, branch.span, DomUnsupported::ConditionalRoot);
            }
            if let Some(expression) = branch.condition {
                let value = self.value(id, expression);
                if value == Some(ValueKind::ContextDependent) {
                    continue;
                }
                if index == 0
                    && let Some(value) = value
                    && self.native_condition(id, owner, expression, value)
                {
                    first_condition = value;
                } else {
                    admitted = false;
                    self.reject(id, expression.span(), DomUnsupported::ConditionalCondition);
                }
            }
        }
        Some(if first_condition == ValueKind::ContextDependent {
            ConditionalFrame::new(owner, admitted)
        } else {
            ConditionalFrame::with_condition(owner, admitted, first_condition)
        })
    }

    fn native_condition(
        &self,
        id: NodeId,
        owner: &IfOp<'arena>,
        expression: ExprRef<'arena>,
        value: ValueKind,
    ) -> bool {
        use crate::decision::dom::vue::VueReadKind;
        if !R::NATIVE_SETUP
            || !matches!(value, ValueKind::FileDependent | ValueKind::LiteralConstant)
            || owner.branches.len() != 1
        {
            return false;
        }
        let Some(file) = self.file else { return false };
        let Some(record) = file.native_conditional(id).filter(|row| row.accepts(owner)) else {
            return false;
        };
        let ExprRef::Js(expression) = expression else {
            return false;
        };
        let Some(row) = self.facts.vue_expressions.get(id) else {
            return false;
        };
        let [read] = row.reads() else { return false };
        let resolution = row.resolution();
        record.input().matches_expression(expression)
            && core::ptr::eq(resolution.file(), file)
            && resolution.node() == id
            && resolution.scope() == Some(record.scope())
            && row.value() == value
            && record.binding() == Some(read.binding().id())
            && read.occurrence().usage == Usage::Read
            && matches!(read.kind(), VueReadKind::SetupConst | VueReadKind::SetupLet)
            && self.reads.classify(read.occurrence(), read.binding()) == Some(read.kind())
            && read.binding().declaration().is_some_and(|declaration| {
                declaration.scope == record.scope()
                    && declaration.is_direct_program()
                    && declaration.boolean_initializer().is_some()
            })
    }

    pub(super) fn complete_conditional(
        &mut self,
        id: NodeId,
        span: Span,
        frame: ConditionalFrame<'owner, 'arena>,
    ) -> Result<(), DecisionBuildError> {
        if let Some(conditional) = frame.finish(id)? {
            self.facts.controls.insert(id, conditional);
        } else if !self.facts.unsupported.iter().any(|row| row.node == id) {
            self.reject(id, span, DomUnsupported::ConditionalRoot);
        }
        Ok(())
    }
}