Enum ExpressionKind 

pub enum ExpressionKind {
    Identifier(String),
    NumericLiteral(f64),
    StringLiteral(String),
    BigIntLiteral(String),
    BooleanLiteral(bool),
    NullLiteral,
    RegexLiteral(String),
    TemplateString(String),
    UnaryExpression {
        operator: String,
        argument: Box<Expression>,
    },
    UpdateExpression {
        operator: String,
        argument: Box<Expression>,
        prefix: bool,
    },
    BinaryExpression {
        left: Box<Expression>,
        operator: String,
        right: Box<Expression>,
    },
    ConditionalExpression {
        test: Box<Expression>,
        consequent: Box<Expression>,
        alternate: Box<Expression>,
    },
    MemberExpression {
        object: Box<Expression>,
        property: Box<Expression>,
        computed: bool,
        optional: bool,
    },
    CallExpression {
        func: Box<Expression>,
        args: Vec<Expression>,
    },
    NewExpression {
        func: Box<Expression>,
        args: Vec<Expression>,
    },
    AssignmentExpression {
        left: Box<Expression>,
        operator: String,
        right: Box<Expression>,
    },
    AsExpression {
        expression: Box<Expression>,
        type_annotation: TypeAnnotation,
    },
    ArrowFunction {
        type_params: Vec<TypeParameter>,
        params: Vec<FunctionParam>,
        return_type: Option<TypeAnnotation>,
        body: Box<Statement>,
        async_: bool,
    },
    ObjectLiteral {
        properties: Vec<ObjectProperty>,
    },
    ArrayLiteral {
        elements: Vec<Expression>,
    },
    SpreadElement(Box<Expression>),
    AwaitExpression(Box<Expression>),
    YieldExpression(Option<Box<Expression>>),
    ImportExpression {
        module_specifier: Box<Expression>,
    },
    FunctionExpression {
        name: Option<String>,
        type_params: Vec<TypeParameter>,
        params: Vec<FunctionParam>,
        return_type: Option<TypeAnnotation>,
        body: Vec<Statement>,
        async_: bool,
        generator: bool,
    },
    TaggedTemplateExpression {
        tag: Box<Expression>,
        template: Box<Expression>,
    },
    TypeAssertionExpression {
        expression: Box<Expression>,
        type_annotation: TypeAnnotation,
    },
    NonNullExpression(Box<Expression>),
    JsxElement(Box<JsxElement>),
    JsxFragment(Box<JsxFragment>),
    JsxSelfClosingElement(Box<JsxSelfClosingElement>),
}

Represents the different kinds of expressions in TypeScript.

Variants

Identifier(String)

An identifier.

NumericLiteral(f64)

A numeric literal.

StringLiteral(String)

A string literal.

BigIntLiteral(String)

A BigInt literal.

BooleanLiteral(bool)

A boolean literal.

NullLiteral

A null literal.

RegexLiteral(String)

A regular expression literal.

TemplateString(String)

A template string literal.

UnaryExpression

A unary expression.

Fields

operator: String

Unary operator.

argument: Box<Expression>

Argument expression.

UpdateExpression

An update expression.

Fields

operator: String

Update operator.

argument: Box<Expression>

Argument expression.

prefix: bool

Whether the operator is a prefix.

BinaryExpression

A binary expression.

Fields

left: Box<Expression>

Left-hand side expression.

operator: String

Binary operator.

right: Box<Expression>

Right-hand side expression.

ConditionalExpression

A conditional (ternary) expression.

Fields

test: Box<Expression>

Condition expression.

consequent: Box<Expression>

Expression to evaluate if the condition is true.

alternate: Box<Expression>

Expression to evaluate if the condition is false.

MemberExpression

A member expression.

Fields

object: Box<Expression>

Object expression.

property: Box<Expression>

Property expression.

computed: bool

Whether the property is computed (using []).

optional: bool

Whether the access is optional (using ?.).

CallExpression

A call expression.

Fields

func: Box<Expression>

Function to call.

args: Vec<Expression>

Arguments to the function call.

NewExpression

A new expression.

Fields

func: Box<Expression>

Constructor function to call.

args: Vec<Expression>

Arguments to the constructor call.

AssignmentExpression

An assignment expression.

Fields

left: Box<Expression>

Left-hand side expression.

operator: String

Assignment operator.

right: Box<Expression>

Right-hand side expression.

AsExpression

An ‘as’ expression (type assertion).

Fields

expression: Box<Expression>

Expression being asserted.

type_annotation: TypeAnnotation

Type annotation being asserted to.

ArrowFunction

An arrow function expression.

Fields

type_params: Vec<TypeParameter>

Type parameters of the arrow function.

params: Vec<FunctionParam>

Parameters of the arrow function.

return_type: Option<TypeAnnotation>

Return type of the arrow function.

body: Box<Statement>

Body of the arrow function.

async_: bool

Whether the arrow function is async.

ObjectLiteral

An object literal.

Fields

properties: Vec<ObjectProperty>

Properties within the object literal.

ArrayLiteral

An array literal.

Fields

elements: Vec<Expression>

Elements within the array literal.

SpreadElement(Box<Expression>)

A spread element.

AwaitExpression(Box<Expression>)

An await expression.

YieldExpression(Option<Box<Expression>>)

A yield expression.

ImportExpression

An import expression.

Fields

module_specifier: Box<Expression>

Module specifier being imported.

FunctionExpression

A function expression.

Fields

name: Option<String>

Optional name of the function.

type_params: Vec<TypeParameter>

Type parameters of the function.

params: Vec<FunctionParam>

Parameters of the function.

return_type: Option<TypeAnnotation>

Return type of the function.

body: Vec<Statement>

Body of the function.

async_: bool

Whether the function is async.

generator: bool

Whether the function is a generator.

TaggedTemplateExpression

A tagged template expression.

Fields

tag: Box<Expression>

Tag function expression.

template: Box<Expression>

Template literal expression.

TypeAssertionExpression

A type assertion expression (e.g., <Type>expression).

Fields

expression: Box<Expression>

Expression being asserted.

type_annotation: TypeAnnotation

Type annotation being asserted to.

NonNullExpression(Box<Expression>)

A non-null expression (e.g., expression!).

JsxElement(Box<JsxElement>)

A JSX element.

JsxFragment(Box<JsxFragment>)

A JSX fragment.

JsxSelfClosingElement(Box<JsxSelfClosingElement>)

A self-closing JSX element.

Trait Implementations

impl Clone for ExpressionKind

fn clone(&self) -> ExpressionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExpressionKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ExpressionKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.