fix(es/minifier): Fix termination detection (#10741)

**Description:**

`terminates()` of `swc_ecma_utils` was wrong.

**Related issue:**

 - Closes #10720

Author: kdy1

.changeset/warm-lamps-prove.md

@@ -0,0 +1,6 @@
+---
+swc_core: patch
+swc_ecma_utils: patch
+---
+
+fix(es/minifier): Fix termination detection 

crates/swc_ecma_minifier/tests/fixture/issues/10720/input.js

@@ -0,0 +1,19 @@
+export function someFn({
+    someVal,
+    shouldBreak
+}) {
+    switch (someVal) {
+        case 'one':
+            // if there is a certain condition, we exit
+            if (shouldBreak === 'break') {
+                break
+            }
+
+            return 1
+        default:
+            return 0
+    }
+
+    // this code gets hit if we break
+    return 11
+}

crates/swc_ecma_minifier/tests/fixture/issues/10720/output.js

@@ -0,0 +1,12 @@
+export function someFn({ someVal, shouldBreak }) {
+    switch(someVal){
+        case 'one':
+            // if there is a certain condition, we exit
+            if ('break' === shouldBreak) break;
+            return 1;
+        default:
+            return 0;
+    }
+    // this code gets hit if we break
+    return 11;
+}

crates/swc_ecma_minifier/tests/fixture/next/wrap-contracts/output.js

@@ -25989,8 +25989,7 @@ class Zip {
                                 throw Error(`Support for ${contractDefinition.srcWasmLang} not implemented yet.`);
                         }
                         return this.logger.info(`WASM ${contractDefinition.srcWasmLang} handler created in ${benchmark.elapsed()}`), new WasmHandlerApi_1.WasmHandlerApi(swGlobal, contractDefinition, jsExports || wasmInstance.exports);
-                    }
-                    {
+                    } else {
                         this.logger.info('Creating handler for js contract', contractDefinition.txId);
                         const normalizedSource = (0, normalize_source_1.normalizeContractSource)(contractDefinition.src, evaluationOptions.useVM2);
                         if (!evaluationOptions.allowUnsafeClient && normalizedSource.includes('SmartWeave.unsafeClient')) throw Error('Using unsafeClient is not allowed by default. Use EvaluationOptions.allowUnsafeClient flag.');

crates/swc_ecma_minifier/tests/libs-size.snapshot.md

@@ -9,6 +9,6 @@
 | react.js | 70.45 KiB | 22.44 KiB | 8.04 KiB |
 | terser.js | 1.08 MiB | 446.68 KiB | 120.49 KiB |
 | three.js | 1.19 MiB | 630.83 KiB | 154.80 KiB |
-| typescript.js | 10.45 MiB | 3.17 MiB | 840.67 KiB |
+| typescript.js | 10.45 MiB | 3.17 MiB | 840.66 KiB |
 | victory.js | 2.30 MiB | 694.16 KiB | 154.24 KiB |
 | vue.js | 334.13 KiB | 113.72 KiB | 41.82 KiB |

crates/swc_ecma_utils/src/lib.rs

@@ -467,24 +467,64 @@ pub trait StmtExt {
 
     /// stmts contain top level return/break/continue/throw
     fn terminates(&self) -> bool {
-        fn terminates_many(stmts: &[Stmt], allow_break: bool, allow_throw: bool) -> bool {
+        fn terminates_many(
+            stmts: &[Stmt],
+            in_switch: bool,
+            allow_break: bool,
+            allow_throw: bool,
+        ) -> Result<bool, ()> {
             stmts
                 .iter()
                 .rev()
-                .any(|s| terminates(s, allow_break, allow_throw))
-        }
-
-        fn terminates(stmt: &Stmt, allow_break: bool, allow_throw: bool) -> bool {
-            match stmt {
-                Stmt::Break(_) => allow_break,
+                .map(|s| terminates(s, in_switch, allow_break, allow_throw))
+                .try_fold(false, |acc, x| x.map(|v| acc || v))
+        }
+
+        fn terminates(
+            stmt: &Stmt,
+            in_switch: bool,
+            allow_break: bool,
+            allow_throw: bool,
+        ) -> Result<bool, ()> {
+            Ok(match stmt {
+                Stmt::Break(_) => {
+                    if in_switch {
+                        // In case of `break` in switch, we should stop the analysis because the
+                        // statements after `if (foo) break;` may not execute.
+                        //
+                        // So the `return 1` in
+                        //
+                        // ```js
+                        // switch (foo) {
+                        //   case 1:
+                        //     if (bar) break;
+                        //     return 1;
+                        //   default:
+                        //     return 0;
+                        // }
+                        // ```
+                        //
+                        // may not execute and we should return `false`.
+                        return Err(());
+                    } else {
+                        allow_break
+                    }
+                }
                 Stmt::Throw(_) => allow_throw,
                 Stmt::Continue(_) | Stmt::Return(_) => true,
-                Stmt::Block(block) => terminates_many(&block.stmts, allow_break, allow_throw),
-                Stmt::If(IfStmt {
-                    cons,
-                    alt: Some(alt),
-                    ..
-                }) => cons.terminates() && alt.terminates(),
+                Stmt::Block(block) => {
+                    terminates_many(&block.stmts, in_switch, allow_break, allow_throw)?
+                }
+                Stmt::If(IfStmt { cons, alt, .. }) => {
+                    if let Some(alt) = alt {
+                        terminates(cons, in_switch, allow_break, allow_throw)?
+                            && terminates(alt, in_switch, allow_break, allow_throw)?
+                    } else {
+                        terminates(cons, in_switch, allow_break, allow_throw)?;
+
+                        false
+                    }
+                }
                 Stmt::Switch(s) => {
                     let mut has_default = false;
                     let mut has_non_empty_terminates = false;
@@ -495,12 +535,12 @@ pub trait StmtExt {
                         }
 
                         if !case.cons.is_empty() {
-                            let t = terminates_many(&case.cons, false, allow_throw);
+                            let t = terminates_many(&case.cons, true, false, allow_throw)?;
 
                             if t {
                                 has_non_empty_terminates = true
                             } else {
-                                return false;
+                                return Ok(false);
                             }
                         }
                     }
@@ -509,17 +549,17 @@ pub trait StmtExt {
                 }
                 Stmt::Try(t) => {
                     if let Some(h) = &t.handler {
-                        terminates_many(&t.block.stmts, allow_break, false)
-                            && terminates_many(&h.body.stmts, allow_break, allow_throw)
+                        terminates_many(&t.block.stmts, in_switch, allow_break, false)?
+                            && terminates_many(&h.body.stmts, in_switch, allow_break, allow_throw)?
                     } else {
-                        terminates_many(&t.block.stmts, allow_break, allow_throw)
+                        terminates_many(&t.block.stmts, in_switch, allow_break, allow_throw)?
                     }
                 }
                 _ => false,
-            }
+            })
         }
 
-        terminates(self.as_stmt(), true, true)
+        terminates(self.as_stmt(), false, true, true) == Ok(true)
     }
 
     fn may_have_side_effects(&self, ctx: ExprCtx) -> bool {