From 8c045fb182b3549b6f0bc10ecfc5a8fe13d5ed6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?=
 <kdy1997.dev@gmail.com>
Date: Wed, 10 Jul 2024 23:08:07 +0900
Subject: [PATCH] fixup for rebase

---
 crates/swc_ecma_ast/src/expr.rs               |   7 --
 crates/swc_ecma_ast/src/pat.rs                |   1 +
 .../src/edge_default_param.rs                 |   8 --
 .../src/template_literal_caching.rs           |  10 --
 .../src/block_scoping/mod.rs                  |  51 +--------
 .../src/classes/constructor.rs                |   3 +-
 .../swc_ecma_compat_es2015/src/classes/mod.rs |   9 +-
 .../src/computed_props.rs                     |  25 -----
 .../src/destructuring.rs                      | 103 ++----------------
 crates/swc_ecma_compat_es2015/src/for_of.rs   |   5 +-
 .../src/function_name.rs                      |   2 -
 .../swc_ecma_compat_es2015/src/generator.rs   |  75 ++++++-------
 .../swc_ecma_compat_es2015/src/new_target.rs  |   2 +-
 .../src/object_super.rs                       |   8 +-
 .../swc_ecma_compat_es2015/src/parameters.rs  |  25 +----
 crates/swc_ecma_compat_es2015/src/spread.rs   |   6 +-
 .../src/template_literal.rs                   |   3 +-
 .../src/typeof_symbol.rs                      |   5 +-
 .../src/exponentiation.rs                     |   2 +-
 .../src/nullish_coalescing.rs                 |   2 -
 20 files changed, 69 insertions(+), 283 deletions(-)

diff --git a/crates/swc_ecma_ast/src/expr.rs b/crates/swc_ecma_ast/src/expr.rs
index b6a6fcf1e8cb6..1f9ab3b8ae8f5 100644
--- a/crates/swc_ecma_ast/src/expr.rs
+++ b/crates/swc_ecma_ast/src/expr.rs
@@ -336,14 +336,9 @@ impl Expr {
             exprs.remove(0)
         } else {
             SeqExpr {
-            Expr::Seq(Box::new(SeqExpr {
                 span: DUMMY_SP,
                 exprs,
             }
-            Box::new(SeqExpr {
-                span: DUMMY_SP,
-                exprs,
-            })
             .into()
         }
     }
@@ -609,8 +604,6 @@ impl From<ImportWith> for ObjectLit {
                     PropOrSpread::Prop(Prop::KeyValue(Box::new(KeyValueProp {
                         key: PropName::Ident(item.key),
                         value: Lit::Str(item.value).into(),
-                        value: Expr::Lit(Box::new(Lit::Str(item.value))),
-                        value: Box::new(Lit::Str(item.value)).into(),
                     })))
                 })
                 .collect(),
diff --git a/crates/swc_ecma_ast/src/pat.rs b/crates/swc_ecma_ast/src/pat.rs
index ba82f8f96f10e..c75a82feafec9 100644
--- a/crates/swc_ecma_ast/src/pat.rs
+++ b/crates/swc_ecma_ast/src/pat.rs
@@ -58,6 +58,7 @@ impl Clone for Pat {
 impl Default for Pat {
     fn default() -> Self {
         Invalid { span: DUMMY_SP }.into()
+        Pat::Invalid(Invalid { span: DUMMY_SP })
     }
 }
 impl Take for Pat {
diff --git a/crates/swc_ecma_compat_bugfixes/src/edge_default_param.rs b/crates/swc_ecma_compat_bugfixes/src/edge_default_param.rs
index 9ebdd1a39225e..e4ba6f3a821ec 100644
--- a/crates/swc_ecma_compat_bugfixes/src/edge_default_param.rs
+++ b/crates/swc_ecma_compat_bugfixes/src/edge_default_param.rs
@@ -50,14 +50,6 @@ impl VisitMut for EdgeDefaultParam {
                         right: value.clone(),
                     }
                     .into(),
-                    value: Box::new(
-                        AssignPat {
-                            span: *span,
-                            left: key.clone().into(),
-                            right: value.clone(),
-                        }
-                        .into(),
-                    ),
                 });
 
                 n.props[idx] = prop;
diff --git a/crates/swc_ecma_compat_bugfixes/src/template_literal_caching.rs b/crates/swc_ecma_compat_bugfixes/src/template_literal_caching.rs
index 9e833bbf3a892..765e05e894e2e 100644
--- a/crates/swc_ecma_compat_bugfixes/src/template_literal_caching.rs
+++ b/crates/swc_ecma_compat_bugfixes/src/template_literal_caching.rs
@@ -81,14 +81,6 @@ impl Fold for TemplateLiteralCaching {
                             }
                             .into(),
                         ),
-                        Some(Expr::Arrow(ArrowExpr {
-                            span: DUMMY_SP,
-                            params: vec![t.clone().into()],
-                            body: Box::new(BlockStmtOrExpr::Expr(t.into())),
-                            is_async: false,
-                            is_generator: false,
-                            ..Default::default()
-                        })),
                     )
                 }
 
