fix(minifier): Do not merge if statements with different local variable values

The `merge_similar_ifs` function was using `SyntaxContext::within_ignored_ctxt()` when comparing if statement consequence blocks. This made identifiers with the same name but different syntax contexts (different local variables) compare as equal, causing incorrect merging.

Fixes #11517

Co-authored-by: Donny/강동윤 <kdy1@users.noreply.github.com>

Author: github-actions[bot]

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

@@ -1,6 +1,6 @@
 use std::mem::swap;
 
-use swc_common::{util::take::Take, EqIgnoreSpan, Spanned, SyntaxContext, DUMMY_SP};
+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;
@@ -119,9 +119,12 @@ impl Optimizer<'_> {
                     (
                         Some(Stmt::If(l @ IfStmt { alt: None, .. })),
                         Some(Stmt::If(r @ IfStmt { alt: None, .. })),
-                    ) => SyntaxContext::within_ignored_ctxt(|| {
+                    ) => {
+                        // We should NOT ignore syntax context here because the cons blocks
+                        // may contain references to local variables with the same name but
+                        // different values. See https://github.com/swc-project/swc/issues/11517
                         l.cons.eq_ignore_span(&r.cons) && l.cons.terminates()
-                    }),
+                    }
                     _ => false,
                 });
         if !has_work {
@@ -143,9 +146,11 @@ impl Optimizer<'_> {
                             match &mut cur {
                                 Some(cur_if) => {
                                     // If cons is same, we merge conditions.
-                                    if SyntaxContext::within_ignored_ctxt(|| {
-                                        cur_if.cons.eq_ignore_span(&stmt.cons)
-                                    }) {
+                                    // We should NOT ignore syntax context here because the cons
+                                    // blocks may contain references to local variables with the
+                                    // same name but different values.
+                                    // See https://github.com/swc-project/swc/issues/11517
+                                    if cur_if.cons.eq_ignore_span(&stmt.cons) {
                                         cur_if.test = BinExpr {
                                             span: DUMMY_SP,
                                             left: cur_if.test.take(),

crates/swc_ecma_minifier/tests/exec.rs

@@ -11498,7 +11498,39 @@ function printError() {
 }
 
 printError()
-    
+
+        ",
+    );
+}
+
+#[test]
+fn issue_11517() {
+    // Test that the minifier does not incorrectly merge if statements with
+    // similar structures but different string literal values in local variables.
+    run_default_exec_test(
+        "
+const buildErrorLog = ({
+  errorType,
+  mode,
+}) => {
+  const isModeA = mode === 'modeA';
+  const isModeB = mode === 'modeB';
+
+  if (errorType === 'A_ERROR') {
+    const message = 'A error occured';
+    return { fieldX: true, fieldY: true, message };
+  }
+  if (errorType === 'B_ERROR') {
+    const message = 'B error occured';
+    return { fieldX: true, fieldY: true, message };
+  }
+  return { fieldX: true, fieldY: true, message: 'Invalid configuration' };
+};
+
+const resultA = buildErrorLog({ errorType: 'A_ERROR', mode: 'modeA' });
+const resultB = buildErrorLog({ errorType: 'B_ERROR', mode: 'modeB' });
+console.log('A:', resultA.message);
+console.log('B:', resultB.message);
         ",
     );
 }