Enum TsExpr 

pub enum TsExpr {
    Lit(TsLit),
    Var(String),
    BinOp(String, Box<TsExpr>, Box<TsExpr>),
    UnaryOp(String, Box<TsExpr>),
    Call(Box<TsExpr>, Vec<TsExpr>),
    MethodCall(Box<TsExpr>, String, Vec<TsExpr>),
    New(Box<TsExpr>, Vec<TsExpr>),
    Arrow(Vec<(String, Option<TsType>)>, Box<TsExpr>),
    Ternary(Box<TsExpr>, Box<TsExpr>, Box<TsExpr>),
    As(Box<TsExpr>, TsType),
    Satisfies(Box<TsExpr>, TsType),
    TypeAssert(Box<TsExpr>),
    ObjectLit(Vec<(String, TsExpr)>),
    ArrayLit(Vec<TsExpr>),
    Template(Vec<TsTemplatePart>),
    Await(Box<TsExpr>),
    Nullish(Box<TsExpr>, Box<TsExpr>),
    OptChain(Box<TsExpr>, String),
}

TypeScript expression AST node.

Variants

Lit(TsLit)

A literal value.

Var(String)

A variable reference: x, myVar

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

A binary operation: lhs + rhs

UnaryOp(String, Box<TsExpr>)

A unary operation: !x, -n

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

A function/method call: f(a, b)

MethodCall(Box<TsExpr>, String, Vec<TsExpr>)

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

New(Box<TsExpr>, Vec<TsExpr>)

Constructor call: new Foo(a, b)

Arrow(Vec<(String, Option<TsType>)>, Box<TsExpr>)

Arrow function: (x: T) => expr

Ternary(Box<TsExpr>, Box<TsExpr>, Box<TsExpr>)

Ternary expression: cond ? then : else

As(Box<TsExpr>, TsType)

Type assertion: expr as T

Satisfies(Box<TsExpr>, TsType)

Satisfies expression: expr satisfies T

TypeAssert(Box<TsExpr>)

Non-null assertion: expr!

ObjectLit(Vec<(String, TsExpr)>)

Object literal: { key: val }

ArrayLit(Vec<TsExpr>)

Array literal: [a, b, c]

Template(Vec<TsTemplatePart>)

Template literal: `Hello ${name}!`

Await(Box<TsExpr>)

Await expression: await p

Nullish(Box<TsExpr>, Box<TsExpr>)

Nullish coalescing: a ?? b

OptChain(Box<TsExpr>, String)

Optional chaining: obj?.prop

Trait Implementations

impl Clone for TsExpr

fn clone(&self) -> TsExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TsExpr

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

Formats the value using the given formatter.

impl Display for TsExpr

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

Formats the value using the given formatter.

impl PartialEq for TsExpr

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