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

react_compiler_ast/
expressions.rs
