fix(es/minifier): don't eliminate class expr if some side effects contain this (#11003)

**Description:**

Manual reasoning:
> Um...There are some options to handle this problem:
> 1. Prefer size. Check if there's any `this` in the statement with side
effect. This could be inefficient and I'm not sure whether there's any
other corner case.
> 2. Prefer performance. Just like what oxc does, keep entire class
declarations if some static property contains side effect initializer.
>
> Since it's anti-pattern code, I'm not sure above options are worthy
just for this case...Maybe a better one is emitting warnings for all
those anti-pattern code. However, swc minifier doesn't diagnostic system
for minifier, and I don't know how many code in swc minifier is used for
handling such cases (so it could be redundant to introduce it now).

After some consideration I finally decide to directly add
`contains_this_expr` check for it.

**Related issue:**

 - Closes #10981

Author: CPunisher

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

@@ -668,27 +668,32 @@ impl Optimizer<'_> {
                     return Some(cls.take().into());
                 }
 
+                let Some(side_effects) =
+                    extract_class_side_effect(self.ctx.expr_ctx, &mut cls.class)
+                else {
+                    return Some(cls.take().into());
+                };
+
                 report_change!(
                     "ignore_return_value: Dropping unused class expr as it does not have any side \
                      effect"
                 );
                 self.changed = true;
 
-                let exprs: Vec<Box<Expr>> =
-                    extract_class_side_effect(self.ctx.expr_ctx, *cls.class.take())
-                        .into_iter()
-                        .filter_map(|mut e| self.ignore_return_value(&mut e))
-                        .map(Box::new)
-                        .collect();
+                let side_effects: Vec<Box<Expr>> = side_effects
+                    .into_iter()
+                    .filter_map(|e| self.ignore_return_value(e))
+                    .map(Box::new)
+                    .collect();
 
-                if exprs.is_empty() {
+                if side_effects.is_empty() {
                     return None;
                 }
 
                 return Some(
                     SeqExpr {
                         span: cls.class.span,
-                        exprs,
+                        exprs: side_effects,
                     }
                     .into(),
                 );

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

@@ -521,34 +521,43 @@ impl Optimizer<'_> {
                     .map(|v| v.usage_count == 0 && v.property_mutation_count == 0)
                     .unwrap_or(false)
                 {
+                    let class = decl.as_mut_class().unwrap();
+                    let Some(side_effects) =
+                        extract_class_side_effect(self.ctx.expr_ctx, &mut class.class)
+                    else {
+                        return;
+                    };
+
                     self.changed = true;
                     report_change!(
                         "unused: Dropping a decl '{}{:?}' because it is not used",
                         ident.sym,
                         ident.ctxt
                     );
-                    // This will remove the declaration.
-                    let class = decl.take().class().unwrap();
-                    let mut side_effects =
-                        extract_class_side_effect(self.ctx.expr_ctx, *class.class);
-
-                    if !side_effects.is_empty() {
-                        self.prepend_stmts.push(
-                            ExprStmt {
-                                span: DUMMY_SP,
-                                expr: if side_effects.len() > 1 {
-                                    SeqExpr {
-                                        span: DUMMY_SP,
-                                        exprs: side_effects,
-                                    }
-                                    .into()
-                                } else {
-                                    side_effects.remove(0)
-                                },
-                            }
-                            .into(),
-                        )
+
+                    let mut side_effects: Vec<_> =
+                        side_effects.into_iter().map(|expr| expr.take()).collect();
+                    decl.take();
+
+                    if side_effects.is_empty() {
+                        return;
                     }
+
+                    self.prepend_stmts.push(
+                        ExprStmt {
+                            span: DUMMY_SP,
+                            expr: if side_effects.len() > 1 {
+                                SeqExpr {
+                                    span: DUMMY_SP,
+                                    exprs: side_effects,
+                                }
+                                .into()
+                            } else {
+                                side_effects.remove(0)
+                            },
+                        }
+                        .into(),
+                    );
                 }
             }
             Decl::Fn(FnDecl { ident, .. }) => {

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

@@ -8,7 +8,7 @@ use swc_atoms::Atom;
 use swc_common::{util::take::Take, Mark, SyntaxContext, DUMMY_SP};
 use swc_ecma_ast::*;
 use swc_ecma_transforms_base::perf::{Parallel, ParallelExt};
-use swc_ecma_utils::{collect_decls, ExprCtx, ExprExt, Remapper};
+use swc_ecma_utils::{collect_decls, contains_this_expr, ExprCtx, ExprExt, Remapper};
 use swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};
 use tracing::debug;
 
@@ -161,34 +161,40 @@ impl Drop for WithCtx<'_, '_> {
     }
 }
 
-pub(crate) fn extract_class_side_effect(expr_ctx: ExprCtx, c: Class) -> Vec<Box<Expr>> {
+pub(crate) fn extract_class_side_effect(
+    expr_ctx: ExprCtx,
+    c: &mut Class,
+) -> Option<Vec<&mut Box<Expr>>> {
     let mut res = Vec::new();
-    if let Some(e) = c.super_class {
+    if let Some(e) = &mut c.super_class {
         if e.may_have_side_effects(expr_ctx) {
             res.push(e);
         }
     }
 
-    for m in c.body {
+    for m in &mut c.body {
         match m {
             ClassMember::Method(ClassMethod {
                 key: PropName::Computed(key),
                 ..
             }) => {
                 if key.expr.may_have_side_effects(expr_ctx) {
-                    res.push(key.expr);
+                    res.push(&mut key.expr);
                 }
             }
 
             ClassMember::ClassProp(p) => {
-                if let PropName::Computed(key) = p.key {
+                if let PropName::Computed(key) = &mut p.key {
                     if key.expr.may_have_side_effects(expr_ctx) {
-                        res.push(key.expr);
+                        res.push(&mut key.expr);
                     }
                 }
 
-                if let Some(v) = p.value {
+                if let Some(v) = &mut p.value {
                     if p.is_static && v.may_have_side_effects(expr_ctx) {
+                        if contains_this_expr(v) {
+                            return None;
+                        }
                         res.push(v);
                     }
                 }
@@ -199,6 +205,9 @@ pub(crate) fn extract_class_side_effect(expr_ctx: ExprCtx, c: Class) -> Vec<Box<
                 ..
             }) => {
                 if v.may_have_side_effects(expr_ctx) {
+                    if contains_this_expr(v) {
+                        return None;
+                    }
                     res.push(v);
                 }
             }
@@ -207,7 +216,7 @@ pub(crate) fn extract_class_side_effect(expr_ctx: ExprCtx, c: Class) -> Vec<Box<
         }
     }
 
-    res
+    Some(res)
 }
 
 pub(crate) fn is_valid_for_lhs(e: &Expr) -> bool {

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

@@ -0,0 +1,15 @@
+class C {
+    static foo = bar;
+}
+
+(class C {
+    static foo = bar;
+});
+
+class D {
+    static #_ = (this.FOO = {});
+}
+
+(class D {
+    static #_ = (this.FOO = {});
+});

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

@@ -0,0 +1,10 @@
+class C {
+    static foo = bar;
+}
+bar;
+class D {
+    static #_ = this.FOO = {};
+}
+(class {
+    static #_ = this.FOO = {};
+});