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>)

Tuple Fields

0: ArrayExpr<'a>

[0,,]

ArrowFunc(ArrowFuncExpr<'a>)

Tuple Fields

0: ArrowFuncExpr<'a>

An arrow function

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

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

Tuple Fields

0: Vec<FuncArg<'a>>

1: bool

Used for resolving possible sequence expressions that are arrow parameters

Assign(AssignExpr<'a>)

Tuple Fields

0: AssignExpr<'a>

Assignment or update assignment

a = 0
b += 1

Await(Box<Expr<'a>>)

Tuple Fields

0: Box<Expr<'a>>

The await keyword followed by another Expr

Binary(BinaryExpr<'a>)

Tuple Fields

0: BinaryExpr<'a>

An operation that has two arguments

Class(Class<'a>)

Tuple Fields

0: Class<'a>

A class expression see Class

Call(CallExpr<'a>)

Tuple Fields

0: CallExpr<'a>

Calling a function or method

Conditional(ConditionalExpr<'a>)

Tuple Fields

0: ConditionalExpr<'a>

A ternery expression

Func(Func<'a>)

Tuple Fields

0: Func<'a>

see Function

Ident(Ident<'a>)

Tuple Fields

0: Ident<'a>

An identifier

Lit(Lit<'a>)

Tuple Fields

0: Lit<'a>

A literal value, see Literal

Logical(LogicalExpr<'a>)

Tuple Fields

0: LogicalExpr<'a>

A specialized BinaryExpr for logical evaluation

true && true
false || true

Member(MemberExpr<'a>)

Tuple Fields

0: MemberExpr<'a>

Accessing the member of a value

b['thing'];
c.stuff;

MetaProp(MetaProp<'a>)

Tuple Fields

0: MetaProp<'a>

currently just new.target

New(NewExpr<'a>)

Tuple Fields

0: NewExpr<'a>

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

{} Calling a constructor

Obj(ObjExpr<'a>)

Tuple Fields

0: ObjExpr<'a>

Sequence(SequenceExpr<'a>)

Tuple Fields

0: SequenceExpr<'a>

Any sequence of expressions separated with a comma

Spread(Box<Expr<'a>>)

Tuple Fields

0: Box<Expr<'a>>

... followed by an Expr

Super

super

TaggedTemplate(TaggedTemplateExpr<'a>)

Tuple Fields

0: TaggedTemplateExpr<'a>

A template literal preceded by a tag function identifier

This

this

Unary(UnaryExpr<'a>)

Tuple Fields

0: UnaryExpr<'a>

An operation that has one argument

typeof 'a';
+9;

Update(UpdateExpr<'a>)

Tuple Fields

0: UpdateExpr<'a>

Increment or decrement

1++
--2

Yield(YieldExpr<'a>)

Tuple Fields

0: 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

Performs the conversion.

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

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

Performs the conversion.

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: &Expr<'a>) -> bool

This method tests for !=.

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