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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use fxhash::FxHashMap;
use rnode::NodeId;
use stc_ts_ast_rnode::{RClassMember, RExpr, RStmt};
use stc_ts_types::{Type, TypeParamDecl};

/// Stores ast mutation information.
///
/// This includes every information required to generate correct `.d.ts` files.
///
/// Note that validations are done by the [crate::analyzer::Analyzer], so
/// implementors of this trait should not lint on something lint `implicit any`.
#[derive(Default)]
pub struct Mutations {
    pub for_pats: FxHashMap<NodeId, PatMut>,
    pub for_var_decls: FxHashMap<NodeId, VarDeclMut>,
    pub for_fns: FxHashMap<NodeId, FunctionMut>,
    pub for_classes: FxHashMap<NodeId, ClassMut>,
    pub for_class_members: FxHashMap<NodeId, ClassMemberMut>,
    pub for_class_props: FxHashMap<NodeId, ClassPropMut>,
    pub for_export_defaults: FxHashMap<NodeId, ExportDefaultMut>,
    pub for_module_items: FxHashMap<NodeId, ModuleItemMut>,

    /// Used for validation, not dts generation.
    pub for_exprs: FxHashMap<NodeId, ExprMut>,
    /// Used for validation, not dts generation.
    pub for_callable: FxHashMap<NodeId, CallableMut>,
}

#[derive(Default)]
pub struct PatMut {
    /// None: No change
    pub optional: Option<bool>,
    pub ty: Option<Type>,
}

#[derive(Default)]
pub struct VarDeclMut {
    pub remove_init: bool,
}

#[derive(Default)]
pub struct FunctionMut {
    pub ret_ty: Option<Type>,
}

#[derive(Default)]
pub struct CallableMut {
    pub type_params: Option<TypeParamDecl>,
}

#[derive(Default)]
pub struct ExprMut {
    pub type_ann: Option<Type>,
}

#[derive(Default)]
pub struct ClassMut {
    pub super_class: Option<Box<RExpr>>,
    pub additional_members: Vec<RClassMember>,
}

#[derive(Default)]
pub struct ClassMemberMut {
    pub remove: bool,
}

#[derive(Default)]
pub struct ClassPropMut {
    pub ty: Option<Type>,
}

#[derive(Default)]
pub struct ExportDefaultMut {
    pub replace_with: Option<Box<RExpr>>,
}

#[derive(Default)]
pub struct ModuleItemMut {
    /// Used to handle
    ///
    /// ```ts
    /// declare function Mix<T, U>(c1: T, c2: U): T & U;
    /// class C1 extends Mix(Private, Private2) {
    /// }
    /// ```
    ///
    /// As code above becomes
    ///
    /// ```ts
    /// declare const C1_base: typeof Private & typeof Private2;
    /// declare class C1 extends C1_base {
    /// }
    /// ```
    ///
    /// we need to prepend statements.
    pub prepend_stmts: Vec<RStmt>,

    /// Used to handle
    ///
    /// ```ts
    /// export default function someFunc() {
    ///     return 'hello!';
    /// }
    ///
    /// someFunc.someProp = 'yo';
    /// ```
    ///
    /// As the code above becomes
    ///
    /// ```ts
    /// declare function someFunc(): string;
    /// declare namespace someFunc {
    ///     var someProp: string;
    /// }
    /// export default someFunc;
    /// ```
    ///
    /// we need to append statements.
    pub append_stmts: Vec<RStmt>,
}