fix(minifier): do not convert while to fors in DCE (#8484)

crates/oxc_minifier/src/ast_passes/mod.rs

@@ -20,7 +20,7 @@ pub use collapse_variable_declarations::CollapseVariableDeclarations;
 pub use convert_to_dotted_properties::ConvertToDottedProperties;
 pub use exploit_assigns::ExploitAssigns;
 pub use minimize_exit_points::MinimizeExitPoints;
-pub use normalize::Normalize;
+pub use normalize::{Normalize, NormalizeOptions};
 pub use peephole_fold_constants::PeepholeFoldConstants;
 pub use peephole_minimize_conditions::PeepholeMinimizeConditions;
 pub use peephole_remove_dead_code::PeepholeRemoveDeadCode;

crates/oxc_minifier/src/ast_passes/normalize.rs

@@ -7,6 +7,11 @@ use oxc_traverse::{traverse_mut_with_ctx, ReusableTraverseCtx, Traverse, Travers
 
 use crate::{ctx::Ctx, CompressOptions, CompressorPass};
 
+#[derive(Default)]
+pub struct NormalizeOptions {
+    pub convert_while_to_fors: bool,
+}
+
 /// Normalize AST
 ///
 /// Make subsequent AST passes easier to analyze:
@@ -24,7 +29,8 @@ use crate::{ctx::Ctx, CompressOptions, CompressorPass};
 ///
 /// <https://github.com/google/closure-compiler/blob/v20240609/src/com/google/javascript/jscomp/Normalize.java>
 pub struct Normalize {
-    options: CompressOptions,
+    options: NormalizeOptions,
+    compress_options: CompressOptions,
 }
 
 impl<'a> CompressorPass<'a> for Normalize {
@@ -44,10 +50,10 @@ impl<'a> Traverse<'a> for Normalize {
 
     fn exit_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
         match stmt {
-            Statement::WhileStatement(_) => {
+            Statement::IfStatement(s) => Self::wrap_to_avoid_ambiguous_else(s, ctx),
+            Statement::WhileStatement(_) if self.options.convert_while_to_fors => {
                 Self::convert_while_to_for(stmt, ctx);
             }
-            Statement::IfStatement(s) => Self::wrap_to_avoid_ambiguous_else(s, ctx),
             _ => {}
         }
     }
@@ -66,7 +72,7 @@ impl<'a> Traverse<'a> for Normalize {
             Expression::ArrowFunctionExpression(e) => {
                 self.recover_arrow_expression_after_drop_console(e);
             }
-            Expression::CallExpression(_) if self.options.drop_console => {
+            Expression::CallExpression(_) if self.compress_options.drop_console => {
                 self.compress_console(expr, ctx);
             }
             _ => {}
@@ -75,31 +81,31 @@ impl<'a> Traverse<'a> for Normalize {
 }
 
 impl<'a> Normalize {
-    pub fn new(options: CompressOptions) -> Self {
-        Self { options }
+    pub fn new(options: NormalizeOptions, compress_options: CompressOptions) -> Self {
+        Self { options, compress_options }
     }
 
     /// Drop `drop_debugger` statement.
     ///
     /// Enabled by `compress.drop_debugger`
     fn drop_debugger(&mut self, stmt: &Statement<'a>) -> bool {
-        matches!(stmt, Statement::DebuggerStatement(_)) && self.options.drop_debugger
+        matches!(stmt, Statement::DebuggerStatement(_)) && self.compress_options.drop_debugger
     }
 
     fn compress_console(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
-        debug_assert!(self.options.drop_console);
+        debug_assert!(self.compress_options.drop_console);
         if Self::is_console(expr) {
             *expr = ctx.ast.void_0(expr.span());
         }
     }
 
     fn drop_console(&mut self, stmt: &Statement<'a>) -> bool {
-        self.options.drop_console
+        self.compress_options.drop_console
             && matches!(stmt, Statement::ExpressionStatement(expr) if Self::is_console(&expr.expression))
     }
 
     fn recover_arrow_expression_after_drop_console(&self, expr: &mut ArrowFunctionExpression<'a>) {
-        if self.options.drop_console && expr.expression && expr.body.is_empty() {
+        if self.compress_options.drop_console && expr.expression && expr.body.is_empty() {
             expr.expression = false;
         }
     }
@@ -171,16 +177,18 @@ impl<'a> Normalize {
 mod test {
     use oxc_allocator::Allocator;
 
+    use super::NormalizeOptions;
     use crate::{tester, CompressOptions};
 
     fn test(source_text: &str, expected: &str) {
         let allocator = Allocator::default();
-        let options = CompressOptions {
+        let compress_options = CompressOptions {
             drop_debugger: true,
             drop_console: true,
             ..CompressOptions::default()
         };
-        let mut pass = super::Normalize::new(options);
+        let options = NormalizeOptions { convert_while_to_fors: true };
+        let mut pass = super::Normalize::new(options, compress_options);
         tester::test(&allocator, source_text, expected, &mut pass);
     }
 

crates/oxc_minifier/src/compressor.rs

@@ -4,7 +4,7 @@ use oxc_semantic::{ScopeTree, SemanticBuilder, SymbolTable};
 use oxc_traverse::ReusableTraverseCtx;
 
 use crate::{
-    ast_passes::{DeadCodeElimination, Normalize, PeepholeOptimizations},
+    ast_passes::{DeadCodeElimination, Normalize, NormalizeOptions, PeepholeOptimizations},
     CompressOptions, CompressorPass,
 };
 
@@ -32,7 +32,8 @@ impl<'a> Compressor<'a> {
     ) {
         let mut ctx = ReusableTraverseCtx::new(scopes, symbols, self.allocator);
         // RemoveUnusedCode::new(self.options).build(program, &mut ctx);
-        Normalize::new(self.options).build(program, &mut ctx);
+        let normalize_options = NormalizeOptions { convert_while_to_fors: true };
+        Normalize::new(normalize_options, self.options).build(program, &mut ctx);
         PeepholeOptimizations::new(self.options.target, true, self.options)
             .run_in_loop(program, &mut ctx);
         PeepholeOptimizations::new(self.options.target, false, self.options)
@@ -52,7 +53,8 @@ impl<'a> Compressor<'a> {
         program: &mut Program<'a>,
     ) {
         let mut ctx = ReusableTraverseCtx::new(scopes, symbols, self.allocator);
-        Normalize::new(self.options).build(program, &mut ctx);
+        let normalize_options = NormalizeOptions { convert_while_to_fors: false };
+        Normalize::new(normalize_options, self.options).build(program, &mut ctx);
         DeadCodeElimination::new().build(program, &mut ctx);
     }
 }

crates/oxc_minifier/src/tester.rs

@@ -6,7 +6,7 @@ use oxc_span::SourceType;
 use oxc_traverse::ReusableTraverseCtx;
 
 use crate::{
-    ast_passes::{CompressorPass, Normalize},
+    ast_passes::{CompressorPass, Normalize, NormalizeOptions},
     CompressOptions,
 };
 
@@ -44,7 +44,9 @@ fn run<'a, P: CompressorPass<'a>>(
         let (symbols, scopes) =
             SemanticBuilder::new().build(&program).semantic.into_symbol_table_and_scope_tree();
         let mut ctx = ReusableTraverseCtx::new(scopes, symbols, allocator);
-        Normalize::new(CompressOptions::all_false()).build(&mut program, &mut ctx);
+        let normalize_options = NormalizeOptions { convert_while_to_fors: true };
+        Normalize::new(normalize_options, CompressOptions::all_false())
+            .build(&mut program, &mut ctx);
         pass.build(&mut program, &mut ctx);
     }
 

crates/oxc_minifier/tests/ast_passes/dead_code_elimination.rs

@@ -110,6 +110,12 @@ fn dce_if_statement() {
     test("if (typeof 1 === 'string') { REMOVE; }", "");
 }
 
+#[test]
+fn dce_while_statement() {
+    test_same("while (true);");
+    test_same("while (false);");
+}
+
 #[test]
 fn dce_conditional_expression() {
     test("false ? foo : bar;", "bar");