rolldown_ecmascript_utils 1.1.5

Helper utilities for ECMAScript processing
Documentation 
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use oxc::allocator::GetAllocator;
use oxc::{
  allocator::{IntoIn as _, TakeIn},
  ast::ast::{
    ArrayAssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty,
    AssignmentTargetPropertyIdentifier, AssignmentTargetPropertyProperty, AssignmentTargetRest,
    AssignmentTargetWithDefault, BindingPattern, BindingProperty, IdentifierReference,
    ObjectAssignmentTarget,
  },
};

use crate::{AstFactory, BindingPatternExt as _};

pub trait BindingPropertyExt<'ast> {
  fn into_assignment_target_property(
    self,
    ast_factory: &AstFactory<'ast>,
  ) -> AssignmentTargetProperty<'ast>;
}

impl<'ast> BindingPropertyExt<'ast> for BindingProperty<'ast> {
  fn into_assignment_target_property(
    self,
    ast_factory: &AstFactory<'ast>,
  ) -> AssignmentTargetProperty<'ast> {
    match self.value {
      BindingPattern::AssignmentPattern(assign_pat) => {
        let assign_pat = assign_pat.unbox();
        if self.shorthand {
          let binding_id = assign_pat.left.get_binding_identifier().unwrap();
          AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(
            AssignmentTargetPropertyIdentifier::boxed(
              self.span,
              IdentifierReference::new(binding_id.span, binding_id.name, ast_factory),
              Some(assign_pat.right),
              ast_factory,
            ),
          )
        } else {
          AssignmentTargetProperty::AssignmentTargetPropertyProperty(
            AssignmentTargetPropertyProperty::boxed(
              self.span,
              self.key,
              AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(
                AssignmentTargetWithDefault::boxed(
                  assign_pat.span,
                  assign_pat.left.into_assignment_target(ast_factory),
                  assign_pat.right,
                  ast_factory,
                ),
              ),
              self.computed,
              ast_factory,
            ),
          )
          .into_in(ast_factory.allocator())
        }
      }
      BindingPattern::BindingIdentifier(ref id) => {
        if self.shorthand {
          AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(
            AssignmentTargetPropertyIdentifier::boxed(
              self.span,
              IdentifierReference::new(id.span, id.name, ast_factory),
              None,
              ast_factory,
            ),
          )
        } else {
          AssignmentTargetProperty::AssignmentTargetPropertyProperty(
            AssignmentTargetPropertyProperty::boxed(
              self.span,
              self.key,
              AssignmentTargetMaybeDefault::from(self.value.into_assignment_target(ast_factory)),
              self.computed,
              ast_factory,
            ),
          )
          .into_in(ast_factory.allocator())
        }
      }
      BindingPattern::ArrayPattern(arr_pat) => {
        let mut arr_pat = arr_pat.unbox();
        let rest = arr_pat.rest.take().map(|rest| {
          AssignmentTargetRest::boxed(
            rest.span,
            rest.unbox().argument.into_assignment_target(ast_factory),
            ast_factory,
          )
        });
        let mut elements =
          oxc::allocator::Vec::with_capacity_in(arr_pat.elements.len(), ast_factory);
        arr_pat.elements.take_in(&ast_factory.allocator()).into_iter().for_each(|element| {
          elements.push(element.map(|binding_pat| {
            AssignmentTargetMaybeDefault::from(binding_pat.into_assignment_target(ast_factory))
          }));
        });
        AssignmentTargetProperty::AssignmentTargetPropertyProperty(
          AssignmentTargetPropertyProperty::boxed(
            self.span,
            self.key,
            AssignmentTargetMaybeDefault::ArrayAssignmentTarget(ArrayAssignmentTarget::boxed(
              arr_pat.span,
              elements,
              rest,
              ast_factory,
            )),
            self.computed,
            ast_factory,
          ),
        )
        .into_in(ast_factory.allocator())
      }
      BindingPattern::ObjectPattern(obj_pat) => {
        let mut obj_pat = obj_pat.unbox();
        let rest = obj_pat.rest.take().map(|rest| {
          AssignmentTargetRest::boxed(
            rest.span,
            rest.unbox().argument.into_assignment_target(ast_factory),
            ast_factory,
          )
        });
        let mut properties =
          oxc::allocator::Vec::with_capacity_in(obj_pat.properties.len(), ast_factory);
        obj_pat.properties.take_in(&ast_factory.allocator()).into_iter().for_each(|property| {
          properties.push(property.into_assignment_target_property(ast_factory));
        });
        AssignmentTargetProperty::AssignmentTargetPropertyProperty(
          AssignmentTargetPropertyProperty::boxed(
            self.span,
            self.key,
            AssignmentTargetMaybeDefault::ObjectAssignmentTarget(ObjectAssignmentTarget::boxed(
              obj_pat.span,
              properties,
              rest,
              ast_factory,
            )),
            self.computed,
            ast_factory,
          ),
        )
        .into_in(ast_factory.allocator())
      }
    }
  }
}