refactor(es/minifier): Don't create invalid nodes (#6191)

**Description:**

A sequential expression should have at leat two elements.

crates/swc/tests/tsc.rs

@@ -413,6 +413,8 @@ fn matrix(input: &Path) -> Vec<TestUnitData> {
 }
 
 fn compile(output: &Path, test_unit_data: TestUnitData) {
+    let _testing = testing::init();
+
     let cm = test_unit_data.cm;
 
     let c = Compiler::new(cm.clone());

crates/swc_ecma_minifier/src/compress/optimize/conditionals.rs

@@ -3,6 +3,7 @@ use std::mem::swap;
 use swc_common::{util::take::Take, EqIgnoreSpan, Spanned, DUMMY_SP};
 use swc_ecma_ast::*;
 use swc_ecma_transforms_base::ext::ExprRefExt;
+use swc_ecma_transforms_optimization::debug_assert_valid;
 use swc_ecma_utils::{ExprExt, ExprFactory, StmtExt, StmtLike};
 
 use super::Optimizer;
@@ -282,7 +283,10 @@ where
         };
 
         let new_expr = self.compress_similar_cons_alt(&mut stmt.test, cons, alt, true);
+
         if let Some(v) = new_expr {
+            debug_assert_valid(&v);
+
             self.changed = true;
             *s = Stmt::Expr(ExprStmt {
                 span: stmt.span,
@@ -346,6 +350,9 @@ where
         alt: &mut Expr,
         is_for_if_stmt: bool,
     ) -> Option<Expr> {
+        debug_assert_valid(cons);
+        debug_assert_valid(alt);
+
         if cons.eq_ignore_span(alt) && !matches!(&*cons, Expr::Yield(..) | Expr::Fn(..)) {
             report_change!("conditionals: cons is same as alt");
             return Some(Expr::Seq(SeqExpr {
@@ -578,10 +585,7 @@ where
                     span: DUMMY_SP,
                     left: test.take(),
                     op: op!("||"),
-                    right: Box::new(Expr::Seq(SeqExpr {
-                        span: alt.span,
-                        exprs: alt.exprs.take(),
-                    })),
+                    right: Expr::from_exprs(alt.exprs.take()),
                 }));
                 Some(Expr::Seq(SeqExpr {
                     span: DUMMY_SP,
@@ -601,10 +605,7 @@ where
                     span: DUMMY_SP,
                     left: test.take(),
                     op: op!("&&"),
-                    right: Box::new(Expr::Seq(SeqExpr {
-                        span: cons.span,
-                        exprs: cons.exprs.take(),
-                    })),
+                    right: Expr::from_exprs(cons.exprs.take()),
                 }));
                 Some(Expr::Seq(SeqExpr {
                     span: DUMMY_SP,

crates/swc_ecma_minifier/src/compress/optimize/if_return.rs

@@ -1,5 +1,6 @@
 use swc_common::{util::take::Take, Spanned, DUMMY_SP};
 use swc_ecma_ast::*;
+use swc_ecma_transforms_optimization::debug_assert_valid;
 use swc_ecma_utils::{undefined, StmtExt, StmtLike};
 use swc_ecma_visit::{noop_visit_type, Visit, VisitWith};
 
@@ -55,6 +56,8 @@ where
 
         for stmt in stmts.iter_mut() {
             self.merge_nested_if_returns(stmt, terminates);
+
+            debug_assert_valid(&*stmt);
         }
 
         if terminates || is_fn_body {
@@ -69,12 +72,18 @@ where
         match s {
             Stmt::Block(s) => {
                 self.merge_if_returns(&mut s.stmts, terminate, false);
+
+                debug_assert_valid(&*s);
             }
             Stmt::If(s) => {
                 self.merge_nested_if_returns(&mut s.cons, can_work);
 
+                debug_assert_valid(&s.cons);
+
                 if let Some(alt) = s.alt.as_deref_mut() {
                     self.merge_nested_if_returns(alt, can_work);
+
+                    debug_assert_valid(&*alt);
                 }
             }
             _ => {}
@@ -366,6 +375,8 @@ where
         }
 
         if let Some(mut cur) = cur {
+            self.normalize_expr(&mut cur);
+
             match &*cur {
                 Expr::Seq(seq)
                     if !should_preserve_last_return

crates/swc_ecma_minifier/src/compress/optimize/iife.rs

@@ -450,7 +450,6 @@ where
             Callee::Super(_) | Callee::Import(_) => return,
             Callee::Expr(e) => &mut **e,
         };
-        self.normalize_expr(callee);
 
         if self.ctx.dont_invoke_iife {
             log_abort!("iife: Inline is prevented");
@@ -582,10 +581,7 @@ where
                         exprs.push(body.take());
 
                         report_change!("inline: Inlining a call to an arrow function");
-                        *e = Expr::Seq(SeqExpr {
-                            span: DUMMY_SP,
-                            exprs,
-                        });
+                        *e = *Expr::from_exprs(exprs);
                         e.visit_mut_with(self);
                     }
                 }
@@ -986,7 +982,9 @@ where
                     };
                     self.merge_sequences_in_seq_expr(&mut e);
 
-                    return Some(Expr::Seq(e));
+                    let mut e = Expr::Seq(e);
+                    self.normalize_expr(&mut e);
+                    return Some(e);
                 }
                 _ => {}
             }
@@ -1008,7 +1006,9 @@ where
         };
         self.merge_sequences_in_seq_expr(&mut e);
 
-        Some(Expr::Seq(e))
+        let mut e = Expr::Seq(e);
+        self.normalize_expr(&mut e);
+        Some(e)
     }
 
     fn can_be_inlined_for_iife(&self, arg: &Expr) -> bool {