swc-project · kdy1 · Nov 17, 2025 · Nov 10, 2025 · Nov 10, 2025 · Nov 10, 2025
@@ -0,0 +1,6 @@
+---
+swc_core: patch
+swc_ecma_minifier: patch
+---
+
+fix(es/minifier): Prevent compress.comparisons from transforming expressions with side effects
@@ -42,7 +42,10 @@ impl Optimizer<'_> {
         }
 
         if e.op == op!("===") || e.op == op!("!==") {
-            if (e.left.is_ident() || e.left.is_member()) && e.left.eq_ignore_span(&e.right) {
+            if (e.left.is_ident() || e.left.is_member())
+                && e.left.eq_ignore_span(&e.right)
+                && !contains_update_or_assign(&e.left)
+            {
                 self.changed = true;
                 report_change!("Reducing comparison of same variable ({})", e.op);
 
@@ -288,3 +291,71 @@ impl Optimizer<'_> {
         }
     }
 }
+
+/// Check if an expression contains update expressions (++, --) or assignments
+/// that would make duplicate evaluations produce different results.
+fn contains_update_or_assign(expr: &Expr) -> bool {
+    match expr {
+        Expr::Update(..) | Expr::Assign(..) => true,
+
+        Expr::Bin(BinExpr { left, right, .. }) => {
+            contains_update_or_assign(left) || contains_update_or_assign(right)
+        }
+
+        Expr::Unary(UnaryExpr { arg, .. }) => contains_update_or_assign(arg),
+
+        Expr::Cond(CondExpr {
+            test, cons, alt, ..
+        }) => {
+            contains_update_or_assign(test)
+                || contains_update_or_assign(cons)
+                || contains_update_or_assign(alt)
+        }
+
+        Expr::Member(MemberExpr { obj, prop, .. }) => {
+            contains_update_or_assign(obj)
+                || match prop {
+                    MemberProp::Computed(ComputedPropName { expr, .. }) => {
+                        contains_update_or_assign(expr)
+                    }
+                    _ => false,
+                }
+        }
+
+        Expr::Call(CallExpr {
+            callee: Callee::Expr(callee),
+            args,
+            ..
+        }) => {
+            contains_update_or_assign(callee)
+                || args.iter().any(|arg| contains_update_or_assign(&arg.expr))
+        }
+
+        Expr::Seq(SeqExpr { exprs, .. }) => {
+            exprs.iter().any(|expr| contains_update_or_assign(expr))
+        }
+
+        Expr::Paren(ParenExpr { expr, .. }) => contains_update_or_assign(expr),
+
+        Expr::OptChain(OptChainExpr { base, .. }) => match &**base {
+            OptChainBase::Member(member) => {
+                contains_update_or_assign(&member.obj)
+                    || match &member.prop {
+                        MemberProp::Computed(ComputedPropName { expr, .. }) => {
+                            contains_update_or_assign(expr)
+                        }
+                        _ => false,
+                    }
+            }
+            OptChainBase::Call(call) => {
+                contains_update_or_assign(&call.callee)
+                    || call
+                        .args
+                        .iter()
+                        .any(|arg| contains_update_or_assign(&arg.expr))
+            }
+        },
+
-
+
+        Expr::Await(AwaitExpr { arg, .. }) => contains_update_or_assign(arg),
-
+
+        Expr::TaggedTpl(TaggedTpl { tag, tpl, .. }) => {
+            contains_update_or_assign(tag)
+                || tpl.exprs.iter().any(|expr| contains_update_or_assign(expr))
+        }
-
+
+        Expr::SuperProp(SuperPropExpr { prop, .. }) => match prop {
+            SuperProp::Computed(ComputedPropName { expr, .. }) => {
+                contains_update_or_assign(expr)
+            }
+            _ => false,
+        },
-
+
+        Expr::Yield(YieldExpr { arg, .. }) => {
+            arg.as_ref()
+                .map(|arg| contains_update_or_assign(arg))
+                .unwrap_or(false)
+        }
-
+
+        // Handle TypeScript-specific expression wrappers
+        Expr::TsTypeAssertion(TsTypeAssertion { expr, .. })
+        | Expr::TsConstAssertion(TsConstAssertion { expr, .. })
+        | Expr::TsNonNull(TsNonNullExpr { expr, .. })
+        | Expr::TsAs(TsAsExpr { expr, .. })
+        | Expr::TsInstantiation(TsInstantiation { expr, .. })
+        | Expr::TsSatisfies(TsSatisfiesExpr { expr, .. }) => contains_update_or_assign(expr),
-
+
+        Expr::Await(AwaitExpr { arg, .. }) => contains_update_or_assign(arg),
-
+
+        Expr::TaggedTpl(TaggedTpl { tag, tpl, .. }) => {
+            contains_update_or_assign(tag)
+                || tpl.exprs.iter().any(|expr| contains_update_or_assign(expr))
+        }
-
+
+        Expr::SuperProp(SuperPropExpr { prop, .. }) => match prop {
+            SuperProp::Computed(ComputedPropName { expr, .. }) => {
+                contains_update_or_assign(expr)
+            }
+            _ => false,
+        },
-
+
+        Expr::Yield(YieldExpr { arg, .. }) => {
+            arg.as_ref()
+                .map(|arg| contains_update_or_assign(arg))
+                .unwrap_or(false)
+        }
-
+
+        // Handle TypeScript-specific expression wrappers
+        Expr::TsTypeAssertion(TsTypeAssertion { expr, .. })
+        | Expr::TsConstAssertion(TsConstAssertion { expr, .. })
+        | Expr::TsNonNull(TsNonNullExpr { expr, .. })
+        | Expr::TsAs(TsAsExpr { expr, .. })
+        | Expr::TsInstantiation(TsInstantiation { expr, .. })
+        | Expr::TsSatisfies(TsSatisfiesExpr { expr, .. }) => contains_update_or_assign(expr),
+        _ => false,
+    }
+}
-
-        _ => false,
-    }
-}
+
+        Expr::Object(ObjectLit { props, .. }) => {
+            props.iter().any(|prop| match prop {
+                PropOrSpread::Spread(SpreadElement { expr, .. }) => {
+                    contains_update_or_assign(expr)
+                }
+                PropOrSpread::Prop(prop) => match &**prop {
+                    Prop::KeyValue(KeyValueProp { key, value }) => {
+                        check_prop_name_for_side_effects(key)
+                            || contains_update_or_assign(value)
+                    }
+                    Prop::Assign(AssignProp { value, .. }) => {
+                        contains_update_or_assign(value)
+                    }
+                    Prop::Getter(GetterProp { key, .. })
+                    | Prop::Setter(SetterProp { key, .. })
+                    | Prop::Method(MethodProp { key, .. }) => {
+                        check_prop_name_for_side_effects(key)
+                    }
+                    Prop::Shorthand(_) => false,
+                },
+            })
+        }
+
+        _ => false,
+    }
+}
+
+/// Checks if a property name contains side effects, i.e., if it's a computed property whose expression contains update or assignment.
+fn check_prop_name_for_side_effects(key: &PropName) -> bool {
+    match key {
+        PropName::Computed(ComputedPropName { expr, .. }) => contains_update_or_assign(expr),
+        _ => false,
+    }
+}
-
-        _ => false,
-    }
-}
+
+        Expr::Object(ObjectLit { props, .. }) => {
+            props.iter().any(|prop| match prop {
+                PropOrSpread::Spread(SpreadElement { expr, .. }) => {
+                    contains_update_or_assign(expr)
+                }
+                PropOrSpread::Prop(prop) => match &**prop {
+                    Prop::KeyValue(KeyValueProp { key, value }) => {
+                        check_prop_name_for_side_effects(key)
+                            || contains_update_or_assign(value)
+                    }
+                    Prop::Assign(AssignProp { value, .. }) => {
+                        contains_update_or_assign(value)
+                    }
+                    Prop::Getter(GetterProp { key, .. })
+                    | Prop::Setter(SetterProp { key, .. })
+                    | Prop::Method(MethodProp { key, .. }) => {
+                        check_prop_name_for_side_effects(key)
+                    }
+                    Prop::Shorthand(_) => false,
+                },
+            })
+        }
+
+        _ => false,
+    }
+}
+
+/// Checks if a property name contains side effects, i.e., if it's a computed property whose expression contains update or assignment.
+fn check_prop_name_for_side_effects(key: &PropName) -> bool {
+    match key {
+        PropName::Computed(ComputedPropName { expr, .. }) => contains_update_or_assign(expr),
+        _ => false,
+    }
+}
@@ -0,0 +1,3 @@
+{
+    "comparisons": true
+}
@@ -0,0 +1,5 @@
+// Issue #11255: compress.comparisons should not optimize comparisons with side effects
+let PC = 0;
+const Stack = [0, ''];
+const Code = [0, 0, 1];
+console.log(Stack[Code[++PC]] === Stack[Code[++PC]]);
@@ -0,0 +1,5 @@
+// Issue #11255: compress.comparisons should not optimize comparisons with side effects
+let PC = 0;
+const Stack = [0, ''];
+const Code = [0, 0, 1];
+console.log(Stack[Code[++PC]] === Stack[Code[++PC]]);
@@ -0,0 +1,12 @@
+// Issue #11255: compress.comparisons should not optimize comparisons with side effects
+let o = 0;
+const c = [
+    0,
+    ''
+];
+const l = [
+    0,
+    0,
+    1
+];
+console.log(c[l[++o]] === c[l[++o]]);