LibJS: Box ExpressionKind::Assignment variant

Libraries/LibJS/Rust/src/ast.rs

@@ -300,12 +300,12 @@ impl FunctionTable {
             ExpressionKind::Update(data) => {
                 self.collect_from_expression(&data.argument, result);
             }
-            ExpressionKind::Assignment { lhs, rhs, .. } => {
-                match lhs {
+            ExpressionKind::Assignment(data) => {
+                match &data.lhs {
                     AssignmentLhs::Expression(expr) => self.collect_from_expression(expr, result),
                     AssignmentLhs::Pattern(pat) => self.collect_from_pattern(pat, result),
                 }
-                self.collect_from_expression(rhs, result);
+                self.collect_from_expression(&data.rhs, result);
             }
             ExpressionKind::Conditional {
                 test,
@@ -1344,6 +1344,13 @@ pub struct UpdateExprData {
     pub prefixed: bool,
 }
 
+#[derive(Clone, Debug)]
+pub struct AssignmentExprData {
+    pub op: AssignmentOp,
+    pub lhs: AssignmentLhs,
+    pub rhs: Box<Expression>,
+}
+
 // =============================================================================
 // Expression enum
 // =============================================================================
@@ -1370,11 +1377,7 @@ pub enum ExpressionKind {
         operand: Box<Expression>,
     },
     Update(Box<UpdateExprData>),
-    Assignment {
-        op: AssignmentOp,
-        lhs: AssignmentLhs,
-        rhs: Box<Expression>,
-    },
+    Assignment(Box<AssignmentExprData>),
     Conditional {
         test: Box<Expression>,
         consequent: Box<Expression>,

Libraries/LibJS/Rust/src/ast_dump.rs

@@ -787,14 +787,14 @@ fn dump_expression(expression: &Expression, state: &DumpState) {
             dump_expression(&data.argument, &child_state(state, true));
         }
 
-        ExpressionKind::Assignment { op, lhs, rhs } => {
+        ExpressionKind::Assignment(data) => {
             dump_node!(
                 state,
                 "AssignmentExpression",
                 &expression.range,
-                color_op(state, assignment_op_to_string(*op))
+                color_op(state, assignment_op_to_string(data.op))
             );
-            match lhs {
+            match &data.lhs {
                 AssignmentLhs::Expression(expression) => {
                     dump_expression(expression, &child_state(state, false));
                 }
@@ -802,7 +802,7 @@ fn dump_expression(expression: &Expression, state: &DumpState) {
                     dump_binding_pattern(pattern, &child_state(state, false), state);
                 }
             }
-            dump_expression(rhs, &child_state(state, true));
+            dump_expression(&data.rhs, &child_state(state, true));
         }
 
         ExpressionKind::Conditional {

Libraries/LibJS/Rust/src/bytecode/codegen.rs

@@ -272,8 +272,8 @@ fn generate_expression_inner(
         }
 
         // === Assignment ===
-        ExpressionKind::Assignment { op, lhs, rhs } => {
-            generate_assignment_expression(generator, *op, lhs, rhs, preferred_dst)
+        ExpressionKind::Assignment(data) => {
+            generate_assignment_expression(generator, data.op, &data.lhs, &data.rhs, preferred_dst)
         }
 
         // === Template literals ===

Libraries/LibJS/Rust/src/parser/expressions.rs

@@ -895,11 +895,11 @@ impl Parser<'_> {
                     return (
                         self.expression(
                             start,
-                            ExpressionKind::Assignment {
+                            ExpressionKind::Assignment(Box::new(AssignmentExprData {
                                 op,
                                 lhs: AssignmentLhs::Pattern(binding_pattern),
                                 rhs: Box::new(rhs),
-                            },
+                            })),
                         ),
                         ForbiddenTokens::none(),
                     );
@@ -921,11 +921,11 @@ impl Parser<'_> {
                 (
                     self.expression(
                         start,
-                        ExpressionKind::Assignment {
+                        ExpressionKind::Assignment(Box::new(AssignmentExprData {
                             op,
                             lhs: AssignmentLhs::Expression(Box::new(lhs)),
                             rhs: Box::new(rhs),
-                        },
+                        })),
                     ),
                     ForbiddenTokens::none(),
                 )