Enum resast::expr::Expr

pub enum Expr<'a> {
    Array(ArrayExpr<'a>),
    ArrowFunc(ArrowFuncExpr<'a>),
    ArrowParamPlaceHolder(Vec<FuncArg<'a>>, bool),
    Assign(AssignExpr<'a>),
    Await(Box<Expr<'a>>),
    Binary(BinaryExpr<'a>),
    Class(Class<'a>),
    Call(CallExpr<'a>),
    Conditional(ConditionalExpr<'a>),
    Func(Func<'a>),
    Ident(Ident<'a>),
    Lit(Lit<'a>),
    Logical(LogicalExpr<'a>),
    Member(MemberExpr<'a>),
    MetaProp(MetaProp<'a>),
    New(NewExpr<'a>),
    Obj(ObjExpr<'a>),
    Sequence(SequenceExpr<'a>),
    Spread(Box<Expr<'a>>),
    Super,
    TaggedTemplate(TaggedTemplateExpr<'a>),
    This,
    Unary(UnaryExpr<'a>),
    Update(UpdateExpr<'a>),
    Yield(YieldExpr<'a>),
}

A slightly more granular program part that a statement

Variants

Array(ArrayExpr<'a>)

[0,,]

ArrowFunc(ArrowFuncExpr<'a>)

An arrow function

() => console.log();
x => {
    return x;
}

ArrowParamPlaceHolder(Vec<FuncArg<'a>>, bool)

Used for resolving possible sequence expressions that are arrow parameters

Assign(AssignExpr<'a>)

Assignment or update assignment

a = 0
b += 1

Await(Box<Expr<'a>>)

The await keyword followed by another Expr

Binary(BinaryExpr<'a>)

An operation that has two arguments

Class(Class<'a>)

A class expression see Class

Call(CallExpr<'a>)

Calling a function or method

Conditional(ConditionalExpr<'a>)

A ternery expression

Func(Func<'a>)

see Function

Ident(Ident<'a>)

An identifier

Lit(Lit<'a>)

A literal value, see Literal

Logical(LogicalExpr<'a>)

A specialized BinaryExpr for logical evaluation

true && true
false || true

Member(MemberExpr<'a>)

Accessing the member of a value

b['thing'];
c.stuff;

MetaProp(MetaProp<'a>)

currently just new.target

New(NewExpr<'a>)

var a = true ? 'stuff' : 'things';

{} Calling a constructor

Obj(ObjExpr<'a>)

Sequence(SequenceExpr<'a>)

Any sequence of expressions separated with a comma

Spread(Box<Expr<'a>>)

... followed by an Expr

Super

super

TaggedTemplate(TaggedTemplateExpr<'a>)

A template literal preceded by a tag function identifier

This

this

Unary(UnaryExpr<'a>)

An operation that has one argument

typeof 'a';
+9;

Update(UpdateExpr<'a>)

Increment or decrement

1++
--2

Yield(YieldExpr<'a>)

yield a value from inside of a generator function

Implementations

impl<'a> Expr<'a>

pub fn ident_from(s: &'a str) -> Self

Trait Implementations

impl<'a> Clone for Expr<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Expr<'a>

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

Formats the value using the given formatter.

impl<'a> From<Expr<'a>> for Expr<'a>

fn from(other: Expr<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<SequenceExprEntry<'a>> for Expr<'a>

fn from(other: SequenceExprEntry<'a>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq<Expr<'a>> for Expr<'a>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> StructuralPartialEq for Expr<'a>