Enum ezno_parser::expressions::Expression

source ·

pub enum Expression {
Show 37 variants
    NumberLiteral(NumberStructure, Span, ExpressionId),
    StringLiteral(String, Quoted, Span, ExpressionId),
    BooleanLiteral(bool, Span, ExpressionId),
    RegexLiteral {
        pattern: String,
        flags: Option<String>,
        position: Span,
        id: ExpressionId,
    },
    ArrayLiteral(Vec<SpreadExpression>, Span, ExpressionId),
    ObjectLiteral(ObjectLiteral),
    TemplateLiteral(TemplateLiteral),
    ParenthesizedExpression(Box<MultipleExpression>, Span, ExpressionId),
    BinaryOperation {
        lhs: Box<Expression>,
        operator: BinaryOperator,
        rhs: Box<Expression>,
        id: ExpressionId,
    },
    SpecialOperators(SpecialOperators, Span, ExpressionId),
    UnaryOperation {
        operator: UnaryOperator,
        operand: Box<Expression>,
        position: Span,
        id: ExpressionId,
    },
    Assignment {
        lhs: LHSOfAssignment,
        rhs: Box<Expression>,
        id: ExpressionId,
    },
    BinaryAssignmentOperation {
        lhs: VariableOrPropertyAccess,
        operator: BinaryAssignmentOperator,
        rhs: Box<Expression>,
        id: ExpressionId,
    },
    UnaryPrefixAssignmentOperation {
        operator: UnaryPrefixAssignmentOperator,
        operand: VariableOrPropertyAccess,
        position: Span,
        id: ExpressionId,
    },
    UnaryPostfixAssignmentOperation {
        operand: VariableOrPropertyAccess,
        operator: UnaryPostfixAssignmentOperator,
        position: Span,
        id: ExpressionId,
    },
    VariableReference(String, Span, ExpressionId),
    ThisReference(Span, ExpressionId),
    SuperExpression(SuperReference, Span, ExpressionId),
    NewTarget(Span, ExpressionId),
    DynamicImport {
        path: Box<Expression>,
        position: Span,
        expression_id: ExpressionId,
    },
    PropertyAccess {
        parent: Box<Expression>,
        property: PropertyReference,
        position: Span,
        expression_id: ExpressionId,
        is_optional: bool,
    },
    Index {
        indexee: Box<Expression>,
        indexer: Box<MultipleExpression>,
        position: Span,
        expression_id: ExpressionId,
    },
    FunctionCall {
        function: Box<Expression>,
        type_arguments: Option<Vec<TypeReference>>,
        arguments: Vec<SpreadExpression>,
        position: Span,
        expression_id: ExpressionId,
    },
    ConstructorCall {
        constructor: Box<Expression>,
        type_arguments: Option<Vec<TypeReference>>,
        arguments: Option<Vec<SpreadExpression>>,
        position: Span,
        expression_id: ExpressionId,
    },
    TernaryExpression {
        condition: Box<Expression>,
        truthy_result: Box<Expression>,
        falsy_result: Box<Expression>,
        id: ExpressionId,
    },
    ArrowFunction(ArrowFunction),
    ExpressionFunction(ExpressionFunction),
    ExtractedArrowFunction(ExtractedFunction<ArrowFunctionBase>),
    ExtractedExpressionFunction(ExtractedFunction<ExpressionFunctionBase>),
    ClassExpression(ClassDeclaration<ExpressionPosition>, ExpressionId),
    Null(Span, ExpressionId),
    PrefixComment(String, Box<Expression>, Span, ExpressionId),
    PostfixComment(Box<Expression>, String, Span, ExpressionId),
    Comment(String, Span),
    JSXRoot(JSXRoot),
    IsExpression(IsExpression),
    Cursor {
        cursor_id: CursorId<Expression>,
        position: Span,
        expression_id: ExpressionId,
    },
}