@@ -113,7 +105,6 @@ impl Fold for TemplateLiteralCaching {
                 let t = private_ident!("t");
                 self.create_binding(t.clone(), None);
                 let inline_cache: Expr = BinExpr {
-                let inline_cache = BinExpr {
                     span: DUMMY_SP,
                     op: op!("||"),
                     left: t.clone().into(),
@@ -126,7 +117,6 @@ impl Fold for TemplateLiteralCaching {
                     .into(),
                 }
                 .into();
-                });
 
                 // The original tag function becomes a plain function call.
                 // The expressions omitted from the cached Strings tag are
diff --git a/crates/swc_ecma_compat_es2015/src/block_scoping/mod.rs b/crates/swc_ecma_compat_es2015/src/block_scoping/mod.rs
index 92f0892fd68c7..c2e6a47fa205e 100644
--- a/crates/swc_ecma_compat_es2015/src/block_scoping/mod.rs
+++ b/crates/swc_ecma_compat_es2015/src/block_scoping/mod.rs
@@ -143,7 +143,7 @@ impl BlockScoping {
             let mut env_hoister =
                 FnEnvHoister::new(SyntaxContext::empty().apply_mark(self.unresolved_mark));
             body_stmt.visit_mut_with(&mut env_hoister);
-            let mut inits: Vec<Expr> = vec![];
+            let mut inits: Vec<Box<Expr>> = vec![];
 
             for mut var in env_hoister.to_decl() {
                 if let Some(init) = var.init.take() {
@@ -591,7 +591,7 @@ impl VisitMut for BlockScoping {
             if self.var_decl_kind == VarDeclKind::Var {
                 var.init = None
             } else {
-                var.init = Some(var.span().into())
+                var.init = Some(Expr::undefined(var.span()))
             }
         }
     }
@@ -828,37 +828,6 @@ impl VisitMut for FlowHelper<'_> {
                         }
                         .into(),
                     ),
-                    arg: Some(Box::new(Expr::Object(ObjectLit {
-                        span,
-                        props: vec![PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
-                            key: PropName::Ident(Ident::new_no_ctxt("v".into(), DUMMY_SP)),
-                            value: s.arg.take().unwrap_or_else(|| {
-                                Box::new(Expr::Unary(UnaryExpr {
-                                    span: DUMMY_SP,
-                                    op: op!("void"),
-                                    arg: Expr::undefined(DUMMY_SP),
-                                }))
-                            }),
-                        })))],
-                    }))),
-                    arg: Some(
-                        ObjectLit {
-                            span,
-                            props: vec![PropOrSpread::Prop(Box::new(Prop::KeyValue(
-                                KeyValueProp {
-                                    key: PropName::Ident(Ident::new_no_ctxt("v".into(), DUMMY_SP)),
-                                    value: s.arg.take().unwrap_or_else(|| {
-                                        Box::new(Expr::Unary(UnaryExpr {
-                                            span: DUMMY_SP,
-                                            op: op!("void"),
-                                            arg: Expr::undefined(DUMMY_SP),
-                                        }))
-                                    }),
-                                },
-                            )))],
-                        }
-                        .into(),
-                    ),
                 });
             }
             _ => node.visit_mut_children_with(self),
@@ -902,9 +871,9 @@ struct MutationHandler<'a> {
 }
 
 impl MutationHandler<'_> {
-    fn make_reassignment(&self, orig: Option<Expr>) -> Expr {
+    fn make_reassignment(&self, orig: Option<Box<Expr>>) -> Expr {
         if self.map.is_empty() {
-            return *orig.unwrap_or_else(|| DUMMY_SP.into());
+            return *orig.unwrap_or_else(|| Expr::undefined(DUMMY_SP));
         }
 
         let mut exprs = Vec::with_capacity(self.map.len() + 1);
@@ -919,18 +888,8 @@ impl MutationHandler<'_> {
                 }
                 .into(),
             );
-            exprs.push(Box::new(Expr::Assign(AssignExpr {
-                span: DUMMY_SP,
-                left: Ident::new(id.0.clone(), DUMMY_SP, id.1).into(),
-                op: op!("="),
-                right: Box::new(Expr::Ident(Ident::new(id.0.clone(), DUMMY_SP, *ctxt))),
-            })));
-                    right: Box::new(Expr::Ident(Ident::new(id.0.clone(), DUMMY_SP, *ctxt))),
-                }
-                .into(),
-            );
         }
-        exprs.push(orig.unwrap_or_else(|| DUMMY_SP.into()));
+        exprs.push(orig.unwrap_or_else(|| Expr::undefined(DUMMY_SP)));
 
         SeqExpr {
             span: DUMMY_SP,
diff --git a/crates/swc_ecma_compat_es2015/src/classes/constructor.rs b/crates/swc_ecma_compat_es2015/src/classes/constructor.rs
index 2abe823cca678..58ee2a518d2bf 100644
--- a/crates/swc_ecma_compat_es2015/src/classes/constructor.rs
+++ b/crates/swc_ecma_compat_es2015/src/classes/constructor.rs
@@ -237,7 +237,6 @@ impl VisitMut for ConstructorFolder<'_> {
                             left: call,
                             op: op!("||"),
                             right: Box::new(ThisExpr { span: DUMMY_SP }.into()),
-                            right: Box::new(Expr::This(ThisExpr { span: DUMMY_SP })),
                         }
                         .into()
                     } else {
@@ -366,7 +365,7 @@ pub(super) enum ReturningMode {
     Returning {
         /// Mark for `_this`
         mark: Mark,
-        arg: Option<Expr>,
+        arg: Option<Box<Expr>>,
     },
 
     /// `super()` call
diff --git a/crates/swc_ecma_compat_es2015/src/classes/mod.rs b/crates/swc_ecma_compat_es2015/src/classes/mod.rs
index 95d4f3310b534..470c30634f3f6 100644
--- a/crates/swc_ecma_compat_es2015/src/classes/mod.rs
+++ b/crates/swc_ecma_compat_es2015/src/classes/mod.rs
@@ -106,9 +106,9 @@ pub struct Config {
 
 struct Data {
     key_prop: Box<PropName>,
-    method: Option<Expr>,
-    set: Option<Expr>,
-    get: Option<Expr>,
+    method: Option<Box<Expr>>,
+    set: Option<Box<Expr>>,
+    get: Option<Box<Expr>>,
 }
 
 #[swc_trace]
@@ -966,7 +966,6 @@ where
                     .map(Some)
                     .collect(),
             }
-            .into()
             .as_arg()
         }
 
@@ -1277,7 +1276,7 @@ fn is_always_initialized(body: &[Stmt]) -> bool {
     !v.found
 }
 
-fn escape_keywords(mut e: Expr) -> Expr {
+fn escape_keywords(mut e: Box<Expr>) -> Box<Expr> {
     if let Expr::Fn(f) = &mut *e {
         if let Some(i) = &mut f.ident {
             let sym = Ident::verify_symbol(&i.sym);
diff --git a/crates/swc_ecma_compat_es2015/src/computed_props.rs b/crates/swc_ecma_compat_es2015/src/computed_props.rs
index b5e4bd059a686..ccb45c7ae4454 100644
--- a/crates/swc_ecma_compat_es2015/src/computed_props.rs
+++ b/crates/swc_ecma_compat_es2015/src/computed_props.rs
@@ -114,10 +114,6 @@ impl VisitMut for ComputedProps {
                             }
                             .into(),
                         ),
-                        right: Box::new(Expr::Object(ObjectLit {
-                            span: DUMMY_SP,
-                            props: obj_props,
-                        })),
                     }
                     .into()
                 },
@@ -219,21 +215,6 @@ impl VisitMut for ComputedProps {
                                         }
                                         .into(),
                                     ),
-                                    right: Box::new(Expr::Bin(BinExpr {
-                                        span,
-                                        left: mutator_elem.clone().into(),
-                                        op: op!("||"),
-                                        right: Box::new(Expr::Object(ObjectLit {
-                                            span,
-                                            left: mutator_elem.clone().into(),
-                                            op: op!("||"),
-                                            right: Box::new(Expr::Object(ObjectLit {
-                                                span,
-                                                props: vec![],
-                                            })),
-                                        }
-                                        .into(),
-                                    ),
                                 }
                                 .into(),
                             );
@@ -253,10 +234,6 @@ impl VisitMut for ComputedProps {
                                         }
                                         .into(),
                                     ),
-                                    right: Box::new(Expr::Fn(FnExpr {
-                                        ident: None,
-                                        function,
-                                    })),
                                 }
                                 .into(),
                             );
