feat(minifier): remove unused private class members (#14026)

sapphi-red · sapphi-red · commit aac45ef6bbc2 · 2025-09-24T03:34:31.000Z
Compress
```js
class C {
  #unused = 1;
  #used = 2;
  method() { return this.#used; }
}
```
to
```js
class C {
  #used = 2;
  method() { return this.#used; }
}
```
.

The symbol usage is collected in the main traverse. The removal happens in `exit_class_body`. This way we don't need additional traverse.
diff --git a/crates/oxc_minifier/src/peephole/mod.rs b/crates/oxc_minifier/src/peephole/mod.rs
@@ -13,6 +13,7 @@ mod normalize;
 mod remove_dead_code;
 mod remove_unused_declaration;
 mod remove_unused_expression;
+mod remove_unused_private_members;
 mod replace_known_methods;
 mod substitute_alternate_syntax;
 
@@ -123,6 +124,7 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
                 ctx.scoping_mut().delete_reference(*reference_id_to_remove);
             }
         }
+        debug_assert!(ctx.state.class_symbols_stack.is_empty());
     }
 
     fn exit_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) {
@@ -362,15 +364,37 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
         Self::convert_to_dotted_properties(expr, &ctx);
     }
 
+    fn enter_class_body(&mut self, _body: &mut ClassBody<'a>, ctx: &mut TraverseCtx<'a>) {
+        ctx.state.class_symbols_stack.push_class_scope();
+    }
+
     fn exit_class_body(&mut self, body: &mut ClassBody<'a>, ctx: &mut TraverseCtx<'a>) {
         let ctx = &mut Ctx::new(ctx);
         Self::remove_dead_code_exit_class_body(body, ctx);
+        Self::remove_unused_private_members(body, ctx);
+        ctx.state.class_symbols_stack.pop_class_scope();
     }
 
     fn exit_catch_clause(&mut self, catch: &mut CatchClause<'a>, ctx: &mut TraverseCtx<'a>) {
         let ctx = Ctx::new(ctx);
         Self::substitute_catch_clause(catch, &ctx);
     }
