rolldown_ecmascript_utils 0.1.0

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
147
148
149
150
151
152
153
154
155
156
157

use oxc::{
  allocator::{Allocator, Box, Dummy as _, IntoIn as _, TakeIn},
  ast::ast::{
    ArrayAssignmentTarget, AssignmentTargetMaybeDefault, AssignmentTargetProperty,
    AssignmentTargetPropertyIdentifier, AssignmentTargetPropertyProperty, AssignmentTargetRest,
    AssignmentTargetWithDefault, BindingPatternKind, BindingProperty, IdentifierReference,
    ObjectAssignmentTarget,
  },
};

use crate::BindingPatternExt as _;

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

impl<'ast> BindingPropertyExt<'ast> for BindingProperty<'ast> {
  fn into_assignment_target_property(
    self,
    alloc: &'ast Allocator,
  ) -> AssignmentTargetProperty<'ast> {
    match self.value.kind {
      BindingPatternKind::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 {
              span: self.span,
              init: Some(assign_pat.right),
              binding: IdentifierReference {
                name: binding_id.name,
                span: binding_id.span,
                ..IdentifierReference::dummy(alloc)
              },
            }
            .into_in(alloc),
          )
        } else {
          AssignmentTargetProperty::AssignmentTargetPropertyProperty(
            AssignmentTargetPropertyProperty {
              name: self.key,
              span: self.span,
              binding: AssignmentTargetMaybeDefault::AssignmentTargetWithDefault(
                AssignmentTargetWithDefault {
                  span: assign_pat.span,
                  init: assign_pat.right,
                  binding: assign_pat.left.into_assignment_target(alloc),
                }
                .into_in(alloc),
              ),
              ..AssignmentTargetPropertyProperty::dummy(alloc)
            }
            .into_in(alloc),
          )
          .into_in(alloc)
        }
      }
      BindingPatternKind::BindingIdentifier(ref id) => {
        if self.shorthand {
          AssignmentTargetProperty::AssignmentTargetPropertyIdentifier(
            AssignmentTargetPropertyIdentifier {
              init: None,
              span: self.span,
              binding: IdentifierReference {
                name: id.name,
                span: id.span,
                ..IdentifierReference::dummy(alloc)
              },
            }
            .into_in(alloc),
          )
        } else {
          AssignmentTargetProperty::AssignmentTargetPropertyProperty(
            AssignmentTargetPropertyProperty {
              name: self.key,
              span: self.span,
              binding: AssignmentTargetMaybeDefault::from(self.value.into_assignment_target(alloc)),
              ..AssignmentTargetPropertyProperty::dummy(alloc)
            }
            .into_in(alloc),
          )
          .into_in(alloc)
        }
      }
      BindingPatternKind::ArrayPattern(arr_pat) => {
        let mut arr_pat = arr_pat.unbox();
        let mut elements = oxc::allocator::Vec::with_capacity_in(arr_pat.elements.len(), alloc);
        arr_pat.elements.take_in(alloc).into_iter().for_each(|element| {
          elements.push(element.map(|binding_pat| {
            AssignmentTargetMaybeDefault::from(binding_pat.into_assignment_target(alloc))
          }));
        });
        AssignmentTargetProperty::AssignmentTargetPropertyProperty(
          AssignmentTargetPropertyProperty {
            name: self.key,
            span: self.span,
            binding: AssignmentTargetMaybeDefault::ArrayAssignmentTarget(
              ArrayAssignmentTarget {
                elements,
                span: arr_pat.span,
                rest: arr_pat.rest.map(|rest| {
                  Box::new_in(
                    AssignmentTargetRest {
                      span: rest.span,
                      target: rest.unbox().argument.into_assignment_target(alloc),
                    },
                    alloc,
                  )
                }),
              }
              .into_in(alloc),
            ),
            ..AssignmentTargetPropertyProperty::dummy(alloc)
          }
          .into_in(alloc),
        )
        .into_in(alloc)
      }
      BindingPatternKind::ObjectPattern(obj_pat) => {
        let mut obj_pat = obj_pat.unbox();
        let mut properties = oxc::allocator::Vec::with_capacity_in(obj_pat.properties.len(), alloc);
        obj_pat.properties.take_in(alloc).into_iter().for_each(|property| {
          properties.push(property.into_assignment_target_property(alloc));
        });
        AssignmentTargetProperty::AssignmentTargetPropertyProperty(
          AssignmentTargetPropertyProperty {
            name: self.key,
            span: self.span,
            binding: AssignmentTargetMaybeDefault::ObjectAssignmentTarget(
              ObjectAssignmentTarget {
                properties,
                span: obj_pat.span,
                rest: obj_pat.rest.map(|rest| {
                  Box::new_in(
                    AssignmentTargetRest {
                      span: rest.span,
                      target: rest.unbox().argument.into_assignment_target(alloc),
                    },
                    alloc,
                  )
                }),
              }
              .into_in(alloc),
            ),
            ..AssignmentTargetPropertyProperty::dummy(alloc)
          }
          .into_in(alloc),
        )
        .into_in(alloc)
      }
    }
  }
}