react_compiler_ast/
expressions.rs

1use serde::Deserialize;
2use serde::Serialize;
3
4use crate::common::BaseNode;
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, Deserialize)]
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<Box<serde_json::Value>>,
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<serde_json::Value>>,
28}
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
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, Deserialize)]
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<Box<serde_json::Value>>,
95    #[serde(
96        default,
97        skip_serializing_if = "Option::is_none",
98        rename = "typeArguments"
99    )]
100    pub type_arguments: Option<Box<serde_json::Value>>,
101    #[serde(default, skip_serializing_if = "Option::is_none")]
102    pub optional: Option<bool>,
103}
104
105#[derive(Debug, Clone, Serialize, Deserialize)]
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, Deserialize)]
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<Box<serde_json::Value>>,
127    #[serde(
128        default,
129        skip_serializing_if = "Option::is_none",
130        rename = "typeArguments"
131    )]
132    pub type_arguments: Option<Box<serde_json::Value>>,
133}
134
135#[derive(Debug, Clone, Serialize, Deserialize)]
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, Deserialize)]
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, Deserialize)]
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, Deserialize)]
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, Deserialize)]
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, Deserialize)]
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, Deserialize)]
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, Deserialize)]
200pub struct SequenceExpression {
201    #[serde(flatten)]
202    pub base: BaseNode,
203    pub expressions: Vec<Expression>,
204}
205
206#[derive(Debug, Clone, Serialize, Deserialize)]
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<Box<serde_json::Value>>,
226    #[serde(
227        default,
228        skip_serializing_if = "Option::is_none",
229        rename = "typeParameters"
230    )]
231    pub type_parameters: Option<Box<serde_json::Value>>,
232    #[serde(
233        default,
234        skip_serializing_if = "Option::is_none",
235        rename = "predicate",
236        deserialize_with = "crate::common::nullable_value"
237    )]
238    pub predicate: Option<Box<serde_json::Value>>,
239}
240
241#[derive(Debug, Clone, Serialize, Deserialize)]
242#[serde(tag = "type")]
243pub enum ArrowFunctionBody {
244    BlockStatement(BlockStatement),
245    #[serde(untagged)]
246    Expression(Box<Expression>),
247}
248
249#[derive(Debug, Clone, Serialize, Deserialize)]
250pub struct FunctionExpression {
251    #[serde(flatten)]
252    pub base: BaseNode,
253    pub params: Vec<PatternLike>,
254    pub body: BlockStatement,
255    #[serde(default)]
256    pub id: Option<Identifier>,
257    #[serde(default)]
258    pub generator: bool,
259    #[serde(default, rename = "async")]
260    pub is_async: bool,
261    #[serde(
262        default,
263        skip_serializing_if = "Option::is_none",
264        rename = "returnType"
265    )]
266    pub return_type: Option<Box<serde_json::Value>>,
267    #[serde(
268        default,
269        skip_serializing_if = "Option::is_none",
270        rename = "typeParameters"
271    )]
272    pub type_parameters: Option<Box<serde_json::Value>>,
273    #[serde(
274        default,
275        skip_serializing_if = "Option::is_none",
276        rename = "predicate",
277        deserialize_with = "crate::common::nullable_value"
278    )]
279    pub predicate: Option<Box<serde_json::Value>>,
280}
281
282#[derive(Debug, Clone, Serialize, Deserialize)]
283pub struct ObjectExpression {
284    #[serde(flatten)]
285    pub base: BaseNode,
286    pub properties: Vec<ObjectExpressionProperty>,
287}
288
289#[derive(Debug, Clone, Serialize, Deserialize)]
290#[serde(tag = "type")]
291pub enum ObjectExpressionProperty {
292    ObjectProperty(ObjectProperty),
293    ObjectMethod(ObjectMethod),
294    SpreadElement(SpreadElement),
295}
296
297#[derive(Debug, Clone, Serialize, Deserialize)]
298pub struct ObjectProperty {
299    #[serde(flatten)]
300    pub base: BaseNode,
301    pub key: Box<Expression>,
302    pub value: Box<Expression>,
303    pub computed: bool,
304    pub shorthand: bool,
305    #[serde(default, skip_serializing_if = "Option::is_none")]
306    pub decorators: Option<Vec<serde_json::Value>>,
307    #[serde(default, skip_serializing_if = "Option::is_none")]
308    pub method: Option<bool>,
309}
310
311#[derive(Debug, Clone, Serialize, Deserialize)]
312pub struct ObjectMethod {
313    #[serde(flatten)]
314    pub base: BaseNode,
315    pub method: bool,
316    pub kind: ObjectMethodKind,
317    pub key: Box<Expression>,
318    pub params: Vec<PatternLike>,
319    pub body: BlockStatement,
320    pub computed: bool,
321    #[serde(default)]
322    pub id: Option<Identifier>,
323    #[serde(default)]
324    pub generator: bool,
325    #[serde(default, rename = "async")]
326    pub is_async: bool,
327    #[serde(default, skip_serializing_if = "Option::is_none")]
328    pub decorators: Option<Vec<serde_json::Value>>,
329    #[serde(
330        default,
331        skip_serializing_if = "Option::is_none",
332        rename = "returnType"
333    )]
334    pub return_type: Option<Box<serde_json::Value>>,
335    #[serde(
336        default,
337        skip_serializing_if = "Option::is_none",
338        rename = "typeParameters"
339    )]
340    pub type_parameters: Option<Box<serde_json::Value>>,
341    #[serde(
342        default,
343        skip_serializing_if = "Option::is_none",
344        rename = "predicate",
345        deserialize_with = "crate::common::nullable_value"
346    )]
347    pub predicate: Option<Box<serde_json::Value>>,
348}
349
350#[derive(Debug, Clone, Serialize, Deserialize)]
351#[serde(rename_all = "lowercase")]
352pub enum ObjectMethodKind {
353    Method,
354    Get,
355    Set,
356}
357
358#[derive(Debug, Clone, Serialize, Deserialize)]
359pub struct ArrayExpression {
360    #[serde(flatten)]
361    pub base: BaseNode,
362    pub elements: Vec<Option<Expression>>,
363}
364
365#[derive(Debug, Clone, Serialize, Deserialize)]
366pub struct NewExpression {
367    #[serde(flatten)]
368    pub base: BaseNode,
369    pub callee: Box<Expression>,
370    pub arguments: Vec<Expression>,
371    #[serde(
372        default,
373        skip_serializing_if = "Option::is_none",
374        rename = "typeParameters"
375    )]
376    pub type_parameters: Option<Box<serde_json::Value>>,
377    #[serde(
378        default,
379        skip_serializing_if = "Option::is_none",
380        deserialize_with = "crate::common::nullable_value",
381        rename = "typeArguments"
382    )]
383    pub type_arguments: Option<Box<serde_json::Value>>,
384}
385
386#[derive(Debug, Clone, Serialize, Deserialize)]
387pub struct TemplateLiteral {
388    #[serde(flatten)]
389    pub base: BaseNode,
390    pub quasis: Vec<TemplateElement>,
391    pub expressions: Vec<Expression>,
392}
393
394#[derive(Debug, Clone, Serialize, Deserialize)]
395pub struct TaggedTemplateExpression {
396    #[serde(flatten)]
397    pub base: BaseNode,
398    pub tag: Box<Expression>,
399    pub quasi: TemplateLiteral,
400    #[serde(
401        default,
402        skip_serializing_if = "Option::is_none",
403        rename = "typeParameters"
404    )]
405    pub type_parameters: Option<Box<serde_json::Value>>,
406}
407
408#[derive(Debug, Clone, Serialize, Deserialize)]
409pub struct AwaitExpression {
410    #[serde(flatten)]
411    pub base: BaseNode,
412    pub argument: Box<Expression>,
413}
414
415#[derive(Debug, Clone, Serialize, Deserialize)]
416pub struct YieldExpression {
417    #[serde(flatten)]
418    pub base: BaseNode,
419    #[serde(default, skip_serializing_if = "Option::is_none")]
420    pub argument: Option<Box<Expression>>,
421    pub delegate: bool,
422}
423
424#[derive(Debug, Clone, Serialize, Deserialize)]
425pub struct SpreadElement {
426    #[serde(flatten)]
427    pub base: BaseNode,
428    pub argument: Box<Expression>,
429}
430
431#[derive(Debug, Clone, Serialize, Deserialize)]
432pub struct MetaProperty {
433    #[serde(flatten)]
434    pub base: BaseNode,
435    pub meta: Identifier,
436    pub property: Identifier,
437}
438
439#[derive(Debug, Clone, Serialize, Deserialize)]
440pub struct ClassExpression {
441    #[serde(flatten)]
442    pub base: BaseNode,
443    #[serde(default)]
444    pub id: Option<Identifier>,
445    #[serde(rename = "superClass")]
446    pub super_class: Option<Box<Expression>>,
447    pub body: ClassBody,
448    #[serde(default, skip_serializing_if = "Option::is_none")]
449    pub decorators: Option<Vec<serde_json::Value>>,
450    #[serde(
451        default,
452        skip_serializing_if = "Option::is_none",
453        rename = "implements"
454    )]
455    pub implements: Option<Vec<serde_json::Value>>,
456    #[serde(
457        default,
458        skip_serializing_if = "Option::is_none",
459        rename = "superTypeParameters"
460    )]
461    pub super_type_parameters: Option<Box<serde_json::Value>>,
462    #[serde(
463        default,
464        skip_serializing_if = "Option::is_none",
465        rename = "typeParameters"
466    )]
467    pub type_parameters: Option<Box<serde_json::Value>>,
468}
469
470#[derive(Debug, Clone, Serialize, Deserialize)]
471pub struct ClassBody {
472    #[serde(flatten)]
473    pub base: BaseNode,
474    pub body: Vec<serde_json::Value>,
475}
476
477#[derive(Debug, Clone, Serialize, Deserialize)]
478pub struct PrivateName {
479    #[serde(flatten)]
480    pub base: BaseNode,
481    pub id: Identifier,
482}
483
484#[derive(Debug, Clone, Serialize, Deserialize)]
485pub struct Super {
486    #[serde(flatten)]
487    pub base: BaseNode,
488}
489
490#[derive(Debug, Clone, Serialize, Deserialize)]
491pub struct Import {
492    #[serde(flatten)]
493    pub base: BaseNode,
494}
495
496#[derive(Debug, Clone, Serialize, Deserialize)]
497pub struct ThisExpression {
498    #[serde(flatten)]
499    pub base: BaseNode,
500}
501
502#[derive(Debug, Clone, Serialize, Deserialize)]
503pub struct ParenthesizedExpression {
504    #[serde(flatten)]
505    pub base: BaseNode,
506    pub expression: Box<Expression>,
507}
508
509// TypeScript expression nodes (pass-through with serde_json::Value for type args)
510#[derive(Debug, Clone, Serialize, Deserialize)]
511pub struct TSAsExpression {
512    #[serde(flatten)]
513    pub base: BaseNode,
514    pub expression: Box<Expression>,
515    #[serde(rename = "typeAnnotation")]
516    pub type_annotation: Box<serde_json::Value>,
517}
518
519#[derive(Debug, Clone, Serialize, Deserialize)]
520pub struct TSSatisfiesExpression {
521    #[serde(flatten)]
522    pub base: BaseNode,
523    pub expression: Box<Expression>,
524    #[serde(rename = "typeAnnotation")]
525    pub type_annotation: Box<serde_json::Value>,
526}
527
528#[derive(Debug, Clone, Serialize, Deserialize)]
529pub struct TSNonNullExpression {
530    #[serde(flatten)]
531    pub base: BaseNode,
532    pub expression: Box<Expression>,
533}
534
535#[derive(Debug, Clone, Serialize, Deserialize)]
536pub struct TSTypeAssertion {
537    #[serde(flatten)]
538    pub base: BaseNode,
539    pub expression: Box<Expression>,
540    #[serde(rename = "typeAnnotation")]
541    pub type_annotation: Box<serde_json::Value>,
542}
543
544#[derive(Debug, Clone, Serialize, Deserialize)]
545pub struct TSInstantiationExpression {
546    #[serde(flatten)]
547    pub base: BaseNode,
548    pub expression: Box<Expression>,
549    #[serde(rename = "typeParameters")]
550    pub type_parameters: Box<serde_json::Value>,
551}
552
553// Flow expression nodes
554#[derive(Debug, Clone, Serialize, Deserialize)]
555pub struct TypeCastExpression {
556    #[serde(flatten)]
557    pub base: BaseNode,
558    pub expression: Box<Expression>,
559    #[serde(rename = "typeAnnotation")]
560    pub type_annotation: Box<serde_json::Value>,
561}
react_compiler_ast/expressions.rs

react_compiler_ast/
expressions.rs
