refactor(minifier): use Ctx

crates/oxc_minifier/src/peephole/collapse_variable_declarations.rs

@@ -1,6 +1,7 @@
 use oxc_allocator::Vec;
 use oxc_ast::ast::*;
-use oxc_traverse::TraverseCtx;
+
+use crate::ctx::Ctx;
 
 use super::PeepholeOptimizations;
 
@@ -17,7 +18,7 @@ impl<'a> PeepholeOptimizations {
     pub fn collapse_variable_declarations(
         &mut self,
         stmts: &mut Vec<'a, Statement<'a>>,
-        ctx: &mut TraverseCtx<'a>,
+        ctx: Ctx<'a, '_>,
     ) {
         self.join_vars(stmts, ctx);
         self.maybe_collapse_into_for_statements(stmts, ctx);
@@ -44,7 +45,7 @@ impl<'a> PeepholeOptimizations {
         None
     }
 
-    fn join_vars(&mut self, stmts: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) {
+    fn join_vars(&mut self, stmts: &mut Vec<'a, Statement<'a>>, ctx: Ctx<'a, '_>) {
         if stmts.len() < 2 {
             return;
         }
@@ -102,7 +103,7 @@ impl<'a> PeepholeOptimizations {
     fn maybe_collapse_into_for_statements(
         &mut self,
         stmts: &mut Vec<'a, Statement<'a>>,
-        ctx: &mut TraverseCtx<'a>,
+        ctx: Ctx<'a, '_>,
     ) {
         if stmts.len() <= 1 {
             return;
@@ -142,7 +143,7 @@ impl<'a> PeepholeOptimizations {
         &mut self,
         i: usize,
         stmts: &mut Vec<'a, Statement<'a>>,
-        ctx: &mut TraverseCtx<'a>,
+        ctx: Ctx<'a, '_>,
     ) {
         if let Statement::ExpressionStatement(expr_stmt) = ctx.ast.move_statement(&mut stmts[i]) {
             if let Statement::ForStatement(for_stmt) = &mut stmts[i + 1] {
@@ -156,7 +157,7 @@ impl<'a> PeepholeOptimizations {
         &mut self,
         i: usize,
         stmts: &mut Vec<'a, Statement<'a>>,
-        ctx: &mut TraverseCtx<'a>,
+        ctx: Ctx<'a, '_>,
     ) {
         if let Statement::VariableDeclaration(var) = ctx.ast.move_statement(&mut stmts[i]) {
             if let Statement::ForStatement(for_stmt) = &mut stmts[i + 1] {
@@ -181,7 +182,7 @@ impl<'a> PeepholeOptimizations {
         &mut self,
         i: usize,
         stmts: &mut Vec<'a, Statement<'a>>,
-        ctx: &mut TraverseCtx<'a>,
+        ctx: Ctx<'a, '_>,
     ) {
         if let Statement::VariableDeclaration(decl) = &stmts[i] {
             if decl.kind.is_var()

crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs

@@ -1,10 +1,10 @@
 use oxc_ast::ast::*;
 use oxc_syntax::identifier::is_identifier_name;
-use oxc_traverse::TraverseCtx;
 
-use super::LatePeepholeOptimizations;
 use crate::ctx::Ctx;
 
+use super::LatePeepholeOptimizations;
+
 impl<'a> LatePeepholeOptimizations {
     /// Converts property accesses from quoted string or bracket access syntax to dot or unquoted string
     /// syntax, where possible. Dot syntax is more compact.
@@ -13,10 +13,7 @@ impl<'a> LatePeepholeOptimizations {
     ///
     /// `foo['bar']` -> `foo.bar`
     /// `foo?.['bar']` -> `foo?.bar`
-    pub fn convert_to_dotted_properties(
-        expr: &mut MemberExpression<'a>,
-        ctx: &mut TraverseCtx<'a>,
-    ) {
+    pub fn convert_to_dotted_properties(expr: &mut MemberExpression<'a>, ctx: Ctx<'a, '_>) {
         let MemberExpression::ComputedMemberExpression(e) = expr else { return };
         let Expression::StringLiteral(s) = &e.expression else { return };
         if is_identifier_name(&s.value) {
@@ -32,8 +29,7 @@ impl<'a> LatePeepholeOptimizations {
             return;
         }
         if let Some(n) = Ctx::string_to_equivalent_number_value(v) {
-            e.expression =
-                Ctx(ctx).ast.expression_numeric_literal(s.span, n, None, NumberBase::Decimal);
+            e.expression = ctx.ast.expression_numeric_literal(s.span, n, None, NumberBase::Decimal);
         }
     }
 }

crates/oxc_minifier/src/peephole/fold_constants.rs

@@ -8,7 +8,7 @@ use oxc_syntax::{
     number::NumberBase,
     operator::{BinaryOperator, LogicalOperator},
 };
-use oxc_traverse::{Ancestor, TraverseCtx};
+use oxc_traverse::Ancestor;
 
 use crate::ctx::Ctx;
 
@@ -18,12 +18,7 @@ impl<'a, 'b> PeepholeOptimizations {
     /// Constant Folding
     ///
     /// <https://github.com/google/closure-compiler/blob/v20240609/src/com/google/javascript/jscomp/PeepholeFoldConstants.java>
-    pub fn fold_constants_exit_expression(
-        &mut self,
-        expr: &mut Expression<'a>,
-        ctx: &mut TraverseCtx<'a>,
-    ) {
-        let ctx = Ctx(ctx);
+    pub fn fold_constants_exit_expression(&mut self, expr: &mut Expression<'a>, ctx: Ctx<'a, '_>) {
         if let Some(folded_expr) = match expr {
             Expression::BinaryExpression(e) => Self::try_fold_binary_expr(e, ctx)
                 .or_else(|| Self::try_fold_binary_typeof_comparison(e, ctx)),