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

//! Input eligibility is specific to a normally completed original Model root.

use super::VaporBuilder;
use crate::decision::vapor::{VaporPart, VaporUnsupported, model};
use vize_l0::id::NodeId;
use vize_l2::{
    file::NativeFileModelState,
    op::{BindingOp, ElementOp, ModelOp},
};

impl<'owner, 'arena> VaporBuilder<'_, 'owner, 'arena> {
    pub(super) fn model_opening(&self, node: NodeId, element: &'owner ElementOp<'arena>) -> bool {
        let Some(setup) = self.setup else {
            return false;
        };
        let [original] = setup.file().native_models() else {
            return false;
        };
        let NativeFileModelState::Admitted(model_node) = original.state() else {
            return false;
        };
        let [binding @ BindingOp::Model(model)] = element.bindings.as_slice() else {
            return false;
        };
        self.frames.is_empty()
            && self.facts.roots.len() == 1
            && self.non_comments == 1
            && self.root_element == Some(node)
            && model::classify(setup, node, element, model_node, binding, model).is_ok()
    }

    pub(super) fn model_binding(
        &mut self,
        node: NodeId,
        binding: &'owner BindingOp<'arena>,
        model: &'owner ModelOp<'arena>,
    ) -> Result<(), VaporUnsupported> {
        let setup = self.setup.ok_or(VaporUnsupported::ModelOrigin)?;
        let [(parent, Some(element), true)] = self.frames.as_slice() else {
            return Err(VaporUnsupported::ModelShape);
        };
        let [
            VaporPart::Open {
                node: opening,
                element: actual,
                void: true,
            },
        ] = self.facts.parts.as_slice()
        else {
            return Err(VaporUnsupported::ModelShape);
        };
        if self.facts.roots.len() != 1
            || self.non_comments != 1
            || self.root_element != Some(*parent)
            || opening != parent
            || !core::ptr::eq(*actual, *element)
        {
            return Err(VaporUnsupported::ModelShape);
        }
        let model = model::classify(setup, *parent, element, node, binding, model)?;
        self.facts.parts.push(VaporPart::Model { model });
        Ok(())
    }

    pub(super) fn finish_model(&mut self) {
        let Some(setup) = self.setup else { return };
        let [original] = setup.file().native_models() else {
            return;
        };
        let NativeFileModelState::Admitted(node) = original.state() else {
            return;
        };
        if self.facts.parts.iter().any(|part| {
            matches!(part,
            VaporPart::Model { model } if model.resolution().node() == node)
        }) && !(self.frames.is_empty()
            && self.facts.roots.len() == 1
            && self.non_comments == 1
            && self.root_element == original.element_node()
            && matches!(
                self.facts.parts.as_slice(),
                [VaporPart::Open { void: true, .. }, VaporPart::Model { .. }]
            ))
        {
            self.reject(
                node,
                original.input().operand().value_span(),
                VaporUnsupported::ModelShape,
            );
        }
    }
}