Enum Expr 

pub enum Expr {
    Literal(Literal),
    Ident(String),
    Binary {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
        span: Option<Span>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<Expr>,
        span: Option<Span>,
    },
    Call {
        callee: Box<Expr>,
        args: Vec<Expr>,
        span: Option<Span>,
    },
    Member {
        object: Box<Expr>,
        property: Box<Expr>,
        computed: bool,
        span: Option<Span>,
    },
    Array(Vec<Expr>),
    Object(Vec<(String, Expr)>),
    Function(Box<Function>),
    Conditional {
        test: Box<Expr>,
        consequent: Box<Expr>,
        alternate: Box<Expr>,
        span: Option<Span>,
    },
    Assign {
        target: Box<Expr>,
        value: Box<Expr>,
        span: Option<Span>,
    },
    TemplateLiteral(Vec<TemplatePart>),
}

An expression that produces a value.

Variants

Literal(Literal)

Literal value.

Ident(String)

Variable reference.

Binary

Binary operation: left op right.

Fields

left: Box<Expr>

op: BinaryOp

right: Box<Expr>

span: Option<Span>

Source location (populated by readers; ignored by writers).

Unary

Unary operation: op expr.

Fields

op: UnaryOp

expr: Box<Expr>

span: Option<Span>

Source location (populated by readers; ignored by writers).

Call

Function call: callee(args...).

Fields

callee: Box<Expr>

args: Vec<Expr>

span: Option<Span>

Source location (populated by readers; ignored by writers).

Member

Member access: object.property or object[property].

Fields

object: Box<Expr>

property: Box<Expr>

computed: bool

True for obj[expr], false for obj.ident.

span: Option<Span>

Source location (populated by readers; ignored by writers).

Array(Vec<Expr>)

Array literal: [a, b, c].

Object(Vec<(String, Expr)>)

Object literal: { key: value, ... }.

Function(Box<Function>)

Anonymous function: function(params) { body }.

Conditional

Ternary/conditional: cond ? then : else.

Fields

test: Box<Expr>

consequent: Box<Expr>

alternate: Box<Expr>

span: Option<Span>

Source location (populated by readers; ignored by writers).

Assign

Assignment: target = value.

Fields

target: Box<Expr>

value: Box<Expr>

span: Option<Span>

Source location (populated by readers; ignored by writers).

TemplateLiteral(Vec<TemplatePart>)

Template literal: `text${expr}more`.

Carries the original template structure for languages that support native string interpolation (TypeScript/JavaScript). Writers for other languages (Lua, Python) fall back to string concatenation.

Implementations

impl Expr

pub fn null() -> Self

pub fn bool(v: bool) -> Self

pub fn number(v: impl Into<f64>) -> Self

pub fn string(v: impl Into<String>) -> Self

pub fn ident(name: impl Into<String>) -> Self

pub fn binary(left: Expr, op: BinaryOp, right: Expr) -> Self

pub fn unary(op: UnaryOp, expr: Expr) -> Self

pub fn call(callee: Expr, args: Vec<Expr>) -> Self

pub fn member(object: Expr, property: impl Into<String>) -> Self

pub fn index(object: Expr, index: Expr) -> Self

pub fn array(items: Vec<Expr>) -> Self

pub fn object(pairs: Vec<(String, Expr)>) -> Self

pub fn conditional(test: Expr, consequent: Expr, alternate: Expr) -> Self

pub fn assign(target: Expr, value: Expr) -> Self

pub fn template_literal(parts: Vec<TemplatePart>) -> Self

pub fn with_span(self, span: Span) -> Self

Attach a source location span to this expression.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Expr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructureEq for Expr

fn structure_eq(&self, other: &Self) -> bool

Compare two values for structural equality.

impl StructuralPartialEq for Expr