vize_l2 0.429.1

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
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

//! Owned mirrors of the expression payloads (P2-5b).
//!
//! The folio stores expressions as **owned text plus span**, never as AST
//! references, because arena references cannot persist across a compile
//! (P1-11's contract, enforced by the debug arena-generation stamp in
//! `crates/vize_carton/src/allocator/generation.rs`): a `js(...)` payload
//! re-parses into the arena on load through
//! [`JsExpr::parse_in`](crate::expr::JsExpr::parse_in) (or totally via
//! [`ExprRef::parse_js_in`](crate::expr::ExprRef::parse_js_in)). The
//! owned mirrors *do* implement `PartialEq` - equality here compares what
//! the folio carries, which is explicit text, not expression semantics;
//! the pessimal no-equality law lives on the arena types.

use vize_l0::{Span, String};

use crate::expr::{ExprRef, OpaqueReason};

/// Mirror of [`ExprRef`]: one expression payload as the folio carries it.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FolioExpr {
    /// `js(...)` - re-parses into the arena on load.
    Js {
        /// The exact text the retained AST was parsed from.
        source: String,
        /// The authored range of `source`.
        span: Span,
    },
    /// `foreign(...)` - dialect id + source + span (the phase-6 dialect
    /// contract owns the side tables' folio spelling; until then they do
    /// not serialize - see [`crate::expr::ForeignExpr::facts`]).
    Foreign {
        /// The dialect id.
        dialect: String,
        /// The exact authored text.
        source: String,
        /// The authored range of `source`.
        span: Span,
    },
    /// `opaque(...)` - reason + slice + span; pessimal semantics travel
    /// with the reason.
    Opaque {
        /// Why no AST exists.
        reason: OpaqueReason,
        /// The exact authored (or rebuilt) text.
        source: String,
        /// The authored range of `source`.
        span: Span,
    },
    /// `vue.filter(...)` - Vue 2 pipe-filter chain as authored text.
    Filter {
        /// The exact authored text, pipes included.
        source: String,
        /// The authored range of `source`.
        span: Span,
    },
}

/// Mirror of [`crate::op::ForBinding`].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FolioForBinding {
    /// The iterated collection, object, or range.
    pub source: FolioExpr,
    /// The per-iteration value binding.
    pub value: FolioExpr,
    /// The second binding position (object key), when authored.
    pub key: Option<FolioExpr>,
    /// The third binding position (index), when authored.
    pub index: Option<FolioExpr>,
}

/// Mirror of [`crate::op::BindingContract`].
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FolioContract {
    /// What the view reads.
    pub read: FolioExpr,
    /// What updates write into.
    pub write: FolioExpr,
}

/// Bridge one live expression reference into the owned model.
///
/// Exhaustive with no `_` arm on purpose (the staleness discipline of
/// [`super`]): a new `ExprRef` variant must break this file loudly.
pub(in crate::folio) fn own_expr(expr: &ExprRef<'_>) -> FolioExpr {
    match expr {
        ExprRef::Js(js) => FolioExpr::Js {
            source: String::from(js.source),
            span: js.span,
        },
        ExprRef::Foreign(foreign) => FolioExpr::Foreign {
            dialect: String::from(foreign.dialect),
            source: String::from(foreign.source),
            span: foreign.span,
        },
        ExprRef::Opaque(opaque) => FolioExpr::Opaque {
            reason: opaque.reason,
            source: String::from(opaque.source),
            span: opaque.span,
        },
        ExprRef::Filter(filter) => FolioExpr::Filter {
            source: String::from(filter.source),
            span: filter.span,
        },
    }
}