Enum JsExpr 

pub enum JsExpr {
    Lit(JsLit),
    Var(String),
    Call(Box<JsExpr>, Vec<JsExpr>),
    Method(Box<JsExpr>, String, Vec<JsExpr>),
    Field(Box<JsExpr>, String),
    Index(Box<JsExpr>, Box<JsExpr>),
    Arrow(Vec<String>, Box<JsStmt>),
    Ternary(Box<JsExpr>, Box<JsExpr>, Box<JsExpr>),
    BinOp(String, Box<JsExpr>, Box<JsExpr>),
    UnOp(String, Box<JsExpr>),
    Await(Box<JsExpr>),
    New(String, Vec<JsExpr>),
    Spread(Box<JsExpr>),
    Object(Vec<(String, JsExpr)>),
    Array(Vec<JsExpr>),
}

JavaScript expression for code generation.

Variants

Lit(JsLit)

A literal value: 42n, "hello", true, etc.

Var(String)

A variable identifier: x, _t0, Nat_add

Call(Box<JsExpr>, Vec<JsExpr>)

A function call: f(a, b, c)

Method(Box<JsExpr>, String, Vec<JsExpr>)

A method call: obj.method(a, b)

Field(Box<JsExpr>, String)

Property access: obj.field

Index(Box<JsExpr>, Box<JsExpr>)

Array index: arr[i]

Arrow(Vec<String>, Box<JsStmt>)

Arrow function: (x, y) => { stmts }

Ternary(Box<JsExpr>, Box<JsExpr>, Box<JsExpr>)

Ternary expression: cond ? then_expr : else_expr

BinOp(String, Box<JsExpr>, Box<JsExpr>)

Binary operator: lhs + rhs, a === b, etc.

UnOp(String, Box<JsExpr>)

Unary operator: !x, -n, typeof x

Await(Box<JsExpr>)

Await expression: await promise

New(String, Vec<JsExpr>)

Constructor call: new MyClass(a, b)

Spread(Box<JsExpr>)

Spread expression: ...arr

Object(Vec<(String, JsExpr)>)

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

Array(Vec<JsExpr>)

Array literal: [a, b, c]

Trait Implementations

impl Clone for JsExpr

fn clone(&self) -> JsExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JsExpr

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

Formats the value using the given formatter.

impl Display for JsExpr

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

Formats the value using the given formatter.

impl PartialEq for JsExpr

fn eq(&self, other: &JsExpr) -> 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 StructuralPartialEq for JsExpr