react_compiler_ast/
expressions.rs

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

react_compiler_ast/
expressions.rs
