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

// use swc_common::Spanned;
use swc_ecma_ast::*;
use swc_ecma_visit::Fold;

/// This transform validates span on debug mode and does nothing on release
/// mode.
pub struct Validator {
    pub name: &'static str,
}

impl Fold for Validator {
    // fn fold_assign_expr(&mut self, node: AssignExpr) -> AssignExpr {
    //     if node.span.is_dummy() {
    //         return node.fold_children_with(self);
    //     }
    //
    //     if !node.left.span().is_dummy() {
    //         gte!(self, AssignExpr, node.left.span().lo(), node.span().lo());
    //     }
    //
    //     //        if !node.right.span().is_dummy() {
    //     //            eq!(self, AssignExpr, node.right.span().hi(),
    // node.span().hi());     //        }
    //
    //     node.fold_children_with(self)
    // }
    //
    // fn fold_bin_expr(&mut self, node: BinExpr) -> BinExpr {
    //     if node.span.is_dummy() {
    //         return node.fold_children_with(self);
    //     }
    //
    //     if !node.left.span().is_dummy() {
    //         gte!(self, BinExpr, node.left.span().lo(), node.span().lo());
    //     }
    //
    //     if !node.right.span().is_dummy() {
    //         gte!(self, BinExpr, node.span().hi(), node.right.span().hi());
    //     }
    //
    //     node.fold_children_with(self)
    // }
    //
    // fn fold_cond_expr(&mut self, node: CondExpr) -> CondExpr {
    //     if node.span.is_dummy() {
    //         return node.fold_children_with(self);
    //     }
    //
    //     if !node.test.span().is_dummy() {
    //         gte!(self, CondExpr, node.test.span().lo(), node.span().lo());
    //     }
    //
    //     if !node.alt.span().is_dummy() {
    //         lte!(self, CondExpr, node.alt.span().hi(), node.span().hi());
    //     }
    //
    //     node.fold_children_with(self)
    // }
    //
    // fn fold_member_expr(&mut self, node: MemberExpr) -> MemberExpr {
    //     if node.span.is_dummy() {
    //         return node.fold_children_with(self);
    //     }
    //
    //     if !node.obj.span().is_dummy() {
    //         ne!(self, MemberExpr, node.span(), node.obj.span());
    //     }
    //
    //     if !node.prop.span().is_dummy() {
    //         ne!(self, MemberExpr, node.span(), node.prop.span());
    //     }
    //
    //     if !node.obj.span().is_dummy() {
    //         lte!(self, MemberExpr, node.span().lo(), node.obj.span().lo());
    //     }
    //
    //     if !node.computed && !node.prop.span().is_dummy() {
    //         gte!(self, MemberExpr, node.span().hi(), node.prop.span().hi());
    //     }
    //
    //     node.fold_children_with(self)
    // }
    //
    // fn fold_unary_expr(&mut self, node: UnaryExpr) -> UnaryExpr {
    //     if node.span.is_dummy() {
    //         return node.fold_children_with(self);
    //     }
    //
    //     if !node.arg.span().is_dummy() {
    //         lte!(self, UnaryExpr, node.arg.span().hi(), node.span().hi())
    //     }
    //
    //     node.fold_children_with(self)
    // }
    //
    // fn fold_update_expr(&mut self, node: UpdateExpr) -> UpdateExpr {
    //     if node.span.is_dummy() {
    //         return node.fold_children_with(self);
    //     }
    //
    //     if node.prefix {
    //         if !node.arg.span().is_dummy() {
    //             lte!(self, UpdateExpr, node.arg.span().hi(), node.span().hi())
    //         }
    //     } else if !node.arg.span().is_dummy() {
    //         gte!(self, UpdateExpr, node.arg.span().lo(), node.span().lo())
    //     }
    //
    //     node.fold_children_with(self)
    // }

    #[inline(always)] // prevent stack overflow on debug build
    fn fold_module(&mut self, module: Module) -> Module {
        module
    }
}