+
+    fn exit_private_field_expression(
+        &mut self,
+        node: &mut PrivateFieldExpression<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+        ctx.state.class_symbols_stack.push_private_member_to_current_class(node.field.name);
+    }
+
+    fn exit_private_in_expression(
+        &mut self,
+        node: &mut PrivateInExpression<'a>,
+        ctx: &mut TraverseCtx<'a>,
+    ) {
+        ctx.state.class_symbols_stack.push_private_member_to_current_class(node.left.name);
+    }
 }
 
 pub struct DeadCodeElimination {
diff --git a/crates/oxc_minifier/src/peephole/remove_unused_private_members.rs b/crates/oxc_minifier/src/peephole/remove_unused_private_members.rs
@@ -0,0 +1,157 @@
+use oxc_ast::ast::*;
+use oxc_ecmascript::side_effects::MayHaveSideEffects;
+
+use crate::ctx::Ctx;
+
+use super::PeepholeOptimizations;
+
+impl<'a> PeepholeOptimizations {
+    /// Remove unused private fields and methods from class body
+    ///
+    /// This function uses the private member usage collected during the main traverse
+    /// to remove unused private fields and methods from the class body.
+    pub fn remove_unused_private_members(body: &mut ClassBody<'a>, ctx: &mut Ctx<'a, '_>) {
+        let old_len = body.body.len();
+        body.body.retain(|element| match element {
+            ClassElement::PropertyDefinition(prop) => {
+                let PropertyKey::PrivateIdentifier(private_id) = &prop.key else {
+                    return true;
+                };
+                if ctx
+                    .state
+                    .class_symbols_stack
+                    .is_private_member_used_in_current_class(&private_id.name)
+                {
+                    return true;
+                }
+                prop.value.as_ref().is_some_and(|value| value.may_have_side_effects(ctx))
+            }
+            ClassElement::MethodDefinition(method) => {
+                let PropertyKey::PrivateIdentifier(private_id) = &method.key else {
+                    return true;
+                };
+                ctx.state
+                    .class_symbols_stack
+                    .is_private_member_used_in_current_class(&private_id.name)
+            }
+            ClassElement::AccessorProperty(accessor) => {
+                let PropertyKey::PrivateIdentifier(private_id) = &accessor.key else {
+                    return true;
+                };
+                if ctx
+                    .state
+                    .class_symbols_stack
+                    .is_private_member_used_in_current_class(&private_id.name)
+                {
+                    return true;
+                }
+                accessor.value.as_ref().is_some_and(|value| value.may_have_side_effects(ctx))
+            }
+            ClassElement::StaticBlock(_) => true,
+            ClassElement::TSIndexSignature(_) => {
+                unreachable!("TypeScript syntax should be transformed away")
+            }
+        });
+        if body.body.len() != old_len {
+            ctx.state.changed = true;
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::tester::{test, test_same};
+
+    #[test]
+    fn test_remove_unused_private_fields() {
+        test(
+            "class C { #unused = 1; #used = 2; method() { return this.#used; } } new C();",
+            "class C { #used = 2; method() { return this.#used; } } new C();",
+        );
+        test(
+            "class C { #unused = 1; #used = 2; method(foo) { return #used in foo; } } new C();",
+            "class C { #used = 2; method(foo) { return #used in foo; } } new C();",
+        );
+        test(
+            "class C { #unused; #used; method() { return this.#used; } } new C();",
+            "class C { #used; method() { return this.#used; } } new C();",
+        );
+        test("class C { #a = 1; #b = 2; #c = 3; } new C();", "class C { } new C();");
+        test(
+            "class C { static #unused = 1; static #used = 2; static method() { return C.#used; } }",
+            "class C { static #used = 2; static method() { return C.#used; } }",
+        );
+        test(
+            "class C { public = 1; #unused = 2; #used = 3; method() { return this.public + this.#used; } } new C();",
+            "class C { public = 1; #used = 3; method() { return this.public + this.#used; } } new C();",
+        );
+        test_same("class C { #unused = foo(); method() { return 1; } } new C();");
+    }
+
+    #[test]
+    fn test_remove_unused_private_methods() {
+        test(
+            "class C { #unusedMethod() { return 1; } #usedMethod() { return 2; } method() { return this.#usedMethod(); } } new C();",
+            "class C { #usedMethod() { return 2; } method() { return this.#usedMethod(); } } new C();",
+        );
+        test("class C { #a() {} #b() {} #c() {} } new C();", "class C { } new C();");
+        test(
+            "class C { static #unusedMethod() { return 1; } static #usedMethod() { return 2; } static method() { return C.#usedMethod(); } }",
+            "class C { static #usedMethod() { return 2; } static method() { return C.#usedMethod(); } }",
+        );
+        test_same(
+            "class C { #helper() { return 1; } method() { return this.#helper(); } } new C();",
+        );
+    }
+
+    #[test]
+    fn test_remove_unused_private_accessors() {
+        test(
+            "class C { accessor #unused = 1; accessor #used = 2; method() { return this.#used; } } new C();",
+            "class C { accessor #used = 2; method() { return this.#used; } } new C();",
+        );
+        test_same("class C { accessor #unused = foo(); method() { return 1; } } new C();");
+    }
+
+    #[test]
+    fn test_nested_classes() {
+        test(
+            r"class Outer {
+                #shared = 1;
+                #unusedOuter = 2;
+
+                method() {
+                    return this.#shared;
+                }
+
+                getInner() {
+                    return class Inner {
+                        #shared = 3;
+                        #unusedInner = 4;
+
+                        method() {
+                            return this.#shared;
+                        }
+                    };
+                }
+            } new Outer();",
+            r"class Outer {
+                #shared = 1;
+
+                method() {
+                    return this.#shared;
+                }
+
+                getInner() {
+                    return class {
+                        #shared = 3;
+
+                        method() {
+                            return this.#shared;
+                        }
+                    };
+                }
+            } new Outer();",
+        );
+    }
+}
diff --git a/crates/oxc_minifier/src/state.rs b/crates/oxc_minifier/src/state.rs
@@ -1,7 +1,7 @@
 use oxc_ecmascript::constant_evaluation::ConstantValue;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 
