1use serde::Deserialize;2use serde::Serialize;34use crate::common::BaseNode;5use crate::common::RawNode;6use crate::jsx::JSXElement;7use crate::jsx::JSXFragment;8use crate::literals::*;9use crate::operators::*;10use crate::patterns::AssignmentPattern;11use crate::patterns::PatternLike;12use crate::statements::BlockStatement;1314#[derive(Debug, Clone, Serialize, Deserialize)]15pub struct Identifier {16    #[serde(flatten)]17    pub base: BaseNode,18    pub name: String,19    #[serde(20        default,21        skip_serializing_if = "Option::is_none",22        rename = "typeAnnotation"23    )]24    pub type_annotation: Option<RawNode>,25    #[serde(default, skip_serializing_if = "Option::is_none")]26    pub optional: Option<bool>,27    #[serde(default, skip_serializing_if = "Option::is_none")]28    pub decorators: Option<Vec<RawNode>>,29}3031#[derive(Debug, Clone, Serialize, Deserialize)]32#[serde(tag = "type")]33pub enum Expression {34    Identifier(Identifier),35    StringLiteral(StringLiteral),36    NumericLiteral(NumericLiteral),37    BooleanLiteral(BooleanLiteral),38    NullLiteral(NullLiteral),39    BigIntLiteral(BigIntLiteral),40    RegExpLiteral(RegExpLiteral),41    CallExpression(CallExpression),42    MemberExpression(MemberExpression),43    OptionalCallExpression(OptionalCallExpression),44    OptionalMemberExpression(OptionalMemberExpression),45    BinaryExpression(BinaryExpression),46    LogicalExpression(LogicalExpression),47    UnaryExpression(UnaryExpression),48    UpdateExpression(UpdateExpression),49    ConditionalExpression(ConditionalExpression),50    AssignmentExpression(AssignmentExpression),51    SequenceExpression(SequenceExpression),52    ArrowFunctionExpression(ArrowFunctionExpression),53    FunctionExpression(FunctionExpression),54    ObjectExpression(ObjectExpression),55    ArrayExpression(ArrayExpression),56    NewExpression(NewExpression),57    TemplateLiteral(TemplateLiteral),58    TaggedTemplateExpression(TaggedTemplateExpression),59    AwaitExpression(AwaitExpression),60    YieldExpression(YieldExpression),61    SpreadElement(SpreadElement),62    MetaProperty(MetaProperty),63    ClassExpression(ClassExpression),64    PrivateName(PrivateName),65    Super(Super),66    Import(Import),67    ThisExpression(ThisExpression),68    ParenthesizedExpression(ParenthesizedExpression),69    // JSX expressions70    JSXElement(Box<JSXElement>),71    JSXFragment(JSXFragment),72    // Pattern (can appear in expression position in error recovery)73    AssignmentPattern(AssignmentPattern),74    // TypeScript expressions75    TSAsExpression(TSAsExpression),76    TSSatisfiesExpression(TSSatisfiesExpression),77    TSNonNullExpression(TSNonNullExpression),78    TSTypeAssertion(TSTypeAssertion),79    TSInstantiationExpression(TSInstantiationExpression),80    // Flow expressions81    TypeCastExpression(TypeCastExpression),82}8384#[derive(Debug, Clone, Serialize, Deserialize)]85pub struct CallExpression {86    #[serde(flatten)]87    pub base: BaseNode,88    pub callee: Box<Expression>,89    pub arguments: Vec<Expression>,90    #[serde(91        default,92        skip_serializing_if = "Option::is_none",93        rename = "typeParameters"94    )]95    pub type_parameters: Option<RawNode>,96    #[serde(97        default,98        skip_serializing_if = "Option::is_none",99        rename = "typeArguments"100    )]101    pub type_arguments: Option<RawNode>,102    #[serde(default, skip_serializing_if = "Option::is_none")]103    pub optional: Option<bool>,104}105106#[derive(Debug, Clone, Serialize, Deserialize)]107pub struct MemberExpression {108    #[serde(flatten)]109    pub base: BaseNode,110    pub object: Box<Expression>,111    pub property: Box<Expression>,112    pub computed: bool,113}114115#[derive(Debug, Clone, Serialize, Deserialize)]116pub struct OptionalCallExpression {117    #[serde(flatten)]118    pub base: BaseNode,119    pub callee: Box<Expression>,120    pub arguments: Vec<Expression>,121    pub optional: bool,122    #[serde(123        default,124        skip_serializing_if = "Option::is_none",125        rename = "typeParameters"126    )]127    pub type_parameters: Option<RawNode>,128    #[serde(129        default,130        skip_serializing_if = "Option::is_none",131        rename = "typeArguments"132    )]133    pub type_arguments: Option<RawNode>,134}135136#[derive(Debug, Clone, Serialize, Deserialize)]137pub struct OptionalMemberExpression {138    #[serde(flatten)]139    pub base: BaseNode,140    pub object: Box<Expression>,141    pub property: Box<Expression>,142    pub computed: bool,143    pub optional: bool,144}145146#[derive(Debug, Clone, Serialize, Deserialize)]147pub struct BinaryExpression {148    #[serde(flatten)]149    pub base: BaseNode,150    pub operator: BinaryOperator,151    pub left: Box<Expression>,152    pub right: Box<Expression>,153}154155#[derive(Debug, Clone, Serialize, Deserialize)]156pub struct LogicalExpression {157    #[serde(flatten)]158    pub base: BaseNode,159    pub operator: LogicalOperator,160    pub left: Box<Expression>,161    pub right: Box<Expression>,162}163164#[derive(Debug, Clone, Serialize, Deserialize)]165pub struct UnaryExpression {166    #[serde(flatten)]167    pub base: BaseNode,168    pub operator: UnaryOperator,169    pub prefix: bool,170    pub argument: Box<Expression>,171}172173#[derive(Debug, Clone, Serialize, Deserialize)]174pub struct UpdateExpression {175    #[serde(flatten)]176    pub base: BaseNode,177    pub operator: UpdateOperator,178    pub argument: Box<Expression>,179    pub prefix: bool,180}181182#[derive(Debug, Clone, Serialize, Deserialize)]183pub struct ConditionalExpression {184    #[serde(flatten)]185    pub base: BaseNode,186    pub test: Box<Expression>,187    pub consequent: Box<Expression>,188    pub alternate: Box<Expression>,189}190191#[derive(Debug, Clone, Serialize, Deserialize)]192pub struct AssignmentExpression {193    #[serde(flatten)]194    pub base: BaseNode,195    pub operator: AssignmentOperator,196    pub left: Box<PatternLike>,197    pub right: Box<Expression>,198}199200#[derive(Debug, Clone, Serialize, Deserialize)]201pub struct SequenceExpression {202    #[serde(flatten)]203    pub base: BaseNode,204    pub expressions: Vec<Expression>,205}206207#[derive(Debug, Clone, Serialize, Deserialize)]208pub struct ArrowFunctionExpression {209    #[serde(flatten)]210    pub base: BaseNode,211    pub params: Vec<PatternLike>,212    pub body: Box<ArrowFunctionBody>,213    #[serde(default)]214    pub id: Option<Identifier>,215    #[serde(default)]216    pub generator: bool,217    #[serde(default, rename = "async")]218    pub is_async: bool,219    #[serde(default, skip_serializing_if = "Option::is_none")]220    pub expression: Option<bool>,221    #[serde(222        default,223        skip_serializing_if = "Option::is_none",224        rename = "returnType"225    )]226    pub return_type: Option<RawNode>,227    #[serde(228        default,229        skip_serializing_if = "Option::is_none",230        rename = "typeParameters"231    )]232    pub type_parameters: Option<RawNode>,233    #[serde(234        default,235        skip_serializing_if = "Option::is_none",236        rename = "predicate",237        deserialize_with = "crate::common::nullable_value"238    )]239    pub predicate: Option<RawNode>,240}241242#[derive(Debug, Clone, Serialize, Deserialize)]243#[serde(tag = "type")]244pub enum ArrowFunctionBody {245    BlockStatement(BlockStatement),246    #[serde(untagged)]247    Expression(Box<Expression>),248}249250#[derive(Debug, Clone, Serialize, Deserialize)]251pub struct FunctionExpression {252    #[serde(flatten)]253    pub base: BaseNode,254    pub params: Vec<PatternLike>,255    pub body: BlockStatement,256    #[serde(default)]257    pub id: Option<Identifier>,258    #[serde(default)]259    pub generator: bool,260    #[serde(default, rename = "async")]261    pub is_async: bool,262    #[serde(263        default,264        skip_serializing_if = "Option::is_none",265        rename = "returnType"266    )]267    pub return_type: Option<RawNode>,268    #[serde(269        default,270        skip_serializing_if = "Option::is_none",271        rename = "typeParameters"272    )]273    pub type_parameters: Option<RawNode>,274    #[serde(275        default,276        skip_serializing_if = "Option::is_none",277        rename = "predicate",278        deserialize_with = "crate::common::nullable_value"279    )]280    pub predicate: Option<RawNode>,281}282283#[derive(Debug, Clone, Serialize, Deserialize)]284pub struct ObjectExpression {285    #[serde(flatten)]286    pub base: BaseNode,287    pub properties: Vec<ObjectExpressionProperty>,288}289290#[derive(Debug, Clone, Serialize, Deserialize)]291#[serde(tag = "type")]292pub enum ObjectExpressionProperty {293    ObjectProperty(ObjectProperty),294    ObjectMethod(ObjectMethod),295    SpreadElement(SpreadElement),296}297298#[derive(Debug, Clone, Serialize, Deserialize)]299pub struct ObjectProperty {300    #[serde(flatten)]301    pub base: BaseNode,302    pub key: Box<Expression>,303    pub value: Box<Expression>,304    pub computed: bool,305    pub shorthand: bool,306    #[serde(default, skip_serializing_if = "Option::is_none")]307    pub decorators: Option<Vec<RawNode>>,308    #[serde(default, skip_serializing_if = "Option::is_none")]309    pub method: Option<bool>,310}311312#[derive(Debug, Clone, Serialize, Deserialize)]313pub struct ObjectMethod {314    #[serde(flatten)]315    pub base: BaseNode,316    pub method: bool,317    pub kind: ObjectMethodKind,318    pub key: Box<Expression>,319    pub params: Vec<PatternLike>,320    pub body: BlockStatement,321    pub computed: bool,322    #[serde(default)]323    pub id: Option<Identifier>,324    #[serde(default)]325    pub generator: bool,326    #[serde(default, rename = "async")]327    pub is_async: bool,328    #[serde(default, skip_serializing_if = "Option::is_none")]329    pub decorators: Option<Vec<RawNode>>,330    #[serde(331        default,332        skip_serializing_if = "Option::is_none",333        rename = "returnType"334    )]335    pub return_type: Option<RawNode>,336    #[serde(337        default,338        skip_serializing_if = "Option::is_none",339        rename = "typeParameters"340    )]341    pub type_parameters: Option<RawNode>,342    #[serde(343        default,344        skip_serializing_if = "Option::is_none",345        rename = "predicate",346        deserialize_with = "crate::common::nullable_value"347    )]348    pub predicate: Option<RawNode>,349}350351#[derive(Debug, Clone, Serialize, Deserialize)]352#[serde(rename_all = "lowercase")]353pub enum ObjectMethodKind {354    Method,355    Get,356    Set,357}358359#[derive(Debug, Clone, Serialize, Deserialize)]360pub struct ArrayExpression {361    #[serde(flatten)]362    pub base: BaseNode,363    pub elements: Vec<Option<Expression>>,364}365366#[derive(Debug, Clone, Serialize, Deserialize)]367pub struct NewExpression {368    #[serde(flatten)]369    pub base: BaseNode,370    pub callee: Box<Expression>,371    pub arguments: Vec<Expression>,372    #[serde(373        default,374        skip_serializing_if = "Option::is_none",375        rename = "typeParameters"376    )]377    pub type_parameters: Option<RawNode>,378    #[serde(379        default,380        skip_serializing_if = "Option::is_none",381        deserialize_with = "crate::common::nullable_value",382        rename = "typeArguments"383    )]384    pub type_arguments: Option<RawNode>,385}386387#[derive(Debug, Clone, Serialize, Deserialize)]388pub struct TemplateLiteral {389    #[serde(flatten)]390    pub base: BaseNode,391    pub quasis: Vec<TemplateElement>,392    pub expressions: Vec<Expression>,393}394395#[derive(Debug, Clone, Serialize, Deserialize)]396pub struct TaggedTemplateExpression {397    #[serde(flatten)]398    pub base: BaseNode,399    pub tag: Box<Expression>,400    pub quasi: TemplateLiteral,401    #[serde(402        default,403        skip_serializing_if = "Option::is_none",404        rename = "typeParameters"405    )]406    pub type_parameters: Option<RawNode>,407}408409#[derive(Debug, Clone, Serialize, Deserialize)]410pub struct AwaitExpression {411    #[serde(flatten)]412    pub base: BaseNode,413    pub argument: Box<Expression>,414}415416#[derive(Debug, Clone, Serialize, Deserialize)]417pub struct YieldExpression {418    #[serde(flatten)]419    pub base: BaseNode,420    #[serde(default, skip_serializing_if = "Option::is_none")]421    pub argument: Option<Box<Expression>>,422    pub delegate: bool,423}424425#[derive(Debug, Clone, Serialize, Deserialize)]426pub struct SpreadElement {427    #[serde(flatten)]428    pub base: BaseNode,429    pub argument: Box<Expression>,430}431432#[derive(Debug, Clone, Serialize, Deserialize)]433pub struct MetaProperty {434    #[serde(flatten)]435    pub base: BaseNode,436    pub meta: Identifier,437    pub property: Identifier,438}439440#[derive(Debug, Clone, Serialize, Deserialize)]441pub struct ClassExpression {442    #[serde(flatten)]443    pub base: BaseNode,444    #[serde(default)]445    pub id: Option<Identifier>,446    #[serde(rename = "superClass")]447    pub super_class: Option<Box<Expression>>,448    pub body: ClassBody,449    #[serde(default, skip_serializing_if = "Option::is_none")]450    pub decorators: Option<Vec<RawNode>>,451    #[serde(452        default,453        skip_serializing_if = "Option::is_none",454        rename = "implements"455    )]456    pub implements: Option<Vec<RawNode>>,457    #[serde(458        default,459        skip_serializing_if = "Option::is_none",460        rename = "superTypeParameters"461    )]462    pub super_type_parameters: Option<RawNode>,463    #[serde(464        default,465        skip_serializing_if = "Option::is_none",466        rename = "typeParameters"467    )]468    pub type_parameters: Option<RawNode>,469}470471#[derive(Debug, Clone, Serialize, Deserialize)]472pub struct ClassBody {473    #[serde(flatten)]474    pub base: BaseNode,475    pub body: Vec<RawNode>,476}477478#[derive(Debug, Clone, Serialize, Deserialize)]479pub struct PrivateName {480    #[serde(flatten)]481    pub base: BaseNode,482    pub id: Identifier,483}484485#[derive(Debug, Clone, Serialize, Deserialize)]486pub struct Super {487    #[serde(flatten)]488    pub base: BaseNode,489}490491#[derive(Debug, Clone, Serialize, Deserialize)]492pub struct Import {493    #[serde(flatten)]494    pub base: BaseNode,495}496497#[derive(Debug, Clone, Serialize, Deserialize)]498pub struct ThisExpression {499    #[serde(flatten)]500    pub base: BaseNode,501}502503#[derive(Debug, Clone, Serialize, Deserialize)]504pub struct ParenthesizedExpression {505    #[serde(flatten)]506    pub base: BaseNode,507    pub expression: Box<Expression>,508}509510// TypeScript expression nodes (pass-through with RawNode for type args)511#[derive(Debug, Clone, Serialize, Deserialize)]512pub struct TSAsExpression {513    #[serde(flatten)]514    pub base: BaseNode,515    pub expression: Box<Expression>,516    #[serde(rename = "typeAnnotation")]517    pub type_annotation: RawNode,518}519520#[derive(Debug, Clone, Serialize, Deserialize)]521pub struct TSSatisfiesExpression {522    #[serde(flatten)]523    pub base: BaseNode,524    pub expression: Box<Expression>,525    #[serde(rename = "typeAnnotation")]526    pub type_annotation: RawNode,527}528529#[derive(Debug, Clone, Serialize, Deserialize)]530pub struct TSNonNullExpression {531    #[serde(flatten)]532    pub base: BaseNode,533    pub expression: Box<Expression>,534}535536#[derive(Debug, Clone, Serialize, Deserialize)]537pub struct TSTypeAssertion {538    #[serde(flatten)]539    pub base: BaseNode,540    pub expression: Box<Expression>,541    #[serde(rename = "typeAnnotation")]542    pub type_annotation: RawNode,543}544545#[derive(Debug, Clone, Serialize, Deserialize)]546pub struct TSInstantiationExpression {547    #[serde(flatten)]548    pub base: BaseNode,549    pub expression: Box<Expression>,550    #[serde(rename = "typeParameters")]551    pub type_parameters: RawNode,552}553554// Flow expression nodes555#[derive(Debug, Clone, Serialize, Deserialize)]556pub struct TypeCastExpression {557    #[serde(flatten)]558    pub base: BaseNode,559    pub expression: Box<Expression>,560    #[serde(rename = "typeAnnotation")]561    pub type_annotation: RawNode,562}