Enum ExprRef 

pub enum ExprRef<'a> {
    Js(&'a JsExpr<'a>),
    Foreign(&'a ForeignExpr<'a>),
    Filter(&'a VueFilterExpr<'a>),
    Opaque(&'a OpaqueExpr<'a>),
}

One expression position’s reference: retained JS AST, foreign dialect, or the classified escape.

A reference, deliberately: payloads are shared &'a borrows of the compile arena, so two positions may name the same payload (ui.model’s read/write typically do), and the enum stays two words. Nothing here survives Allocator::reset - the folio carries the owned form (P1-11’s contract; see crate::dump).

Variants

Js(&'a JsExpr<'a>)

The retained oxc AST with its exact source text and authored span.

Foreign(&'a ForeignExpr<'a>)

A foreign-dialect expression (type-only until phase 6).

Filter(&'a VueFilterExpr<'a>)

Vue 2 pipe-filter chain (the dialect reading of |).

Opaque(&'a OpaqueExpr<'a>)

The escape variant: no AST exists, pessimal semantics apply.

Implementations

impl<'a> ExprRef<'a>

pub const fn mnemonic(&self) -> &'static str

The payload’s stage-wide mnemonic - the keyword its folio token starts with.

pub const fn source(&self) -> &'a str

The exact authored (or synthesized) text of the expression.

For ExprRef::Js this is the text the AST was parsed from and covers (the P1-5 raw contract); for the other variants it is all the compiler knows.

pub const fn span(&self) -> Span

The authored range of ExprRef::source in the compiled file.

pub fn parse_js_in( allocator: &'a Allocator, source: &'a str, span: Span, ) -> Self

The total load-path constructor: parse source as one complete TS-dialect expression into the arena, falling back to the escape variant when the text is not admitted.

This is how a folio’s js(...) payload re-enters an arena (the owned page stores slice + span only, because AST references cannot persist across a compile - P1-11). It never panics and never half-succeeds (the MLIR one-shot import: lowerings are total functions): text JsExpr::parse_in refuses comes back as ExprRef::Opaque with the classified reason and pessimal semantics, which is exactly what a hand-edited or stale folio has earned.

Trait Implementations

impl<'a> Clone for ExprRef<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for ExprRef<'a>

impl<'a> Debug for ExprRef<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<ExprRef<'a>> for OnHandlerRef<'a>

fn from(value: ExprRef<'a>) -> Self

Converts to this type from the input type.