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

use rnode::{VisitMut, VisitMutWith};
use stc_ts_ast_rnode::{
    RBlockStmt, RClassMember, RDecl, REmptyStmt, RExportDecl, RIdent, RModuleDecl, RModuleItem, RPropName, RStmt, RTsModuleDecl,
};
use swc_common::DUMMY_SP;

/// Handles
///
/// ```ts
/// foo();
/// bar();
/// bar() {}
/// ```
#[derive(Debug, Default)]
pub(crate) struct RealImplRemover {
    last_ambient_fn_name: Option<RIdent>,
}

impl VisitMut<RStmt> for RealImplRemover {
    fn visit_mut(&mut self, node: &mut RStmt) {
        node.visit_mut_children_with(self);

        if let RStmt::Decl(RDecl::Fn(ref decl)) = node {
            if decl.function.body.is_none() {
                self.last_ambient_fn_name = Some(decl.ident.clone());
            } else {
                let name = self.last_ambient_fn_name.take();
                if let Some(prev_name) = name {
                    if prev_name.sym == decl.ident.sym {
                        *node = RStmt::Empty(REmptyStmt { span: DUMMY_SP });
                    }
                }
            }
        }
    }
}
impl VisitMut<RModuleItem> for RealImplRemover {
    fn visit_mut(&mut self, node: &mut RModuleItem) {
        node.visit_mut_children_with(self);

        if let RModuleItem::ModuleDecl(RModuleDecl::ExportDecl(RExportDecl { decl: RDecl::Fn(decl), .. })) = &node {
            if decl.function.body.is_none() {
                self.last_ambient_fn_name = Some(decl.ident.clone());
            } else {
                let name = self.last_ambient_fn_name.take();
                if let Some(prev_name) = name {
                    if prev_name.sym == decl.ident.sym {
                        *node = RModuleItem::Stmt(RStmt::Empty(REmptyStmt { span: DUMMY_SP }));
                    }
                }
            }
        }
    }
}

impl VisitMut<Vec<RClassMember>> for RealImplRemover {
    fn visit_mut(&mut self, members: &mut Vec<RClassMember>) {
        let mut last_ambient = None;

        members.retain_mut(|member| match member {
            RClassMember::Method(m) => match m.key {
                RPropName::Ident(ref i) => {
                    if m.function.body.is_none() {
                        last_ambient = Some(i.sym.clone());
                        return true;
                    }

                    if let Some(prev_name) = last_ambient.take() {
                        if prev_name == i.sym {
                            return false;
                        }
                    }
                    true
                }
                _ => true,
            },
            _ => true,
        });
    }
}

/// Noop.
impl VisitMut<RBlockStmt> for RealImplRemover {
    fn visit_mut(&mut self, _: &mut RBlockStmt) {}
}

/// Noop.
impl VisitMut<RTsModuleDecl> for RealImplRemover {
    fn visit_mut(&mut self, _: &mut RTsModuleDecl) {}
}