perf(es/ast): Make Expr 64 bytes

crates/swc_ecma_ast/src/expr.rs

@@ -55,7 +55,7 @@ pub enum Expr {
     Bin(BinExpr),
 
     #[tag("AssignmentExpression")]
-    Assign(AssignExpr),
+    Assign(Box<AssignExpr>),
 
     //
     // Logical {
@@ -79,7 +79,7 @@ pub enum Expr {
     Cond(CondExpr),
 
     #[tag("CallExpression")]
-    Call(CallExpr),
+    Call(Box<CallExpr>),
 
     /// `new Cat()`
     #[tag("NewExpression")]
@@ -107,7 +107,7 @@ pub enum Expr {
     TaggedTpl(TaggedTpl),
 
     #[tag("ArrowFunctionExpression")]
-    Arrow(ArrowExpr),
+    Arrow(Box<ArrowExpr>),
 
     #[tag("ClassExpression")]
     Class(ClassExpr),
@@ -449,18 +449,18 @@ boxed_expr!(FnExpr);
 boxed_expr!(UnaryExpr);
 boxed_expr!(UpdateExpr);
 boxed_expr!(BinExpr);
-boxed_expr!(AssignExpr);
+boxed_expr!(Box<AssignExpr>);
 boxed_expr!(MemberExpr);
 boxed_expr!(SuperPropExpr);
 boxed_expr!(CondExpr);
-boxed_expr!(CallExpr);
+boxed_expr!(Box<CallExpr>);
 boxed_expr!(NewExpr);
 boxed_expr!(SeqExpr);
 bridge_from!(Box<Expr>, Expr, Ident);
 boxed_expr!(Lit);
 boxed_expr!(Tpl);
 boxed_expr!(TaggedTpl);
-boxed_expr!(ArrowExpr);
+boxed_expr!(Box<ArrowExpr>);
 boxed_expr!(ClassExpr);
 boxed_expr!(YieldExpr);
 boxed_expr!(MetaPropExpr);
@@ -826,6 +826,8 @@ pub struct AssignExpr {
     pub right: Box<Expr>,
 }
 
+bridge_expr_from!(Box<AssignExpr>, AssignExpr);
+
 impl Take for AssignExpr {
     fn dummy() -> Self {
         AssignExpr {
@@ -979,6 +981,8 @@ pub struct CallExpr {
     // pub type_params: Option<TsTypeParamInstantiation>,
 }
 
+bridge_expr_from!(Box<CallExpr>, CallExpr);
+
 impl Take for CallExpr {
     fn dummy() -> Self {
         Default::default()
@@ -1057,6 +1061,8 @@ pub struct ArrowExpr {
     pub return_type: Option<Box<TsTypeAnn>>,
 }
 
+bridge_expr_from!(Box<ArrowExpr>, ArrowExpr);
+
 impl Take for ArrowExpr {
     fn dummy() -> Self {
         ArrowExpr {
@@ -1706,13 +1712,13 @@ impl From<OptChainBase> for Expr {
                 callee,
                 args,
                 type_args,
-            }) => Self::Call(CallExpr {
+            }) => Self::Call(Box::new(CallExpr {
                 callee: Callee::Expr(callee),
                 args,
                 span,
                 type_args,
                 ctxt,
-            }),
+            })),
             OptChainBase::Member(member) => Self::Member(member),
         }
     }

crates/swc_ecma_codegen/src/util.rs

@@ -194,12 +194,12 @@ impl StartsWithAlphaNum for Expr {
                 .unwrap_or(false),
 
             //
-            Expr::Assign(AssignExpr { ref left, .. }) => left.starts_with_alpha_num(),
+            Expr::Assign(expr) => expr.left.starts_with_alpha_num(),
 
             Expr::Bin(BinExpr { ref left, .. }) | Expr::Cond(CondExpr { test: ref left, .. }) => {
                 left.starts_with_alpha_num()
             }
-            Expr::Call(CallExpr { callee: left, .. }) => left.starts_with_alpha_num(),
+            Expr::Call(expr) => expr.callee.starts_with_alpha_num(),
             Expr::Member(MemberExpr { obj: ref left, .. }) => left.starts_with_alpha_num(),
 
             Expr::Unary(UnaryExpr { op, .. }) => {

crates/swc_ecma_compat_es2017/src/async_to_generator.rs

@@ -431,7 +431,7 @@ impl Actual {
         expr.visit_mut_children_with(self);
 
         match expr {
-            Expr::Arrow(arrow_expr @ ArrowExpr { is_async: true, .. }) => {
+            Expr::Arrow(arrow_expr) if arrow_expr.is_async => {
                 arrow_expr.visit_mut_with(&mut self.hoister);
 
                 let mut wrapper = FunctionWrapper::from(arrow_expr.take());

crates/swc_ecma_ext_transforms/src/jest.rs

@@ -38,10 +38,8 @@ impl Jest {
             match item.try_into_stmt() {
                 Ok(stmt) => match &stmt {
                     Stmt::Expr(ExprStmt { expr, .. }) => match &**expr {
-                        Expr::Call(CallExpr {
-                            callee: Callee::Expr(callee),
-                            ..
-                        }) => {
+                        Expr::Call(call) if matches!(call.callee, Callee::Expr(..)) => {
+                            let callee = call.callee.as_expr().unwrap();
                             if self.should_hoist(callee) {
                                 hoisted.push(T::from(stmt))
                             } else {
@@ -130,10 +128,9 @@ fn is_global_jest(e: &Expr) -> bool {
     match e {
         Expr::Ident(i) => i.sym == *"jest",
         Expr::Member(MemberExpr { obj, .. }) => is_global_jest(obj),
-        Expr::Call(CallExpr {
-            callee: Callee::Expr(callee),
-            ..
-        }) => is_global_jest(callee),
+        Expr::Call(call) if matches!(call.callee, Callee::Expr(..)) => {
+            is_global_jest(call.callee.as_expr().unwrap())
+        }
         _ => false,
     }
 }

crates/swc_ecma_lints/src/rules/no_throw_literal.rs

@@ -61,14 +61,12 @@ impl NoThrowLiteral {
             | Expr::Await(_)
             | Expr::OptChain(_) => true,
 
-            Expr::Assign(AssignExpr {
-                op, left, right, ..
-            }) => match op {
-                op!("=") | op!("&&=") => self.could_be_error(right.as_ref()),
+            Expr::Assign(assign) => match assign.op {
+                op!("=") | op!("&&=") => self.could_be_error(assign.right.as_ref()),
                 op!("||=") | op!("??=") => {
-                    if let AssignTarget::Simple(left) = left {
+                    if let AssignTarget::Simple(left) = &assign.left {
                         self.could_simple_target_be_error(left)
-                            || self.could_be_error(right.as_ref())
+                            || self.could_be_error(assign.right.as_ref())
                     } else {
                         false
                     }

crates/swc_ecma_parser/src/parser/expr.rs

@@ -127,14 +127,10 @@ impl<I: Tokens> Parser<I> {
 
                 let type_parameters = p.parse_ts_type_params(false, true)?;
                 let mut arrow = p.parse_assignment_expr_base()?;
-                match *arrow {
-                    Expr::Arrow(ArrowExpr {
-                        ref mut span,
-                        ref mut type_params,
-                        ..
-                    }) => {
-                        *span = Span::new(type_parameters.span.lo, span.hi);
-                        *type_params = Some(type_parameters);
+                match &mut *arrow {
+                    Expr::Arrow(expr) => {
+                        expr.span = Span::new(type_parameters.span.lo, expr.span.hi);
+                        expr.type_params = Some(type_parameters);
                     }
                     _ => unexpected!(p, "("),
                 }