LibJS: Box ExpressionKind::Update variant

Libraries/LibJS/Rust/src/ast.rs

@@ -297,8 +297,8 @@ impl FunctionTable {
             ExpressionKind::Unary { operand, .. } => {
                 self.collect_from_expression(operand, result);
             }
-            ExpressionKind::Update { argument, .. } => {
-                self.collect_from_expression(argument, result);
+            ExpressionKind::Update(data) => {
+                self.collect_from_expression(&data.argument, result);
             }
             ExpressionKind::Assignment { lhs, rhs, .. } => {
                 match lhs {
@@ -1337,6 +1337,13 @@ pub struct LogicalExprData {
     pub rhs: Box<Expression>,
 }
 
+#[derive(Clone, Debug)]
+pub struct UpdateExprData {
+    pub op: UpdateOp,
+    pub argument: Box<Expression>,
+    pub prefixed: bool,
+}
+
 // =============================================================================
 // Expression enum
 // =============================================================================
@@ -1362,11 +1369,7 @@ pub enum ExpressionKind {
         op: UnaryOp,
         operand: Box<Expression>,
     },
-    Update {
-        op: UpdateOp,
-        argument: Box<Expression>,
-        prefixed: bool,
-    },
+    Update(Box<UpdateExprData>),
     Assignment {
         op: AssignmentOp,
         lhs: AssignmentLhs,

Libraries/LibJS/Rust/src/ast_dump.rs

@@ -776,19 +776,15 @@ fn dump_expression(expression: &Expression, state: &DumpState) {
             dump_expression(operand, &child_state(state, true));
         }
 
-        ExpressionKind::Update {
-            op,
-            argument,
-            prefixed,
-        } => {
-            let prefix_str = if *prefixed { "prefix" } else { "postfix" };
+        ExpressionKind::Update(data) => {
+            let prefix_str = if data.prefixed { "prefix" } else { "postfix" };
             dump_node!(
                 state,
                 "UpdateExpression",
                 &expression.range,
-                format!("({}, {})", update_op_to_string(*op), prefix_str)
+                format!("({}, {})", update_op_to_string(data.op), prefix_str)
             );
-            dump_expression(argument, &child_state(state, true));
+            dump_expression(&data.argument, &child_state(state, true));
         }
 
         ExpressionKind::Assignment { op, lhs, rhs } => {

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

@@ -267,11 +267,9 @@ fn generate_expression_inner(
         }
 
         // === Update (++/--) ===
-        ExpressionKind::Update {
-            op,
-            argument,
-            prefixed,
-        } => generate_update_expression(generator, *op, argument, *prefixed),
+        ExpressionKind::Update(data) => {
+            generate_update_expression(generator, data.op, &data.argument, data.prefixed)
+        }
 
         // === Assignment ===
         ExpressionKind::Assignment { op, lhs, rhs } => {

Libraries/LibJS/Rust/src/parser.rs

@@ -960,7 +960,7 @@ impl<'a> Parser<'a> {
     }
 
     fn is_update_expression(expression: &Expression) -> bool {
-        matches!(&expression.inner, ExpressionKind::Update { .. })
+        matches!(&expression.inner, ExpressionKind::Update(_))
     }
 
     // === Main entry point ===

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

@@ -1062,11 +1062,11 @@ impl Parser<'_> {
                 (
                     self.expression(
                         start,
-                        ExpressionKind::Update {
+                        ExpressionKind::Update(Box::new(UpdateExprData {
                             op: UpdateOp::Increment,
                             argument: Box::new(lhs),
                             prefixed: false,
-                        },
+                        })),
                     ),
                     ForbiddenTokens::none(),
                 )
@@ -1082,11 +1082,11 @@ impl Parser<'_> {
                 (
                     self.expression(
                         start,
-                        ExpressionKind::Update {
+                        ExpressionKind::Update(Box::new(UpdateExprData {
                             op: UpdateOp::Decrement,
                             argument: Box::new(lhs),
                             prefixed: false,
-                        },
+                        })),
                     ),
                     ForbiddenTokens::none(),
                 )
@@ -1119,11 +1119,11 @@ impl Parser<'_> {
                 }
                 self.expression(
                     start,
-                    ExpressionKind::Update {
+                    ExpressionKind::Update(Box::new(UpdateExprData {
                         op: UpdateOp::Increment,
                         argument: Box::new(expression),
                         prefixed: true,
-                    },
+                    })),
                 )
             }
             TokenType::MinusMinus => {
@@ -1141,11 +1141,11 @@ impl Parser<'_> {
                 }
                 self.expression(
                     start,
-                    ExpressionKind::Update {
+                    ExpressionKind::Update(Box::new(UpdateExprData {
                         op: UpdateOp::Decrement,
                         argument: Box::new(expression),
                         prefixed: true,
-                    },
+                    })),
                 )
             }
             TokenType::ExclamationMark