react_compiler_ast/
expressions.rs

1use serde::Deserialize;
2use serde::Serialize;
3
4use 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;
13
14#[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}
30
31#[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 expressions
70    JSXElement(Box<JSXElement>),
71    JSXFragment(JSXFragment),
72    // Pattern (can appear in expression position in error recovery)
73    AssignmentPattern(AssignmentPattern),
74    // TypeScript expressions
75    TSAsExpression(TSAsExpression),
76    TSSatisfiesExpression(TSSatisfiesExpression),
77    TSNonNullExpression(TSNonNullExpression),
78    TSTypeAssertion(TSTypeAssertion),
79    TSInstantiationExpression(TSInstantiationExpression),
80    // Flow expressions
81    TypeCastExpression(TypeCastExpression),
82}
83
84#[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}
105
106#[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}
114
115#[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}
135
136#[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}
145
146#[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}
154
155#[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}
163
164#[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}
172
173#[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}
181
182#[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}
190
191#[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}
199
200#[derive(Debug, Clone, Serialize, Deserialize)]
201pub struct SequenceExpression {
202    #[serde(flatten)]
203    pub base: BaseNode,
204    pub expressions: Vec<Expression>,
205}
206
207#[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}
241
242#[derive(Debug, Clone, Serialize, Deserialize)]
243#[serde(tag = "type")]
244pub enum ArrowFunctionBody {
245    BlockStatement(BlockStatement),
246    #[serde(untagged)]
247    Expression(Box<Expression>),
248}
249
250#[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}
282
283#[derive(Debug, Clone, Serialize, Deserialize)]
284pub struct ObjectExpression {
285    #[serde(flatten)]
286    pub base: BaseNode,
287    pub properties: Vec<ObjectExpressionProperty>,
288}
289
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(tag = "type")]
292pub enum ObjectExpressionProperty {
293    ObjectProperty(ObjectProperty),
294    ObjectMethod(ObjectMethod),
295    SpreadElement(SpreadElement),
296}
297
298#[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}
311
312#[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}
350
351#[derive(Debug, Clone, Serialize, Deserialize)]
352#[serde(rename_all = "lowercase")]
353pub enum ObjectMethodKind {
354    Method,
355    Get,
356    Set,
357}
358
359#[derive(Debug, Clone, Serialize, Deserialize)]
360pub struct ArrayExpression {
361    #[serde(flatten)]
362    pub base: BaseNode,
363    pub elements: Vec<Option<Expression>>,
364}
365
366#[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}
386
387#[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}
394
395#[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}
408
409#[derive(Debug, Clone, Serialize, Deserialize)]
410pub struct AwaitExpression {
411    #[serde(flatten)]
412    pub base: BaseNode,
413    pub argument: Box<Expression>,
414}
415
416#[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}
424
425#[derive(Debug, Clone, Serialize, Deserialize)]
426pub struct SpreadElement {
427    #[serde(flatten)]
428    pub base: BaseNode,
429    pub argument: Box<Expression>,
430}
431
432#[derive(Debug, Clone, Serialize, Deserialize)]
433pub struct MetaProperty {
434    #[serde(flatten)]
435    pub base: BaseNode,
436    pub meta: Identifier,
437    pub property: Identifier,
438}
439
440#[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}
470
471#[derive(Debug, Clone, Serialize, Deserialize)]
472pub struct ClassBody {
473    #[serde(flatten)]
474    pub base: BaseNode,
475    pub body: Vec<RawNode>,
476}
477
478#[derive(Debug, Clone, Serialize, Deserialize)]
479pub struct PrivateName {
480    #[serde(flatten)]
481    pub base: BaseNode,
482    pub id: Identifier,
483}
484
485#[derive(Debug, Clone, Serialize, Deserialize)]
486pub struct Super {
487    #[serde(flatten)]
488    pub base: BaseNode,
489}
490
491#[derive(Debug, Clone, Serialize, Deserialize)]
492pub struct Import {
493    #[serde(flatten)]
494    pub base: BaseNode,
495}
496
497#[derive(Debug, Clone, Serialize, Deserialize)]
498pub struct ThisExpression {
499    #[serde(flatten)]
500    pub base: BaseNode,
501}
502
503#[derive(Debug, Clone, Serialize, Deserialize)]
504pub struct ParenthesizedExpression {
505    #[serde(flatten)]
506    pub base: BaseNode,
507    pub expression: Box<Expression>,
508}
509
510// 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}
519
520#[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}
528
529#[derive(Debug, Clone, Serialize, Deserialize)]
530pub struct TSNonNullExpression {
531    #[serde(flatten)]
532    pub base: BaseNode,
533    pub expression: Box<Expression>,
534}
535
536#[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}
544
545#[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}
553
554// Flow expression nodes
555#[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}
react_compiler_ast/expressions.rs

react_compiler_ast/
expressions.rs
