vize_l2 0.503.0

L2 - the Davinci semantic IR (codename Disegno): the neutral op family every input dialect lowers into
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

//! Close only the actual factory frame after its normal callback.

use super::{Builder, Frame, Owner, element::ElementAllocation};
use crate::op::{ComponentOp, ElementOp, Op, Region};
use vize_l0::Box;

pub(super) struct ClosedFrame<'a> {
    pub(super) original_for: Option<core::ptr::NonNull<crate::op::OriginalForOp<'a>>>,
    pub(super) element: Option<ElementAllocation<'a>>,
}

impl<'a> Builder<'a> {
    pub(super) fn close(&mut self, frame: Frame<'a>) -> ClosedFrame<'a> {
        let children = Region { ops: frame.ops };
        let bindings = frame.bindings;
        let span = frame.span;
        let mut original = None;
        let mut element = None;
        let op = match frame.owner {
            Owner::OriginalFor(id) => {
                let owner = Box::new_in(
                    crate::op::OriginalForOp {
                        id,
                        region: children,
                        span,
                    },
                    &self.allocator,
                );
                original = Some(core::ptr::NonNull::from(owner.as_ref()));
                Op::OriginalFor(owner)
            }
            Owner::Element {
                tag,
                namespace,
                attributes,
            } => {
                let owner = Box::new_in(
                    ElementOp {
                        tag,
                        namespace,
                        attributes,
                        bindings,
                        children,
                        span,
                    },
                    &self.allocator,
                );
                element = Some(ElementAllocation::original(owner.as_ref()));
                Op::Element(owner)
            }
            Owner::Component { name, attributes } => Op::Component(Box::new_in(
                ComponentOp {
                    name,
                    attributes,
                    bindings,
                    children,
                    span,
                },
                &self.allocator,
            )),
        };
        self.push(op);
        ClosedFrame {
            original_for: original,
            element,
        }
    }
}