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(default, skip_serializing_if = "Option::is_none")]
346    pub predicate: Option<Box<serde_json::Value>>,
347}
348
349#[derive(Debug, Clone, Serialize, Deserialize)]
350pub struct DeclareClass {
351    #[serde(flatten)]
352    pub base: BaseNode,
353    pub id: Identifier,
354    pub body: Box<serde_json::Value>,
355    #[serde(
356        default,
357        skip_serializing_if = "Option::is_none",
358        rename = "typeParameters"
359    )]
360    pub type_parameters: Option<Box<serde_json::Value>>,
361    #[serde(default, skip_serializing_if = "Option::is_none")]
362    pub extends: Option<Vec<serde_json::Value>>,
363    #[serde(default, skip_serializing_if = "Option::is_none")]
364    pub mixins: Option<Vec<serde_json::Value>>,
365    #[serde(default, skip_serializing_if = "Option::is_none")]
366    pub implements: Option<Vec<serde_json::Value>>,
367}
368
369#[derive(Debug, Clone, Serialize, Deserialize)]
370pub struct DeclareModule {
371    #[serde(flatten)]
372    pub base: BaseNode,
373    pub id: Box<serde_json::Value>,
374    pub body: Box<serde_json::Value>,
375    #[serde(default, skip_serializing_if = "Option::is_none")]
376    pub kind: Option<String>,
377}
378
379#[derive(Debug, Clone, Serialize, Deserialize)]
380pub struct DeclareModuleExports {
381    #[serde(flatten)]
382    pub base: BaseNode,
383    #[serde(rename = "typeAnnotation")]
384    pub type_annotation: Box<serde_json::Value>,
385}
386
387#[derive(Debug, Clone, Serialize, Deserialize)]
388pub struct DeclareExportDeclaration {
389    #[serde(flatten)]
390    pub base: BaseNode,
391    #[serde(default, skip_serializing_if = "Option::is_none")]
392    pub declaration: Option<Box<serde_json::Value>>,
393    #[serde(default, skip_serializing_if = "Option::is_none")]
394    pub specifiers: Option<Vec<serde_json::Value>>,
395    #[serde(default, skip_serializing_if = "Option::is_none")]
396    pub source: Option<StringLiteral>,
397    #[serde(default, skip_serializing_if = "Option::is_none")]
398    pub default: Option<bool>,
399}
400
401#[derive(Debug, Clone, Serialize, Deserialize)]
402pub struct DeclareExportAllDeclaration {
403    #[serde(flatten)]
404    pub base: BaseNode,
405    pub source: StringLiteral,
406}
407
408#[derive(Debug, Clone, Serialize, Deserialize)]
409pub struct DeclareInterface {
410    #[serde(flatten)]
411    pub base: BaseNode,
412    pub id: Identifier,
413    pub body: Box<serde_json::Value>,
414    #[serde(
415        default,
416        skip_serializing_if = "Option::is_none",
417        rename = "typeParameters"
418    )]
419    pub type_parameters: Option<Box<serde_json::Value>>,
420    #[serde(default, skip_serializing_if = "Option::is_none")]
421    pub extends: Option<Vec<serde_json::Value>>,
422    #[serde(default, skip_serializing_if = "Option::is_none")]
423    pub mixins: Option<Vec<serde_json::Value>>,
424    #[serde(default, skip_serializing_if = "Option::is_none")]
425    pub implements: Option<Vec<serde_json::Value>>,
426}
427
428#[derive(Debug, Clone, Serialize, Deserialize)]
429pub struct DeclareTypeAlias {
430    #[serde(flatten)]
431    pub base: BaseNode,
432    pub id: Identifier,
433    pub right: Box<serde_json::Value>,
434    #[serde(
435        default,
436        skip_serializing_if = "Option::is_none",
437        rename = "typeParameters"
438    )]
439    pub type_parameters: Option<Box<serde_json::Value>>,
440}
441
442#[derive(Debug, Clone, Serialize, Deserialize)]
443pub struct DeclareOpaqueType {
444    #[serde(flatten)]
445    pub base: BaseNode,
446    pub id: Identifier,
447    #[serde(default, skip_serializing_if = "Option::is_none")]
448    pub supertype: Option<Box<serde_json::Value>>,
449    #[serde(default, skip_serializing_if = "Option::is_none")]
450    pub impltype: Option<Box<serde_json::Value>>,
451    #[serde(
452        default,
453        skip_serializing_if = "Option::is_none",
454        rename = "typeParameters"
455    )]
456    pub type_parameters: Option<Box<serde_json::Value>>,
457}
458
459#[derive(Debug, Clone, Serialize, Deserialize)]
460pub struct EnumDeclaration {
461    #[serde(flatten)]
462    pub base: BaseNode,
463    pub id: Identifier,
464    pub body: Box<serde_json::Value>,
465}
react_compiler_ast/declarations.rs

react_compiler_ast/
declarations.rs
