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

react_compiler_ast/
expressions.rs
