react_compiler_ast/
expressions.rs

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

react_compiler_ast/
expressions.rs
