1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use crate::{
    decl::{Decl, VarDecl},
    expr::{ClassExpr, Expr, FnExpr},
    ident::Ident,
    lit::Str,
    typescript::{TsExportAssignment, TsImportEqualsDecl, TsInterfaceDecl, TsNamespaceExportDecl},
};
use swc_common::{ast_node, Span};

#[ast_node]
pub enum ModuleDecl {
    Import(ImportDecl),
    ExportDecl(Decl),
    ExportNamed(NamedExport),

    ExportDefaultDecl(ExportDefaultDecl),

    ExportDefaultExpr(Box<Expr>),
    ExportAll(ExportAll),
    TsImportEqualsDecl(TsImportEqualsDecl),
    TsExportAssignment(TsExportAssignment),
    TsNamespaceExportDecl(TsNamespaceExportDecl),
}

#[ast_node]
pub struct ImportDecl {
    pub span: Span,
    pub specifiers: Vec<ImportSpecifier>,

    pub src: Str,
}

/// `export * from 'mod'`
#[ast_node]
pub struct ExportAll {
    pub span: Span,
    pub src: Str,
}

/// `export { foo } from 'mod'`
/// `export { foo as bar } from 'mod'`
#[ast_node]
pub struct NamedExport {
    pub span: Span,
    pub specifiers: Vec<ExportSpecifier>,

    pub src: Option<Str>,
}

#[ast_node]
pub enum ExportDefaultDecl {
    Class(ClassExpr),

    Fn(FnExpr),

    Var(VarDecl),

    TsInterfaceDecl(TsInterfaceDecl),
}

#[ast_node]
pub enum ImportSpecifier {
    Specific(ImportSpecific),
    Default(ImportDefault),
    Namespace(ImportStarAs),
}

/// e.g. `import foo from 'mod.js'`
#[ast_node]
pub struct ImportDefault {
    pub span: Span,
    pub local: Ident,
}
/// e.g. `import * as foo from 'mod.js'`.
#[ast_node]
pub struct ImportStarAs {
    pub span: Span,
    pub local: Ident,
}
/// e.g. local = foo, imported = None `import { foo } from 'mod.js'`
/// e.g. local = bar, imported = Some(foo) for `import { foo as bar } from
/// 'mod.js'`
#[ast_node]
pub struct ImportSpecific {
    pub span: Span,
    pub local: Ident,
    pub imported: Option<Ident>,
}

#[ast_node]
pub struct ExportSpecifier {
    pub span: Span,
    /// `foo` in `export { foo as bar }`
    pub orig: Ident,
    /// `Some(bar)` in `export { foo as bar }`
    pub exported: Option<Ident>,
}