Enum ViewNode 

pub enum ViewNode<'a> {
    Element {
        tag: Symbol,
        attrs: Vec<Attr<'a>>,
        children: Vec<ViewNode<'a>>,
        span: Span,
    },
    Text {
        text: &'a Expr<'a>,
        span: Span,
    },
    Component {
        name: Symbol,
        props: Vec<(Symbol, &'a Expr<'a>)>,
        prop_spans: Vec<Span>,
        children: Vec<ViewNode<'a>>,
        span: Span,
    },
    Each {
        pattern: Pattern,
        iterable: &'a Expr<'a>,
        key: Option<&'a Expr<'a>>,
        index: Option<Symbol>,
        body: Vec<ViewNode<'a>>,
        empty: Vec<ViewNode<'a>>,
        span: Span,
    },
    If {
        arms: Vec<(&'a Expr<'a>, Vec<ViewNode<'a>>)>,
        otherwise: Option<Vec<ViewNode<'a>>>,
        span: Span,
    },
    Handler {
        event: Symbol,
        modifiers: Vec<EventModifier>,
        body: &'a [Stmt<'a>],
        span: Span,
    },
    Raw {
        html: &'a Expr<'a>,
        span: Span,
    },
    Inspect {
        scrutinee: &'a Expr<'a>,
        arms: Vec<ViewArm<'a>>,
        span: Span,
    },
    Let {
        var: Symbol,
        value: &'a Expr<'a>,
        span: Span,
    },
    Extends {
        layout: Symbol,
        span: Span,
    },
    Block {
        name: Symbol,
        default: Option<Vec<ViewNode<'a>>>,
        span: Span,
    },
    Children {
        span: Span,
    },
}

One node of a view tree.

Variants

Element

An HTML element with its attributes (in source order) and children.

Fields

tag: Symbol

attrs: Vec<Attr<'a>>

children: Vec<ViewNode<'a>>

span: Span

Text

A text child: a literal or interpolated string expression (escaped on render).

Fields

text: &'a Expr<'a>

span: Span

Component

A use of a declared component (Counter, <TodoRow …/>). prop_spans[i] is where props[i] was written — the whole name={value} attribute — so a refusal about one prop points at that prop.

Fields

name: Symbol

props: Vec<(Symbol, &'a Expr<'a>)>

prop_spans: Vec<Span>

children: Vec<ViewNode<'a>>

span: Span

Each

for each <pattern> in <iterable>[, keyed by <key>][, at index <i>]: — one body per item; empty renders when the collection has no items. index counts from LOOP_INDEX_BASE.

Fields

pattern: Pattern

iterable: &'a Expr<'a>

key: Option<&'a Expr<'a>>

index: Option<Symbol>

body: Vec<ViewNode<'a>>

empty: Vec<ViewNode<'a>>

span: Span

If

when <cond>: … otherwise: — arms in order, then the fallback.

Fields

arms: Vec<(&'a Expr<'a>, Vec<ViewNode<'a>>)>

otherwise: Option<Vec<ViewNode<'a>>>

span: Span

Handler

An event handler on the containing element: the legacy on click: + statements, or an LGX on-click={action} directive (whose expression becomes a one-call body). modifiers are the .prevent / .stop / .enter … qualifiers, already classified by the event-modifier catalogue (crate::lgx::html::EventModifier).

Fields

event: Symbol

modifiers: Vec<EventModifier>

body: &'a [Stmt<'a>]

span: Span

Raw

raw <string> — trusted markup inserted verbatim.

Fields

html: &'a Expr<'a>

span: Span

Inspect

{inspect v:} {when Pat:} … {end} — a pattern match whose arms are subtrees.

Fields

scrutinee: &'a Expr<'a>

arms: Vec<ViewArm<'a>>

span: Span

Let

{let x be e} — a template-local binding, in scope for the following siblings.

Fields

var: Symbol

value: &'a Expr<'a>

span: Span

Extends

{extends Layout} — this view fills the named layout’s blocks.

Fields

layout: Symbol

span: Span

Block

{block name:} … {end} (with a default) or {block name} (a slot to fill).

Fields

name: Symbol

default: Option<Vec<ViewNode<'a>>>

span: Span

Children

{children} — where a component’s caller-supplied children render.

Fields

span: Span

Implementations

impl<'a> ViewNode<'a>

pub fn span(&self) -> Span

Where this node was written.

★ EVERY VARIANT ALREADY CARRIED A span AND NOTHING COULD ASK FOR IT. The browser-tier refusals in lgx_lower all walk this tree, and each one destructured the node with .. — so a page refused because of ONE element reported at Span::default(), which renders as the top of the file. The author was told their page could not be lowered and left to find which of forty nodes did it.

TOTAL, deliberately: a new ViewNode variant does not compile until it says where it is.

impl<'a> ViewNode<'a>

pub fn construct(&self) -> &'static str

The construct as an author writes it, for a message that names what it is about.

Trait Implementations

impl<'a> Clone for ViewNode<'a>

fn clone(&self) -> ViewNode<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ViewNode<'a>

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

Formats the value using the given formatter.