fix(minifier): keep private class members used in nested classes (#14217)

refs #14026, #14209

Author: sapphi-red

crates/oxc_minifier/src/peephole/mod.rs

@@ -372,7 +372,7 @@ impl<'a> Traverse<'a, MinifierState<'a>> for PeepholeOptimizations {
         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();
+        ctx.state.class_symbols_stack.pop_class_scope(Self::get_declared_private_symbols(body));
     }
 
     fn exit_catch_clause(&mut self, catch: &mut CatchClause<'a>, ctx: &mut TraverseCtx<'a>) {

crates/oxc_minifier/src/peephole/remove_unused_private_members.rs

@@ -56,6 +56,33 @@ impl<'a> PeepholeOptimizations {
             ctx.state.changed = true;
         }
     }
+
+    pub fn get_declared_private_symbols(body: &ClassBody<'a>) -> impl Iterator<Item = Atom<'a>> {
+        body.body.iter().filter_map(|element| match element {
+            ClassElement::PropertyDefinition(prop) => {
+                let PropertyKey::PrivateIdentifier(private_id) = &prop.key else {
+                    return None;
+                };
+                Some(private_id.name)
+            }
+            ClassElement::MethodDefinition(method) => {
+                let PropertyKey::PrivateIdentifier(private_id) = &method.key else {
+                    return None;
+                };
+                Some(private_id.name)
+            }
+            ClassElement::AccessorProperty(accessor) => {
+                let PropertyKey::PrivateIdentifier(private_id) = &accessor.key else {
+                    return None;
+                };
+                Some(private_id.name)
+            }
+            ClassElement::StaticBlock(_) => None,
+            ClassElement::TSIndexSignature(_) => {
+                unreachable!("TypeScript syntax should be transformed away")
+            }
+        })
+    }
 }
 
 #[cfg(test)]
@@ -153,5 +180,19 @@ mod test {
                 }
             } new Outer();",
         );
+        test_same(
+            r"class Outer {
+                #shared = 1;
+
+                getInner() {
+                    let self = this;
+                    return class {
+                        method() {
+                            return self.#shared;
+                        }
+                    };
+                }
+            } new Outer();",
+        );
     }
 }

crates/oxc_minifier/src/state.rs

@@ -57,8 +57,13 @@ impl<'a> ClassSymbolsStack<'a> {
     }
 
     /// Exit the current class scope
-    pub fn pop_class_scope(&mut self) {
-        self.stack.pop();
+    pub fn pop_class_scope(&mut self, declared_private_symbols: impl Iterator<Item = Atom<'a>>) {
+        let mut used_private_symbols = self.stack.pop();
+        declared_private_symbols.for_each(|name| {
+            used_private_symbols.remove(&name);
+        });
+        // if the symbol was not declared in this class, that is declared in the class outside the current class
+        self.stack.last_mut().extend(used_private_symbols);
     }
 
     /// Add a private member to the current class scope