feat(ast)!: Box rest fields of ArrayAssignmentTarget and ObjectAssignmentTarget

crates/oxc_ast/src/ast/js.rs

@@ -861,7 +861,7 @@ pub struct ArrayAssignmentTarget<'a> {
     pub span: Span,
     pub elements: Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>,
     #[estree(append_to = elements)]
-    pub rest: Option<AssignmentTargetRest<'a>>,
+    pub rest: Option<Box<'a, AssignmentTargetRest<'a>>>,
 }
 
 /// `{ foo }` in `({ foo } = obj);`
@@ -879,7 +879,7 @@ pub struct ObjectAssignmentTarget<'a> {
     pub span: Span,
     pub properties: Vec<'a, AssignmentTargetProperty<'a>>,
     #[estree(append_to = properties)]
-    pub rest: Option<AssignmentTargetRest<'a>>,
+    pub rest: Option<Box<'a, AssignmentTargetRest<'a>>>,
 }
 
 /// `rest` in `[foo, ...rest] = arr;` or `({foo, ...rest} = obj);`.

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -250,14 +250,14 @@ const _: () = {
     assert!(align_of::<AssignmentTargetPattern>() == 8);
 
     // Padding: 0 bytes
-    assert!(size_of::<ArrayAssignmentTarget>() == 56);
+    assert!(size_of::<ArrayAssignmentTarget>() == 40);
     assert!(align_of::<ArrayAssignmentTarget>() == 8);
     assert!(offset_of!(ArrayAssignmentTarget, span) == 0);
     assert!(offset_of!(ArrayAssignmentTarget, elements) == 8);
     assert!(offset_of!(ArrayAssignmentTarget, rest) == 32);
 
     // Padding: 0 bytes
-    assert!(size_of::<ObjectAssignmentTarget>() == 56);
+    assert!(size_of::<ObjectAssignmentTarget>() == 40);
     assert!(align_of::<ObjectAssignmentTarget>() == 8);
     assert!(offset_of!(ObjectAssignmentTarget, span) == 0);
     assert!(offset_of!(ObjectAssignmentTarget, properties) == 8);
@@ -1842,14 +1842,14 @@ const _: () = {
     assert!(align_of::<AssignmentTargetPattern>() == 4);
 
     // Padding: 0 bytes
-    assert!(size_of::<ArrayAssignmentTarget>() == 40);
+    assert!(size_of::<ArrayAssignmentTarget>() == 28);
     assert!(align_of::<ArrayAssignmentTarget>() == 4);
     assert!(offset_of!(ArrayAssignmentTarget, span) == 0);
     assert!(offset_of!(ArrayAssignmentTarget, elements) == 8);
     assert!(offset_of!(ArrayAssignmentTarget, rest) == 24);
 
     // Padding: 0 bytes
-    assert!(size_of::<ObjectAssignmentTarget>() == 40);
+    assert!(size_of::<ObjectAssignmentTarget>() == 28);
     assert!(align_of::<ObjectAssignmentTarget>() == 4);
     assert!(offset_of!(ObjectAssignmentTarget, span) == 0);
     assert!(offset_of!(ObjectAssignmentTarget, properties) == 8);

crates/oxc_ast/src/generated/ast_builder.rs

@@ -2751,12 +2751,15 @@ impl<'a> AstBuilder<'a> {
     /// * `elements`
     /// * `rest`
     #[inline]
-    pub fn assignment_target_pattern_array_assignment_target(
+    pub fn assignment_target_pattern_array_assignment_target<T1>(
         self,
         span: Span,
         elements: Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>,
-        rest: Option<AssignmentTargetRest<'a>>,
-    ) -> AssignmentTargetPattern<'a> {
+        rest: T1,
+    ) -> AssignmentTargetPattern<'a>
+    where
+        T1: IntoIn<'a, Option<Box<'a, AssignmentTargetRest<'a>>>>,
+    {
         AssignmentTargetPattern::ArrayAssignmentTarget(
             self.alloc_array_assignment_target(span, elements, rest),
         )
@@ -2771,12 +2774,15 @@ impl<'a> AstBuilder<'a> {
     /// * `properties`
     /// * `rest`
     #[inline]
-    pub fn assignment_target_pattern_object_assignment_target(
+    pub fn assignment_target_pattern_object_assignment_target<T1>(
         self,
         span: Span,
         properties: Vec<'a, AssignmentTargetProperty<'a>>,
-        rest: Option<AssignmentTargetRest<'a>>,
-    ) -> AssignmentTargetPattern<'a> {
+        rest: T1,
+    ) -> AssignmentTargetPattern<'a>
+    where
+        T1: IntoIn<'a, Option<Box<'a, AssignmentTargetRest<'a>>>>,
+    {
         AssignmentTargetPattern::ObjectAssignmentTarget(
             self.alloc_object_assignment_target(span, properties, rest),
         )
@@ -2792,13 +2798,16 @@ impl<'a> AstBuilder<'a> {
     /// * `elements`
     /// * `rest`
     #[inline]
-    pub fn array_assignment_target(
+    pub fn array_assignment_target<T1>(
         self,
         span: Span,
         elements: Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>,
-        rest: Option<AssignmentTargetRest<'a>>,
-    ) -> ArrayAssignmentTarget<'a> {
-        ArrayAssignmentTarget { span, elements, rest }
+        rest: T1,
+    ) -> ArrayAssignmentTarget<'a>
+    where
+        T1: IntoIn<'a, Option<Box<'a, AssignmentTargetRest<'a>>>>,
+    {
+        ArrayAssignmentTarget { span, elements, rest: rest.into_in(self.allocator) }
     }
 
     /// Build an [`ArrayAssignmentTarget`], and store it in the memory arena.
@@ -2811,12 +2820,15 @@ impl<'a> AstBuilder<'a> {
     /// * `elements`
     /// * `rest`
     #[inline]
-    pub fn alloc_array_assignment_target(
+    pub fn alloc_array_assignment_target<T1>(
         self,
         span: Span,
         elements: Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>,
-        rest: Option<AssignmentTargetRest<'a>>,
-    ) -> Box<'a, ArrayAssignmentTarget<'a>> {
+        rest: T1,
+    ) -> Box<'a, ArrayAssignmentTarget<'a>>
+    where
+        T1: IntoIn<'a, Option<Box<'a, AssignmentTargetRest<'a>>>>,
+    {
         Box::new_in(self.array_assignment_target(span, elements, rest), self.allocator)
     }
 
@@ -2830,13 +2842,16 @@ impl<'a> AstBuilder<'a> {
     /// * `properties`
     /// * `rest`
     #[inline]
-    pub fn object_assignment_target(
+    pub fn object_assignment_target<T1>(
         self,
         span: Span,
         properties: Vec<'a, AssignmentTargetProperty<'a>>,
-        rest: Option<AssignmentTargetRest<'a>>,
-    ) -> ObjectAssignmentTarget<'a> {
-        ObjectAssignmentTarget { span, properties, rest }
+        rest: T1,
+    ) -> ObjectAssignmentTarget<'a>
+    where
+        T1: IntoIn<'a, Option<Box<'a, AssignmentTargetRest<'a>>>>,
+    {
+        ObjectAssignmentTarget { span, properties, rest: rest.into_in(self.allocator) }
     }
 
     /// Build an [`ObjectAssignmentTarget`], and store it in the memory arena.
@@ -2849,17 +2864,23 @@ impl<'a> AstBuilder<'a> {
     /// * `properties`
     /// * `rest`
     #[inline]
-    pub fn alloc_object_assignment_target(
+    pub fn alloc_object_assignment_target<T1>(
         self,
         span: Span,
         properties: Vec<'a, AssignmentTargetProperty<'a>>,
-        rest: Option<AssignmentTargetRest<'a>>,
-    ) -> Box<'a, ObjectAssignmentTarget<'a>> {
+        rest: T1,
+    ) -> Box<'a, ObjectAssignmentTarget<'a>>
+    where
+        T1: IntoIn<'a, Option<Box<'a, AssignmentTargetRest<'a>>>>,
+    {
         Box::new_in(self.object_assignment_target(span, properties, rest), self.allocator)
     }
 
     /// Build an [`AssignmentTargetRest`].
     ///
+    /// If you want the built node to be allocated in the memory arena,
+    /// use [`AstBuilder::alloc_assignment_target_rest`] instead.
+    ///
     /// ## Parameters
     /// * `span`: The [`Span`] covering this node
     /// * `target`
@@ -2872,6 +2893,23 @@ impl<'a> AstBuilder<'a> {
         AssignmentTargetRest { span, target }
     }
 
+    /// Build an [`AssignmentTargetRest`], and store it in the memory arena.
+    ///
+    /// Returns a [`Box`] containing the newly-allocated node.
+    /// If you want a stack-allocated node, use [`AstBuilder::assignment_target_rest`] instead.
+    ///
+    /// ## Parameters
+    /// * `span`: The [`Span`] covering this node
+    /// * `target`
+    #[inline]
+    pub fn alloc_assignment_target_rest(
+        self,
+        span: Span,
+        target: AssignmentTarget<'a>,
+    ) -> Box<'a, AssignmentTargetRest<'a>> {
+        Box::new_in(self.assignment_target_rest(span, target), self.allocator)
+    }
+
     /// Build an [`AssignmentTargetMaybeDefault::AssignmentTargetWithDefault`].
     ///
     /// This node contains an [`AssignmentTargetWithDefault`] that will be stored in the memory arena.

crates/oxc_ast/src/generated/derive_dummy.rs

@@ -451,7 +451,7 @@ impl<'a> Dummy<'a> for SimpleAssignmentTarget<'a> {
 impl<'a> Dummy<'a> for AssignmentTargetPattern<'a> {
     /// Create a dummy [`AssignmentTargetPattern`].
     ///
-    /// Has cost of making 1 allocation (56 bytes).
+    /// Has cost of making 1 allocation (40 bytes).
     fn dummy(allocator: &'a Allocator) -> Self {
         Self::ArrayAssignmentTarget(Dummy::dummy(allocator))
     }

crates/oxc_formatter/src/generated/ast_nodes.rs

@@ -5030,7 +5030,7 @@ impl<'a> AstNode<'a, ArrayAssignmentTarget<'a>> {
     #[inline]
     pub fn elements(&self) -> &AstNode<'a, Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>> {
         let following_node =
-            self.inner.rest.as_ref().map(SiblingNode::from).or(self.following_node);
+            self.inner.rest.as_deref().map(SiblingNode::from).or(self.following_node);
         self.allocator.alloc(AstNode {
             inner: &self.inner.elements,
             allocator: self.allocator,
@@ -5044,7 +5044,7 @@ impl<'a> AstNode<'a, ArrayAssignmentTarget<'a>> {
         let following_node = self.following_node;
         self.allocator
             .alloc(self.inner.rest.as_ref().map(|inner| AstNode {
-                inner,
+                inner: inner.as_ref(),
                 allocator: self.allocator,
                 parent: self.allocator.alloc(AstNodes::ArrayAssignmentTarget(transmute_self(self))),
                 following_node,
@@ -5077,7 +5077,7 @@ impl<'a> AstNode<'a, ObjectAssignmentTarget<'a>> {
     #[inline]
     pub fn properties(&self) -> &AstNode<'a, Vec<'a, AssignmentTargetProperty<'a>>> {
         let following_node =
-            self.inner.rest.as_ref().map(SiblingNode::from).or(self.following_node);
+            self.inner.rest.as_deref().map(SiblingNode::from).or(self.following_node);
         self.allocator.alloc(AstNode {
             inner: &self.inner.properties,
             allocator: self.allocator,
@@ -5091,7 +5091,7 @@ impl<'a> AstNode<'a, ObjectAssignmentTarget<'a>> {
         let following_node = self.following_node;
         self.allocator
             .alloc(self.inner.rest.as_ref().map(|inner| AstNode {
-                inner,
+                inner: inner.as_ref(),
                 allocator: self.allocator,
                 parent:
                     self.allocator.alloc(AstNodes::ObjectAssignmentTarget(transmute_self(self))),

crates/oxc_parser/src/js/grammar.rs

@@ -89,7 +89,7 @@ impl<'a> CoverGrammar<'a, ArrayExpression<'a>> for ArrayAssignmentTarget<'a> {
                             p.error(diagnostics::invalid_rest_assignment_target(argument.span()));
                         }
                         let target = AssignmentTarget::cover(argument, p);
-                        rest = Some(p.ast.assignment_target_rest(span, target));
+                        rest = Some(p.ast.alloc(p.ast.assignment_target_rest(span, target)));
                         if let Some(span) = p.state.trailing_commas.get(&expr.span.start) {
                             p.error(diagnostics::rest_element_trailing_comma(*span));
                         }
@@ -153,7 +153,7 @@ impl<'a> CoverGrammar<'a, ObjectExpression<'a>> for ObjectAssignmentTarget<'a> {
                             p.error(diagnostics::invalid_rest_assignment_target(argument.span()));
                         }
                         let target = AssignmentTarget::cover(argument, p);
-                        rest = Some(p.ast.assignment_target_rest(span, target));
+                        rest = Some(p.ast.alloc(p.ast.assignment_target_rest(span, target)));
                     } else {
                         return p.fatal_error(diagnostics::spread_last_element(spread.span));
                     }

crates/oxc_transformer/src/es2018/object_rest_spread.rs

@@ -326,6 +326,7 @@ impl<'a> ObjectRestSpread<'a, '_> {
         ctx: &mut TraverseCtx<'a>,
     ) -> Option<SpreadPair<'a>> {
         let rest = object_assignment_target.rest.take()?;
+        let rest_target = rest.unbox();
         let mut all_primitives = true;
         let keys =
             ctx.ast.vec_from_iter(object_assignment_target.properties.iter_mut().filter_map(|e| {
@@ -347,7 +348,7 @@ impl<'a> ObjectRestSpread<'a, '_> {
                 }
             }));
         Some(SpreadPair {
-            lhs: BindingPatternOrAssignmentTarget::AssignmentTarget(rest.target),
+            lhs: BindingPatternOrAssignmentTarget::AssignmentTarget(rest_target.target),
             keys,
             has_no_properties: object_assignment_target.is_empty(),
             all_primitives,

crates/oxc_traverse/src/generated/ancestor.rs

@@ -4150,10 +4150,10 @@ impl<'a, 't> ArrayAssignmentTargetWithoutElements<'a, 't> {
     }
 
     #[inline]
-    pub fn rest(self) -> &'t Option<AssignmentTargetRest<'a>> {
+    pub fn rest(self) -> &'t Option<Box<'a, AssignmentTargetRest<'a>>> {
         unsafe {
             &*((self.0 as *const u8).add(OFFSET_ARRAY_ASSIGNMENT_TARGET_REST)
-                as *const Option<AssignmentTargetRest<'a>>)
+                as *const Option<Box<'a, AssignmentTargetRest<'a>>>)
         }
     }
 }
@@ -4217,10 +4217,10 @@ impl<'a, 't> ObjectAssignmentTargetWithoutProperties<'a, 't> {
     }
 
     #[inline]
-    pub fn rest(self) -> &'t Option<AssignmentTargetRest<'a>> {
+    pub fn rest(self) -> &'t Option<Box<'a, AssignmentTargetRest<'a>>> {
         unsafe {
             &*((self.0 as *const u8).add(OFFSET_OBJECT_ASSIGNMENT_TARGET_REST)
-                as *const Option<AssignmentTargetRest<'a>>)
+                as *const Option<Box<'a, AssignmentTargetRest<'a>>>)
         }
     }
 }

crates/oxc_traverse/src/generated/walk.rs

@@ -1035,10 +1035,10 @@ unsafe fn walk_array_assignment_target<'a, State, Tr: Traverse<'a, State>>(
         walk_assignment_target_maybe_default(traverser, item as *mut _, ctx);
     }
     if let Some(field) = &mut *((node as *mut u8).add(ancestor::OFFSET_ARRAY_ASSIGNMENT_TARGET_REST)
-        as *mut Option<AssignmentTargetRest>)
+        as *mut Option<Box<AssignmentTargetRest>>)
     {
         ctx.retag_stack(AncestorType::ArrayAssignmentTargetRest);
-        walk_assignment_target_rest(traverser, field as *mut _, ctx);
+        walk_assignment_target_rest(traverser, (&mut **field) as *mut _, ctx);
     }
     ctx.pop_stack(pop_token);
     traverser.exit_array_assignment_target(&mut *node, ctx);
@@ -1060,10 +1060,10 @@ unsafe fn walk_object_assignment_target<'a, State, Tr: Traverse<'a, State>>(
     }
     if let Some(field) = &mut *((node as *mut u8)
         .add(ancestor::OFFSET_OBJECT_ASSIGNMENT_TARGET_REST)
-        as *mut Option<AssignmentTargetRest>)
+        as *mut Option<Box<AssignmentTargetRest>>)
     {
         ctx.retag_stack(AncestorType::ObjectAssignmentTargetRest);
-        walk_assignment_target_rest(traverser, field as *mut _, ctx);
+        walk_assignment_target_rest(traverser, (&mut **field) as *mut _, ctx);
     }
     ctx.pop_stack(pop_token);
     traverser.exit_object_assignment_target(&mut *node, ctx);

napi/parser/generated/deserialize/js.js

@@ -323,7 +323,7 @@ function deserializeAssignmentExpression(pos) {
 
 function deserializeArrayAssignmentTarget(pos) {
   const elements = deserializeVecOptionAssignmentTargetMaybeDefault(pos + 8);
-  const rest = deserializeOptionAssignmentTargetRest(pos + 32);
+  const rest = deserializeOptionBoxAssignmentTargetRest(pos + 32);
   if (rest !== null) elements.push(rest);
   return {
     type: 'ArrayPattern',
@@ -335,7 +335,7 @@ function deserializeArrayAssignmentTarget(pos) {
 
 function deserializeObjectAssignmentTarget(pos) {
   const properties = deserializeVecAssignmentTargetProperty(pos + 8);
-  const rest = deserializeOptionAssignmentTargetRest(pos + 32);
+  const rest = deserializeOptionBoxAssignmentTargetRest(pos + 32);
   if (rest !== null) properties.push(rest);
   return {
     type: 'ObjectPattern',
@@ -4389,9 +4389,13 @@ function deserializeVecOptionAssignmentTargetMaybeDefault(pos) {
   return arr;
 }
 
-function deserializeOptionAssignmentTargetRest(pos) {
-  if (uint8[pos + 8] === 51) return null;
-  return deserializeAssignmentTargetRest(pos);
+function deserializeBoxAssignmentTargetRest(pos) {
+  return deserializeAssignmentTargetRest(uint32[pos >> 2]);
+}
+
+function deserializeOptionBoxAssignmentTargetRest(pos) {
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
+  return deserializeBoxAssignmentTargetRest(pos);
 }
 
 function deserializeVecAssignmentTargetProperty(pos) {