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

//! Bounded server-rendering semantics from the sole canonical decision walk.
//!
//! These facts retain the actual L2 nodes. HTML eligibility, void content,
//! root attribute inheritance and fragment boundaries are SSR decisions;
//! string escaping, helper names and JavaScript spelling belong to L4.

use alloc::vec::Vec;
use vize_l0::{Span, id::NodeId, side_table::SideTable};
use vize_l2::op::{CommentOp, ElementOp, InterpolationOp, TextOp};

pub(super) mod build;
mod file;
mod native;
mod scoped;
mod setup;
#[cfg(test)]
mod tests;
pub use file::{NativeSsrFileAnalysis, build_ssr_file_decisions};
pub use native::{NativeSsrBuildError, NativeTemplateSsrAnalysis, build_native_ssr_file_decisions};
pub use scoped::{NativeTemplateScopedSsrAnalysis, build_native_scoped_ssr_file_decisions};
pub use setup::{
    NativeSelectedSetupSsrAnalysis, SsrSetupExpression, SsrSetupRead, SsrSetupReadKind,
    build_native_selected_setup_ssr_decisions,
};

/// A whole SSR view retains unsupported locations instead of partial output.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SsrUnsupported {
    Operation,
    Namespace,
    ElementName,
    ElementSemantics,
    VoidChildren,
    AttributeName,
    AttributeSemantics,
    DuplicateAttribute,
    Binding,
    UnsafeComment,
    FileExpression,
    FileScope,
    FileBinding,
    SetupReadAccess,
    Expression,
    RootTextGrouping,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SsrRejection {
    pub node: NodeId,
    pub span: Span,
    pub reason: SsrUnsupported,
}

/// The original ordered node at an admitted opening, leaf or closing event.
#[derive(Debug, Clone, Copy)]
pub enum SsrPart<'owner, 'arena> {
    Open {
        node: NodeId,
        element: &'owner ElementOp<'arena>,
        void: bool,
    },
    Close {
        node: NodeId,
        element: &'owner ElementOp<'arena>,
    },
    Text {
        node: NodeId,
        text: &'owner TextOp<'arena>,
    },
    Comment {
        node: NodeId,
        comment: &'owner CommentOp<'arena>,
    },
    Interpolation {
        node: NodeId,
        interpolation: &'owner InterpolationOp<'arena>,
    },
}

/// Immutable SSR facts beside their exact sealed native analysis.
#[derive(Debug)]
pub struct SsrFacts<'owner, 'arena> {
    parts: Vec<SsrPart<'owner, 'arena>>,
    unsupported: Vec<SsrRejection>,
    inherit_attrs: Option<NodeId>,
    fragment: bool,
    expressions: SideTable<SsrSetupExpression<'owner, 'arena>>,
}

impl<'owner, 'arena> SsrFacts<'owner, 'arena> {
    #[must_use]
    pub fn parts(&self) -> &[SsrPart<'owner, 'arena>] {
        &self.parts
    }

    #[must_use]
    pub fn unsupported(&self) -> &[SsrRejection] {
        &self.unsupported
    }

    /// A single non-comment native root receives the component's fallthrough.
    #[must_use]
    pub const fn inherit_attrs(&self) -> Option<NodeId> {
        self.inherit_attrs
    }

    /// Multiple authored root nodes need SSR hydration fragment boundaries.
    #[must_use]
    pub const fn fragment(&self) -> bool {
        self.fragment
    }

    /// A row exists only after the original input and all setup reads join.
    #[must_use]
    pub fn expression(&self, node: NodeId) -> Option<&SsrSetupExpression<'owner, 'arena>> {
        self.expressions.get(node)
    }
}