refactor(minifier): only minify on ast node exit (#8059)

crates/oxc_minifier/src/ast_passes/collapse_variable_declarations.rs

@@ -20,7 +20,7 @@ impl<'a> CompressorPass<'a> for CollapseVariableDeclarations {
 }
 
 impl<'a> Traverse<'a> for CollapseVariableDeclarations {
-    fn enter_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) {
+    fn exit_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) {
         self.join_vars(stmts, ctx);
     }
 }

crates/oxc_minifier/src/ast_passes/mod.rs

@@ -58,8 +58,8 @@ impl<'a> CompressorPass<'a> for CollapsePass {
 }
 
 impl<'a> Traverse<'a> for CollapsePass {
-    fn enter_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) {
-        self.x1_collapse_variable_declarations.enter_statements(stmts, ctx);
+    fn exit_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) {
+        self.x1_collapse_variable_declarations.exit_statements(stmts, ctx);
     }
 }
 
@@ -134,10 +134,6 @@ impl<'a> CompressorPass<'a> for LatePeepholeOptimizations {
 }
 
 impl<'a> Traverse<'a> for LatePeepholeOptimizations {
-    fn enter_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
-        self.x1_peephole_remove_dead_code.enter_statement(stmt, ctx);
-    }
-
     fn exit_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
         self.x1_peephole_remove_dead_code.exit_statement(stmt, ctx);
         self.x2_peephole_minimize_conditions.exit_statement(stmt, ctx);
@@ -164,23 +160,19 @@ impl<'a> Traverse<'a> for LatePeepholeOptimizations {
         self.x3_peephole_substitute_alternate_syntax.exit_return_statement(stmt, ctx);
     }
 
-    fn enter_variable_declaration(
+    fn exit_variable_declaration(
         &mut self,
         decl: &mut VariableDeclaration<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        self.x3_peephole_substitute_alternate_syntax.enter_variable_declaration(decl, ctx);
-    }
-
-    fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
-        self.x3_peephole_substitute_alternate_syntax.enter_expression(expr, ctx);
-        self.x4_peephole_replace_known_methods.enter_expression(expr, ctx);
+        self.x3_peephole_substitute_alternate_syntax.exit_variable_declaration(decl, ctx);
     }
 
     fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         self.x1_peephole_remove_dead_code.exit_expression(expr, ctx);
         self.x2_peephole_minimize_conditions.exit_expression(expr, ctx);
         self.x3_peephole_substitute_alternate_syntax.exit_expression(expr, ctx);
+        self.x4_peephole_replace_known_methods.exit_expression(expr, ctx);
         self.x5_peephole_fold_constants.exit_expression(expr, ctx);
     }
 
@@ -191,14 +183,6 @@ impl<'a> Traverse<'a> for LatePeepholeOptimizations {
     fn exit_call_expression(&mut self, expr: &mut CallExpression<'a>, ctx: &mut TraverseCtx<'a>) {
         self.x3_peephole_substitute_alternate_syntax.exit_call_expression(expr, ctx);
     }
-
-    fn enter_binary_expression(
-        &mut self,
-        expr: &mut BinaryExpression<'a>,
-        ctx: &mut TraverseCtx<'a>,
-    ) {
-        self.x3_peephole_substitute_alternate_syntax.enter_binary_expression(expr, ctx);
-    }
 }
 
 // See `createPeepholeOptimizationsPass`
@@ -232,10 +216,6 @@ impl<'a> CompressorPass<'a> for PeepholeOptimizations {
 }
 
 impl<'a> Traverse<'a> for PeepholeOptimizations {
-    fn enter_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
-        self.x5_peephole_remove_dead_code.enter_statement(stmt, ctx);
-    }
-
     fn exit_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
         self.x2_peephole_minimize_conditions.exit_statement(stmt, ctx);
         self.x5_peephole_remove_dead_code.exit_statement(stmt, ctx);
@@ -253,22 +233,18 @@ impl<'a> Traverse<'a> for PeepholeOptimizations {
         self.x3_peephole_substitute_alternate_syntax.exit_return_statement(stmt, ctx);
     }
 
-    fn enter_variable_declaration(
+    fn exit_variable_declaration(
         &mut self,
         decl: &mut VariableDeclaration<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        self.x3_peephole_substitute_alternate_syntax.enter_variable_declaration(decl, ctx);
-    }
-
-    fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
-        self.x3_peephole_substitute_alternate_syntax.enter_expression(expr, ctx);
-        self.x4_peephole_replace_known_methods.enter_expression(expr, ctx);
+        self.x3_peephole_substitute_alternate_syntax.exit_variable_declaration(decl, ctx);
     }
 
     fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         self.x2_peephole_minimize_conditions.exit_expression(expr, ctx);
         self.x3_peephole_substitute_alternate_syntax.exit_expression(expr, ctx);
