refactor(minfier): clean up method names

Author: Boshen

crates/oxc_minifier/src/peephole/minimize_conditional_expression.rs

@@ -20,12 +20,12 @@ impl<'a> PeepholeOptimizations {
         ctx: &mut Ctx<'a, '_>,
     ) -> Expression<'a> {
         let mut cond_expr = ctx.ast.conditional_expression(span, test, consequent, alternate);
-        Self::try_minimize_conditional(&mut cond_expr, ctx)
+        Self::minimize_conditional_expression(&mut cond_expr, ctx)
             .unwrap_or_else(|| Expression::ConditionalExpression(ctx.ast.alloc(cond_expr)))
     }
 
     /// `MangleIfExpr`: <https://github.com/evanw/esbuild/blob/v0.24.2/internal/js_ast/js_ast_helpers.go#L2745>
-    pub fn try_minimize_conditional(
+    pub fn minimize_conditional_expression(
         expr: &mut ConditionalExpression<'a>,
         ctx: &mut Ctx<'a, '_>,
     ) -> Option<Expression<'a>> {

crates/oxc_minifier/src/peephole/minimize_conditions.rs

@@ -66,7 +66,7 @@ impl<'a> PeepholeOptimizations {
     //  ^^^^^^^^^^^^^^ `ctx.expression_value_type(&e.left).is_boolean()` is `true`.
     // `x >> +y !== 0` -> `x >> +y`
     //  ^^^^^^^ ctx.expression_value_type(&e.left).is_number()` is `true`.
-    pub fn try_minimize_binary(expr: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
+    pub fn minimize_binary(expr: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
         let Expression::BinaryExpression(e) = expr else { return };
         if !e.operator.is_equality() {
             return;
@@ -123,7 +123,7 @@ impl<'a> PeepholeOptimizations {
     ///
     /// In `IsLooselyEqual`, `true` and `false` are converted to `1` and `0` first.
     /// <https://tc39.es/ecma262/multipage/abstract-operations.html#sec-islooselyequal>
-    pub fn try_compress_is_loose_boolean(e: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
+    pub fn minimize_loose_boolean(e: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
         let Expression::BinaryExpression(e) = e else { return };
         if !matches!(e.operator, BinaryOperator::Equality | BinaryOperator::Inequality) {
             return;
@@ -170,7 +170,7 @@ impl<'a> PeepholeOptimizations {
     /// Compress `a = a || b` to `a ||= b`
     ///
     /// This can only be done for resolved identifiers as this would avoid setting `a` when `a` is truthy.
-    pub fn try_compress_normal_assignment_to_combined_logical_assignment(
+    pub fn minimize_normal_assignment_to_combined_logical_assignment(
         expr: &mut AssignmentExpression<'a>,
         ctx: &mut Ctx<'a, '_>,
     ) {
@@ -207,7 +207,7 @@ impl<'a> PeepholeOptimizations {
     }
 
     /// Compress `a = a + b` to `a += b`
-    pub fn try_compress_normal_assignment_to_combined_assignment(
+    pub fn minimize_normal_assignment_to_combined_assignment(
         expr: &mut AssignmentExpression<'a>,
         ctx: &mut Ctx<'a, '_>,
     ) {
@@ -227,7 +227,7 @@ impl<'a> PeepholeOptimizations {
 
     /// Compress `a -= 1` to `--a` and `a -= -1` to `++a`
     #[expect(clippy::float_cmp)]
-    pub fn try_compress_assignment_to_update_expression(
+    pub fn minimize_assignment_to_update_expression(
         expr: &mut Expression<'a>,
         ctx: &mut Ctx<'a, '_>,
     ) {

crates/oxc_minifier/src/peephole/minimize_expression_in_boolean_context.rs

@@ -11,14 +11,17 @@ impl<'a> PeepholeOptimizations {
     /// Simplify syntax when we know it's used inside a boolean context, e.g. `if (boolean_context) {}`.
     ///
     /// `SimplifyBooleanExpr`: <https://github.com/evanw/esbuild/blob/v0.24.2/internal/js_ast/js_ast_helpers.go#L2059>
-    pub fn try_fold_expr_in_boolean_context(expr: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
+    pub fn minimize_expression_in_boolean_context(
+        expr: &mut Expression<'a>,
+        ctx: &mut Ctx<'a, '_>,
+    ) {
         match expr {
             // "!!a" => "a"
             Expression::UnaryExpression(u1) if u1.operator.is_not() => {
                 if let Expression::UnaryExpression(u2) = &mut u1.argument {
                     if u2.operator.is_not() {
                         let mut e = u2.argument.take_in(ctx.ast);
-                        Self::try_fold_expr_in_boolean_context(&mut e, ctx);
+                        Self::minimize_expression_in_boolean_context(&mut e, ctx);
                         *expr = e;
                         ctx.state.changed = true;
                     }
@@ -44,8 +47,8 @@ impl<'a> PeepholeOptimizations {
             }
             // "if (!!a && !!b)" => "if (a && b)"
             Expression::LogicalExpression(e) if e.operator.is_and() => {
-                Self::try_fold_expr_in_boolean_context(&mut e.left, ctx);
-                Self::try_fold_expr_in_boolean_context(&mut e.right, ctx);
+                Self::minimize_expression_in_boolean_context(&mut e.left, ctx);
+                Self::minimize_expression_in_boolean_context(&mut e.right, ctx);
                 // "if (anything && truthyNoSideEffects)" => "if (anything)"
                 if e.right.get_side_free_boolean_value(ctx) == Some(true) {
                     *expr = e.left.take_in(ctx.ast);
@@ -54,8 +57,8 @@ impl<'a> PeepholeOptimizations {
             }
             // "if (!!a ||!!b)" => "if (a || b)"
             Expression::LogicalExpression(e) if e.operator == LogicalOperator::Or => {
-                Self::try_fold_expr_in_boolean_context(&mut e.left, ctx);
-                Self::try_fold_expr_in_boolean_context(&mut e.right, ctx);
+                Self::minimize_expression_in_boolean_context(&mut e.left, ctx);
+                Self::minimize_expression_in_boolean_context(&mut e.right, ctx);
                 // "if (anything || falsyNoSideEffects)" => "if (anything)"
                 if e.right.get_side_free_boolean_value(ctx) == Some(false) {
                     *expr = e.left.take_in(ctx.ast);
@@ -64,8 +67,8 @@ impl<'a> PeepholeOptimizations {
             }
             Expression::ConditionalExpression(e) => {
                 // "if (a ? !!b : !!c)" => "if (a ? b : c)"
-                Self::try_fold_expr_in_boolean_context(&mut e.consequent, ctx);
-                Self::try_fold_expr_in_boolean_context(&mut e.alternate, ctx);
+                Self::minimize_expression_in_boolean_context(&mut e.consequent, ctx);
+                Self::minimize_expression_in_boolean_context(&mut e.alternate, ctx);
                 if let Some(boolean) = e.consequent.get_side_free_boolean_value(ctx) {
                     let right = e.alternate.take_in(ctx.ast);
                     let left = e.test.take_in(ctx.ast);
@@ -98,7 +101,7 @@ impl<'a> PeepholeOptimizations {
             }
             Expression::SequenceExpression(seq_expr) => {
                 if let Some(last) = seq_expr.expressions.last_mut() {
-                    Self::try_fold_expr_in_boolean_context(last, ctx);
+                    Self::minimize_expression_in_boolean_context(last, ctx);
                 }
             }
             _ => {}

crates/oxc_minifier/src/peephole/minimize_not_expression.rs

@@ -10,17 +10,17 @@ use super::PeepholeOptimizations;
 impl<'a> PeepholeOptimizations {
     pub fn minimize_not(span: Span, expr: Expression<'a>, ctx: &mut Ctx<'a, '_>) -> Expression<'a> {
         let mut unary = ctx.ast.expression_unary(span, UnaryOperator::LogicalNot, expr);
-        Self::try_minimize_not(&mut unary, ctx);
+        Self::minimize_unary(&mut unary, ctx);
         unary
     }
 
     /// `MaybeSimplifyNot`: <https://github.com/evanw/esbuild/blob/v0.24.2/internal/js_ast/js_ast_helpers.go#L73>
-    pub fn try_minimize_not(expr: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
+    pub fn minimize_unary(expr: &mut Expression<'a>, ctx: &mut Ctx<'a, '_>) {
         let Expression::UnaryExpression(e) = expr else { return };
         if !e.operator.is_not() {
             return;
         }
-        Self::try_fold_expr_in_boolean_context(&mut e.argument, ctx);
+        Self::minimize_expression_in_boolean_context(&mut e.argument, ctx);
         match &mut e.argument {
             // `!!true` -> `true`
             // `!!false` -> `false`

crates/oxc_minifier/src/peephole/minimize_statements.rs

@@ -557,7 +557,7 @@ impl<'a> PeepholeOptimizations {
                         };
                         let test = if_stmt.test.take_in(ctx.ast);
                         let mut test = Self::minimize_not(test.span(), test, ctx);
-                        Self::try_fold_expr_in_boolean_context(&mut test, ctx);
+                        Self::minimize_expression_in_boolean_context(&mut test, ctx);
                         let consequent = if body.len() == 1 {
                             body.remove(0)
                         } else {