react_compiler_ast/
declarations.rs

1use serde::Deserialize;
2use serde::Serialize;
3
4use crate::common::BaseNode;
5use crate::expressions::Expression;
6use crate::expressions::Identifier;
7use crate::literals::StringLiteral;
8
9/// Union of Declaration types that can appear in export declarations
10#[derive(Debug, Clone, Serialize, Deserialize)]
11#[serde(tag = "type")]
12pub enum Declaration {
13    FunctionDeclaration(crate::statements::FunctionDeclaration),
14    ClassDeclaration(crate::statements::ClassDeclaration),
15    VariableDeclaration(crate::statements::VariableDeclaration),
16    TSTypeAliasDeclaration(TSTypeAliasDeclaration),
17    TSInterfaceDeclaration(TSInterfaceDeclaration),
18    TSEnumDeclaration(TSEnumDeclaration),
19    TSModuleDeclaration(TSModuleDeclaration),
20    TSDeclareFunction(TSDeclareFunction),
21    TypeAlias(TypeAlias),
22    OpaqueType(OpaqueType),
23    InterfaceDeclaration(InterfaceDeclaration),
24    EnumDeclaration(EnumDeclaration),
25}
26
27/// The declaration/expression that can appear in `export default <decl>`
28#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(tag = "type")]
30pub enum ExportDefaultDecl {
31    FunctionDeclaration(crate::statements::FunctionDeclaration),
32    ClassDeclaration(crate::statements::ClassDeclaration),
33    EnumDeclaration(EnumDeclaration),
34    #[serde(untagged)]
35    Expression(Box<Expression>),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
39pub struct ImportDeclaration {
40    #[serde(flatten)]
41    pub base: BaseNode,
42    pub specifiers: Vec<ImportSpecifier>,
43    pub source: StringLiteral,
44    #[serde(
45        default,
46        skip_serializing_if = "Option::is_none",
47        rename = "importKind"
48    )]
49    pub import_kind: Option<ImportKind>,
50    #[serde(default, skip_serializing_if = "Option::is_none")]
51    pub assertions: Option<Vec<ImportAttribute>>,
52    #[serde(default, skip_serializing_if = "Option::is_none")]
53    pub attributes: Option<Vec<ImportAttribute>>,
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(rename_all = "lowercase")]
58pub enum ImportKind {
59    Value,
60    Type,
61    Typeof,
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(tag = "type")]
66pub enum ImportSpecifier {
67    ImportSpecifier(ImportSpecifierData),
68    ImportDefaultSpecifier(ImportDefaultSpecifierData),
69    ImportNamespaceSpecifier(ImportNamespaceSpecifierData),
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
73pub struct ImportSpecifierData {
74    #[serde(flatten)]
75    pub base: BaseNode,
76    pub local: Identifier,
77    pub imported: ModuleExportName,
78    #[serde(default, rename = "importKind")]
79    pub import_kind: Option<ImportKind>,
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
83pub struct ImportDefaultSpecifierData {
84    #[serde(flatten)]
85    pub base: BaseNode,
86    pub local: Identifier,
87}
88
89#[derive(Debug, Clone, Serialize, Deserialize)]
90pub struct ImportNamespaceSpecifierData {
91    #[serde(flatten)]
92    pub base: BaseNode,
93    pub local: Identifier,
94}
95
96#[derive(Debug, Clone, Serialize, Deserialize)]
97pub struct ImportAttribute {
98    #[serde(flatten)]
99    pub base: BaseNode,
100    pub key: Identifier,
101    pub value: StringLiteral,
102}
103
104/// Identifier or StringLiteral used as module export names
105#[derive(Debug, Clone, Serialize, Deserialize)]
106#[serde(tag = "type")]
107pub enum ModuleExportName {
108    Identifier(Identifier),
109    StringLiteral(StringLiteral),
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize)]
113pub struct ExportNamedDeclaration {
114    #[serde(flatten)]
115    pub base: BaseNode,
116    pub declaration: Option<Box<Declaration>>,
117    pub specifiers: Vec<ExportSpecifier>,
118    pub source: Option<StringLiteral>,
119    #[serde(default, rename = "exportKind")]
120    pub export_kind: Option<ExportKind>,
121    #[serde(default, skip_serializing_if = "Option::is_none")]
122    pub assertions: Option<Vec<ImportAttribute>>,
123    #[serde(default, skip_serializing_if = "Option::is_none")]
124    pub attributes: Option<Vec<ImportAttribute>>,
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
128#[serde(rename_all = "lowercase")]
129pub enum ExportKind {
130    Value,
131    Type,
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize)]
135#[serde(tag = "type")]
136pub enum ExportSpecifier {
137    ExportSpecifier(ExportSpecifierData),
138    ExportDefaultSpecifier(ExportDefaultSpecifierData),
139    ExportNamespaceSpecifier(ExportNamespaceSpecifierData),
140}
141
142#[derive(Debug, Clone, Serialize, Deserialize)]
143pub struct ExportSpecifierData {
144    #[serde(flatten)]
145    pub base: BaseNode,
146    pub local: ModuleExportName,
147    pub exported: ModuleExportName,
148    #[serde(
149        default,
150        skip_serializing_if = "Option::is_none",
151        rename = "exportKind"
152    )]
153    pub export_kind: Option<ExportKind>,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
157pub struct ExportDefaultSpecifierData {
158    #[serde(flatten)]
159    pub base: BaseNode,
160    pub exported: Identifier,
161}
162
163#[derive(Debug, Clone, Serialize, Deserialize)]
164pub struct ExportNamespaceSpecifierData {
165    #[serde(flatten)]
166    pub base: BaseNode,
167    pub exported: ModuleExportName,
168}
169
170#[derive(Debug, Clone, Serialize, Deserialize)]
171pub struct ExportDefaultDeclaration {
172    #[serde(flatten)]
173    pub base: BaseNode,
174    pub declaration: Box<ExportDefaultDecl>,
175    #[serde(
176        default,
177        skip_serializing_if = "Option::is_none",
178        rename = "exportKind"
179    )]
180    pub export_kind: Option<ExportKind>,
181}
182
183#[derive(Debug, Clone, Serialize, Deserialize)]
184pub struct ExportAllDeclaration {
185    #[serde(flatten)]
186    pub base: BaseNode,
187    pub source: StringLiteral,
188    #[serde(
189        default,
190        skip_serializing_if = "Option::is_none",
191        rename = "exportKind"
192    )]
193    pub export_kind: Option<ExportKind>,
194    #[serde(default, skip_serializing_if = "Option::is_none")]
195    pub assertions: Option<Vec<ImportAttribute>>,
196    #[serde(default, skip_serializing_if = "Option::is_none")]
197    pub attributes: Option<Vec<ImportAttribute>>,
198}
199
200// TypeScript declarations (pass-through via serde_json::Value for bodies)
201#[derive(Debug, Clone, Serialize, Deserialize)]
202pub struct TSTypeAliasDeclaration {
203    #[serde(flatten)]
204    pub base: BaseNode,
205    pub id: Identifier,
206    #[serde(rename = "typeAnnotation")]
207    pub type_annotation: Box<serde_json::Value>,
208    #[serde(
209        default,
210        skip_serializing_if = "Option::is_none",
211        rename = "typeParameters"
212    )]
213    pub type_parameters: Option<Box<serde_json::Value>>,
214    #[serde(default, skip_serializing_if = "Option::is_none")]
215    pub declare: Option<bool>,
216}
217
218#[derive(Debug, Clone, Serialize, Deserialize)]
219pub struct TSInterfaceDeclaration {
220    #[serde(flatten)]
221    pub base: BaseNode,
222    pub id: Identifier,
223    pub body: Box<serde_json::Value>,
224    #[serde(
225        default,
226        skip_serializing_if = "Option::is_none",
227        rename = "typeParameters"
228    )]
229    pub type_parameters: Option<Box<serde_json::Value>>,
230    #[serde(default, skip_serializing_if = "Option::is_none")]
231    pub extends: Option<Vec<serde_json::Value>>,
232    #[serde(default, skip_serializing_if = "Option::is_none")]
233    pub declare: Option<bool>,
234}
235
236#[derive(Debug, Clone, Serialize, Deserialize)]
237pub struct TSEnumDeclaration {
238    #[serde(flatten)]
239    pub base: BaseNode,
240    pub id: Identifier,
241    pub members: Vec<serde_json::Value>,
242    #[serde(default, skip_serializing_if = "Option::is_none")]
243    pub declare: Option<bool>,
244    #[serde(default, skip_serializing_if = "Option::is_none", rename = "const")]
245    pub is_const: Option<bool>,
246}
247
248#[derive(Debug, Clone, Serialize, Deserialize)]
249pub struct TSModuleDeclaration {
250    #[serde(flatten)]
251    pub base: BaseNode,
252    pub id: Box<serde_json::Value>,
253    pub body: Box<serde_json::Value>,
254    #[serde(default, skip_serializing_if = "Option::is_none")]
255    pub declare: Option<bool>,
256    #[serde(default, skip_serializing_if = "Option::is_none")]
257    pub global: Option<bool>,
258}
259
260#[derive(Debug, Clone, Serialize, Deserialize)]
261pub struct TSDeclareFunction {
262    #[serde(flatten)]
263    pub base: BaseNode,
264    pub id: Option<Identifier>,
265    pub params: Vec<serde_json::Value>,
266    #[serde(default, skip_serializing_if = "Option::is_none", rename = "async")]
267    pub is_async: Option<bool>,
268    #[serde(default, skip_serializing_if = "Option::is_none")]
269    pub declare: Option<bool>,
270    #[serde(default, skip_serializing_if = "Option::is_none")]
271    pub generator: Option<bool>,
272    #[serde(
273        default,
274        skip_serializing_if = "Option::is_none",
275        rename = "returnType"
276    )]
277    pub return_type: Option<Box<serde_json::Value>>,
278    #[serde(
279        default,
280        skip_serializing_if = "Option::is_none",
281        rename = "typeParameters"
282    )]
283    pub type_parameters: Option<Box<serde_json::Value>>,
284}
285
286// Flow declarations (pass-through)
287#[derive(Debug, Clone, Serialize, Deserialize)]
288pub struct TypeAlias {
289    #[serde(flatten)]
290    pub base: BaseNode,
291    pub id: Identifier,
292    pub right: Box<serde_json::Value>,
293    #[serde(default, rename = "typeParameters")]
294    pub type_parameters: Option<Box<serde_json::Value>>,
295}
296
297#[derive(Debug, Clone, Serialize, Deserialize)]
298pub struct OpaqueType {
299    #[serde(flatten)]
300    pub base: BaseNode,
301    pub id: Identifier,
302    #[serde(rename = "supertype")]
303    pub supertype: Option<Box<serde_json::Value>>,
304    pub impltype: Box<serde_json::Value>,
305    #[serde(
306        default,
307        skip_serializing_if = "Option::is_none",
308        rename = "typeParameters"
309    )]
310    pub type_parameters: Option<Box<serde_json::Value>>,
311}
312
313#[derive(Debug, Clone, Serialize, Deserialize)]
314pub struct InterfaceDeclaration {
315    #[serde(flatten)]
316    pub base: BaseNode,
317    pub id: Identifier,
318    pub body: Box<serde_json::Value>,
319    #[serde(
320        default,
321        skip_serializing_if = "Option::is_none",
322        rename = "typeParameters"
323    )]
324    pub type_parameters: Option<Box<serde_json::Value>>,
325    #[serde(default, skip_serializing_if = "Option::is_none")]
326    pub extends: Option<Vec<serde_json::Value>>,
327    #[serde(default, skip_serializing_if = "Option::is_none")]
328    pub mixins: Option<Vec<serde_json::Value>>,
329    #[serde(default, skip_serializing_if = "Option::is_none")]
330    pub implements: Option<Vec<serde_json::Value>>,
331}
332
333#[derive(Debug, Clone, Serialize, Deserialize)]
334pub struct DeclareVariable {
335    #[serde(flatten)]
336    pub base: BaseNode,
337    pub id: Identifier,
338}
339
340#[derive(Debug, Clone, Serialize, Deserialize)]
341pub struct DeclareFunction {
342    #[serde(flatten)]
343    pub base: BaseNode,
344    pub id: Identifier,
345    #[serde(
346        default,
347        skip_serializing_if = "Option::is_none",
348        deserialize_with = "crate::common::nullable_value"
349    )]
350    pub predicate: Option<Box<serde_json::Value>>,
351}
352
353#[derive(Debug, Clone, Serialize, Deserialize)]
354pub struct DeclareClass {
355    #[serde(flatten)]
356    pub base: BaseNode,
357    pub id: Identifier,
358    pub body: Box<serde_json::Value>,
359    #[serde(
360        default,
361        skip_serializing_if = "Option::is_none",
362        rename = "typeParameters"
363    )]
364    pub type_parameters: Option<Box<serde_json::Value>>,
365    #[serde(default, skip_serializing_if = "Option::is_none")]
366    pub extends: Option<Vec<serde_json::Value>>,
367    #[serde(default, skip_serializing_if = "Option::is_none")]
368    pub mixins: Option<Vec<serde_json::Value>>,
369    #[serde(default, skip_serializing_if = "Option::is_none")]
370    pub implements: Option<Vec<serde_json::Value>>,
371}
372
373#[derive(Debug, Clone, Serialize, Deserialize)]
374pub struct DeclareModule {
375    #[serde(flatten)]
376    pub base: BaseNode,
377    pub id: Box<serde_json::Value>,
378    pub body: Box<serde_json::Value>,
379    #[serde(default, skip_serializing_if = "Option::is_none")]
380    pub kind: Option<String>,
381}
382
383#[derive(Debug, Clone, Serialize, Deserialize)]
384pub struct DeclareModuleExports {
385    #[serde(flatten)]
386    pub base: BaseNode,
387    #[serde(rename = "typeAnnotation")]
388    pub type_annotation: Box<serde_json::Value>,
389}
390
391#[derive(Debug, Clone, Serialize, Deserialize)]
392pub struct DeclareExportDeclaration {
393    #[serde(flatten)]
394    pub base: BaseNode,
395    #[serde(default, skip_serializing_if = "Option::is_none")]
396    pub declaration: Option<Box<serde_json::Value>>,
397    #[serde(default, skip_serializing_if = "Option::is_none")]
398    pub specifiers: Option<Vec<serde_json::Value>>,
399    #[serde(default, skip_serializing_if = "Option::is_none")]
400    pub source: Option<StringLiteral>,
401    #[serde(default, skip_serializing_if = "Option::is_none")]
402    pub default: Option<bool>,
403}
404
405#[derive(Debug, Clone, Serialize, Deserialize)]
406pub struct DeclareExportAllDeclaration {
407    #[serde(flatten)]
408    pub base: BaseNode,
409    pub source: StringLiteral,
410}
411
412#[derive(Debug, Clone, Serialize, Deserialize)]
413pub struct DeclareInterface {
414    #[serde(flatten)]
415    pub base: BaseNode,
416    pub id: Identifier,
417    pub body: Box<serde_json::Value>,
418    #[serde(
419        default,
420        skip_serializing_if = "Option::is_none",
421        rename = "typeParameters"
422    )]
423    pub type_parameters: Option<Box<serde_json::Value>>,
424    #[serde(default, skip_serializing_if = "Option::is_none")]
425    pub extends: Option<Vec<serde_json::Value>>,
426    #[serde(default, skip_serializing_if = "Option::is_none")]
427    pub mixins: Option<Vec<serde_json::Value>>,
428    #[serde(default, skip_serializing_if = "Option::is_none")]
429    pub implements: Option<Vec<serde_json::Value>>,
430}
431
432#[derive(Debug, Clone, Serialize, Deserialize)]
433pub struct DeclareTypeAlias {
434    #[serde(flatten)]
435    pub base: BaseNode,
436    pub id: Identifier,
437    pub right: Box<serde_json::Value>,
438    #[serde(
439        default,
440        skip_serializing_if = "Option::is_none",
441        rename = "typeParameters"
442    )]
443    pub type_parameters: Option<Box<serde_json::Value>>,
444}
445
446#[derive(Debug, Clone, Serialize, Deserialize)]
447pub struct DeclareOpaqueType {
448    #[serde(flatten)]
449    pub base: BaseNode,
450    pub id: Identifier,
451    #[serde(default, skip_serializing_if = "Option::is_none")]
452    pub supertype: Option<Box<serde_json::Value>>,
453    #[serde(default, skip_serializing_if = "Option::is_none")]
454    pub impltype: Option<Box<serde_json::Value>>,
455    #[serde(
456        default,
457        skip_serializing_if = "Option::is_none",
458        rename = "typeParameters"
459    )]
460    pub type_parameters: Option<Box<serde_json::Value>>,
461}
462
463#[derive(Debug, Clone, Serialize, Deserialize)]
464pub struct EnumDeclaration {
465    #[serde(flatten)]
466    pub base: BaseNode,
467    pub id: Identifier,
468    pub body: Box<serde_json::Value>,
469}
react_compiler_ast/declarations.rs

react_compiler_ast/
declarations.rs
