vize_l3 0.551.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
121
122
123

//! Admit the actual private factory resolution, without another AST walk.

use super::{DomBuilder, DomExpressionFacts, DomUnsupported, ValueKind};
use crate::decision::dom::file::{DomFileExpression, matches_expression};
use crate::decision::dom::vue::policy::FileReads;
use crate::decision::dom::vue::{VueReadKind, VueRenderExpression, VueRenderRead};
use alloc::vec::Vec;
use vize_l0::id::NodeId;
use vize_l2::{expr::JsExpr, file::Namespace};

mod native;

impl<'owner, 'arena, F: DomExpressionFacts, R: FileReads<'owner, 'arena>>
    DomBuilder<'_, 'owner, 'arena, F, R>
{
    pub(super) fn file_value(
        &mut self,
        node: NodeId,
        expression: &JsExpr<'arena>,
    ) -> Option<ValueKind> {
        let file = self.file?;
        let Some(resolution) = file
            .expression(node)
            .filter(|row| matches_expression(*row, expression))
        else {
            self.reject(node, expression.span, DomUnsupported::FileExpression);
            return None;
        };
        if !resolution.scope().is_some_and(|scope| {
            file.scopes()
                .get(scope.index() as usize)
                .is_some_and(|record| record.id == scope)
        }) {
            self.reject(node, expression.span, DomUnsupported::FileScope);
            return None;
        };
        if let Some(rejected) = native::refusal(file, node, expression, R::NATIVE_SETUP) {
            self.reject(rejected.node, rejected.span, rejected.reason);
            return None;
        }
        if self.in_original_for_body()
            && expression
                .ast
                .get_identifier_reference()
                .is_some_and(|identifier| expression.source != identifier.name.as_str())
        {
            self.reject(node, expression.span, DomUnsupported::ForBody);
            return None;
        }
        let table = resolution.table()?;
        // These identities were resolved by the actual minting factory. Check
        // recorded declarations only, rather than rerunning scope/name lookup.
        let mut reads = Vec::new();
        for occurrence in table.occurrences() {
            let Some(binding) = resolution
                .binding(occurrence.binding)
                .filter(|binding| resolution.accepts(*binding))
            else {
                self.reject(node, expression.span, DomUnsupported::FileBinding);
                return None;
            };
            let script = binding.declaration().is_some_and(|declaration| {
                declaration.namespace == Namespace::Value && declaration.name == occurrence.name
            });
            let original_value = if script {
                None
            } else {
                self.for_value(resolution, expression, occurrence, binding)
            };
            if !script && original_value.is_none() {
                self.reject(node, expression.span, DomUnsupported::FileBinding);
                return None;
            }
            if R::RECORD {
                let Some(kind) =
                    original_value.or_else(|| self.reads.classify(occurrence, binding))
                else {
                    self.reject(node, expression.span, DomUnsupported::VueReadAccess);
                    return None;
                };
                reads.push(VueRenderRead {
                    occurrence,
                    binding,
                    kind,
                });
            }
        }
        if self.in_original_for_body()
            && !(expression.ast.is_identifier_reference()
                && matches!(reads.as_slice(), [read] if read.kind == VueReadKind::ForValue))
        {
            self.reject(node, expression.span, DomUnsupported::ForBody);
            return None;
        }
        // A direct identifier has no call/member descendants whose behavior
        // could vary despite immutable reads. Complete read lists alone do not
        // prove purity or constant evaluation of a compound expression.
        let constant_read = expression.ast.is_identifier_reference()
            && matches!(reads.as_slice(), [read] if read.kind == VueReadKind::SetupConst);
        let value = if expression.ast.is_literal() || constant_read {
            ValueKind::LiteralConstant
        } else if !table.occurrences().is_empty() {
            ValueKind::FileDependent
        } else {
            self.reject(node, expression.span, DomUnsupported::Expression);
            return None;
        };
        self.facts
            .file_expressions
            .insert(node, DomFileExpression { resolution });
        if R::RECORD {
            self.facts.vue_expressions.insert(
                node,
                VueRenderExpression {
                    resolution,
                    reads,
                    value,
                },
            );
        }
        Some(value)
    }
}