Enum Expression 

#[repr(C, u8)]
pub enum Expression<'a> {
    BooleanLiteral(Box<'a, BooleanLiteral>),
    NullLiteral(Box<'a, NullLiteral>),
    NumericLiteral(Box<'a, NumericLiteral<'a>>),
    BigIntLiteral(Box<'a, BigIntLiteral<'a>>),
    RegExpLiteral(Box<'a, RegExpLiteral<'a>>),
    StringLiteral(Box<'a, StringLiteral<'a>>),
    TemplateLiteral(Box<'a, TemplateLiteral<'a>>),
    Identifier(Box<'a, IdentifierReference<'a>>),
    MetaProperty(Box<'a, MetaProperty<'a>>),
    Super(Box<'a, Super>),
    ArrayExpression(Box<'a, ArrayExpression<'a>>),
    ArrowFunctionExpression(Box<'a, ArrowFunctionExpression<'a>>),
    AssignmentExpression(Box<'a, AssignmentExpression<'a>>),
    AwaitExpression(Box<'a, AwaitExpression<'a>>),
    BinaryExpression(Box<'a, BinaryExpression<'a>>),
    CallExpression(Box<'a, CallExpression<'a>>),
    ChainExpression(Box<'a, ChainExpression<'a>>),
    ClassExpression(Box<'a, Class<'a>>),
    ConditionalExpression(Box<'a, ConditionalExpression<'a>>),
    FunctionExpression(Box<'a, Function<'a>>),
    ImportExpression(Box<'a, ImportExpression<'a>>),
    LogicalExpression(Box<'a, LogicalExpression<'a>>),
    NewExpression(Box<'a, NewExpression<'a>>),
    ObjectExpression(Box<'a, ObjectExpression<'a>>),
    ParenthesizedExpression(Box<'a, ParenthesizedExpression<'a>>),
    SequenceExpression(Box<'a, SequenceExpression<'a>>),
    TaggedTemplateExpression(Box<'a, TaggedTemplateExpression<'a>>),
    ThisExpression(Box<'a, ThisExpression>),
    UnaryExpression(Box<'a, UnaryExpression<'a>>),
    UpdateExpression(Box<'a, UpdateExpression<'a>>),
    YieldExpression(Box<'a, YieldExpression<'a>>),
    PrivateInExpression(Box<'a, PrivateInExpression<'a>>),
    JSXElement(Box<'a, JSXElement<'a>>),
    JSXFragment(Box<'a, JSXFragment<'a>>),
    TSAsExpression(Box<'a, TSAsExpression<'a>>),
    TSSatisfiesExpression(Box<'a, TSSatisfiesExpression<'a>>),
    TSTypeAssertion(Box<'a, TSTypeAssertion<'a>>),
    TSNonNullExpression(Box<'a, TSNonNullExpression<'a>>),
    TSInstantiationExpression(Box<'a, TSInstantiationExpression<'a>>),
    V8IntrinsicExpression(Box<'a, V8IntrinsicExpression<'a>>),
    ComputedMemberExpression(Box<'a, ComputedMemberExpression<'a>>),
    StaticMemberExpression(Box<'a, StaticMemberExpression<'a>>),
    PrivateFieldExpression(Box<'a, PrivateFieldExpression<'a>>),
}

Represents a type for AST nodes corresponding to JavaScript’s expressions.

Inherits variants from MemberExpression. See ast module docs for explanation of inheritance.

Variants

BooleanLiteral(Box<'a, BooleanLiteral>)

See BooleanLiteral for AST node details.

NullLiteral(Box<'a, NullLiteral>)

See NullLiteral for AST node details.

NumericLiteral(Box<'a, NumericLiteral<'a>>)

See NumericLiteral for AST node details.

BigIntLiteral(Box<'a, BigIntLiteral<'a>>)

See BigIntLiteral for AST node details.

RegExpLiteral(Box<'a, RegExpLiteral<'a>>)

See RegExpLiteral for AST node details.

StringLiteral(Box<'a, StringLiteral<'a>>)

See StringLiteral for AST node details.

TemplateLiteral(Box<'a, TemplateLiteral<'a>>)

See TemplateLiteral for AST node details.

Identifier(Box<'a, IdentifierReference<'a>>)

See IdentifierReference for AST node details.

MetaProperty(Box<'a, MetaProperty<'a>>)

See MetaProperty for AST node details.

Super(Box<'a, Super>)

See Super for AST node details.

ArrayExpression(Box<'a, ArrayExpression<'a>>)

See ArrayExpression for AST node details.

ArrowFunctionExpression(Box<'a, ArrowFunctionExpression<'a>>)

See ArrowFunctionExpression for AST node details.

AssignmentExpression(Box<'a, AssignmentExpression<'a>>)

See AssignmentExpression for AST node details.

AwaitExpression(Box<'a, AwaitExpression<'a>>)

See AwaitExpression for AST node details.

BinaryExpression(Box<'a, BinaryExpression<'a>>)

See BinaryExpression for AST node details.

CallExpression(Box<'a, CallExpression<'a>>)

See CallExpression for AST node details.

ChainExpression(Box<'a, ChainExpression<'a>>)

See ChainExpression for AST node details.

ClassExpression(Box<'a, Class<'a>>)

See Class for AST node details.

ConditionalExpression(Box<'a, ConditionalExpression<'a>>)

See ConditionalExpression for AST node details.

FunctionExpression(Box<'a, Function<'a>>)

See Function for AST node details.

ImportExpression(Box<'a, ImportExpression<'a>>)

See ImportExpression for AST node details.

LogicalExpression(Box<'a, LogicalExpression<'a>>)

See LogicalExpression for AST node details.

NewExpression(Box<'a, NewExpression<'a>>)

See NewExpression for AST node details.

ObjectExpression(Box<'a, ObjectExpression<'a>>)

See ObjectExpression for AST node details.

ParenthesizedExpression(Box<'a, ParenthesizedExpression<'a>>)

See ParenthesizedExpression for AST node details.

SequenceExpression(Box<'a, SequenceExpression<'a>>)

See SequenceExpression for AST node details.

TaggedTemplateExpression(Box<'a, TaggedTemplateExpression<'a>>)

See TaggedTemplateExpression for AST node details.

ThisExpression(Box<'a, ThisExpression>)

See ThisExpression for AST node details.

UnaryExpression(Box<'a, UnaryExpression<'a>>)

See UnaryExpression for AST node details.

UpdateExpression(Box<'a, UpdateExpression<'a>>)

See UpdateExpression for AST node details.

YieldExpression(Box<'a, YieldExpression<'a>>)

See YieldExpression for AST node details.

PrivateInExpression(Box<'a, PrivateInExpression<'a>>)

See PrivateInExpression for AST node details.

JSXElement(Box<'a, JSXElement<'a>>)

See JSXElement for AST node details.

JSXFragment(Box<'a, JSXFragment<'a>>)

See JSXFragment for AST node details.

TSAsExpression(Box<'a, TSAsExpression<'a>>)

See TSAsExpression for AST node details.

TSSatisfiesExpression(Box<'a, TSSatisfiesExpression<'a>>)

See TSSatisfiesExpression for AST node details.

TSTypeAssertion(Box<'a, TSTypeAssertion<'a>>)

See TSTypeAssertion for AST node details.

TSNonNullExpression(Box<'a, TSNonNullExpression<'a>>)

See TSNonNullExpression for AST node details.

TSInstantiationExpression(Box<'a, TSInstantiationExpression<'a>>)

See TSInstantiationExpression for AST node details.

V8IntrinsicExpression(Box<'a, V8IntrinsicExpression<'a>>)

See V8IntrinsicExpression for AST node details.

ComputedMemberExpression(Box<'a, ComputedMemberExpression<'a>>)

Inherited from MemberExpression.

MemberExpression[?Yield, ?Await] [ Expression[+In, ?Yield, ?Await] ]

StaticMemberExpression(Box<'a, StaticMemberExpression<'a>>)

Inherited from MemberExpression.

MemberExpression[?Yield, ?Await] . IdentifierName

PrivateFieldExpression(Box<'a, PrivateFieldExpression<'a>>)

Inherited from MemberExpression.

MemberExpression[?Yield, ?Await] . PrivateIdentifier

Implementations

impl<'a> Expression<'a>

pub fn is_member_expression(&self) -> bool

Return if a Expression is a MemberExpression.

pub fn into_member_expression(self) -> MemberExpression<'a>

Convert Expression to MemberExpression.

Panic

Panics if not convertible.

pub fn as_member_expression(&self) -> Option<&MemberExpression<'a>>

Convert &Expression to &MemberExpression.

pub fn as_member_expression_mut(&mut self) -> Option<&mut MemberExpression<'a>>

Convert &mut Expression to &mut MemberExpression.

pub fn to_member_expression(&self) -> &MemberExpression<'a>

Convert &Expression to &MemberExpression.

Panic

Panics if not convertible.

pub fn to_member_expression_mut(&mut self) -> &mut MemberExpression<'a>

Convert &mut Expression to &mut MemberExpression.

Panic

Panics if not convertible.

impl<'a> Expression<'a>

pub fn is_typescript_syntax(&self) -> bool

Returns true if this expression is TypeScript-specific syntax.

pub fn is_primary_expression(&self) -> bool

Returns true if this is a primary expression.

pub fn is_literal(&self) -> bool

true if this Expression is a literal expression for a primitive value.

Does not include TemplateLiterals, object literals, or array literals.

pub fn is_string_literal(&self) -> bool

Returns true for string and template literals.

pub fn is_no_substitution_template(&self) -> bool

Return true if the expression is a plain template.

pub fn is_number_literal(&self) -> bool

Returns true for numeric and big int literals.

pub fn is_big_int_literal(&self) -> bool

Returns true for bigint literals.

pub fn is_specific_string_literal(&self, string: &str) -> bool

Returns true for string literals matching the expected value. Note that non-substitution template literals are not considered.

pub fn is_null(&self) -> bool

Determines whether the given expr is a null literal

pub fn is_undefined(&self) -> bool

Determines whether the given expr is a undefined literal

pub fn is_void(&self) -> bool

Determines whether the given expr is a void expr

pub fn is_void_0(&self) -> bool

Determines whether the given expr is a void 0

pub fn is_number(&self) -> bool

Returns true for numeric literals

pub fn is_number_0(&self) -> bool

Determines whether the given expr is a 0

pub fn is_number_value(&self, val: f64) -> bool

Determines whether the given expr is a specific number literal.

pub fn is_specific_raw_number_literal(&self, val: &str) -> bool

Determines whether the given numeral literal’s raw value is exactly val

pub fn evaluate_to_undefined(&self) -> bool

Determines whether the given expr evaluate to undefined

pub fn is_null_or_undefined(&self) -> bool

Determines whether the given expr is a null or undefined or void 0

Corresponds to a nullish value check.

pub fn is_nan(&self) -> bool

Determines whether the given expr is a NaN literal

pub fn without_parentheses(&self) -> &Expression<'a>

Remove nested parentheses from this expression.

pub fn without_parentheses_mut(&mut self) -> &mut Expression<'a>

Remove nested parentheses from this expression.

pub fn is_specific_id(&self, name: &str) -> bool

Returns true if this Expression is an IdentifierReference with specified name.

pub fn is_specific_member_access(&self, object: &str, property: &str) -> bool

Returns true if this Expression is a MemberExpression with the specified object name and property name.

For example, Array.from is a specific member access with object Array and property from and could be checked like expr.is_specific_member_access("Array", "from").

pub fn into_inner_expression(self) -> Expression<'a>

Returns the expression inside of this one, if applicable, and takes ownership of it. For example, if the expression is a ParenthesizedExpression, it will return the expression inside the parentheses. Or if this is part of a TypeScript expression like as, satisfies, or !, then it will return the expression that is being type asserted.

For getting a reference to the expression inside, use Expression::get_inner_expression.

pub fn get_inner_expression(&self) -> &Expression<'a>

Gets the expression inside of this one, if applicable, and returns a reference to it. For example, if the expression is a ParenthesizedExpression, it will return the expression inside the parentheses. Or if this is part of a TypeScript expression like as, satisfies, or !, then it will return the expression that is being type asserted.

For taking ownership of the expression inside, use Expression::into_inner_expression. For getting a mutable reference to the expression inside, use Expression::get_inner_expression_mut.

pub fn get_inner_expression_mut(&mut self) -> &mut Expression<'a>

Gets the expression inside of this one, if applicable, and returns a mutable reference to it. For example, if the expression is a ParenthesizedExpression, it will return the expression inside the parentheses. Or if this is part of a TypeScript expression like as, satisfies, or !, then it will return the expression that is being type asserted.

For taking ownership of the expression inside, use Expression::into_inner_expression. For getting an immutable reference to the expression inside, use Expression::get_inner_expression.

pub fn into_chain_element(self) -> Option<ChainElement<'a>>

Turns any chainable expression such as a.b or b() into the chained equivalent such as a?.b or b?.().

pub fn is_identifier_reference(&self) -> bool

Returns true if this Expression is an IdentifierReference.

pub fn get_identifier_reference(&self) -> Option<&IdentifierReference<'a>>

Returns the IdentifierReference if this expression is an Expression::Identifier, or contains an Expression::Identifier and reruns None otherwise.

pub fn is_function(&self) -> bool

Returns true if this Expression is a function (either Function or ArrowFunctionExpression).

pub fn is_anonymous_function_definition(&self) -> bool

Returns true if this Expression is an anonymous function definition. Note that this includes Classs. https://262.ecma-international.org/15.0/#sec-isanonymousfunctiondefinition

pub fn is_call_expression(&self) -> bool

Returns true if this Expression is a CallExpression.

pub fn is_super(&self) -> bool

Returns true if this Expression is a Super.

pub fn is_super_call_expression(&self) -> bool

Returns true if this Expression is a CallExpression with Super as callee.

pub fn is_call_like_expression(&self) -> bool

Returns true if this Expression is a CallExpression, NewExpression, or ImportExpression.

pub fn is_binaryish(&self) -> bool

Returns true if this Expression is a BinaryExpression or LogicalExpression.

pub fn get_member_expr(&self) -> Option<&MemberExpression<'a>>

Returns the MemberExpression if this expression is a MemberExpression, contains a MemberExpression, or is or part of a ChainExpression (such as a?.b), and returns None otherwise if this is not a member expression.

pub fn is_require_call(&self) -> bool

Returns true if this Expression is a require call.

See CallExpression::is_require_call for details of the exact patterns that match.

pub fn is_assignment(&self) -> bool

Returns true if this is an assignment expression.

pub fn is_entity_name_expression(&self) -> bool

Is identifier or a.b expression where a is an identifier.

pub fn is_property_access_entity_name_expression(&self) -> bool

a.b expression where a is an identifier.

pub fn is_jsx(&self) -> bool

Returns true if this Expression is a JSXElement or JSXFragment.

Trait Implementations

impl<'new_alloc> CloneIn<'new_alloc> for Expression<'_>

type Cloned = Expression<'new_alloc>

The type of the cloned object.

fn clone_in( &self, allocator: &'new_alloc Allocator, ) -> <Expression<'_> as CloneIn<'new_alloc>>::Cloned

Clone self into the given allocator. allocator may be the same one that self is already in.

fn clone_in_with_semantic_ids( &self, allocator: &'new_alloc Allocator, ) -> <Expression<'_> as CloneIn<'new_alloc>>::Cloned

Almost identical as clone_in, but for some special type, it will also clone the semantic ids. Please use this method only if you make sure semantic info is synced with the ast node.

impl<'a> ConstantEvaluation<'a> for Expression<'a>

fn evaluate_value_to( &self, ctx: &impl ConstantEvaluationCtx<'a>, target_ty: Option<ValueType>, ) -> Option<ConstantValue<'a>>

Evaluate the expression to a constant value.

fn evaluate_value( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<ConstantValue<'a>>

Evaluate the expression to a constant value.

fn evaluate_value_to_number( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<f64>

Evaluate the expression to a constant value and convert it to a number.

fn evaluate_value_to_bigint( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<BigInt>

Evaluate the expression to a constant value and convert it to a bigint.

fn evaluate_value_to_boolean( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<bool>

Evaluate the expression to a constant value and convert it to a boolean.

fn evaluate_value_to_string( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<Cow<'a, str>>

Evaluate the expression to a constant value and convert it to a string.

fn get_side_free_number_value( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<f64>

fn get_side_free_bigint_value( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<BigInt>

fn get_side_free_boolean_value( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<bool>

fn get_side_free_string_value( &self, ctx: &impl ConstantEvaluationCtx<'a>, ) -> Option<Cow<'a, str>>

impl ContentEq for Expression<'_>

fn content_eq(&self, other: &Expression<'_>) -> bool

This method tests for contents of self and other to be equal.

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

This method tests for contents of self and other not to be equal. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Debug for Expression<'a>

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

Formats the value using the given formatter.

impl<'a> DetermineValueType<'a> for Expression<'a>

fn value_type(&self, ctx: &impl GlobalContext<'a>) -> ValueType

impl<'a> Dummy<'a> for Expression<'a>

fn dummy(allocator: &'a Allocator) -> Expression<'a>

Create a dummy Expression.

Has cost of making 1 allocation (8 bytes).

impl<'a> From<ChainElement<'a>> for Expression<'a>

fn from(value: ChainElement<'a>) -> Expression<'a>

Converts to this type from the input type.

impl<'a> From<Expression<'a>> for Argument<'a>

fn from(value: Expression<'a>) -> Argument<'a>

Convert Expression to Argument.

impl<'a> From<Expression<'a>> for ArrayExpressionElement<'a>

fn from(value: Expression<'a>) -> ArrayExpressionElement<'a>

Convert Expression to ArrayExpressionElement.

impl<'a> From<Expression<'a>> for ExportDefaultDeclarationKind<'a>

fn from(value: Expression<'a>) -> ExportDefaultDeclarationKind<'a>

Convert Expression to ExportDefaultDeclarationKind.

impl<'a> From<Expression<'a>> for ForStatementInit<'a>

fn from(value: Expression<'a>) -> ForStatementInit<'a>

Convert Expression to ForStatementInit.

impl<'a> From<Expression<'a>> for JSXExpression<'a>

fn from(value: Expression<'a>) -> JSXExpression<'a>

Convert Expression to JSXExpression.

impl<'a> From<Expression<'a>> for PropertyKey<'a>

fn from(value: Expression<'a>) -> PropertyKey<'a>

Convert Expression to PropertyKey.

impl<'a> From<MemberExpression<'a>> for Expression<'a>

fn from(value: MemberExpression<'a>) -> Expression<'a>

Convert MemberExpression to Expression.

impl<'a> GatherNodeParts<'a> for Expression<'a>

fn gather<F>(&self, f: &mut F)

where F: FnMut(&str),

impl GenExpr for Expression<'_>

fn gen_expr(&self, p: &mut Codegen<'_>, precedence: Precedence, ctx: Context)

Generate code for an expression, respecting operator precedence.

fn print_expr(&self, p: &mut Codegen<'_>, precedence: Precedence, ctx: Context)

Generate code for an expression, respecting operator precedence. Alias for gen_expr.

impl GetAddress for Expression<'_>

fn address(&self) -> Address

Get the memory address of a value allocated in the arena.

impl GetPrecedence for Expression<'_>

fn precedence(&self) -> Precedence

impl GetSpan for Expression<'_>

fn span(&self) -> Span

Get the Span for an AST node.

impl GetSpanMut for Expression<'_>

fn span_mut(&mut self) -> &mut Span

Get a mutable reference to an AST node’s Span.

impl IsGlobalReference for Expression<'_>

fn is_global_reference(&self, scoping: &Scoping) -> bool

fn is_global_reference_name(&self, name: &str, scoping: &Scoping) -> bool

impl<'a> IsInt32OrUint32<'a> for Expression<'a>

fn is_int32_or_uint32(&self, ctx: &impl GlobalContext<'a>) -> bool

Whether the value of the expression is a int32 or uint32. If this method returns true, we know that the value cannot be NaN or Infinity.

impl<'a> IsLiteralValue<'a, '_> for Expression<'a>

fn is_literal_value( &self, include_functions: bool, ctx: &impl GlobalContext<'a>, ) -> bool

impl<'a> MayHaveSideEffects<'a> for Expression<'a>

fn may_have_side_effects( &self, ctx: &impl MayHaveSideEffectsContext<'a>, ) -> bool

impl<'a> TakeIn<'a> for Expression<'a>

fn take_in<A>(&mut self, allocator_accessor: A) -> Self

where A: AllocatorAccessor<'a>,

Replace node with a dummy.

fn take_in_box<A>(&mut self, allocator_accessor: A) -> Box<'a, Self>

where A: AllocatorAccessor<'a>,

Replace node with a boxed dummy.

impl<'a> ToBigInt<'a> for Expression<'a>

fn to_big_int(&self, ctx: &impl GlobalContext<'a>) -> Option<BigInt>

impl<'a> ToBoolean<'a> for Expression<'a>

fn to_boolean(&self, ctx: &impl GlobalContext<'a>) -> Option<bool>

impl<'a> ToJsString<'a> for Expression<'a>

fn to_js_string(&self, ctx: &impl GlobalContext<'a>) -> Option<Cow<'a, str>>

impl<'a> ToNumber<'a> for Expression<'a>

fn to_number(&self, ctx: &impl GlobalContext<'a>) -> Option<f64>

impl<'a> ToPrimitive<'a> for Expression<'a>

fn to_primitive(&self, ctx: &impl GlobalContext<'a>) -> ToPrimitiveResult

impl<'a> TryFrom<Argument<'a>> for Expression<'a>

fn try_from( value: Argument<'a>, ) -> Result<Expression<'a>, <Expression<'a> as TryFrom<Argument<'a>>>::Error>

Convert Argument to Expression.

type Error = ()

The type returned in the event of a conversion error.

impl<'a> TryFrom<ArrayExpressionElement<'a>> for Expression<'a>

fn try_from( value: ArrayExpressionElement<'a>, ) -> Result<Expression<'a>, <Expression<'a> as TryFrom<ArrayExpressionElement<'a>>>::Error>

Convert ArrayExpressionElement to Expression.

type Error = ()

The type returned in the event of a conversion error.

impl<'a> TryFrom<ExportDefaultDeclarationKind<'a>> for Expression<'a>

fn try_from( value: ExportDefaultDeclarationKind<'a>, ) -> Result<Expression<'a>, <Expression<'a> as TryFrom<ExportDefaultDeclarationKind<'a>>>::Error>

Convert ExportDefaultDeclarationKind to Expression.

type Error = ()

The type returned in the event of a conversion error.

impl<'a> TryFrom<Expression<'a>> for MemberExpression<'a>

fn try_from( value: Expression<'a>, ) -> Result<MemberExpression<'a>, <MemberExpression<'a> as TryFrom<Expression<'a>>>::Error>

Convert Expression to MemberExpression.

type Error = ()

The type returned in the event of a conversion error.

impl<'a> TryFrom<ForStatementInit<'a>> for Expression<'a>

fn try_from( value: ForStatementInit<'a>, ) -> Result<Expression<'a>, <Expression<'a> as TryFrom<ForStatementInit<'a>>>::Error>

Convert ForStatementInit to Expression.

type Error = ()

The type returned in the event of a conversion error.

impl<'a> TryFrom<JSXExpression<'a>> for Expression<'a>

fn try_from( value: JSXExpression<'a>, ) -> Result<Expression<'a>, <Expression<'a> as TryFrom<JSXExpression<'a>>>::Error>

Convert JSXExpression to Expression.

type Error = ()

The type returned in the event of a conversion error.

impl<'a> TryFrom<PropertyKey<'a>> for Expression<'a>

fn try_from( value: PropertyKey<'a>, ) -> Result<Expression<'a>, <Expression<'a> as TryFrom<PropertyKey<'a>>>::Error>

Convert PropertyKey to Expression.

type Error = ()

The type returned in the event of a conversion error.