-use oxc_span::SourceType;
+use oxc_span::{Atom, SourceType};
 use oxc_syntax::symbol::SymbolId;
 
 use crate::{CompressOptions, symbol_value::SymbolValues};
@@ -16,6 +16,9 @@ pub struct MinifierState<'a> {
 
     pub symbol_values: SymbolValues<'a>,
 
+    /// Private member usage for classes
+    pub class_symbols_stack: ClassSymbolsStack<'a>,
+
     pub changed: bool,
 }
 
@@ -26,7 +29,46 @@ impl MinifierState<'_> {
             options,
             pure_functions: FxHashMap::default(),
             symbol_values: SymbolValues::default(),
+            class_symbols_stack: ClassSymbolsStack::new(),
             changed: false,
         }
     }
 }
+
+/// Stack to track class symbol information
+pub struct ClassSymbolsStack<'a> {
+    stack: Vec<FxHashSet<Atom<'a>>>,
+}
+
+impl<'a> ClassSymbolsStack<'a> {
+    pub fn new() -> Self {
+        Self { stack: Vec::new() }
+    }
+
+    /// Check if the stack is empty
+    pub fn is_empty(&self) -> bool {
+        self.stack.is_empty()
+    }
+
+    /// Enter a new class scope
+    pub fn push_class_scope(&mut self) {
+        self.stack.push(FxHashSet::default());
+    }
+
+    /// Exit the current class scope
+    pub fn pop_class_scope(&mut self) {
+        self.stack.pop();
+    }
+
+    /// Add a private member to the current class scope
+    pub fn push_private_member_to_current_class(&mut self, name: Atom<'a>) {
+        if let Some(current_class) = self.stack.last_mut() {
+            current_class.insert(name);
+        }
+    }
+
+    /// Check if a private member is used in the current class scope
+    pub fn is_private_member_used_in_current_class(&self, name: &Atom<'a>) -> bool {
+        self.stack.last().is_some_and(|current_class| current_class.contains(name))
+    }
+}
diff --git a/tasks/track_memory_allocations/allocs_minifier.snap b/tasks/track_memory_allocations/allocs_minifier.snap
@@ -1,12 +1,12 @@
 File                       | File size      || Sys allocs     | Sys reallocs   || Arena allocs   | Arena reallocs | Arena bytes    
 -------------------------------------------------------------------------------------------------------------------------------------------
-checker.ts                 | 2.92 MB        ||          84073 |          14190 ||         153691 |          29463 | 5.625 MB      
+checker.ts                 | 2.92 MB        ||          84074 |          14190 ||         153691 |          29463 | 5.625 MB      
 
-cal.com.tsx                | 1.06 MB        ||          40525 |           3033 ||          37074 |           4733 | 1.654 MB      
+cal.com.tsx                | 1.06 MB        ||          40526 |           3033 ||          37074 |           4733 | 1.654 MB      
 
 RadixUIAdoptionSection.jsx | 2.52 kB        ||             82 |              8 ||             30 |              6 | 992 B         
 
-pdf.mjs                    | 567.30 kB      ||          19576 |           2900 ||          47400 |           7781 | 1.624 MB      
+pdf.mjs                    | 567.30 kB      ||          19823 |           2900 ||          47400 |           7781 | 1.624 MB      
 
 antd.js                    | 6.69 MB        ||          99854 |          13518 ||         331725 |          70117 | 17.407 MB     
 