+        self.x4_peephole_replace_known_methods.exit_expression(expr, ctx);
         self.x5_peephole_remove_dead_code.exit_expression(expr, ctx);
         self.x6_peephole_fold_constants.exit_expression(expr, ctx);
     }
@@ -280,14 +256,6 @@ impl<'a> Traverse<'a> for PeepholeOptimizations {
     fn exit_call_expression(&mut self, expr: &mut CallExpression<'a>, ctx: &mut TraverseCtx<'a>) {
         self.x3_peephole_substitute_alternate_syntax.exit_call_expression(expr, ctx);
     }
-
-    fn enter_binary_expression(
-        &mut self,
-        expr: &mut BinaryExpression<'a>,
-        ctx: &mut TraverseCtx<'a>,
-    ) {
-        self.x3_peephole_substitute_alternate_syntax.enter_binary_expression(expr, ctx);
-    }
 }
 
 pub struct DeadCodeElimination {
@@ -313,10 +281,6 @@ impl<'a> CompressorPass<'a> for DeadCodeElimination {
 }
 
 impl<'a> Traverse<'a> for DeadCodeElimination {
-    fn enter_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
-        self.x2_peephole_remove_dead_code.enter_statement(stmt, ctx);
-    }
-
     fn exit_statement(&mut self, stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) {
         self.x2_peephole_remove_dead_code.exit_statement(stmt, ctx);
     }

crates/oxc_minifier/src/ast_passes/peephole_replace_known_methods.rs

@@ -22,7 +22,7 @@ impl<'a> CompressorPass<'a> for PeepholeReplaceKnownMethods {
 }
 
 impl<'a> Traverse<'a> for PeepholeReplaceKnownMethods {
-    fn enter_expression(&mut self, node: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
+    fn exit_expression(&mut self, node: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         self.try_fold_known_string_methods(node, ctx);
     }
 }

crates/oxc_minifier/src/ast_passes/peephole_substitute_alternate_syntax.rs

@@ -44,7 +44,7 @@ impl<'a> Traverse<'a> for PeepholeSubstituteAlternateSyntax {
         self.compress_return_statement(stmt);
     }
 
-    fn enter_variable_declaration(
+    fn exit_variable_declaration(
         &mut self,
         decl: &mut VariableDeclaration<'a>,
         ctx: &mut TraverseCtx<'a>,
@@ -77,7 +77,7 @@ impl<'a> Traverse<'a> for PeepholeSubstituteAlternateSyntax {
         self.in_define_export = false;
     }
 
-    fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
+    fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
         let ctx = Ctx(ctx);
         if let Expression::AssignmentExpression(assignment_expr) = expr {
             if let Some(new_expr) = Self::try_compress_assignment_expression(assignment_expr, ctx) {
@@ -85,10 +85,6 @@ impl<'a> Traverse<'a> for PeepholeSubstituteAlternateSyntax {
                 self.changed = true;
             }
         }
-    }
-
-    fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
-        let ctx = Ctx(ctx);
         self.try_compress_boolean(expr, ctx);
         self.try_compress_undefined(expr, ctx);
         match expr {
@@ -138,17 +134,12 @@ impl<'a> Traverse<'a> for PeepholeSubstituteAlternateSyntax {
                     }
                 }
             }
+            Expression::BinaryExpression(expr) => {
+                self.compress_typeof_undefined(expr, ctx);
+            }
             _ => {}
         }
     }
-
-    fn enter_binary_expression(
-        &mut self,
-        expr: &mut BinaryExpression<'a>,
-        ctx: &mut TraverseCtx<'a>,
-    ) {
-        self.compress_typeof_undefined(expr, Ctx(ctx));
-    }
 }
 
 impl<'a, 'b> PeepholeSubstituteAlternateSyntax {

crates/oxc_minifier/src/ast_passes/remove_syntax.rs

@@ -21,7 +21,7 @@ impl<'a> CompressorPass<'a> for RemoveSyntax {
 }
 
 impl<'a> Traverse<'a> for RemoveSyntax {
-    fn enter_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>, _ctx: &mut TraverseCtx<'a>) {
+    fn exit_statements(&mut self, stmts: &mut Vec<'a, Statement<'a>>, _ctx: &mut TraverseCtx<'a>) {
         stmts.retain(|stmt| {
             !(matches!(stmt, Statement::EmptyStatement(_))
                 || self.drop_debugger(stmt)
@@ -29,11 +29,8 @@ impl<'a> Traverse<'a> for RemoveSyntax {
         });
     }
 
-    fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
-        self.compress_console(expr, ctx);
-    }
-
     fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) {
+        self.compress_console(expr, ctx);
         Self::strip_parenthesized_expression(expr, ctx);
     }
 
@@ -114,7 +111,7 @@ mod test {
 
     #[test]
     fn drop_console() {
-        test("console.log()", "");
+        test("console.log()", "void 0;\n");
     }
 
     #[test]