@@ -350,7 +327,6 @@ impl VisitMut for ComputedProps {
             // Last value
             exprs.push(obj_ident.into());
             *expr = SeqExpr {
-            *expr = Expr::Seq(SeqExpr {
                 span: DUMMY_SP,
                 exprs,
             }
@@ -434,7 +410,6 @@ fn prop_name_to_expr(p: PropName, loose: bool) -> (Expr, bool) {
     match p {
         PropName::Ident(i) => (
             if loose {
-                Expr::Ident(i.into())
                 i.into()
             } else {
                 Lit::Str(Str {
diff --git a/crates/swc_ecma_compat_es2015/src/destructuring.rs b/crates/swc_ecma_compat_es2015/src/destructuring.rs
index 0c562db39d12d..35c0d9f400ca7 100644
--- a/crates/swc_ecma_compat_es2015/src/destructuring.rs
+++ b/crates/swc_ecma_compat_es2015/src/destructuring.rs
@@ -557,7 +557,12 @@ struct AssignFolder {
 }
 
 impl AssignFolder {
-    pub fn handle_assign_pat(&mut self, span: Span, mut pat: AssignPat, right: &mut Expr) -> Expr {
+    pub fn handle_assign_pat(
+        &mut self,
+        span: Span,
+        mut pat: AssignPat,
+        right: &mut Box<Expr>,
+    ) -> Expr {
         let ref_ident = make_ref_ident(self.c, &mut self.vars, None);
 
         let mut exprs = vec![Box::new(
@@ -571,7 +576,6 @@ impl AssignFolder {
         )];
 
         let mut assign_cond_expr: Expr = AssignExpr {
-        let mut assign_cond_expr = AssignExpr {
             span,
             left: pat.left.take().try_into().unwrap(),
             op: op!("="),
@@ -680,13 +684,6 @@ impl VisitMut for AssignFolder {
                                                     }
                                                     .into(),
                                                 ),
-                                                right: Box::new(Expr::Array(ArrayLit {
-                                                    span: DUMMY_SP,
-                                                    elems: arr_elems
-                                                        .take()
-                                                        .expect("two rest element?")
-                                                        .collect(),
-                                                })),
                                             }
                                             .into(),
                                         );
@@ -702,7 +699,7 @@ impl VisitMut for AssignFolder {
                                                 debug_assert_eq!(e.spread, None);
                                                 e.expr
                                             })
-                                            .unwrap_or_else(|| p.span().into());
+                                            .unwrap_or_else(|| Expr::undefined(p.span()));
 
                                         let p = p.take();
                                         let mut expr = if let Pat::Assign(pat) = p {
@@ -767,44 +764,6 @@ impl VisitMut for AssignFolder {
                                                 )
                                                 .as_callee(),
                                                 args: vec![right.take().as_arg()],
-                    exprs.push(Box::new(Expr::Assign(AssignExpr {
-                        span: DUMMY_SP,
-                        op: op!("="),
-                        left: ref_ident.clone().into(),
-                        right: if self.c.loose {
-                            right.take()
-                        } else {
-                            match &mut **right {
-                                Expr::Ident(Ident { sym, .. }) if &**sym == "arguments" => {
-                                    Box::new(Expr::Call(CallExpr {
-                                        span: DUMMY_SP,
-                                        callee: member_expr!(
-                                            Default::default(),
-                                            Default::default(),
-                                            Array.prototype.slice.call
-                                        )
-                                        .as_callee(),
-                                        args: vec![right.take().as_arg()],
-                                        ..Default::default()
-                                    }))
-                                }
-                                Expr::Array(..) => right.take(),
-                                _ => {
-                                    // if left has rest then need `_to_array`
-                                    // else `_sliced_to_array`
-                                    if elems.iter().any(|elem| matches!(elem, Some(Pat::Rest(..))))
-                                    {
-                                        Box::new(Expr::Call(CallExpr {
-                                            span: DUMMY_SP,
-                                            callee: member_expr!(
-                                                Default::default(),
-                                                Default::default(),
-                                                Array.prototype.slice.call
-                                            )
-                                            .as_callee(),
-                                            args: vec![right.take().as_arg()],
-                                            ..Default::default()
-                                        }))
                                                 ..Default::default()
                                             }
                                             .into(),
@@ -842,38 +801,6 @@ impl VisitMut for AssignFolder {
                                             )
                                         }
                                     }
-                                    Expr::Array(..) => right.take(),
-                                    _ => {
-                                        // if left has rest then need `_to_array`
-                                        // else `_sliced_to_array`
-                                        if elems
-                                            .iter()
-                                            .any(|elem| matches!(elem, Some(Pat::Rest(..))))
-                                        {
-                                            Box::new(
-                                                CallExpr {
-                                                    span: DUMMY_SP,
-                                                    callee: helper!(to_array),
-                                                    args: vec![right.take().as_arg()],
-                                                    ..Default::default()
-                                                }
-                                                .into(),
-                                            )
-                                        } else {
-                                            Box::new(
-                                                CallExpr {
-                                                    span: DUMMY_SP,
-                                                    callee: helper!(sliced_to_array),
-                                                    args: vec![
-                                                        right.take().as_arg(),
-                                                        elems.len().as_arg(),
-                                                    ],
-                                                    ..Default::default()
-                                                }
-                                                .into(),
-                                            )
-                                        }
-                                    }
                                 }
                             },
                         }
@@ -904,7 +831,6 @@ impl VisitMut for AssignFolder {
                                 );
 
                                 let mut assign_expr: Expr = AssignExpr {
-                                let mut assign_expr = AssignExpr {
                                     span: *span,
                                     left: left.take().try_into().unwrap(),
                                     op: op!("="),
@@ -917,7 +843,6 @@ impl VisitMut for AssignFolder {
                             }
                             Pat::Rest(RestPat { arg, .. }) => {
                                 let mut assign_expr: Expr = AssignExpr {
-                                let mut assign_expr = AssignExpr {
                                     span: elem_span,
                                     op: op!("="),
                                     left: arg.take().try_into().unwrap(),
@@ -939,7 +864,6 @@ impl VisitMut for AssignFolder {
                             }
                             _ => {
                                 let mut assign_expr: Expr = AssignExpr {
-                                let mut assign_expr = AssignExpr {
                                     span: elem_span,
                                     op: op!("="),
                                     left: elem.take().try_into().unwrap(),
@@ -979,8 +903,6 @@ impl VisitMut for AssignFolder {
                                 op: op!("="),
                                 left: p.key.clone().into(),
                                 right: right.take().make_member(p.key.clone().into()).into(),
-                            });
-                                right: right.take().make_member(p.key.clone()).into(),
                             }
                             .into();
                             return;
@@ -1133,7 +1055,7 @@ impl VisitMut for AssignFolder {
         if var_decl.kind == VarDeclKind::Const {
             var_decl.decls.iter_mut().for_each(|v| {
                 if v.init.is_none() {
-                    v.init = Some(DUMMY_SP.into());
+                    v.init = Some(Expr::undefined(DUMMY_SP));
                 }
             })
         }
@@ -1209,7 +1131,7 @@ fn make_ref_idx_expr(ref_ident: &Ident, i: usize) -> MemberExpr {
     ref_ident.clone().computed_member(i as f64)
 }
 
-fn make_ref_ident(c: Config, decls: &mut Vec<VarDeclarator>, init: Option<Expr>) -> Ident {
+fn make_ref_ident(c: Config, decls: &mut Vec<VarDeclarator>, init: Option<Box<Expr>>) -> Ident {
     make_ref_ident_for_array(c, decls, init, None)
 }
 
@@ -1217,7 +1139,7 @@ fn make_ref_ident(c: Config, decls: &mut Vec<VarDeclarator>, init: Option<Expr>)
 fn make_ref_ident_for_array(
     c: Config,
     decls: &mut Vec<VarDeclarator>,
-    mut init: Option<Expr>,
+    mut init: Option<Box<Expr>>,
     elem_cnt: Option<usize>,
 ) -> Ident {
     if elem_cnt.is_none() {
@@ -1281,7 +1203,7 @@ fn make_ref_ident_for_array(
     ref_ident
 }
 
-fn make_ref_prop_expr(ref_ident: &Ident, prop: Expr, mut computed: bool) -> Expr {
+fn make_ref_prop_expr(ref_ident: &Ident, prop: Box<Expr>, mut computed: bool) -> Expr {
     computed |= matches!(*prop, Expr::Lit(Lit::Num(..)) | Expr::Lit(Lit::Str(..)));
 
     MemberExpr {
@@ -1301,8 +1223,6 @@ fn make_ref_prop_expr(ref_ident: &Ident, prop: Expr, mut computed: bool) -> Expr
 
 /// Creates `tmp === void 0 ? def_value : tmp`
 fn make_cond_expr(tmp: Ident, def_value: Box<Expr>) -> Expr {
-    CondExpr {
-fn make_cond_expr(tmp: Ident, def_value: Expr) -> Expr {
     CondExpr {
         span: DUMMY_SP,
         test: BinExpr {
@@ -1320,7 +1240,6 @@ fn make_cond_expr(tmp: Ident, def_value: Expr) -> Expr {
         alt: tmp.into(),
     }
     .into()
-    })
 }
 
 fn can_be_null(e: &Expr) -> bool {
diff --git a/crates/swc_ecma_compat_es2015/src/for_of.rs b/crates/swc_ecma_compat_es2015/src/for_of.rs
index 1d5e5f170a35e..fe1348c7d7174 100644
--- a/crates/swc_ecma_compat_es2015/src/for_of.rs
+++ b/crates/swc_ecma_compat_es2015/src/for_of.rs
@@ -104,7 +104,6 @@ impl ForOf {
                 BinExpr {
                     span: DUMMY_SP,
                     left: Box::new(i.clone().into()),
-                    left: Box::new(Expr::Ident(i.clone())),
                     op: op!("<"),
                     right: arr.clone().make_member(quote_ident!("length")).into(),
                 }
@@ -116,7 +115,6 @@ impl ForOf {
                     prefix: false,
                     op: op!("++"),
                     arg: Box::new(i.clone().into()),
-                    arg: Box::new(Expr::Ident(i.clone())),
                 }
                 .into(),
             );
@@ -449,7 +447,6 @@ impl ForOf {
                     op: op!("!"),
                     arg: {
                         let step_expr: Expr = AssignExpr {
-                        let step_expr = Box::new(Expr::Assign(AssignExpr {
                             span: DUMMY_SP,
                             left: step.into(),
                             op: op!("="),
@@ -589,7 +586,7 @@ impl ForOf {
 /// ```
 #[tracing::instrument(level = "info", skip_all)]
 fn make_finally_block(
-    iterator_return: Expr,
+    iterator_return: Box<Expr>,
     normal_completion_ident: &Ident,
     error_flag_ident: Ident,
     error_ident: Ident,
diff --git a/crates/swc_ecma_compat_es2015/src/function_name.rs b/crates/swc_ecma_compat_es2015/src/function_name.rs
index b1522d2ce7890..c836e13e2d83c 100644
--- a/crates/swc_ecma_compat_es2015/src/function_name.rs
+++ b/crates/swc_ecma_compat_es2015/src/function_name.rs
@@ -78,8 +78,6 @@ impl VisitMut for FnName {
             p.value = if let PropName::Ident(ref i) = p.key {
                 FnExpr {
                     ident: Some(prepare(i.clone().into())),
-                FnExpr {
-                    ident: Some(prepare(i.clone())),
                     ..expr.take()
                 }
                 .into()
diff --git a/crates/swc_ecma_compat_es2015/src/generator.rs b/crates/swc_ecma_compat_es2015/src/generator.rs
index b7e48947d18ee..4b1d17027b096 100644
--- a/crates/swc_ecma_compat_es2015/src/generator.rs
+++ b/crates/swc_ecma_compat_es2015/src/generator.rs
@@ -170,10 +170,10 @@ enum OpCode {
 #[derive(Debug, Is, Clone)]
 enum OpArgs {
     Label(Label),
-    LabelExpr(Label, Expr),
+    LabelExpr(Label, Box<Expr>),
     Stmt(Box<Stmt>),
-    OptExpr(Option<Expr>),
-    PatAndExpr(AssignTarget, Expr),
+    OptExpr(Option<Box<Expr>>),
+    PatAndExpr(AssignTarget, Box<Expr>),
 }
 
 /// whether a generated code block is opening or closing at the current
@@ -741,7 +741,7 @@ impl VisitMut for Generator {
 
                 expressions.push(temp.into());
 
-                *e = *expressions.into();
+                *e = *Expr::from_exprs(expressions);
             }
 
             Expr::Array(node) => {
@@ -816,7 +816,7 @@ impl VisitMut for Generator {
                     &mut args,
                     Some(ExprOrSpread {
                         spread: None,
-                        expr: DUMMY_SP.into(),
+                        expr: Expr::undefined(DUMMY_SP),
                     }),
                     None,
                 ))
@@ -825,7 +825,6 @@ impl VisitMut for Generator {
             };
 
             let apply = callee.apply(
-            let apply = callee.into().apply(
                 node.span,
                 this_arg,
                 arg.take().map(|v| v.as_arg()).into_iter().collect(),
@@ -1202,10 +1201,10 @@ impl Generator {
 
     fn reduce_property(
         &mut self,
-        mut expressions: Vec<Expr>,
+        mut expressions: Vec<Box<Expr>>,
         property: CompiledProp,
         temp: &mut Ident,
-    ) -> Vec<Expr> {
+    ) -> Vec<Box<Expr>> {
         if match &property {
             CompiledProp::Prop(p) => contains_yield(p),
             CompiledProp::Accessor(g, s) => {
@@ -1215,7 +1214,7 @@ impl Generator {
         {
             self.emit_stmt(Stmt::Expr(ExprStmt {
                 span: DUMMY_SP,
-                expr: expressions.take().into(),
+                expr: Expr::from_exprs(expressions.take()),
             }));
         }
 
@@ -1228,16 +1227,12 @@ impl Generator {
                         span: DUMMY_SP,
                         obj: temp.clone().into(),
                         prop: MemberProp::Ident(p.clone().into()),
-                        obj: temp.clone().into(),
-                        prop: MemberProp::Ident(p.clone()),
                     }
                     .into(),
                     right: p.into(),
                 }
                 .into(),
                 Prop::KeyValue(p) => AssignExpr {
-                }),
-                Prop::KeyValue(p) => Expr::Assign(AssignExpr {
                     span: DUMMY_SP,
                     op: op!("="),
                     left: MemberExpr {
@@ -2114,7 +2109,7 @@ impl Generator {
         0
     }
 
-    fn cache_expression(&mut self, node: Expr) -> Ident {
+    fn cache_expression(&mut self, node: Box<Expr>) -> Ident {
         match *node {
             Expr::Ident(i) => i,
             _ => {
@@ -2591,7 +2586,7 @@ impl Generator {
 
     /// Creates an expression that can be used to indicate the value for a
     /// label.
-    fn create_label(&mut self, label: Option<Label>) -> Expr {
+    fn create_label(&mut self, label: Option<Label>) -> Box<Expr> {
         if let Some(label) = label {
             if label.0 > 0 {
                 #[cfg(debug_assertions)]
@@ -2621,10 +2616,6 @@ impl Generator {
                     span: Span::new(BytePos(label.0 as _), BytePos(label.0 as _)),
                 }
                 .into();
-                return Box::new(Expr::Invalid(Invalid {
-                    span: Span::new(BytePos(label.0 as _), BytePos(label.0 as _)),
-                }
-                .into();
             }
         }
 
@@ -2673,7 +2664,7 @@ impl Generator {
     ///
     /// - `expr`: The expression for the return statement.
     /// - `loc`: An optional source map location for the statement.
-    fn create_inline_return(&mut self, expr: Option<Expr>, loc: Option<Span>) -> ReturnStmt {
+    fn create_inline_return(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) -> ReturnStmt {
         ReturnStmt {
             span: loc.unwrap_or(DUMMY_SP),
             arg: Some(
@@ -2694,8 +2685,6 @@ impl Generator {
 
     /// Creates an expression that can be used to resume from a Yield operation.
     fn create_generator_resume(&mut self, loc: Option<Span>) -> Box<Expr> {
-        CallExpr {
-    fn create_generator_resume(&mut self, loc: Option<Span>) -> Expr {
         CallExpr {
             span: loc.unwrap_or(DUMMY_SP),
             callee: self
@@ -2730,7 +2719,7 @@ impl Generator {
     /// - `left`: The left-hand side of the assignment.
     /// - `right`: The right-hand side of the assignment.
     /// - `loc`: An optional source map location for the assignment.
-    fn emit_assignment(&mut self, left: AssignTarget, right: Expr, loc: Option<Span>) {
+    fn emit_assignment(&mut self, left: AssignTarget, right: Box<Expr>, loc: Option<Span>) {
         self.emit_worker(OpCode::Assign, Some(OpArgs::PatAndExpr(left, right)), loc);
     }
 
@@ -2748,7 +2737,7 @@ impl Generator {
     /// - `label`: A label.
     /// - `condition`: The condition.
     /// - `loc`: An optional source map location for the assignment.
-    fn emit_break_when_true(&mut self, label: Label, condition: Expr, loc: Option<Span>) {
+    fn emit_break_when_true(&mut self, label: Label, condition: Box<Expr>, loc: Option<Span>) {
         self.emit_worker(
             OpCode::BreakWhenTrue,
             Some(OpArgs::LabelExpr(label, condition)),
@@ -2762,7 +2751,7 @@ impl Generator {
     /// - `label`: A label.
     /// - `condition`: The condition.
     /// - `loc`: An optional source map location for the assignment.
-    fn emit_break_when_false(&mut self, label: Label, condition: Expr, loc: Option<Span>) {
+    fn emit_break_when_false(&mut self, label: Label, condition: Box<Expr>, loc: Option<Span>) {
         self.emit_worker(
             OpCode::BreakWhenFalse,
             Some(OpArgs::LabelExpr(label, condition)),
@@ -2774,7 +2763,7 @@ impl Generator {
     ///
     /// - `expr`: An optional value for the yield operation.
     /// - `loc`: An optional source map location for the assignment.
-    fn emit_yield_star(&mut self, expr: Option<Expr>, loc: Option<Span>) {
+    fn emit_yield_star(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) {
         self.emit_worker(OpCode::YieldStar, Some(OpArgs::OptExpr(expr)), loc);
     }
 
@@ -2782,7 +2771,7 @@ impl Generator {
     ///
     /// - `expr`: An optional value for the yield operation.
     /// - `loc`: An optional source map location for the assignment.
-    fn emit_yield(&mut self, expr: Option<Expr>, loc: Option<Span>) {
+    fn emit_yield(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) {
         self.emit_worker(OpCode::Yield, Some(OpArgs::OptExpr(expr)), loc);
     }
 
@@ -2790,7 +2779,7 @@ impl Generator {
     ///
     /// - `expr`: An optional value for the operation.
     /// - `loc`: An optional source map location for the assignment.
-    fn emit_return(&mut self, expr: Option<Expr>, loc: Option<Span>) {
+    fn emit_return(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) {
         self.emit_worker(OpCode::Return, Some(OpArgs::OptExpr(expr)), loc);
     }
 
@@ -2798,7 +2787,7 @@ impl Generator {
     ///
     /// - `expr`: A value for the operation.
     /// - `loc`: An optional source map location for the assignment.
-    fn emit_throw(&mut self, expr: Expr, loc: Option<Span>) {
+    fn emit_throw(&mut self, expr: Box<Expr>, loc: Option<Span>) {
         self.emit_worker(OpCode::Throw, Some(OpArgs::OptExpr(Some(expr))), loc);
     }
 
@@ -3277,7 +3266,7 @@ impl Generator {
     }
 
     /// Writes an Assign operation to the current label's statement list.
-    fn write_assign(&mut self, left: AssignTarget, right: Expr, op_loc: Option<Span>) {
+    fn write_assign(&mut self, left: AssignTarget, right: Box<Expr>, op_loc: Option<Span>) {
         self.write_stmt(Stmt::Expr(ExprStmt {
             span: op_loc.unwrap_or(DUMMY_SP),
             expr: AssignExpr {
@@ -3294,7 +3283,7 @@ impl Generator {
     ///
     /// @param expr The value to throw
     /// @param operationLocation The source map location for the operation.
-    fn write_throw(&mut self, expr: Expr, op_loc: Option<Span>) {
+    fn write_throw(&mut self, expr: Box<Expr>, op_loc: Option<Span>) {
         self.last_operation_was_abrupt = true;
         self.last_operation_was_completion = true;
 
@@ -3309,7 +3298,7 @@ impl Generator {
     ///
     /// @param label The label for the Break.
     /// @param operationLocation The source map location for the operation.
-    fn write_return(&mut self, expr: Option<Expr>, op_loc: Option<Span>) {
+    fn write_return(&mut self, expr: Option<Box<Expr>>, op_loc: Option<Span>) {
         self.last_operation_was_abrupt = true;
         self.last_operation_was_completion = true;
 
@@ -3359,7 +3348,7 @@ impl Generator {
     /// @param label The label for the Break.
     /// @param condition The condition for the Break.
     /// @param operationLocation The source map location for the operation.
-    fn write_break_when_true(&mut self, label: Label, cond: Expr, op_loc: Option<Span>) {
+    fn write_break_when_true(&mut self, label: Label, cond: Box<Expr>, op_loc: Option<Span>) {
         let inst = self.create_instruction(Instruction::Break);
         let label = self.create_label(Some(label));
         self.write_stmt(Stmt::If(IfStmt {
@@ -3384,7 +3373,7 @@ impl Generator {
     /// @param label The label for the Break.
     /// @param condition The condition for the Break.
     /// @param operationLocation The source map location for the operation.
-    fn write_break_when_false(&mut self, label: Label, cond: Expr, op_loc: Option<Span>) {
+    fn write_break_when_false(&mut self, label: Label, cond: Box<Expr>, op_loc: Option<Span>) {
         let inst = self.create_instruction(Instruction::Break);
         let label = self.create_label(Some(label));
         self.write_stmt(Stmt::If(IfStmt {
@@ -3413,7 +3402,7 @@ impl Generator {
     ///
     /// - expr: The expression to yield.
     /// - op_loc: The source map location for the operation.
-    fn write_yield(&mut self, expr: Option<Expr>, op_loc: Option<Span>) {
+    fn write_yield(&mut self, expr: Option<Box<Expr>>, op_loc: Option<Span>) {
         self.last_operation_was_abrupt = true;
 
         let inst = self.create_instruction(Instruction::Yield);
@@ -3441,7 +3430,7 @@ impl Generator {
     ///
     /// - expr: The expression to yield.
     /// - op_loc: The source map location for the operation.
-    fn write_yield_star(&mut self, expr: Expr, op_loc: Option<Span>) {
+    fn write_yield_star(&mut self, expr: Box<Expr>, op_loc: Option<Span>) {
         self.last_operation_was_abrupt = true;
 
         let arg1 = self.create_instruction(Instruction::YieldStar);
@@ -3508,13 +3497,21 @@ impl Generator {
     }
 
     /// Returns `(target, this_arg)`
-    fn create_call_binding(&mut self, expr: Expr, is_new_call: bool) -> (Expr, Expr) {
+    fn create_call_binding(
+        &mut self,
+        expr: Box<Expr>,
+        is_new_call: bool,
+    ) -> (Box<Expr>, Box<Expr>) {
         let mut callee = expr;
 
         match &mut *callee {
             Expr::Ident(..) => (
                 callee.clone(),
-                if is_new_call { callee } else { DUMMY_SP.into() },
+                if is_new_call {
+                    callee
+                } else {
+                    Expr::undefined(DUMMY_SP)
+                },
             ),
 
             Expr::Member(MemberExpr { obj, .. }) if !is_new_call => {
@@ -3531,7 +3528,7 @@ impl Generator {
 
             _ => {
                 if !is_new_call {
-                    (callee, DUMMY_SP.into())
+                    (callee, Expr::undefined(DUMMY_SP))
                 } else {
                     let this_arg = self.create_temp_variable();
                     let target = callee.make_assign_to(op!("="), this_arg.clone().into());
diff --git a/crates/swc_ecma_compat_es2015/src/new_target.rs b/crates/swc_ecma_compat_es2015/src/new_target.rs
index f41f678ba12a4..931d2a9628533 100644
--- a/crates/swc_ecma_compat_es2015/src/new_target.rs
+++ b/crates/swc_ecma_compat_es2015/src/new_target.rs
@@ -68,7 +68,7 @@ impl VisitMut for NewTarget {
             };
             match &self.ctx {
                 Ctx::Constructor => *e = this_ctor(*span),
-                Ctx::Method => *e = *DUMMY_SP.into(),
+                Ctx::Method => *e = *Expr::undefined(DUMMY_SP),
                 Ctx::Function(i) => {
                     *e = CondExpr {
                         span: *span,
diff --git a/crates/swc_ecma_compat_es2015/src/object_super.rs b/crates/swc_ecma_compat_es2015/src/object_super.rs
index 615569623dbb3..fc1a995661e04 100644
--- a/crates/swc_ecma_compat_es2015/src/object_super.rs
+++ b/crates/swc_ecma_compat_es2015/src/object_super.rs
@@ -184,13 +184,11 @@ impl SuperReplacer {
 
             ..Default::default()
         }
-        })
-        .into()
         .as_arg()
     }
 
     // .a -> "a"
-    fn normalize_computed_expr(&mut self, prop: &mut SuperProp) -> Expr {
+    fn normalize_computed_expr(&mut self, prop: &mut SuperProp) -> Box<Expr> {
         match prop.take() {
             SuperProp::Ident(IdentName {
                 sym: value, span, ..
@@ -355,7 +353,7 @@ impl SuperReplacer {
         .into()
     }
 
-    fn to_bin_expr(left: Expr, op: AssignOp, rhs: Expr) -> BinExpr {
+    fn to_bin_expr(left: Box<Expr>, op: AssignOp, rhs: Box<Expr>) -> BinExpr {
         BinExpr {
             span: DUMMY_SP,
             left,
@@ -392,7 +390,7 @@ impl SuperReplacer {
         is_update: bool,
         prop: &mut SuperProp,
         op: AssignOp,
-        rhs: Expr,
+        rhs: Box<Expr>,
         prefix: bool,
     ) -> Expr {
         let computed = match prop {
diff --git a/crates/swc_ecma_compat_es2015/src/parameters.rs b/crates/swc_ecma_compat_es2015/src/parameters.rs
index 217cf0f73bdbf..440dd3409e22e 100644
--- a/crates/swc_ecma_compat_es2015/src/parameters.rs
+++ b/crates/swc_ecma_compat_es2015/src/parameters.rs
@@ -158,17 +158,6 @@ impl Params {
                                         }
                                         .into(),
                                     ),
-                                    test: Box::new(Expr::Bin(BinExpr {
-                                        left: Box::new(check_arg_len(i)),
-                                        op: op!("&&"),
-                                        right: Box::new(Expr::Bin(BinExpr {
-                                            left: make_arg_nth(i).into(),
-                                            op: op!("!=="),
-                                            right: Expr::undefined(DUMMY_SP),
-                                            span: DUMMY_SP,
-                                        })),
-                                        span,
-                                    })),
                                     cons: make_arg_nth(i).into(),
                                     alt: right,
                                 }
@@ -188,7 +177,7 @@ impl Params {
                                 span: DUMMY_SP,
                                 left: Box::new(Ident::from(ident).into()),
                                 op: op!("==="),
-                                right: DUMMY_SP.into(),
+                                right: Expr::undefined(DUMMY_SP),
                             }
                             .into(),
                             cons: Box::new(Stmt::Expr(ExprStmt {
@@ -680,8 +669,6 @@ impl VisitMut for Params {
                             })),
                             ..Default::default()
                         }
-                        })
-                        .into()
                         .as_iife()
                         .into(),
                         _ => func,
@@ -822,16 +809,6 @@ fn check_arg_len(n: usize) -> Expr {
     BinExpr {
         left: Expr::Ident(Ident::new_no_ctxt("arguments".into(), DUMMY_SP))
             .make_member(IdentName::new("length".into(), DUMMY_SP))
-    Expr::Ident(Ident::new_no_ctxt("arguments".into(), DUMMY_SP)).computed_member(n)
-    Ident::new_no_ctxt("arguments".into(), DUMMY_SP)
-        .into()
-        .computed_member(n)
-}
-
-fn check_arg_len(n: usize) -> Expr {
-    BinExpr {
-        left: Expr::Ident(Ident::new_no_ctxt("arguments".into(), DUMMY_SP))
-            .make_member(Ident::new_no_ctxt("length".into(), DUMMY_SP))
             .into(),
         op: op!(">"),
         right: n.into(),
diff --git a/crates/swc_ecma_compat_es2015/src/spread.rs b/crates/swc_ecma_compat_es2015/src/spread.rs
index a9413d491e97d..195504e98daaa 100644
--- a/crates/swc_ecma_compat_es2015/src/spread.rs
+++ b/crates/swc_ecma_compat_es2015/src/spread.rs
@@ -95,7 +95,7 @@ impl VisitMut for Spread {
                         (obj.as_ident().unwrap().clone().into(), None)
                     }
 
-                    Expr::Ident(Ident { span, .. }) => (*span.into(), None),
+                    Expr::Ident(Ident { span, .. }) => (Expr::undefined(*span), None),
 
                     Expr::Member(MemberExpr { span, obj, prop }) => {
                         let ident = alias_ident_for(obj, "_instance");
@@ -110,8 +110,6 @@ impl VisitMut for Spread {
 
                         let this = ident.clone().into();
                         let callee: Expr = AssignExpr {
-                        let callee = Expr::Assign(AssignExpr {
-                        let callee = AssignExpr {
                             span: DUMMY_SP,
                             left: ident.into(),
                             op: op!("="),
@@ -318,7 +316,7 @@ impl Spread {
             if let Some(arg) = arg {
                 let ExprOrSpread { expr, spread } = arg;
 
-                fn to_consumable_array(expr: Expr, span: Span) -> CallExpr {
+                fn to_consumable_array(expr: Box<Expr>, span: Span) -> CallExpr {
                     if matches!(*expr, Expr::Lit(Lit::Str(..))) {
                         CallExpr {
                             span,
diff --git a/crates/swc_ecma_compat_es2015/src/template_literal.rs b/crates/swc_ecma_compat_es2015/src/template_literal.rs
index 61a9f191618be..312a260a81dc8 100644
--- a/crates/swc_ecma_compat_es2015/src/template_literal.rs
+++ b/crates/swc_ecma_compat_es2015/src/template_literal.rs
@@ -60,7 +60,7 @@ impl VisitMut for TemplateLiteral {
                 assert_eq!(quasis.len(), exprs.len() + 1);
 
                 // This makes result of addition string
-                let mut obj: Expr = Box::new(
+                let mut obj: Box<Expr> = Box::new(
                     Lit::Str({
                         let s = quasis[0]
                             .cooked
@@ -315,7 +315,6 @@ impl VisitMut for TemplateLiteral {
                         //     return data;
                         // };
                         let assign_expr: Expr = {
-                        let assign_expr = {
                             AssignExpr {
                                 span: DUMMY_SP,
                                 left: fn_ident.clone().into(),
diff --git a/crates/swc_ecma_compat_es2015/src/typeof_symbol.rs b/crates/swc_ecma_compat_es2015/src/typeof_symbol.rs
index c1744d9d59cf1..017d6cc68c947 100644
--- a/crates/swc_ecma_compat_es2015/src/typeof_symbol.rs
+++ b/crates/swc_ecma_compat_es2015/src/typeof_symbol.rs
@@ -65,7 +65,7 @@ impl VisitMut for TypeOfSymbol {
         {
             match &**arg {
                 Expr::Ident(..) => {
-                    let undefined_str: Expr = quote_str!("undefined").into();
+                    let undefined_str: Box<Expr> = quote_str!("undefined").into();
 
                     let test = BinExpr {
                         span: DUMMY_SP,
@@ -90,9 +90,6 @@ impl VisitMut for TypeOfSymbol {
                     }
                     .into();
 
-                    *expr = CondExpr {
-                    });
-
                     *expr = CondExpr {
                         span: *span,
                         test,
diff --git a/crates/swc_ecma_compat_es2016/src/exponentiation.rs b/crates/swc_ecma_compat_es2016/src/exponentiation.rs
index 5a5c1d5442711..82486ffd40b68 100644
--- a/crates/swc_ecma_compat_es2016/src/exponentiation.rs
+++ b/crates/swc_ecma_compat_es2016/src/exponentiation.rs
@@ -137,7 +137,7 @@ impl VisitMut for Exponentiation {
 }
 
 #[tracing::instrument(level = "info", skip_all)]
-fn mk_call(span: Span, left: Expr, right: Expr) -> Expr {
+fn mk_call(span: Span, left: Box<Expr>, right: Box<Expr>) -> Expr {
     // Math.pow()
     CallExpr {
         span,
diff --git a/crates/swc_ecma_compat_es2020/src/nullish_coalescing.rs b/crates/swc_ecma_compat_es2020/src/nullish_coalescing.rs
index 6baa0bd2335b7..c718dae7956a9 100644
--- a/crates/swc_ecma_compat_es2020/src/nullish_coalescing.rs
+++ b/crates/swc_ecma_compat_es2020/src/nullish_coalescing.rs
@@ -226,8 +226,6 @@ impl VisitMut for NullishCoalescing {
 
 #[tracing::instrument(level = "info", skip_all)]
 fn make_cond(c: Config, span: Span, alias: &Ident, var_expr: Expr, init: Box<Expr>) -> Expr {
-    if c.no_document_all {
-fn make_cond(c: Config, span: Span, alias: &Ident, var_expr: Expr, init: Expr) -> Expr {
     if c.no_document_all {
         CondExpr {
             span,