diff --git a/crates/oxc_allocator/src/accessor.rs b/crates/oxc_allocator/src/accessor.rs new file mode 100644 index 0000000000000..dcc174e8f8291 --- /dev/null +++ b/crates/oxc_allocator/src/accessor.rs @@ -0,0 +1,14 @@ +use crate::Allocator; + +/// Accessor for getting the underlying allocator. +pub trait AllocatorAccessor<'a> { + /// Get the underlying allocator. + fn allocator(self) -> &'a Allocator; +} + +impl<'a> AllocatorAccessor<'a> for &'a Allocator { + #[inline] + fn allocator(self) -> &'a Allocator { + self + } +} diff --git a/crates/oxc_allocator/src/lib.rs b/crates/oxc_allocator/src/lib.rs index 296b715f1fce2..46eda5d7200cb 100644 --- a/crates/oxc_allocator/src/lib.rs +++ b/crates/oxc_allocator/src/lib.rs @@ -21,6 +21,7 @@ #![warn(missing_docs)] +mod accessor; mod address; mod alloc; mod allocator; @@ -36,6 +37,7 @@ mod take_in; mod vec; mod vec2; +pub use accessor::AllocatorAccessor; pub use address::{Address, GetAddress}; pub use allocator::Allocator; pub use boxed::Box; diff --git a/crates/oxc_allocator/src/take_in.rs b/crates/oxc_allocator/src/take_in.rs index 62372ddebf9ee..2def27c6a0205 100644 --- a/crates/oxc_allocator/src/take_in.rs +++ b/crates/oxc_allocator/src/take_in.rs @@ -1,12 +1,13 @@ use std::{cell::Cell, mem, num}; -use crate::{Allocator, Box, Vec}; +use crate::{Allocator, AllocatorAccessor, Box, Vec}; /// A trait to replace an existing AST node with a dummy. pub trait TakeIn<'a>: Dummy<'a> { /// Replace node with a dummy. #[must_use] - fn take_in(&mut self, allocator: &'a Allocator) -> Self { + fn take_in>(&mut self, allocator_accessor: A) -> Self { + let allocator = allocator_accessor.allocator(); let dummy = Dummy::dummy(allocator); mem::replace(self, dummy) } diff --git a/crates/oxc_ast/src/ast_builder_impl.rs b/crates/oxc_ast/src/ast_builder_impl.rs index 1f4937b220d0e..b10dba4692dc7 100644 --- a/crates/oxc_ast/src/ast_builder_impl.rs +++ b/crates/oxc_ast/src/ast_builder_impl.rs @@ -2,7 +2,7 @@ use std::borrow::Cow; -use oxc_allocator::{Allocator, Box, FromIn, IntoIn, String, Vec}; +use oxc_allocator::{Allocator, AllocatorAccessor, Box, FromIn, IntoIn, String, Vec}; use oxc_span::{Atom, SPAN, Span}; use oxc_syntax::{number::NumberBase, operator::UnaryOperator, scope::ScopeId}; @@ -19,6 +19,13 @@ impl<'a, T> FromIn<'a, NONE> for Option> { } } +impl<'a> AllocatorAccessor<'a> for AstBuilder<'a> { + #[inline] + fn allocator(self) -> &'a Allocator { + self.allocator + } +} + impl<'a> AstBuilder<'a> { /// Create a new AST builder that will allocate nodes in the given allocator. #[inline] diff --git a/crates/oxc_isolated_declarations/src/module.rs b/crates/oxc_isolated_declarations/src/module.rs index 6aea390cd456c..dacb577ca28da 100644 --- a/crates/oxc_isolated_declarations/src/module.rs +++ b/crates/oxc_isolated_declarations/src/module.rs @@ -187,7 +187,7 @@ impl<'a> IsolatedDeclarations<'a> { stmts.iter_mut().for_each(|stmt| { if let Statement::ExportNamedDeclaration(decl) = stmt { if let Some(declaration) = &mut decl.declaration { - *stmt = Statement::from(declaration.take_in(self.ast.allocator)); + *stmt = Statement::from(declaration.take_in(self.ast)); } } }); diff --git a/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs b/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs index 378a9a75684a6..5c379bfe024e9 100644 --- a/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs +++ b/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs @@ -22,7 +22,7 @@ impl<'a> LatePeepholeOptimizations { *expr = MemberExpression::StaticMemberExpression(ctx.ast.alloc_static_member_expression( e.span, - e.object.take_in(ctx.ast.allocator), + e.object.take_in(ctx.ast), property, e.optional, )); diff --git a/crates/oxc_minifier/src/peephole/fold_constants.rs b/crates/oxc_minifier/src/peephole/fold_constants.rs index 1c71faa59c294..9c8ecdb009eee 100644 --- a/crates/oxc_minifier/src/peephole/fold_constants.rs +++ b/crates/oxc_minifier/src/peephole/fold_constants.rs @@ -132,7 +132,7 @@ impl<'a> PeepholeOptimizations { // (TRUE || x) => TRUE (also, (3 || x) => 3) // (FALSE && x) => FALSE if if lval { op.is_or() } else { op.is_and() } { - return Some(logical_expr.left.take_in(ctx.ast.allocator)); + return Some(logical_expr.left.take_in(ctx.ast)); } else if !left.may_have_side_effects(&ctx) { let should_keep_indirect_access = Self::should_keep_indirect_access(&logical_expr.right, ctx); @@ -147,19 +147,19 @@ impl<'a> PeepholeOptimizations { None, NumberBase::Decimal, ), - logical_expr.right.take_in(ctx.ast.allocator), + logical_expr.right.take_in(ctx.ast), ]), )); } // (FALSE || x) => x // (TRUE && x) => x - return Some(logical_expr.right.take_in(ctx.ast.allocator)); + return Some(logical_expr.right.take_in(ctx.ast)); } // Left side may have side effects, but we know its boolean value. // e.g. true_with_sideeffects || foo() => true_with_sideeffects, foo() // or: false_with_sideeffects && foo() => false_with_sideeffects, foo() - let left = logical_expr.left.take_in(ctx.ast.allocator); - let right = logical_expr.right.take_in(ctx.ast.allocator); + let left = logical_expr.left.take_in(ctx.ast); + let right = logical_expr.right.take_in(ctx.ast); let vec = ctx.ast.vec_from_array([left, right]); let sequence_expr = ctx.ast.expression_sequence(logical_expr.span, vec); return Some(sequence_expr); @@ -174,8 +174,8 @@ impl<'a> PeepholeOptimizations { if !right_boolean && left_child_op.is_or() || right_boolean && left_child_op.is_and() { - let left = left_child.left.take_in(ctx.ast.allocator); - let right = logical_expr.right.take_in(ctx.ast.allocator); + let left = left_child.left.take_in(ctx.ast); + let right = logical_expr.right.take_in(ctx.ast); let logic_expr = ctx.ast.expression_logical( logical_expr.span, left, @@ -204,8 +204,8 @@ impl<'a> PeepholeOptimizations { Some(if left.may_have_side_effects(&ctx) { // e.g. `(a(), null) ?? 1` => `(a(), null, 1)` let expressions = ctx.ast.vec_from_array([ - logical_expr.left.take_in(ctx.ast.allocator), - logical_expr.right.take_in(ctx.ast.allocator), + logical_expr.left.take_in(ctx.ast), + logical_expr.right.take_in(ctx.ast), ]); ctx.ast.expression_sequence(logical_expr.span, expressions) } else { @@ -222,12 +222,12 @@ impl<'a> PeepholeOptimizations { None, NumberBase::Decimal, ), - logical_expr.right.take_in(ctx.ast.allocator), + logical_expr.right.take_in(ctx.ast), ]), )); } // nullish condition => this expression evaluates to the right side. - logical_expr.right.take_in(ctx.ast.allocator) + logical_expr.right.take_in(ctx.ast) }) } ValueType::Number @@ -248,12 +248,12 @@ impl<'a> PeepholeOptimizations { None, NumberBase::Decimal, ), - logical_expr.left.take_in(ctx.ast.allocator), + logical_expr.left.take_in(ctx.ast), ]), )); } // non-nullish condition => this expression evaluates to the left side. - Some(logical_expr.left.take_in(ctx.ast.allocator)) + Some(logical_expr.left.take_in(ctx.ast)) } ValueType::Undetermined => None, } @@ -391,14 +391,14 @@ impl<'a> PeepholeOptimizations { let span = Span::new(left_binary_expr.right.span().start, e.right.span().end); let value = ctx.ast.atom_from_strs_array([&left_str, &right_str]); let right = ctx.ast.expression_string_literal(span, value, None); - let left = left_binary_expr.left.take_in(ctx.ast.allocator); + let left = left_binary_expr.left.take_in(ctx.ast); return Some(ctx.ast.expression_binary(e.span, left, e.operator, right)); } if let Some(new_right) = Self::try_fold_add_op(&mut left_binary_expr.right, &mut e.right, ctx) { - let left = left_binary_expr.left.take_in(ctx.ast.allocator); + let left = left_binary_expr.left.take_in(ctx.ast); return Some(ctx.ast.expression_binary(e.span, left, e.operator, new_right)); } } @@ -437,7 +437,7 @@ impl<'a> PeepholeOptimizations { } left.quasis.extend(right.quasis.drain(1..)); // first quasi is already handled left.expressions.extend(right.expressions.drain(..)); - return Some(left_expr.take_in(ctx.ast.allocator)); + return Some(left_expr.take_in(ctx.ast)); } // "`${x}y` + 'z'" => "`${x}yz`" @@ -453,7 +453,7 @@ impl<'a> PeepholeOptimizations { .cooked .map(|cooked| ctx.ast.atom(&(cooked.as_str().to_string() + &right_str))); last_quasi.value.cooked = new_cooked; - return Some(left_expr.take_in(ctx.ast.allocator)); + return Some(left_expr.take_in(ctx.ast)); } } else if let Expression::TemplateLiteral(right) = right_expr { // "'x' + `y${z}`" => "`xy${z}`" @@ -471,17 +471,17 @@ impl<'a> PeepholeOptimizations { .cooked .map(|cooked| ctx.ast.atom(&(left_str.into_owned() + cooked.as_str()))); first_quasi.value.cooked = new_cooked; - return Some(right_expr.take_in(ctx.ast.allocator)); + return Some(right_expr.take_in(ctx.ast)); } } // remove useless `+ ""` (e.g. `typeof foo + ""` -> `typeof foo`) if Self::evaluates_to_empty_string(left_expr) && right_expr.value_type(&ctx).is_string() { - return Some(right_expr.take_in(ctx.ast.allocator)); + return Some(right_expr.take_in(ctx.ast)); } else if Self::evaluates_to_empty_string(right_expr) && left_expr.value_type(&ctx).is_string() { - return Some(left_expr.take_in(ctx.ast.allocator)); + return Some(left_expr.take_in(ctx.ast)); } None @@ -523,7 +523,7 @@ impl<'a> PeepholeOptimizations { Some(ctx.ast.expression_binary( e.span, - expr_to_move.take_in(ctx.ast.allocator), + expr_to_move.take_in(ctx.ast), op, ctx.value_to_expr(Span::new(left.right.span().start, e.right.span().end), v), )) diff --git a/crates/oxc_minifier/src/peephole/minimize_conditional_expression.rs b/crates/oxc_minifier/src/peephole/minimize_conditional_expression.rs index d9d09520f8bd3..fd8f1980518be 100644 --- a/crates/oxc_minifier/src/peephole/minimize_conditional_expression.rs +++ b/crates/oxc_minifier/src/peephole/minimize_conditional_expression.rs @@ -33,15 +33,15 @@ impl<'a> PeepholeOptimizations { Expression::SequenceExpression(sequence_expr) => { if sequence_expr.expressions.len() > 1 { let span = expr.span(); - let mut sequence = expr.test.take_in(ctx.ast.allocator); + let mut sequence = expr.test.take_in(ctx.ast); let Expression::SequenceExpression(sequence_expr) = &mut sequence else { unreachable!() }; let expr = self.minimize_conditional( span, sequence_expr.expressions.pop().unwrap(), - expr.consequent.take_in(ctx.ast.allocator), - expr.alternate.take_in(ctx.ast.allocator), + expr.consequent.take_in(ctx.ast), + expr.alternate.take_in(ctx.ast), ctx, ); sequence_expr.expressions.push(expr); @@ -51,9 +51,9 @@ impl<'a> PeepholeOptimizations { // "!a ? b : c" => "a ? c : b" Expression::UnaryExpression(test_expr) => { if test_expr.operator.is_not() { - let test = test_expr.argument.take_in(ctx.ast.allocator); - let consequent = expr.alternate.take_in(ctx.ast.allocator); - let alternate = expr.consequent.take_in(ctx.ast.allocator); + let test = test_expr.argument.take_in(ctx.ast); + let consequent = expr.alternate.take_in(ctx.ast); + let alternate = expr.consequent.take_in(ctx.ast); return Some( self.minimize_conditional(expr.span, test, consequent, alternate, ctx), ); @@ -66,8 +66,8 @@ impl<'a> PeepholeOptimizations { return Some(self.join_with_left_associative_op( expr.span, LogicalOperator::Or, - expr.test.take_in(ctx.ast.allocator), - expr.alternate.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + expr.alternate.take_in(ctx.ast), ctx, )); } @@ -78,8 +78,8 @@ impl<'a> PeepholeOptimizations { return Some(self.join_with_left_associative_op( expr.span, LogicalOperator::And, - expr.test.take_in(ctx.ast.allocator), - expr.consequent.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + expr.consequent.take_in(ctx.ast), ctx, )); } @@ -92,9 +92,9 @@ impl<'a> PeepholeOptimizations { BinaryOperator::Inequality | BinaryOperator::StrictInequality ) { test_expr.operator = test_expr.operator.equality_inverse_operator().unwrap(); - let test = expr.test.take_in(ctx.ast.allocator); - let consequent = expr.consequent.take_in(ctx.ast.allocator); - let alternate = expr.alternate.take_in(ctx.ast.allocator); + let test = expr.test.take_in(ctx.ast); + let consequent = expr.consequent.take_in(ctx.ast); + let alternate = expr.alternate.take_in(ctx.ast); return Some( self.minimize_conditional(expr.span, test, alternate, consequent, ctx), ); @@ -110,13 +110,13 @@ impl<'a> PeepholeOptimizations { { match (left.value, right.value) { (true, false) => { - let test = expr.test.take_in(ctx.ast.allocator); + let test = expr.test.take_in(ctx.ast); let test = self.minimize_not(expr.span, test, ctx); let test = self.minimize_not(expr.span, test, ctx); return Some(test); } (false, true) => { - let test = expr.test.take_in(ctx.ast.allocator); + let test = expr.test.take_in(ctx.ast); let test = self.minimize_not(expr.span, test, ctx); return Some(test); } @@ -132,12 +132,12 @@ impl<'a> PeepholeOptimizations { self.join_with_left_associative_op( expr.test.span(), LogicalOperator::And, - expr.test.take_in(ctx.ast.allocator), - consequent.test.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + consequent.test.take_in(ctx.ast), ctx, ), - consequent.consequent.take_in(ctx.ast.allocator), - consequent.alternate.take_in(ctx.ast.allocator), + consequent.consequent.take_in(ctx.ast), + consequent.alternate.take_in(ctx.ast), )); } } @@ -150,12 +150,12 @@ impl<'a> PeepholeOptimizations { self.join_with_left_associative_op( expr.test.span(), LogicalOperator::Or, - expr.test.take_in(ctx.ast.allocator), - alternate.test.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + alternate.test.take_in(ctx.ast), ctx, ), - expr.consequent.take_in(ctx.ast.allocator), - alternate.alternate.take_in(ctx.ast.allocator), + expr.consequent.take_in(ctx.ast), + alternate.alternate.take_in(ctx.ast), )); } } @@ -171,11 +171,11 @@ impl<'a> PeepholeOptimizations { self.join_with_left_associative_op( expr.test.span(), LogicalOperator::Or, - expr.test.take_in(ctx.ast.allocator), - alternate.expressions[0].take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + alternate.expressions[0].take_in(ctx.ast), ctx, ), - expr.consequent.take_in(ctx.ast.allocator), + expr.consequent.take_in(ctx.ast), ]), )); } @@ -192,11 +192,11 @@ impl<'a> PeepholeOptimizations { self.join_with_left_associative_op( expr.test.span(), LogicalOperator::And, - expr.test.take_in(ctx.ast.allocator), - consequent.expressions[0].take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + consequent.expressions[0].take_in(ctx.ast), ctx, ), - expr.alternate.take_in(ctx.ast.allocator), + expr.alternate.take_in(ctx.ast), ]), )); } @@ -210,12 +210,12 @@ impl<'a> PeepholeOptimizations { self.join_with_left_associative_op( expr.test.span(), LogicalOperator::And, - expr.test.take_in(ctx.ast.allocator), - logical_expr.left.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + logical_expr.left.take_in(ctx.ast), ctx, ), LogicalOperator::Or, - expr.alternate.take_in(ctx.ast.allocator), + expr.alternate.take_in(ctx.ast), )); } } @@ -230,12 +230,12 @@ impl<'a> PeepholeOptimizations { self.join_with_left_associative_op( expr.test.span(), LogicalOperator::Or, - expr.test.take_in(ctx.ast.allocator), - logical_expr.left.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + logical_expr.left.take_in(ctx.ast), ctx, ), LogicalOperator::And, - expr.consequent.take_in(ctx.ast.allocator), + expr.consequent.take_in(ctx.ast), )); } } @@ -264,25 +264,25 @@ impl<'a> PeepholeOptimizations { if matches!(consequent.arguments[0], Argument::SpreadElement(_)) && matches!(alternate.arguments[0], Argument::SpreadElement(_)) { - let callee = consequent.callee.take_in(ctx.ast.allocator); + let callee = consequent.callee.take_in(ctx.ast); let consequent_first_arg = { let Argument::SpreadElement(el) = &mut consequent.arguments[0] else { unreachable!() }; - el.argument.take_in(ctx.ast.allocator) + el.argument.take_in(ctx.ast) }; let alternate_first_arg = { let Argument::SpreadElement(el) = &mut alternate.arguments[0] else { unreachable!() }; - el.argument.take_in(ctx.ast.allocator) + el.argument.take_in(ctx.ast) }; let mut args = std::mem::replace(&mut consequent.arguments, ctx.ast.vec()); args[0] = ctx.ast.argument_spread_element( expr.span, ctx.ast.expression_conditional( expr.test.span(), - expr.test.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), consequent_first_arg, alternate_first_arg, ), @@ -293,16 +293,16 @@ impl<'a> PeepholeOptimizations { if !matches!(consequent.arguments[0], Argument::SpreadElement(_)) && !matches!(alternate.arguments[0], Argument::SpreadElement(_)) { - let callee = consequent.callee.take_in(ctx.ast.allocator); + let callee = consequent.callee.take_in(ctx.ast); let consequent_first_arg = - consequent.arguments[0].to_expression_mut().take_in(ctx.ast.allocator); + consequent.arguments[0].to_expression_mut().take_in(ctx.ast); let alternate_first_arg = - alternate.arguments[0].to_expression_mut().take_in(ctx.ast.allocator); + alternate.arguments[0].to_expression_mut().take_in(ctx.ast); let mut args = std::mem::replace(&mut consequent.arguments, ctx.ast.vec()); let cond_expr = self.minimize_conditional( expr.test.span(), - expr.test.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), consequent_first_arg, alternate_first_arg, ctx, @@ -356,12 +356,12 @@ impl<'a> PeepholeOptimizations { if maybe_same_id_expr.is_specific_id(&target_id_name) { return Some(ctx.ast.expression_logical( expr.span, - value_expr.take_in(ctx.ast.allocator), + value_expr.take_in(ctx.ast), LogicalOperator::Coalesce, if is_negate { - expr.alternate.take_in(ctx.ast.allocator) + expr.alternate.take_in(ctx.ast) } else { - expr.consequent.take_in(ctx.ast.allocator) + expr.consequent.take_in(ctx.ast) }, )); } @@ -381,9 +381,7 @@ impl<'a> PeepholeOptimizations { expr_to_inject_optional_chaining, ctx, ) { - return Some( - expr_to_inject_optional_chaining.take_in(ctx.ast.allocator), - ); + return Some(expr_to_inject_optional_chaining.take_in(ctx.ast)); } } } @@ -394,14 +392,13 @@ impl<'a> PeepholeOptimizations { if ctx.expr_eq(&expr.alternate, &expr.consequent) { // "/* @__PURE__ */ a() ? b : b" => "b" if !expr.test.may_have_side_effects(&ctx) { - return Some(expr.consequent.take_in(ctx.ast.allocator)); + return Some(expr.consequent.take_in(ctx.ast)); } // "a ? b : b" => "a, b" - let expressions = ctx.ast.vec_from_array([ - expr.test.take_in(ctx.ast.allocator), - expr.consequent.take_in(ctx.ast.allocator), - ]); + let expressions = ctx + .ast + .vec_from_array([expr.test.take_in(ctx.ast), expr.consequent.take_in(ctx.ast)]); return Some(ctx.ast.expression_sequence(expr.span, expressions)); } @@ -439,15 +436,15 @@ impl<'a> PeepholeOptimizations { } let cond_expr = self.minimize_conditional( expr.span, - expr.test.take_in(ctx.ast.allocator), - consequent.right.take_in(ctx.ast.allocator), - alternate.right.take_in(ctx.ast.allocator), + expr.test.take_in(ctx.ast), + consequent.right.take_in(ctx.ast), + alternate.right.take_in(ctx.ast), ctx, ); Some(ctx.ast.expression_assignment( expr.span, consequent.operator, - alternate.left.take_in(ctx.ast.allocator), + alternate.left.take_in(ctx.ast), cond_expr, )) } @@ -470,7 +467,7 @@ impl<'a> PeepholeOptimizations { if !matches!(expr, Expression::ChainExpression(_)) { *expr = ctx.ast.expression_chain( expr.span(), - expr.take_in(ctx.ast.allocator).into_chain_element().unwrap(), + expr.take_in(ctx.ast).into_chain_element().unwrap(), ); } true @@ -490,7 +487,7 @@ impl<'a> PeepholeOptimizations { Expression::StaticMemberExpression(e) => { if e.object.is_specific_id(target_id_name) { e.optional = true; - e.object = expr_to_inject.take_in(ctx.ast.allocator); + e.object = expr_to_inject.take_in(ctx.ast); return true; } if Self::inject_optional_chaining_if_matched_inner( @@ -505,7 +502,7 @@ impl<'a> PeepholeOptimizations { Expression::ComputedMemberExpression(e) => { if e.object.is_specific_id(target_id_name) { e.optional = true; - e.object = expr_to_inject.take_in(ctx.ast.allocator); + e.object = expr_to_inject.take_in(ctx.ast); return true; } if Self::inject_optional_chaining_if_matched_inner( @@ -520,7 +517,7 @@ impl<'a> PeepholeOptimizations { Expression::CallExpression(e) => { if e.callee.is_specific_id(target_id_name) { e.optional = true; - e.callee = expr_to_inject.take_in(ctx.ast.allocator); + e.callee = expr_to_inject.take_in(ctx.ast); return true; } if Self::inject_optional_chaining_if_matched_inner( @@ -536,7 +533,7 @@ impl<'a> PeepholeOptimizations { ChainElement::StaticMemberExpression(e) => { if e.object.is_specific_id(target_id_name) { e.optional = true; - e.object = expr_to_inject.take_in(ctx.ast.allocator); + e.object = expr_to_inject.take_in(ctx.ast); return true; } if Self::inject_optional_chaining_if_matched_inner( @@ -551,7 +548,7 @@ impl<'a> PeepholeOptimizations { ChainElement::ComputedMemberExpression(e) => { if e.object.is_specific_id(target_id_name) { e.optional = true; - e.object = expr_to_inject.take_in(ctx.ast.allocator); + e.object = expr_to_inject.take_in(ctx.ast); return true; } if Self::inject_optional_chaining_if_matched_inner( @@ -566,7 +563,7 @@ impl<'a> PeepholeOptimizations { ChainElement::CallExpression(e) => { if e.callee.is_specific_id(target_id_name) { e.optional = true; - e.callee = expr_to_inject.take_in(ctx.ast.allocator); + e.callee = expr_to_inject.take_in(ctx.ast); return true; } if Self::inject_optional_chaining_if_matched_inner( diff --git a/crates/oxc_minifier/src/peephole/minimize_conditions.rs b/crates/oxc_minifier/src/peephole/minimize_conditions.rs index 0f2973c3fbbc9..5ad700d46c387 100644 --- a/crates/oxc_minifier/src/peephole/minimize_conditions.rs +++ b/crates/oxc_minifier/src/peephole/minimize_conditions.rs @@ -91,9 +91,9 @@ impl<'a> PeepholeOptimizations { loop { if let Expression::LogicalExpression(logical_expr) = &mut b { if logical_expr.operator == op { - let right = logical_expr.left.take_in(ctx.ast.allocator); + let right = logical_expr.left.take_in(ctx.ast); a = self.join_with_left_associative_op(span, op, a, right, ctx); - b = logical_expr.right.take_in(ctx.ast.allocator); + b = logical_expr.right.take_in(ctx.ast); continue; } } @@ -150,9 +150,9 @@ impl<'a> PeepholeOptimizations { _ => return None, } Some(if b.value { - e.left.take_in(ctx.ast.allocator) + e.left.take_in(ctx.ast) } else { - let argument = e.left.take_in(ctx.ast.allocator); + let argument = e.left.take_in(ctx.ast); ctx.ast.expression_unary(e.span, UnaryOperator::LogicalNot, argument) }) } @@ -247,7 +247,7 @@ impl<'a> PeepholeOptimizations { let new_op = logical_expr.operator.to_assignment_operator(); expr.operator = new_op; - expr.right = logical_expr.right.take_in(ctx.ast.allocator); + expr.right = logical_expr.right.take_in(ctx.ast); true } @@ -269,7 +269,7 @@ impl<'a> PeepholeOptimizations { } expr.operator = new_op; - expr.right = binary_expr.right.take_in(ctx.ast.allocator); + expr.right = binary_expr.right.take_in(ctx.ast); true } @@ -293,7 +293,7 @@ impl<'a> PeepholeOptimizations { } else { return None; }; - let target = target.take_in(ctx.ast.allocator); + let target = target.take_in(ctx.ast); Some(ctx.ast.expression_update(expr.span, operator, true, target)) } } diff --git a/crates/oxc_minifier/src/peephole/minimize_expression_in_boolean_context.rs b/crates/oxc_minifier/src/peephole/minimize_expression_in_boolean_context.rs index be7a9e999fc56..c6bd747f1c1c4 100644 --- a/crates/oxc_minifier/src/peephole/minimize_expression_in_boolean_context.rs +++ b/crates/oxc_minifier/src/peephole/minimize_expression_in_boolean_context.rs @@ -35,7 +35,7 @@ impl<'a> PeepholeOptimizations { 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.allocator); + let mut e = u2.argument.take_in(ctx.ast); self.try_fold_expr_in_boolean_context(&mut e, ctx); *expr = e; return true; @@ -47,7 +47,7 @@ impl<'a> PeepholeOptimizations { && matches!(&e.right, Expression::NumericLiteral(lit) if lit.value == 0.0) && e.left.is_int32_or_uint32(&ctx) => { - let argument = e.left.take_in(ctx.ast.allocator); + let argument = e.left.take_in(ctx.ast); *expr = if matches!( e.operator, BinaryOperator::StrictInequality | BinaryOperator::Inequality @@ -66,7 +66,7 @@ impl<'a> PeepholeOptimizations { self.try_fold_expr_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.allocator); + *expr = e.left.take_in(ctx.ast); return true; } } @@ -76,7 +76,7 @@ impl<'a> PeepholeOptimizations { self.try_fold_expr_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.allocator); + *expr = e.left.take_in(ctx.ast); return true; } } @@ -85,8 +85,8 @@ impl<'a> PeepholeOptimizations { self.try_fold_expr_in_boolean_context(&mut e.consequent, ctx); self.try_fold_expr_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.allocator); - let left = e.test.take_in(ctx.ast.allocator); + let right = e.alternate.take_in(ctx.ast); + let left = e.test.take_in(ctx.ast); let span = e.span; let (op, left) = if boolean { // "if (anything1 ? truthyNoSideEffects : anything2)" => "if (anything1 || anything2)" @@ -99,8 +99,8 @@ impl<'a> PeepholeOptimizations { return true; } if let Some(boolean) = e.alternate.get_side_free_boolean_value(&ctx) { - let left = e.test.take_in(ctx.ast.allocator); - let right = e.consequent.take_in(ctx.ast.allocator); + let left = e.test.take_in(ctx.ast); + let right = e.consequent.take_in(ctx.ast); let span = e.span; let (op, left) = if boolean { // "if (anything1 ? anything2 : truthyNoSideEffects)" => "if (!anything1 || anything2)" diff --git a/crates/oxc_minifier/src/peephole/minimize_for_statement.rs b/crates/oxc_minifier/src/peephole/minimize_for_statement.rs index 98c779a74d086..41e0d1e7ee855 100644 --- a/crates/oxc_minifier/src/peephole/minimize_for_statement.rs +++ b/crates/oxc_minifier/src/peephole/minimize_for_statement.rs @@ -37,9 +37,9 @@ impl<'a> PeepholeOptimizations { } let span = for_stmt.body.span(); - let (first, body) = match for_stmt.body.take_in(ctx.ast.allocator) { + let (first, body) = match for_stmt.body.take_in(ctx.ast) { Statement::BlockStatement(mut block_stmt) => ( - block_stmt.body.get_mut(0).unwrap().take_in(ctx.ast.allocator), + block_stmt.body.get_mut(0).unwrap().take_in(ctx.ast), Some(Statement::BlockStatement(block_stmt)), ), stmt => (stmt, None), @@ -47,7 +47,7 @@ impl<'a> PeepholeOptimizations { let Statement::IfStatement(mut if_stmt) = first else { unreachable!() }; - let expr = match if_stmt.test.take_in(ctx.ast.allocator) { + let expr = match if_stmt.test.take_in(ctx.ast) { Expression::UnaryExpression(unary_expr) if unary_expr.operator.is_not() => { unary_expr.unbox().argument } @@ -55,7 +55,7 @@ impl<'a> PeepholeOptimizations { }; if let Some(test) = &mut for_stmt.test { - let left = test.take_in(ctx.ast.allocator); + let left = test.take_in(ctx.ast); let mut logical_expr = ctx.ast.logical_expression(test.span(), left, LogicalOperator::And, expr); *test = Self::try_fold_and_or(&mut logical_expr, ctx) @@ -79,9 +79,9 @@ impl<'a> PeepholeOptimizations { } let span = for_stmt.body.span(); - let (first, body) = match for_stmt.body.take_in(ctx.ast.allocator) { + let (first, body) = match for_stmt.body.take_in(ctx.ast) { Statement::BlockStatement(mut block_stmt) => ( - block_stmt.body.get_mut(0).unwrap().take_in(ctx.ast.allocator), + block_stmt.body.get_mut(0).unwrap().take_in(ctx.ast), Some(Statement::BlockStatement(block_stmt)), ), stmt => (stmt, None), @@ -89,10 +89,10 @@ impl<'a> PeepholeOptimizations { let Statement::IfStatement(mut if_stmt) = first else { unreachable!() }; - let expr = if_stmt.test.take_in(ctx.ast.allocator); + let expr = if_stmt.test.take_in(ctx.ast); if let Some(test) = &mut for_stmt.test { - let left = test.take_in(ctx.ast.allocator); + let left = test.take_in(ctx.ast); let mut logical_expr = ctx.ast.logical_expression(test.span(), left, LogicalOperator::And, expr); *test = Self::try_fold_and_or(&mut logical_expr, ctx) @@ -101,7 +101,7 @@ impl<'a> PeepholeOptimizations { for_stmt.test = Some(expr); } - let consequent = if_stmt.consequent.take_in(ctx.ast.allocator); + let consequent = if_stmt.consequent.take_in(ctx.ast); for_stmt.body = Self::drop_first_statement(span, body, Some(consequent), ctx); state.changed = true; } @@ -120,7 +120,7 @@ impl<'a> PeepholeOptimizations { } else if block_stmt.body.len() == 2 && !Self::statement_cares_about_scope(&block_stmt.body[1]) { - return block_stmt.body[1].take_in(ctx.ast.allocator); + return block_stmt.body[1].take_in(ctx.ast); } else { block_stmt.body.remove(0); } diff --git a/crates/oxc_minifier/src/peephole/minimize_if_statement.rs b/crates/oxc_minifier/src/peephole/minimize_if_statement.rs index f4cabd7d8ea43..dd130473007ba 100644 --- a/crates/oxc_minifier/src/peephole/minimize_if_statement.rs +++ b/crates/oxc_minifier/src/peephole/minimize_if_statement.rs @@ -27,17 +27,17 @@ impl<'a> PeepholeOptimizations { // "if (a) b();" => "a && b();" e => (LogicalOperator::And, e), }; - let a = e.take_in(ctx.ast.allocator); - let b = expr_stmt.expression.take_in(ctx.ast.allocator); + let a = e.take_in(ctx.ast); + let b = expr_stmt.expression.take_in(ctx.ast); let expr = self.join_with_left_associative_op(if_stmt.span, op, a, b, ctx); return Some(ctx.ast.statement_expression(if_stmt.span, expr)); } else if let Some(Statement::ExpressionStatement(alternate_expr_stmt)) = &mut if_stmt.alternate { // "if (a) b(); else c();" => "a ? b() : c();" - let test = if_stmt.test.take_in(ctx.ast.allocator); - let consequent = expr_stmt.expression.take_in(ctx.ast.allocator); - let alternate = alternate_expr_stmt.expression.take_in(ctx.ast.allocator); + let test = if_stmt.test.take_in(ctx.ast); + let consequent = expr_stmt.expression.take_in(ctx.ast); + let alternate = alternate_expr_stmt.expression.take_in(ctx.ast); let expr = self.minimize_conditional(if_stmt.span, test, consequent, alternate, ctx); return Some(ctx.ast.statement_expression(if_stmt.span, expr)); @@ -47,7 +47,7 @@ impl<'a> PeepholeOptimizations { || if_stmt.alternate.as_ref().is_some_and(Self::is_statement_empty) { // "if (a) {}" => "a;" - let mut expr = if_stmt.test.take_in(ctx.ast.allocator); + let mut expr = if_stmt.test.take_in(ctx.ast); self.remove_unused_expression(&mut expr, state, ctx); return Some(ctx.ast.statement_expression(if_stmt.span, expr)); } else if let Some(Statement::ExpressionStatement(expr_stmt)) = &mut if_stmt.alternate { @@ -59,8 +59,8 @@ impl<'a> PeepholeOptimizations { // "if (a) {} else b();" => "a || b();" e => (LogicalOperator::Or, e), }; - let a = e.take_in(ctx.ast.allocator); - let b = expr_stmt.expression.take_in(ctx.ast.allocator); + let a = e.take_in(ctx.ast); + let b = expr_stmt.expression.take_in(ctx.ast); let expr = self.join_with_left_associative_op(if_stmt.span, op, a, b, ctx); return Some(ctx.ast.statement_expression(if_stmt.span, expr)); } else if let Some(stmt) = &mut if_stmt.alternate { @@ -68,8 +68,8 @@ impl<'a> PeepholeOptimizations { match &mut if_stmt.test { // "if (!a) {} else return b;" => "if (a) return b;" Expression::UnaryExpression(unary_expr) if unary_expr.operator.is_not() => { - if_stmt.test = unary_expr.argument.take_in(ctx.ast.allocator); - if_stmt.consequent = stmt.take_in(ctx.ast.allocator); + if_stmt.test = unary_expr.argument.take_in(ctx.ast); + if_stmt.consequent = stmt.take_in(ctx.ast); if_stmt.alternate = None; state.changed = true; } @@ -77,10 +77,10 @@ impl<'a> PeepholeOptimizations { _ => { if_stmt.test = self.minimize_not( if_stmt.test.span(), - if_stmt.test.take_in(ctx.ast.allocator), + if_stmt.test.take_in(ctx.ast), ctx, ); - if_stmt.consequent = stmt.take_in(ctx.ast.allocator); + if_stmt.consequent = stmt.take_in(ctx.ast); if_stmt.alternate = None; self.try_minimize_if(if_stmt, state, ctx); state.changed = true; @@ -94,7 +94,7 @@ impl<'a> PeepholeOptimizations { if let Expression::UnaryExpression(unary_expr) = &mut if_stmt.test { if unary_expr.operator.is_not() { // "if (!a) return b; else return c;" => "if (a) return c; else return b;" - if_stmt.test = unary_expr.argument.take_in(ctx.ast.allocator); + if_stmt.test = unary_expr.argument.take_in(ctx.ast); std::mem::swap(&mut if_stmt.consequent, alternate); self.wrap_to_avoid_ambiguous_else(if_stmt, state, ctx); state.changed = true; @@ -106,8 +106,8 @@ impl<'a> PeepholeOptimizations { if let Statement::IfStatement(if2_stmt) = &mut if_stmt.consequent { if if2_stmt.alternate.is_none() { // "if (a) if (b) return c;" => "if (a && b) return c;" - let a = if_stmt.test.take_in(ctx.ast.allocator); - let b = if2_stmt.test.take_in(ctx.ast.allocator); + let a = if_stmt.test.take_in(ctx.ast); + let b = if2_stmt.test.take_in(ctx.ast); if_stmt.test = self.join_with_left_associative_op( if_stmt.test.span(), LogicalOperator::And, @@ -115,7 +115,7 @@ impl<'a> PeepholeOptimizations { b, ctx, ); - if_stmt.consequent = if2_stmt.consequent.take_in(ctx.ast.allocator); + if_stmt.consequent = if2_stmt.consequent.take_in(ctx.ast); state.changed = true; } } @@ -139,7 +139,7 @@ impl<'a> PeepholeOptimizations { if_stmt.consequent = Statement::BlockStatement(ctx.ast.alloc( ctx.ast.block_statement_with_scope_id( if_stmt.consequent.span(), - ctx.ast.vec1(if_stmt.consequent.take_in(ctx.ast.allocator)), + ctx.ast.vec1(if_stmt.consequent.take_in(ctx.ast)), scope_id, ), )); diff --git a/crates/oxc_minifier/src/peephole/minimize_logical_expression.rs b/crates/oxc_minifier/src/peephole/minimize_logical_expression.rs index 04be3e5d9a91a..833e98c28e2d5 100644 --- a/crates/oxc_minifier/src/peephole/minimize_logical_expression.rs +++ b/crates/oxc_minifier/src/peephole/minimize_logical_expression.rs @@ -65,7 +65,7 @@ impl<'a> PeepholeOptimizations { .map(|new_expr| { ctx.ast.expression_logical( expr.span, - left.left.take_in(ctx.ast.allocator), + left.left.take_in(ctx.ast), expr.operator, new_expr, ) @@ -142,7 +142,7 @@ impl<'a> PeepholeOptimizations { }; Some(ctx.ast.expression_binary( span, - left_non_value_expr.take_in(ctx.ast.allocator), + left_non_value_expr.take_in(ctx.ast), replace_op, ctx.ast.expression_null_literal(null_expr_span), )) @@ -226,6 +226,6 @@ impl<'a> PeepholeOptimizations { } assignment_expr.span = expr.span; assignment_expr.operator = new_op; - Some(expr.right.take_in(ctx.ast.allocator)) + Some(expr.right.take_in(ctx.ast)) } } diff --git a/crates/oxc_minifier/src/peephole/minimize_not_expression.rs b/crates/oxc_minifier/src/peephole/minimize_not_expression.rs index 07823b8dfddb1..539f073626e15 100644 --- a/crates/oxc_minifier/src/peephole/minimize_not_expression.rs +++ b/crates/oxc_minifier/src/peephole/minimize_not_expression.rs @@ -35,7 +35,7 @@ impl<'a> PeepholeOptimizations { Expression::UnaryExpression(e) if e.operator.is_not() && e.argument.value_type(&ctx).is_boolean() => { - Some(e.argument.take_in(ctx.ast.allocator)) + Some(e.argument.take_in(ctx.ast)) } // `!(a == b)` => `a != b` // `!(a != b)` => `a == b` @@ -43,17 +43,14 @@ impl<'a> PeepholeOptimizations { // `!(a !== b)` => `a === b` Expression::BinaryExpression(e) if e.operator.is_equality() => { e.operator = e.operator.equality_inverse_operator().unwrap(); - Some(expr.argument.take_in(ctx.ast.allocator)) + Some(expr.argument.take_in(ctx.ast)) } // "!(a, b)" => "a, !b" Expression::SequenceExpression(sequence_expr) => { if let Some(last_expr) = sequence_expr.expressions.last_mut() { - *last_expr = self.minimize_not( - last_expr.span(), - last_expr.take_in(ctx.ast.allocator), - ctx, - ); - return Some(expr.argument.take_in(ctx.ast.allocator)); + *last_expr = + self.minimize_not(last_expr.span(), last_expr.take_in(ctx.ast), ctx); + return Some(expr.argument.take_in(ctx.ast)); } None } diff --git a/crates/oxc_minifier/src/peephole/minimize_statements.rs b/crates/oxc_minifier/src/peephole/minimize_statements.rs index 6b6d89b9309a6..d2e8907134274 100644 --- a/crates/oxc_minifier/src/peephole/minimize_statements.rs +++ b/crates/oxc_minifier/src/peephole/minimize_statements.rs @@ -39,9 +39,9 @@ impl<'a> PeepholeOptimizations { let mut result: Vec<'a, Statement<'a>> = ctx.ast.vec_with_capacity(stmts.len()); let mut is_control_flow_dead = false; let mut keep_var = KeepVar::new(ctx.ast); - let mut new_stmts = stmts.take_in(ctx.ast.allocator); + let mut new_stmts = stmts.take_in(ctx.ast); for i in 0..new_stmts.len() { - let stmt = new_stmts[i].take_in(ctx.ast.allocator); + let stmt = new_stmts[i].take_in(ctx.ast); if is_control_flow_dead && !stmt.is_module_declaration() && !matches!(stmt.as_declaration(), Some(Declaration::FunctionDeclaration(_))) @@ -158,7 +158,7 @@ impl<'a> PeepholeOptimizations { // "if (!a) return b; return c;" => "return a ? c : b;" if let Expression::UnaryExpression(unary_expr) = &mut prev_if.test { if unary_expr.operator.is_not() { - prev_if.test = unary_expr.argument.take_in(ctx.ast.allocator); + prev_if.test = unary_expr.argument.take_in(ctx.ast); std::mem::swap(&mut left, &mut right); } } @@ -175,7 +175,7 @@ impl<'a> PeepholeOptimizations { // "if (a) return b; return c;" => "return a ? b : c;" let mut expr = self.minimize_conditional( prev_if.span, - prev_if.test.take_in(ctx.ast.allocator), + prev_if.test.take_in(ctx.ast), left, right, ctx, @@ -245,7 +245,7 @@ impl<'a> PeepholeOptimizations { // "if (!a) throw b; throw c;" => "throw a ? c : b;" if let Expression::UnaryExpression(unary_expr) = &mut prev_if.test { if unary_expr.operator.is_not() { - prev_if.test = unary_expr.argument.take_in(ctx.ast.allocator); + prev_if.test = unary_expr.argument.take_in(ctx.ast); std::mem::swap(&mut left, &mut right); } } @@ -262,7 +262,7 @@ impl<'a> PeepholeOptimizations { // "if (a) throw b; throw c;" => "throw a ? b : c;" let mut expr = self.minimize_conditional( prev_if.span, - prev_if.test.take_in(ctx.ast.allocator), + prev_if.test.take_in(ctx.ast), left, right, ctx, @@ -342,8 +342,8 @@ impl<'a> PeepholeOptimizations { b: &mut Expression<'a>, ctx: Ctx<'a, '_>, ) -> Expression<'a> { - let a = a.take_in(ctx.ast.allocator); - let b = b.take_in(ctx.ast.allocator); + let a = a.take_in(ctx.ast); + let b = b.take_in(ctx.ast); if let Expression::SequenceExpression(mut sequence_expr) = a { // `(a, b); c` sequence_expr.expressions.push(b); @@ -449,8 +449,8 @@ impl<'a> PeepholeOptimizations { if_stmt.test = self.join_with_left_associative_op( if_stmt.test.span(), LogicalOperator::Or, - prev_if_stmt.test.take_in(ctx.ast.allocator), - if_stmt.test.take_in(ctx.ast.allocator), + prev_if_stmt.test.take_in(ctx.ast), + if_stmt.test.take_in(ctx.ast), ctx, ); result.pop(); @@ -518,7 +518,7 @@ impl<'a> PeepholeOptimizations { self.minimize_statements(&mut body, state, ctx); let span = if body.is_empty() { if_stmt.consequent.span() } else { body[0].span() }; - let test = if_stmt.test.take_in(ctx.ast.allocator); + 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); let consequent = if body.len() == 1 { @@ -622,9 +622,8 @@ impl<'a> PeepholeOptimizations { state.changed = true; } } else { - for_stmt.init = Some(ForStatementInit::from( - prev_expr_stmt.expression.take_in(ctx.ast.allocator), - )); + for_stmt.init = + Some(ForStatementInit::from(prev_expr_stmt.expression.take_in(ctx.ast))); result.pop(); state.changed = true; } diff --git a/crates/oxc_minifier/src/peephole/normalize.rs b/crates/oxc_minifier/src/peephole/normalize.rs index 70136b9c5bc0f..ecd3871602172 100644 --- a/crates/oxc_minifier/src/peephole/normalize.rs +++ b/crates/oxc_minifier/src/peephole/normalize.rs @@ -72,7 +72,7 @@ impl<'a> Traverse<'a> for Normalize { fn exit_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { if let Expression::ParenthesizedExpression(paren_expr) = expr { - *expr = paren_expr.expression.take_in(ctx.ast.allocator); + *expr = paren_expr.expression.take_in(ctx.ast); } if let Some(e) = match expr { Expression::Identifier(ident) => Self::try_compress_identifier(ident, ctx), @@ -143,7 +143,7 @@ impl<'a> Normalize { } fn convert_while_to_for(stmt: &mut Statement<'a>, ctx: &mut TraverseCtx<'a>) { - let Statement::WhileStatement(while_stmt) = stmt.take_in(ctx.ast.allocator) else { return }; + let Statement::WhileStatement(while_stmt) = stmt.take_in(ctx.ast) else { return }; let while_stmt = while_stmt.unbox(); let for_stmt = ctx.ast.alloc_for_statement_with_scope_id( while_stmt.span, diff --git a/crates/oxc_minifier/src/peephole/remove_dead_code.rs b/crates/oxc_minifier/src/peephole/remove_dead_code.rs index c967bd0dda2c7..a1d4a10a12eaf 100644 --- a/crates/oxc_minifier/src/peephole/remove_dead_code.rs +++ b/crates/oxc_minifier/src/peephole/remove_dead_code.rs @@ -224,24 +224,19 @@ impl<'a, 'b> PeepholeOptimizations { if_stmt.consequent = ctx.ast.statement_empty(if_stmt.consequent.span()); } } - return Some( - ctx.ast.statement_if( - if_stmt.span, - if_stmt.test.take_in(ctx.ast.allocator), - if_stmt.consequent.take_in(ctx.ast.allocator), - if_stmt - .alternate - .as_mut() - .map(|alternate| alternate.take_in(ctx.ast.allocator)), - ), - ); + return Some(ctx.ast.statement_if( + if_stmt.span, + if_stmt.test.take_in(ctx.ast), + if_stmt.consequent.take_in(ctx.ast), + if_stmt.alternate.as_mut().map(|alternate| alternate.take_in(ctx.ast)), + )); } return Some(if boolean { - if_stmt.consequent.take_in(ctx.ast.allocator) + if_stmt.consequent.take_in(ctx.ast) } else { if_stmt.alternate.as_mut().map_or_else( || ctx.ast.statement_empty(if_stmt.span), - |alternate| alternate.take_in(ctx.ast.allocator), + |alternate| alternate.take_in(ctx.ast), ) }); } @@ -284,7 +279,7 @@ impl<'a, 'b> PeepholeOptimizations { if let Some(var_decl) = &mut var_decl { var_decl .declarations - .splice(0..0, var_init.declarations.take_in(ctx.ast.allocator)); + .splice(0..0, var_init.declarations.take_in(ctx.ast)); } else { var_decl = Some(var_init.take_in_box(ctx.ast.allocator)); } @@ -404,22 +399,22 @@ impl<'a, 'b> PeepholeOptimizations { // "(a, true) ? b : c" => "a, b" let exprs = ctx.ast.vec_from_array([ { - let mut test = expr.test.take_in(ctx.ast.allocator); + let mut test = expr.test.take_in(ctx.ast); self.remove_unused_expression(&mut test, state, ctx); test }, if v { - expr.consequent.take_in(ctx.ast.allocator) + expr.consequent.take_in(ctx.ast) } else { - expr.alternate.take_in(ctx.ast.allocator) + expr.alternate.take_in(ctx.ast) }, ]); ctx.ast.expression_sequence(expr.span, exprs) } else { let result_expr = if v { - expr.consequent.take_in(ctx.ast.allocator) + expr.consequent.take_in(ctx.ast) } else { - expr.alternate.take_in(ctx.ast.allocator) + expr.alternate.take_in(ctx.ast) }; let should_keep_as_sequence_expr = diff --git a/crates/oxc_minifier/src/peephole/remove_unused_expression.rs b/crates/oxc_minifier/src/peephole/remove_unused_expression.rs index b1e5ec9c779e4..9b12c3612a3ce 100644 --- a/crates/oxc_minifier/src/peephole/remove_unused_expression.rs +++ b/crates/oxc_minifier/src/peephole/remove_unused_expression.rs @@ -46,7 +46,7 @@ impl<'a> PeepholeOptimizations { let Expression::UnaryExpression(unary_expr) = e else { return false }; match unary_expr.operator { UnaryOperator::Void | UnaryOperator::LogicalNot => { - *e = unary_expr.argument.take_in(ctx.ast.allocator); + *e = unary_expr.argument.take_in(ctx.ast); state.changed = true; self.remove_unused_expression(e, state, ctx) } @@ -54,7 +54,7 @@ impl<'a> PeepholeOptimizations { if unary_expr.argument.is_identifier_reference() { true } else { - *e = unary_expr.argument.take_in(ctx.ast.allocator); + *e = unary_expr.argument.take_in(ctx.ast); state.changed = true; self.remove_unused_expression(e, state, ctx) } @@ -94,7 +94,7 @@ impl<'a> PeepholeOptimizations { } if self.remove_unused_expression(&mut logical_expr.right, state, ctx) { self.remove_unused_expression(&mut logical_expr.left, state, ctx); - *e = logical_expr.left.take_in(ctx.ast.allocator); + *e = logical_expr.left.take_in(ctx.ast); state.changed = true; return false; } @@ -129,7 +129,7 @@ impl<'a> PeepholeOptimizations { logical_right, ctx, ) { - *e = logical_right.take_in(ctx.ast.allocator); + *e = logical_right.take_in(ctx.ast); state.changed = true; return false; } @@ -160,7 +160,7 @@ impl<'a> PeepholeOptimizations { { assignment_expr.span = *logical_span; assignment_expr.operator = AssignmentOperator::LogicalNullish; - *e = logical_right.take_in(ctx.ast.allocator); + *e = logical_right.take_in(ctx.ast); state.changed = true; return false; } @@ -168,9 +168,9 @@ impl<'a> PeepholeOptimizations { *e = ctx.ast.expression_logical( *logical_span, - new_left_hand_expr.take_in(ctx.ast.allocator), + new_left_hand_expr.take_in(ctx.ast), LogicalOperator::Coalesce, - logical_right.take_in(ctx.ast.allocator), + logical_right.take_in(ctx.ast), ); state.changed = true; return false; @@ -484,7 +484,7 @@ impl<'a> PeepholeOptimizations { if test { return true; } - *e = conditional_expr.test.take_in(ctx.ast.allocator); + *e = conditional_expr.test.take_in(ctx.ast); state.changed = true; return false; } @@ -494,8 +494,8 @@ impl<'a> PeepholeOptimizations { *e = self.join_with_left_associative_op( conditional_expr.span, LogicalOperator::Or, - conditional_expr.test.take_in(ctx.ast.allocator), - conditional_expr.alternate.take_in(ctx.ast.allocator), + conditional_expr.test.take_in(ctx.ast), + conditional_expr.alternate.take_in(ctx.ast), ctx, ); state.changed = true; @@ -507,8 +507,8 @@ impl<'a> PeepholeOptimizations { *e = self.join_with_left_associative_op( conditional_expr.span, LogicalOperator::And, - conditional_expr.test.take_in(ctx.ast.allocator), - conditional_expr.consequent.take_in(ctx.ast.allocator), + conditional_expr.test.take_in(ctx.ast), + conditional_expr.consequent.take_in(ctx.ast), ctx, ); state.changed = true; @@ -542,12 +542,12 @@ impl<'a> PeepholeOptimizations { match (left, right) { (true, true) => true, (true, false) => { - *e = binary_expr.right.take_in(ctx.ast.allocator); + *e = binary_expr.right.take_in(ctx.ast); state.changed = true; false } (false, true) => { - *e = binary_expr.left.take_in(ctx.ast.allocator); + *e = binary_expr.left.take_in(ctx.ast); state.changed = true; false } @@ -555,8 +555,8 @@ impl<'a> PeepholeOptimizations { *e = ctx.ast.expression_sequence( binary_expr.span, ctx.ast.vec_from_array([ - binary_expr.left.take_in(ctx.ast.allocator), - binary_expr.right.take_in(ctx.ast.allocator), + binary_expr.left.take_in(ctx.ast), + binary_expr.right.take_in(ctx.ast), ]), ); state.changed = true; @@ -599,7 +599,7 @@ impl<'a> PeepholeOptimizations { if right_as_primitive.is_symbol() == Some(false) && !binary_expr.right.may_have_side_effects(&ctx) { - *e = binary_expr.left.take_in(ctx.ast.allocator); + *e = binary_expr.left.take_in(ctx.ast); state.changed = true; return true; } @@ -660,19 +660,19 @@ impl<'a> PeepholeOptimizations { if f.expression { // Replace "(() => foo())()" with "foo()" let expr = f.get_expression_mut().unwrap(); - *e = expr.take_in(ctx.ast.allocator); + *e = expr.take_in(ctx.ast); return self.remove_unused_expression(e, state, ctx); } match &mut f.body.statements[0] { Statement::ExpressionStatement(expr_stmt) => { // Replace "(() => { foo() })" with "foo()" - *e = expr_stmt.expression.take_in(ctx.ast.allocator); + *e = expr_stmt.expression.take_in(ctx.ast); return self.remove_unused_expression(e, state, ctx); } Statement::ReturnStatement(ret_stmt) => { if let Some(argument) = &mut ret_stmt.argument { // Replace "(() => { return foo() })" with "foo()" - *e = argument.take_in(ctx.ast.allocator); + *e = argument.take_in(ctx.ast); return self.remove_unused_expression(e, state, ctx); } // Replace "(() => { return })" with "" diff --git a/crates/oxc_minifier/src/peephole/replace_known_methods.rs b/crates/oxc_minifier/src/peephole/replace_known_methods.rs index 6b7be42c2ac07..c5143e602c332 100644 --- a/crates/oxc_minifier/src/peephole/replace_known_methods.rs +++ b/crates/oxc_minifier/src/peephole/replace_known_methods.rs @@ -410,20 +410,16 @@ impl<'a> PeepholeOptimizations { let wrap_with_unary_plus_if_needed = |expr: &mut Expression<'a>| { if expr.value_type(&ctx).is_number() { - expr.take_in(ctx.ast.allocator) + expr.take_in(ctx.ast) } else { - ctx.ast.expression_unary( - SPAN, - UnaryOperator::UnaryPlus, - expr.take_in(ctx.ast.allocator), - ) + ctx.ast.expression_unary(SPAN, UnaryOperator::UnaryPlus, expr.take_in(ctx.ast)) } }; Some(ctx.ast.expression_binary( span, // see [`PeepholeOptimizations::is_binary_operator_that_does_number_conversion`] why it does not require `wrap_with_unary_plus_if_needed` here - first_arg.take_in(ctx.ast.allocator), + first_arg.take_in(ctx.ast), BinaryOperator::Exponential, wrap_with_unary_plus_if_needed(second_arg), )) @@ -633,13 +629,10 @@ impl<'a> PeepholeOptimizations { *node = ctx.ast.expression_call( original_span, - new_root_callee.take_in(ctx.ast.allocator), + new_root_callee.take_in(ctx.ast), Option::::None, ctx.ast.vec_from_iter( - collected_arguments - .into_iter() - .rev() - .flat_map(|arg| arg.take_in(ctx.ast.allocator)), + collected_arguments.into_iter().rev().flat_map(|arg| arg.take_in(ctx.ast)), ), false, ); @@ -701,13 +694,13 @@ impl<'a> PeepholeOptimizations { } if args.is_empty() { - Some(object.take_in(ctx.ast.allocator)) + Some(object.take_in(ctx.ast)) } else if can_merge_until.is_some() { Some(ctx.ast.expression_call( span, - callee.take_in(ctx.ast.allocator), + callee.take_in(ctx.ast), Option::::None, - args.take_in(ctx.ast.allocator), + args.take_in(ctx.ast), false, )) } else { @@ -979,7 +972,7 @@ impl<'a> PeepholeOptimizations { s.span = span; s.value = ctx.ast.atom(&c.to_string()); s.raw = None; - Some(object.take_in(ctx.ast.allocator)) + Some(object.take_in(ctx.ast)) } else { None } diff --git a/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs b/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs index 04e6be287393b..65aeb3e295ba8 100644 --- a/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs +++ b/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs @@ -248,7 +248,7 @@ impl<'a> PeepholeOptimizations { if let Some(body) = arrow_expr.body.statements.first_mut() { if let Statement::ReturnStatement(ret_stmt) = body { let return_stmt_arg = - ret_stmt.argument.as_mut().map(|arg| arg.take_in(ctx.ast.allocator)); + ret_stmt.argument.as_mut().map(|arg| arg.take_in(ctx.ast)); if let Some(arg) = return_stmt_arg { *body = ctx.ast.statement_expression(arg.span(), arg); arrow_expr.expression = true; @@ -291,13 +291,13 @@ impl<'a> PeepholeOptimizations { }; if let Expression::Identifier(ident) = &unary_expr.argument { if ctx.is_global_reference(ident) { - let left = expr.left.take_in(ctx.ast.allocator); + let left = expr.left.take_in(ctx.ast); let right = ctx.ast.expression_string_literal(expr.right.span(), "u", None); return Some(ctx.ast.expression_binary(expr.span, left, new_comp_op, right)); } } - let Expression::UnaryExpression(unary_expr) = expr.left.take_in(ctx.ast.allocator) else { + let Expression::UnaryExpression(unary_expr) = expr.left.take_in(ctx.ast) else { unreachable!() }; let right = ctx.ast.void_0(expr.right.span()); @@ -332,7 +332,7 @@ impl<'a> PeepholeOptimizations { return None; } - Some(expr.argument.take_in(ctx.ast.allocator)) + Some(expr.argument.take_in(ctx.ast)) } /// For `+a - n` => `a - n` (assuming n is a number) @@ -388,9 +388,9 @@ impl<'a> PeepholeOptimizations { let mut new_left = ctx.ast.expression_logical( expr.span, - expr.left.take_in(ctx.ast.allocator), + expr.left.take_in(ctx.ast), expr.operator, - right.left.take_in(ctx.ast.allocator), + right.left.take_in(ctx.ast), ); { @@ -404,7 +404,7 @@ impl<'a> PeepholeOptimizations { expr.span, new_left, expr.operator, - right.right.take_in(ctx.ast.allocator), + right.right.take_in(ctx.ast), )) } @@ -460,7 +460,7 @@ impl<'a> PeepholeOptimizations { .map(|new_expr| { ctx.ast.expression_logical( expr.span, - left.left.take_in(ctx.ast.allocator), + left.left.take_in(ctx.ast), expr.operator, new_expr, ) @@ -580,9 +580,9 @@ impl<'a> PeepholeOptimizations { // `foo != void 0` -> `foo == null`, `foo == undefined` -> `foo == null` if e.operator == BinaryOperator::Inequality || e.operator == BinaryOperator::Equality { let (left, right) = if ctx.is_expression_undefined(&e.right) { - (e.left.take_in(ctx.ast.allocator), ctx.ast.expression_null_literal(e.right.span())) + (e.left.take_in(ctx.ast), ctx.ast.expression_null_literal(e.right.span())) } else if ctx.is_expression_undefined(&e.left) { - (e.right.take_in(ctx.ast.allocator), ctx.ast.expression_null_literal(e.left.span())) + (e.right.take_in(ctx.ast), ctx.ast.expression_null_literal(e.left.span())) } else { return None; }; @@ -684,7 +684,7 @@ impl<'a> PeepholeOptimizations { "Boolean" => match arg { None => Some(ctx.ast.expression_boolean_literal(span, false)), Some(arg) => { - let mut arg = arg.take_in(ctx.ast.allocator); + let mut arg = arg.take_in(ctx.ast); self.try_fold_expr_in_boolean_context(&mut arg, ctx); let arg = ctx.ast.expression_unary(span, UnaryOperator::LogicalNot, arg); Some(self.minimize_not(span, arg, ctx)) @@ -703,7 +703,7 @@ impl<'a> PeepholeOptimizations { span, ctx.ast.expression_string_literal(call_expr.span, "", None), BinaryOperator::Addition, - arg.take_in(ctx.ast.allocator), + arg.take_in(ctx.ast), )) } } @@ -720,8 +720,9 @@ impl<'a> PeepholeOptimizations { // `BigInt(1n)` -> `1n` "BigInt" => match arg { None => None, - Some(arg) => matches!(arg, Expression::BigIntLiteral(_)) - .then(|| arg.take_in(ctx.ast.allocator)), + Some(arg) => { + matches!(arg, Expression::BigIntLiteral(_)).then(|| arg.take_in(ctx.ast)) + } }, _ => None, } @@ -789,28 +790,27 @@ impl<'a> PeepholeOptimizations { } } let callee = ctx.ast.expression_identifier(n.span, "Array"); - let args = args.take_in(ctx.ast.allocator); + let args = args.take_in(ctx.ast); Some(ctx.ast.expression_call(span, callee, NONE, args, false)) } // `new Array(literal)` -> `[literal]` else if arg.is_literal() || matches!(arg, Expression::ArrayExpression(_)) { - let elements = ctx - .ast - .vec1(ArrayExpressionElement::from(arg.take_in(ctx.ast.allocator))); + let elements = + ctx.ast.vec1(ArrayExpressionElement::from(arg.take_in(ctx.ast))); Some(ctx.ast.expression_array(span, elements)) } // `new Array(x)` -> `Array(x)` else { let callee = ctx.ast.expression_identifier(span, "Array"); - let args = args.take_in(ctx.ast.allocator); + let args = args.take_in(ctx.ast); Some(ctx.ast.expression_call(span, callee, NONE, args, false)) } } else { // // `new Array(1, 2, 3)` -> `[1, 2, 3]` let elements = ctx.ast.vec_from_iter( - args.iter_mut().filter_map(|arg| arg.as_expression_mut()).map(|arg| { - ArrayExpressionElement::from(arg.take_in(ctx.ast.allocator)) - }), + args.iter_mut() + .filter_map(|arg| arg.as_expression_mut()) + .map(|arg| ArrayExpressionElement::from(arg.take_in(ctx.ast))), ); Some(ctx.ast.expression_array(span, elements)) } @@ -853,9 +853,9 @@ impl<'a> PeepholeOptimizations { } { Some(ctx.ast.expression_call( e.span, - e.callee.take_in(ctx.ast.allocator), + e.callee.take_in(ctx.ast), NONE, - e.arguments.take_in(ctx.ast.allocator), + e.arguments.take_in(ctx.ast), false, )) } else { @@ -985,22 +985,21 @@ impl<'a> PeepholeOptimizations { ArrayExpressionElement::SpreadElement(spread_el) => { new_args.push(ctx.ast.argument_spread_element( spread_el.span, - spread_el.argument.take_in(ctx.ast.allocator), + spread_el.argument.take_in(ctx.ast), )); } ArrayExpressionElement::Elision(elision) => { new_args.push(ctx.ast.void_0(elision.span).into()); } match_expression!(ArrayExpressionElement) => { - new_args - .push(el.to_expression_mut().take_in(ctx.ast.allocator).into()); + new_args.push(el.to_expression_mut().take_in(ctx.ast).into()); } } } } else { new_args.push(ctx.ast.argument_spread_element( spread_el.span, - spread_el.argument.take_in(ctx.ast.allocator), + spread_el.argument.take_in(ctx.ast), )); } } else { diff --git a/crates/oxc_parser/src/cursor.rs b/crates/oxc_parser/src/cursor.rs index f49a64b5510a0..c43fae0cba762 100644 --- a/crates/oxc_parser/src/cursor.rs +++ b/crates/oxc_parser/src/cursor.rs @@ -334,7 +334,7 @@ impl<'a> ParserImpl<'a> { } pub(crate) fn consume_decorators(&mut self) -> Vec<'a, Decorator<'a>> { - self.state.decorators.take_in(self.ast.allocator) + self.state.decorators.take_in(self.ast) } pub(crate) fn parse_normal_list(&mut self, open: Kind, close: Kind, f: F) -> Vec<'a, T> diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs index c8ab5ca3ca686..7b9ee752dc6ef 100644 --- a/crates/oxc_parser/src/js/expression.rs +++ b/crates/oxc_parser/src/js/expression.rs @@ -660,10 +660,8 @@ impl<'a> ParserImpl<'a> { } // Add `ChainExpression` to `a?.c?.b`; if let Expression::TSInstantiationExpression(mut expr) = lhs { - expr.expression = self.map_to_chain_expression( - expr.expression.span(), - expr.expression.take_in(self.ast.allocator), - ); + expr.expression = self + .map_to_chain_expression(expr.expression.span(), expr.expression.take_in(self.ast)); Expression::TSInstantiationExpression(expr) } else { let span = self.end_span(span); diff --git a/crates/oxc_transformer/src/common/arrow_function_converter.rs b/crates/oxc_transformer/src/common/arrow_function_converter.rs index c5912b010aabf..d90c1768ba044 100644 --- a/crates/oxc_transformer/src/common/arrow_function_converter.rs +++ b/crates/oxc_transformer/src/common/arrow_function_converter.rs @@ -420,10 +420,7 @@ impl<'a> Traverse<'a> for ArrowFunctionConverter<'a> { // prop = (() => { return async () => {} })(); // } // ``` - Some(wrap_expression_in_arrow_function_iife( - expr.take_in(ctx.ast.allocator), - ctx, - )) + Some(wrap_expression_in_arrow_function_iife(expr.take_in(ctx.ast), ctx)) } else { return; } @@ -448,8 +445,7 @@ impl<'a> Traverse<'a> for ArrowFunctionConverter<'a> { return; } - let Expression::ArrowFunctionExpression(arrow_function_expr) = - expr.take_in(ctx.ast.allocator) + let Expression::ArrowFunctionExpression(arrow_function_expr) = expr.take_in(ctx.ast) else { unreachable!() }; @@ -749,8 +745,8 @@ impl<'a> ArrowFunctionConverter<'a> { // The property will as a parameter to pass to the new arrow function. // `super[property]` to `_superprop_get(property)` - argument = Some(computed_member.expression.take_in(ctx.ast.allocator)); - computed_member.object.take_in(ctx.ast.allocator) + argument = Some(computed_member.expression.take_in(ctx.ast)); + computed_member.object.take_in(ctx.ast) } MemberExpression::StaticMemberExpression(static_member) => { if !static_member.object.is_super() { @@ -759,7 +755,7 @@ impl<'a> ArrowFunctionConverter<'a> { // Used to generate the name of the arrow function. property = static_member.property.name.as_str(); - expr.take_in(ctx.ast.allocator) + expr.take_in(ctx.ast) } MemberExpression::PrivateFieldExpression(_) => { // Private fields can't be accessed by `super`. @@ -786,7 +782,7 @@ impl<'a> ArrowFunctionConverter<'a> { } // _value if let Some(assign_value) = assign_value { - arguments.push(Argument::from(assign_value.take_in(ctx.ast.allocator))); + arguments.push(Argument::from(assign_value.take_in(ctx.ast))); } let call = ctx.ast.expression_call(SPAN, callee, NONE, arguments, false); Some(call) @@ -823,7 +819,7 @@ impl<'a> ArrowFunctionConverter<'a> { // Add `this` as the first argument and original arguments as the rest. let mut arguments = ctx.ast.vec_with_capacity(call.arguments.len() + 1); arguments.push(Argument::from(ctx.ast.expression_this(SPAN))); - arguments.extend(call.arguments.take_in(ctx.ast.allocator)); + arguments.extend(call.arguments.take_in(ctx.ast)); let property = ctx.ast.identifier_name(SPAN, "call"); let callee = ctx.ast.member_expression_static(SPAN, object, property, false); @@ -860,7 +856,7 @@ impl<'a> ArrowFunctionConverter<'a> { return None; } - let assignment_target = assignment.left.take_in(ctx.ast.allocator); + let assignment_target = assignment.left.take_in(ctx.ast); let mut assignment_expr = Expression::from(assignment_target.into_member_expression()); self.transform_member_expression_for_super( &mut assignment_expr, @@ -1319,7 +1315,7 @@ impl<'a> ConstructorBodyThisAfterSuperInserter<'a, '_> { fn transform_super_call_expression(&mut self, expr: &mut Expression<'a>) { let assignment = self.create_assignment_to_this_temp_var(); let span = expr.span(); - let exprs = self.ctx.ast.vec_from_array([expr.take_in(self.ctx.ast.allocator), assignment]); + let exprs = self.ctx.ast.vec_from_array([expr.take_in(self.ctx.ast), assignment]); *expr = self.ctx.ast.expression_sequence(span, exprs); } diff --git a/crates/oxc_transformer/src/decorator/legacy/metadata.rs b/crates/oxc_transformer/src/decorator/legacy/metadata.rs index 2318364763386..fb279a57ed455 100644 --- a/crates/oxc_transformer/src/decorator/legacy/metadata.rs +++ b/crates/oxc_transformer/src/decorator/legacy/metadata.rs @@ -393,7 +393,7 @@ impl<'a> LegacyDecoratorMetadata<'a, '_> { let binding = self.ctx.var_declarations.create_uid_var_based_on_node(&left, ctx); let Expression::LogicalExpression(logical) = &mut left else { unreachable!() }; - let right = logical.right.take_in(ctx.ast.allocator); + let right = logical.right.take_in(ctx.ast); // `(_a = A.B)` let right = ctx.ast.expression_assignment( SPAN, diff --git a/crates/oxc_transformer/src/decorator/legacy/mod.rs b/crates/oxc_transformer/src/decorator/legacy/mod.rs index ca0f1f2637fb5..8c21c1c806ba0 100644 --- a/crates/oxc_transformer/src/decorator/legacy/mod.rs +++ b/crates/oxc_transformer/src/decorator/legacy/mod.rs @@ -983,7 +983,7 @@ impl<'a> LegacyDecorator<'a, '_> { let binding = self.ctx.var_declarations.create_uid_var_based_on_node(key, ctx); let operator = AssignmentOperator::Assign; let left = binding.create_read_write_target(ctx); - let right = key.to_expression_mut().take_in(ctx.ast.allocator); + let right = key.to_expression_mut().take_in(ctx.ast); let key_expr = ctx.ast.expression_assignment(SPAN, operator, left, right); *key = PropertyKey::from(key_expr); binding.create_read_expression(ctx) diff --git a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs index f8cdf186a87e5..ad814596c17bd 100644 --- a/crates/oxc_transformer/src/es2016/exponentiation_operator.rs +++ b/crates/oxc_transformer/src/es2016/exponentiation_operator.rs @@ -106,7 +106,7 @@ impl<'a> ExponentiationOperator<'a, '_> { // `#[inline]` so compiler knows `expr` is a `BinaryExpression` #[inline] fn convert_binary_expression(expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { - let binary_expr = match expr.take_in(ctx.ast.allocator) { + let binary_expr = match expr.take_in(ctx.ast) { Expression::BinaryExpression(binary_expr) => binary_expr.unbox(), _ => unreachable!(), }; @@ -258,7 +258,7 @@ impl<'a> ExponentiationOperator<'a, '_> { let replacement_left = AssignmentTarget::ComputedMemberExpression(ctx.ast.alloc_computed_member_expression( member_expr.span, - member_expr.object.take_in(ctx.ast.allocator), + member_expr.object.take_in(ctx.ast), ctx.ast.expression_string_literal(prop_span, prop_name, None), false, )); @@ -337,7 +337,7 @@ impl<'a> ExponentiationOperator<'a, '_> { let prop = if prop.is_literal() { prop.clone_in(ctx.ast.allocator) } else { - let owned_prop = prop.take_in(ctx.ast.allocator); + let owned_prop = prop.take_in(ctx.ast); let binding = self.create_temp_var(owned_prop, &mut temp_var_inits, ctx); *prop = binding.create_read_expression(ctx); binding.create_read_expression(ctx) @@ -498,7 +498,7 @@ impl<'a> ExponentiationOperator<'a, '_> { } } - let binding = self.create_temp_var(obj.take_in(ctx.ast.allocator), temp_var_inits, ctx); + let binding = self.create_temp_var(obj.take_in(ctx.ast), temp_var_inits, ctx); *obj = binding.create_read_expression(ctx); binding.create_read_expression(ctx) } @@ -509,7 +509,7 @@ impl<'a> ExponentiationOperator<'a, '_> { pow_left: Expression<'a>, ctx: &mut TraverseCtx<'a>, ) { - let pow_right = assign_expr.right.take_in(ctx.ast.allocator); + let pow_right = assign_expr.right.take_in(ctx.ast); assign_expr.right = Self::math_pow(pow_left, pow_right, ctx); assign_expr.operator = AssignmentOperator::Assign; } @@ -522,7 +522,7 @@ impl<'a> ExponentiationOperator<'a, '_> { ) { if !temp_var_inits.is_empty() { temp_var_inits.reserve_exact(1); - temp_var_inits.push(expr.take_in(ctx.ast.allocator)); + temp_var_inits.push(expr.take_in(ctx.ast)); *expr = ctx.ast.expression_sequence(SPAN, temp_var_inits); } } diff --git a/crates/oxc_transformer/src/es2017/async_to_generator.rs b/crates/oxc_transformer/src/es2017/async_to_generator.rs index b7fc4dea2ce14..81caf625da1d5 100644 --- a/crates/oxc_transformer/src/es2017/async_to_generator.rs +++ b/crates/oxc_transformer/src/es2017/async_to_generator.rs @@ -173,11 +173,7 @@ impl<'a> AsyncToGenerator<'a, '_> { ) -> Option> { // We don't need to handle top-level await. if Self::is_inside_async_function(ctx) { - Some(ctx.ast.expression_yield( - SPAN, - false, - Some(expr.argument.take_in(ctx.ast.allocator)), - )) + Some(ctx.ast.expression_yield(SPAN, false, Some(expr.argument.take_in(ctx.ast)))) } else { None } @@ -471,7 +467,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> { if arrow.expression { let statement = body.statements.first_mut().unwrap(); let expression = match statement { - Statement::ExpressionStatement(es) => es.expression.take_in(ctx.ast.allocator), + Statement::ExpressionStatement(es) => es.expression.take_in(ctx.ast), _ => unreachable!(), }; *statement = ctx.ast.statement_return(expression.span(), Some(expression)); diff --git a/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs b/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs index f2594fffb83bb..8ee8b557a8209 100644 --- a/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs +++ b/crates/oxc_transformer/src/es2018/async_generator_functions/for_await.rs @@ -118,7 +118,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> { } left @ match_assignment_target!(ForStatementLeft) => { // for await (i of test), for await ({ i } of test) - let target = left.to_assignment_target_mut().take_in(ctx.ast.allocator); + let target = left.to_assignment_target_mut().take_in(ctx.ast); let expression = ctx.ast.expression_assignment( SPAN, AssignmentOperator::Assign, @@ -139,13 +139,13 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> { // instead, we need to remove the useless scope. ctx.scoping_mut().delete_scope(block.scope_id()); } else { - statements.push(stmt_body.take_in(ctx.ast.allocator)); + statements.push(stmt_body.take_in(ctx.ast)); } } statements }; - let iterator = stmt.right.take_in(ctx.ast.allocator); + let iterator = stmt.right.take_in(ctx.ast); let iterator = self.ctx.helper_call_expr( Helper::AsyncIterator, SPAN, diff --git a/crates/oxc_transformer/src/es2018/async_generator_functions/mod.rs b/crates/oxc_transformer/src/es2018/async_generator_functions/mod.rs index 1d897951a6e7a..8cc0f239fff6b 100644 --- a/crates/oxc_transformer/src/es2018/async_generator_functions/mod.rs +++ b/crates/oxc_transformer/src/es2018/async_generator_functions/mod.rs @@ -165,7 +165,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> { } expr.argument.as_mut().map(|argument| { - let argument = Argument::from(argument.take_in(ctx.ast.allocator)); + let argument = Argument::from(argument.take_in(ctx.ast)); let arguments = ctx.ast.vec1(argument); let mut argument = self.ctx.helper_call_expr(Helper::AsyncIterator, SPAN, arguments, ctx); @@ -200,7 +200,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> { return None; } - let mut argument = expr.argument.take_in(ctx.ast.allocator); + let mut argument = expr.argument.take_in(ctx.ast); let arguments = ctx.ast.vec1(Argument::from(argument)); argument = self.ctx.helper_call_expr(Helper::AwaitAsyncGenerator, SPAN, arguments, ctx); diff --git a/crates/oxc_transformer/src/es2018/object_rest_spread.rs b/crates/oxc_transformer/src/es2018/object_rest_spread.rs index 33d3cee4d04a1..5f250f6ed8aa5 100644 --- a/crates/oxc_transformer/src/es2018/object_rest_spread.rs +++ b/crates/oxc_transformer/src/es2018/object_rest_spread.rs @@ -255,7 +255,7 @@ impl<'a> ObjectRestSpread<'a, '_> { expressions.push(ctx.ast.expression_assignment( SPAN, op, - assign_expr.left.take_in(ctx.ast.allocator), + assign_expr.left.take_in(ctx.ast), reference_builder.create_read_expression(ctx), )); @@ -403,7 +403,7 @@ impl<'a> ObjectRestSpread<'a, '_> { break; } } - let mut expressions = ctx.ast.vec1(expr.take_in(ctx.ast.allocator)); + let mut expressions = ctx.ast.vec1(expr.take_in(ctx.ast)); expressions.extend(exprs); *expr = ctx.ast.expression_sequence(SPAN, expressions); } @@ -443,7 +443,7 @@ impl<'a> ObjectRestSpread<'a, '_> { exprs.push(ctx.ast.expression_assignment( SPAN, AssignmentOperator::Assign, - pat.take_in(ctx.ast.allocator), + pat.take_in(ctx.ast), bound_identifier.create_read_expression(ctx), )); *pat = bound_identifier.create_spanned_write_target(SPAN, ctx); @@ -493,7 +493,7 @@ impl<'a, 'ctx> ObjectRestSpread<'a, 'ctx> { for prop in obj_expr.properties.drain(..) { if let ObjectPropertyKind::SpreadProperty(mut spread_prop) = prop { Self::make_object_spread(&mut call_expr, &mut props, transform_ctx, ctx); - let arg = spread_prop.argument.take_in(ctx.ast.allocator); + let arg = spread_prop.argument.take_in(ctx.ast); call_expr.as_mut().unwrap().arguments.push(Argument::from(arg)); } else { props.push(prop); @@ -641,7 +641,7 @@ impl<'a> ObjectRestSpread<'a, '_> { return; } let target = left.to_assignment_target_mut(); - let assign_left = target.take_in(ctx.ast.allocator); + let assign_left = target.take_in(ctx.ast); let flags = SymbolFlags::FunctionScopedVariable; let bound_identifier = ctx.generate_uid("ref", scope_id, flags); let id = bound_identifier.create_binding_pattern(ctx); @@ -673,7 +673,7 @@ impl<'a> ObjectRestSpread<'a, '_> { (empty_stmt.span, ctx.ast.vec()) } else { let span = stmt.span(); - (span, ctx.ast.vec1(stmt.take_in(ctx.ast.allocator))) + (span, ctx.ast.vec1(stmt.take_in(ctx.ast))) }; *stmt = ctx.ast.statement_block_with_scope_id(span, stmts, scope_id); scope_id @@ -1154,7 +1154,7 @@ impl<'a> ReferenceBuilder<'a> { force_create_binding: bool, ctx: &mut TraverseCtx<'a>, ) -> Self { - let expr = expr.take_in(ctx.ast.allocator); + let expr = expr.take_in(ctx.ast); let binding; let maybe_bound_identifier; match &expr { diff --git a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs b/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs index 96adfb6dedbd9..000906ff533f0 100644 --- a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs +++ b/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs @@ -56,7 +56,7 @@ impl<'a> Traverse<'a> for NullishCoalescingOperator<'a, '_> { } // Take ownership of the `LogicalExpression` - let Expression::LogicalExpression(logical_expr) = expr.take_in(ctx.ast.allocator) else { + let Expression::LogicalExpression(logical_expr) = expr.take_in(ctx.ast) else { unreachable!() }; diff --git a/crates/oxc_transformer/src/es2020/optional_chaining.rs b/crates/oxc_transformer/src/es2020/optional_chaining.rs index 9b6327e447ee7..3cca49ec9c06b 100644 --- a/crates/oxc_transformer/src/es2020/optional_chaining.rs +++ b/crates/oxc_transformer/src/es2020/optional_chaining.rs @@ -256,9 +256,7 @@ impl<'a> OptionalChaining<'a, '_> { expr: &mut Expression<'a>, ctx: &TraverseCtx<'a>, ) -> Expression<'a> { - let Expression::ChainExpression(chain_expr) = expr.take_in(ctx.ast.allocator) else { - unreachable!() - }; + let Expression::ChainExpression(chain_expr) = expr.take_in(ctx.ast) else { unreachable!() }; match chain_expr.unbox().expression { element @ match_member_expression!(ChainElement) => { Expression::from(element.into_member_expression()) @@ -283,7 +281,7 @@ impl<'a> OptionalChaining<'a, '_> { // To insert the temp binding in the correct scope, we wrap the expression with // an arrow function. During the chain expression transformation, the temp binding // will be inserted into the arrow function's body. - wrap_expression_in_arrow_function_iife(expr.take_in(ctx.ast.allocator), ctx) + wrap_expression_in_arrow_function_iife(expr.take_in(ctx.ast), ctx) } else { self.transform_chain_expression_impl(false, expr, ctx) } @@ -297,7 +295,7 @@ impl<'a> OptionalChaining<'a, '_> { ) { *expr = if self.is_inside_function_parameter { // Same as the above `transform_chain_expression` explanation - wrap_expression_in_arrow_function_iife(expr.take_in(ctx.ast.allocator), ctx) + wrap_expression_in_arrow_function_iife(expr.take_in(ctx.ast), ctx) } else { // Unfortunately no way to get compiler to see that this branch is provably unreachable. // We don't want to inline this function, to keep `enter_expression` as small as possible. @@ -374,7 +372,7 @@ impl<'a> OptionalChaining<'a, '_> { let binding = self.ctx.var_declarations.create_uid_var_based_on_node(object, ctx); *object = Self::create_assignment_expression( binding.create_write_target(ctx), - object.take_in(ctx.ast.allocator), + object.take_in(ctx.ast), ctx, ); binding.create_read_expression(ctx) @@ -488,7 +486,7 @@ impl<'a> OptionalChaining<'a, '_> { if let Expression::Identifier(ident) = callee { if self.should_specify_context(ident, ctx) { // `foo$bar(...)` -> `foo$bar.call(context, ...)` - let callee = callee.take_in(ctx.ast.allocator); + let callee = callee.take_in(ctx.ast); let property = ctx.ast.identifier_name(SPAN, "call"); let member = ctx.ast.member_expression_static(SPAN, callee, property, false); @@ -534,7 +532,7 @@ impl<'a> OptionalChaining<'a, '_> { if ident.name == "eval" { // `eval?.()` is an indirect eval call transformed to `(0,eval)()` let zero = ctx.ast.number_0(); - let original_callee = expr.take_in(ctx.ast.allocator); + let original_callee = expr.take_in(ctx.ast); let expressions = ctx.ast.vec_from_array([zero, original_callee]); *expr = ctx.ast.expression_sequence(SPAN, expressions); } @@ -651,7 +649,7 @@ impl<'a> OptionalChaining<'a, '_> { // `(_foo = foo)` *object = Self::create_assignment_expression( binding.create_write_target(ctx), - object.take_in(ctx.ast.allocator), + object.take_in(ctx.ast), ctx, ); binding.to_maybe_bound_identifier() diff --git a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs index 301d197682e00..379d2bdbdd553 100644 --- a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs +++ b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs @@ -126,7 +126,7 @@ impl<'a> LogicalAssignmentOperators<'a, '_> { }; let assign_op = AssignmentOperator::Assign; - let right = assignment_expr.right.take_in(ctx.ast.allocator); + let right = assignment_expr.right.take_in(ctx.ast); let right = ctx.ast.expression_assignment(SPAN, assign_op, assign_target, right); let logical_expr = ctx.ast.expression_logical(SPAN, left_expr, operator, right); @@ -153,7 +153,7 @@ impl<'a> LogicalAssignmentOperators<'a, '_> { static_expr: &mut StaticMemberExpression<'a>, ctx: &mut TraverseCtx<'a>, ) -> (Expression<'a>, AssignmentTarget<'a>) { - let object = static_expr.object.take_in(ctx.ast.allocator); + let object = static_expr.object.take_in(ctx.ast); let (object, object_ref) = self.ctx.duplicate_expression(object, true, ctx); let left_expr = Expression::from(ctx.ast.member_expression_static( @@ -179,10 +179,10 @@ impl<'a> LogicalAssignmentOperators<'a, '_> { computed_expr: &mut ComputedMemberExpression<'a>, ctx: &mut TraverseCtx<'a>, ) -> (Expression<'a>, AssignmentTarget<'a>) { - let object = computed_expr.object.take_in(ctx.ast.allocator); + let object = computed_expr.object.take_in(ctx.ast); let (object, object_ref) = self.ctx.duplicate_expression(object, true, ctx); - let expression = computed_expr.expression.take_in(ctx.ast.allocator); + let expression = computed_expr.expression.take_in(ctx.ast); let (expression, expression_ref) = self.ctx.duplicate_expression(expression, true, ctx); let left_expr = Expression::from(ctx.ast.member_expression_computed( diff --git a/crates/oxc_transformer/src/es2022/class_properties/class.rs b/crates/oxc_transformer/src/es2022/class_properties/class.rs index 38ec550d4232d..ee1b652fa6d91 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/class.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/class.rs @@ -705,7 +705,7 @@ impl<'a> ClassProperties<'a, '_> { } // `_Class = class {}` - let class_expr = expr.take_in(ctx.ast.allocator); + let class_expr = expr.take_in(ctx.ast); let assignment = create_assignment(binding, class_expr, ctx); if exprs.is_empty() && self.insert_after_exprs.is_empty() { @@ -734,7 +734,7 @@ impl<'a> ClassProperties<'a, '_> { return; } - let class_expr = expr.take_in(ctx.ast.allocator); + let class_expr = expr.take_in(ctx.ast); exprs.push(class_expr); } diff --git a/crates/oxc_transformer/src/es2022/class_properties/computed_key.rs b/crates/oxc_transformer/src/es2022/class_properties/computed_key.rs index f81798fbcb051..af79dc13ab005 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/computed_key.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/computed_key.rs @@ -34,7 +34,7 @@ impl<'a> ClassProperties<'a, '_> { // 3. At least one property satisfying the above is after this method, // or class contains a static block which is being transformed // (static blocks are always evaluated after computed keys, regardless of order) - let original_key = key.take_in(ctx.ast.allocator); + let original_key = key.take_in(ctx.ast); let (assignment, temp_var) = self.ctx.create_computed_key_temp_var(original_key, ctx); self.insert_before.push(assignment); method.key = PropertyKey::from(temp_var); @@ -62,7 +62,7 @@ impl<'a> ClassProperties<'a, '_> { is_static: bool, ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { - let original_key = key.take_in(ctx.ast.allocator); + let original_key = key.take_in(ctx.ast); if self.ctx.key_needs_temp_var(&original_key, ctx) { let (assignment, ident) = self.ctx.create_computed_key_temp_var(original_key, ctx); if is_static { @@ -117,7 +117,7 @@ impl<'a> ClassProperties<'a, '_> { } // Extract assignment from computed key and insert before class - let assignment = prop.key.take_in(ctx.ast.allocator).into_expression(); + let assignment = prop.key.take_in(ctx.ast).into_expression(); self.insert_before.push(assignment); } } diff --git a/crates/oxc_transformer/src/es2022/class_properties/constructor.rs b/crates/oxc_transformer/src/es2022/class_properties/constructor.rs index d45f8b7b7dc3e..0f03642923d25 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/constructor.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/constructor.rs @@ -565,7 +565,7 @@ impl<'a> ConstructorParamsSuperReplacer<'a, '_> { }); let ctx = &mut *self.ctx; - let super_call = expr.take_in(ctx.ast.allocator); + let super_call = expr.take_in(ctx.ast); *expr = ctx.ast.expression_call( span, Expression::from(ctx.ast.member_expression_static( diff --git a/crates/oxc_transformer/src/es2022/class_properties/private_field.rs b/crates/oxc_transformer/src/es2022/class_properties/private_field.rs index ac1c6e283ffba..af465cdfd3028 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/private_field.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/private_field.rs @@ -60,7 +60,7 @@ impl<'a> ClassProperties<'a, '_> { ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { let span = field_expr.span; - let object = field_expr.object.take_in(ctx.ast.allocator); + let object = field_expr.object.take_in(ctx.ast); let resolved = if is_assignment { match self.classes_stack.find_writeable_private_prop(&field_expr.field) { Some(prop) => prop, @@ -266,7 +266,7 @@ impl<'a> ClassProperties<'a, '_> { // `object.#prop(arg)` -> `_classPrivateFieldLooseBase(object, _prop)[_prop](arg)` let prop_binding = self.classes_stack.find_private_prop(&field_expr.field).prop_binding; - let object = field_expr.object.take_in(ctx.ast.allocator); + let object = field_expr.object.take_in(ctx.ast); call_expr.callee = Expression::from(Self::create_private_field_member_expr_loose( object, prop_binding, @@ -333,7 +333,7 @@ impl<'a> ClassProperties<'a, '_> { let span = field_expr.span; // `(object.#method)()` // ^^^^^^^^^^^^^^^^ is a parenthesized expression - let object = field_expr.object.get_inner_expression_mut().take_in(ctx.ast.allocator); + let object = field_expr.object.get_inner_expression_mut().take_in(ctx.ast); let Some(ResolvedPrivateProp { prop_binding, @@ -495,7 +495,7 @@ impl<'a> ClassProperties<'a, '_> { if self.private_fields_as_properties { // `object.#prop = value` -> `_classPrivateFieldLooseBase(object, _prop)[_prop] = value` // Same for all other assignment operators e.g. `+=`, `&&=`, `??=`. - let object = field_expr.object.take_in(ctx.ast.allocator); + let object = field_expr.object.take_in(ctx.ast); let replacement = Self::create_private_field_member_expr_loose( object, // At least one of `get_binding` or `set_binding` is always present @@ -632,7 +632,7 @@ impl<'a> ClassProperties<'a, '_> { if let Some(operator) = operator.to_binary_operator() { // `Class.#prop += value` -> `_prop._ = _prop._ + value` - let value = assign_expr.right.take_in(ctx.ast.allocator); + let value = assign_expr.right.take_in(ctx.ast); assign_expr.operator = AssignmentOperator::Assign; assign_expr.right = ctx.ast.expression_binary(SPAN, prop_obj, operator, value); } else if let Some(operator) = operator.to_logical_operator() { @@ -640,7 +640,7 @@ impl<'a> ClassProperties<'a, '_> { let span = assign_expr.span; assign_expr.span = SPAN; assign_expr.operator = AssignmentOperator::Assign; - let right = expr.take_in(ctx.ast.allocator); + let right = expr.take_in(ctx.ast); *expr = ctx.ast.expression_logical(span, prop_obj, operator, right); } else { // The above covers all types of `AssignmentOperator` @@ -662,7 +662,7 @@ impl<'a> ClassProperties<'a, '_> { let object = field_expr.object.into_inner_expression(); let class_ident = class_binding.create_read_expression(ctx); - let value = assign_expr.right.take_in(ctx.ast.allocator); + let value = assign_expr.right.take_in(ctx.ast); if operator == AssignmentOperator::Assign { // Replace right side of assignment with `_assertClassBrand(Class, object, _prop)` @@ -672,7 +672,7 @@ impl<'a> ClassProperties<'a, '_> { self.create_assert_class_brand(class_ident, object, value, SPAN, ctx); } else { let class_ident = class_binding.create_read_expression(ctx); - let value = assign_expr.right.take_in(ctx.ast.allocator); + let value = assign_expr.right.take_in(ctx.ast); // Make 2 copies of `object` let (object1, object2) = self.duplicate_object(object, ctx); @@ -722,7 +722,7 @@ impl<'a> ClassProperties<'a, '_> { assign_expr.operator = AssignmentOperator::Assign; assign_expr.right = self.create_assert_class_brand(class_ident2, object2, value, SPAN, ctx); - let right = expr.take_in(ctx.ast.allocator); + let right = expr.take_in(ctx.ast); // `_assertClassBrand(Class, object, _prop)._ && (_prop._ = _assertClassBrand(Class, object, value))` *expr = ctx.ast.expression_logical(span, left, operator, right); } else { @@ -754,7 +754,7 @@ impl<'a> ClassProperties<'a, '_> { class_binding: Option<&BoundIdentifier<'a>>, ctx: &mut TraverseCtx<'a>, ) { - let assign_expr = match expr.take_in(ctx.ast.allocator) { + let assign_expr = match expr.take_in(ctx.ast) { Expression::AssignmentExpression(assign_expr) => assign_expr.unbox(), _ => unreachable!(), }; @@ -926,7 +926,7 @@ impl<'a> ClassProperties<'a, '_> { if self.private_fields_as_properties { let prop_binding = self.classes_stack.find_private_prop(&field_expr.field).prop_binding; // `object.#prop++` -> `_classPrivateFieldLooseBase(object, _prop)[_prop]++` - let object = field_expr.object.take_in(ctx.ast.allocator); + let object = field_expr.object.take_in(ctx.ast); let replacement = Self::create_private_field_member_expr_loose( object, prop_binding, @@ -952,7 +952,7 @@ impl<'a> ClassProperties<'a, '_> { // TODO(improve-on-babel): Could avoid `move_expression` here and replace `update_expr.argument` instead. // Only doing this first to match the order Babel creates temp vars. - let object = field_expr.object.get_inner_expression_mut().take_in(ctx.ast.allocator); + let object = field_expr.object.get_inner_expression_mut().take_in(ctx.ast); if is_static && !is_method { // Unwrap is safe because `is_method` is false, then private prop is always have a `get_binding` @@ -1024,7 +1024,7 @@ impl<'a> ClassProperties<'a, '_> { let UpdateExpression { span, prefix, .. } = **update_expr; update_expr.span = SPAN; update_expr.argument = temp_binding.create_read_write_simple_target(ctx); - let update_expr = expr.take_in(ctx.ast.allocator); + let update_expr = expr.take_in(ctx.ast); if prefix { // Source = `++object.#prop` (prefix `++`) @@ -1121,7 +1121,7 @@ impl<'a> ClassProperties<'a, '_> { let UpdateExpression { span, prefix, .. } = **update_expr; update_expr.span = SPAN; update_expr.argument = temp_binding.create_read_write_simple_target(ctx); - let update_expr = expr.take_in(ctx.ast.allocator); + let update_expr = expr.take_in(ctx.ast); if prefix { // Source = `++object.#prop` (prefix `++`) @@ -1375,7 +1375,7 @@ impl<'a> ClassProperties<'a, '_> { // `o?.Foo.#self.self?.self.unicorn;` -> `(result ? void 0 : object)?.self.unicorn` // ^^^^^^^^^^^^^^^^^ the object has transformed, if the current member is optional, // then we need to wrap it to a conditional expression - let owned_object = object.take_in(ctx.ast.allocator); + let owned_object = object.take_in(ctx.ast); *object = Self::wrap_conditional_check(result, owned_object, ctx); None } else { @@ -1397,7 +1397,7 @@ impl<'a> ClassProperties<'a, '_> { // `Foo.bar.#m?.();` -> `_assertClassBrand(Foo, _Foo$bar = Foo.bar, _m)._?.call(_Foo$bar);` // ^^^^ only the private field is optional // Move out parenthesis and typescript syntax - call_expr.callee = callee.take_in(ctx.ast.allocator); + call_expr.callee = callee.take_in(ctx.ast); self.transform_call_expression_impl(call_expr, ctx); return result; } @@ -1415,9 +1415,9 @@ impl<'a> ClassProperties<'a, '_> { // TODO(improve-on-babel): Consider remove this logic, because it seems no runtime behavior change. let result = result?; let object = callee.to_member_expression_mut().object_mut(); - let (assignment, context) = self.duplicate_object(object.take_in(ctx.ast.allocator), ctx); + let (assignment, context) = self.duplicate_object(object.take_in(ctx.ast), ctx); *object = assignment; - let callee = call_expr.callee.take_in(ctx.ast.allocator); + let callee = call_expr.callee.take_in(ctx.ast); let callee = Self::wrap_conditional_check(result, callee, ctx); Self::substitute_callee_and_insert_context(call_expr, callee, context, ctx); @@ -1438,7 +1438,7 @@ impl<'a> ClassProperties<'a, '_> { object: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { - let mut owned_object = object.get_inner_expression_mut().take_in(ctx.ast.allocator); + let mut owned_object = object.get_inner_expression_mut().take_in(ctx.ast); let owned_object = if let Some(result) = self.transform_chain_element_recursively(&mut owned_object, ctx) @@ -1468,9 +1468,7 @@ impl<'a> ClassProperties<'a, '_> { expr: &mut Expression<'a>, ctx: &TraverseCtx<'a>, ) -> Expression<'a> { - let Expression::ChainExpression(chain_expr) = expr.take_in(ctx.ast.allocator) else { - unreachable!() - }; + let Expression::ChainExpression(chain_expr) = expr.take_in(ctx.ast) else { unreachable!() }; match chain_expr.unbox().expression { element @ match_member_expression!(ChainElement) => { Expression::from(element.into_member_expression()) @@ -1572,10 +1570,8 @@ impl<'a> ClassProperties<'a, '_> { if is_optional_callee { // `o?.Foo.#self?.getSelf?.().#x;` -> `(_ref$getSelf = (_ref2 = _ref = o === null || o === void 0 ? // ^^ is optional void 0 : babelHelpers.assertClassBrand(Foo, o.Foo, _self)._)` - *object = - Self::wrap_conditional_check(result, object.take_in(ctx.ast.allocator), ctx); - let (assignment, context) = - self.duplicate_object(object.take_in(ctx.ast.allocator), ctx); + *object = Self::wrap_conditional_check(result, object.take_in(ctx.ast), ctx); + let (assignment, context) = self.duplicate_object(object.take_in(ctx.ast), ctx); *object = assignment; context } else { @@ -1584,11 +1580,9 @@ impl<'a> ClassProperties<'a, '_> { // ^^^^^^^^^^^^^^^^^^^^^^ to make sure get `getSelf` call has a proper context, we need to assign // the parent of callee (i.e `o?.Foo.#self`) to a temp variable, // and then use it as a first argument of `_ref.call`. - let (assignment, context) = - self.duplicate_object(object.take_in(ctx.ast.allocator), ctx); + let (assignment, context) = self.duplicate_object(object.take_in(ctx.ast), ctx); *object = assignment; - *callee = - Self::wrap_conditional_check(result, callee.take_in(ctx.ast.allocator), ctx); + *callee = Self::wrap_conditional_check(result, callee.take_in(ctx.ast), ctx); context } } else { @@ -1596,15 +1590,14 @@ impl<'a> ClassProperties<'a, '_> { // ^^^^^^^^^^^^^^^^ this is a optional function call, to make sure it has a proper context, // we also need to assign `Foo?.bar()` to a temp variable, and then use // it as a first argument of `_Foo$bar$zoo`. - let (assignment, context) = - self.duplicate_object(object.take_in(ctx.ast.allocator), ctx); + let (assignment, context) = self.duplicate_object(object.take_in(ctx.ast), ctx); *object = assignment; context }; // After the below transformation, the `callee` will be a temp variable. let result = self.transform_expression_to_wrap_nullish_check(callee, ctx); - let owned_callee = callee.take_in(ctx.ast.allocator); + let owned_callee = callee.take_in(ctx.ast); Self::substitute_callee_and_insert_context(call, owned_callee, context, ctx); result } @@ -1701,7 +1694,7 @@ impl<'a> ClassProperties<'a, '_> { { // We still need this unary expr, but it needs to be used as the alternative of the conditional unary_expr.argument = chain_expr; - expr.take_in(ctx.ast.allocator) + expr.take_in(ctx.ast) }, ); } @@ -1761,7 +1754,7 @@ impl<'a> ClassProperties<'a, '_> { // But this is not needed, so we omit it. let prop_binding = self.classes_stack.find_private_prop(&field_expr.field).prop_binding; - let object = field_expr.object.take_in(ctx.ast.allocator); + let object = field_expr.object.take_in(ctx.ast); let replacement = Self::create_private_field_member_expr_loose( object, prop_binding, @@ -1851,7 +1844,7 @@ impl<'a> ClassProperties<'a, '_> { expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>, ) { - let Expression::PrivateInExpression(private_in) = expr.take_in(ctx.ast.allocator) else { + let Expression::PrivateInExpression(private_in) = expr.take_in(ctx.ast) else { unreachable!(); }; diff --git a/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs b/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs index 57e1c032af1a3..821cdb9f964aa 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/static_block_and_prop_init.rs @@ -88,12 +88,7 @@ impl<'a> ClassProperties<'a, '_> { let outer_scope_id = ctx.current_scope_id(); ctx.scoping_mut().change_scope_parent_id(scope_id, Some(outer_scope_id)); - wrap_statements_in_arrow_function_iife( - stmts.take_in(ctx.ast.allocator), - scope_id, - block.span, - ctx, - ) + wrap_statements_in_arrow_function_iife(stmts.take_in(ctx.ast), scope_id, block.span, ctx) } fn convert_static_block_with_single_expression_to_expression( @@ -110,7 +105,7 @@ impl<'a> ClassProperties<'a, '_> { // Delete scope for static block ctx.scoping_mut().delete_scope(scope_id); - expr.take_in(ctx.ast.allocator) + expr.take_in(ctx.ast) } /// Replace reference to class name with reference to temp var for class. diff --git a/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs b/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs index c3231fd234f42..9b940898f7ad2 100644 --- a/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs +++ b/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs @@ -90,7 +90,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> { is_callee: bool, ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { - let property = member.expression.take_in(ctx.ast.allocator); + let property = member.expression.take_in(ctx.ast); self.create_super_prop_get(member.span, property, is_callee, ctx) } @@ -205,7 +205,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> { expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>, ) { - let Expression::AssignmentExpression(assign_expr) = expr.take_in(ctx.ast.allocator) else { + let Expression::AssignmentExpression(assign_expr) = expr.take_in(ctx.ast) else { unreachable!() }; let AssignmentExpression { span, operator, right: value, left } = assign_expr.unbox(); @@ -233,7 +233,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> { expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>, ) { - let Expression::AssignmentExpression(assign_expr) = expr.take_in(ctx.ast.allocator) else { + let Expression::AssignmentExpression(assign_expr) = expr.take_in(ctx.ast) else { unreachable!() }; let AssignmentExpression { span, operator, right: value, left } = assign_expr.unbox(); @@ -368,7 +368,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> { expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>, ) { - let Expression::UpdateExpression(mut update_expr) = expr.take_in(ctx.ast.allocator) else { + let Expression::UpdateExpression(mut update_expr) = expr.take_in(ctx.ast) else { unreachable!() }; let SimpleAssignmentTarget::StaticMemberExpression(member) = &mut update_expr.argument @@ -431,7 +431,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> { expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>, ) { - let Expression::UpdateExpression(mut update_expr) = expr.take_in(ctx.ast.allocator) else { + let Expression::UpdateExpression(mut update_expr) = expr.take_in(ctx.ast) else { unreachable!() }; let SimpleAssignmentTarget::ComputedMemberExpression(member) = &mut update_expr.argument @@ -441,7 +441,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> { let temp_var_name_base = get_var_name_from_node(member.as_ref()); - let property = member.expression.get_inner_expression_mut().take_in(ctx.ast.allocator); + let property = member.expression.get_inner_expression_mut().take_in(ctx.ast); *expr = self.transform_super_update_expression_impl( &temp_var_name_base, diff --git a/crates/oxc_transformer/src/es2022/class_static_block.rs b/crates/oxc_transformer/src/es2022/class_static_block.rs index 42a6290d74dcb..51cd39c997106 100644 --- a/crates/oxc_transformer/src/es2022/class_static_block.rs +++ b/crates/oxc_transformer/src/es2022/class_static_block.rs @@ -159,12 +159,7 @@ impl ClassStaticBlock { // Always strict mode since we're in a class. *ctx.scoping_mut().scope_flags_mut(scope_id) = ScopeFlags::Function | ScopeFlags::Arrow | ScopeFlags::StrictMode; - wrap_statements_in_arrow_function_iife( - stmts.take_in(ctx.ast.allocator), - scope_id, - block.span, - ctx, - ) + wrap_statements_in_arrow_function_iife(stmts.take_in(ctx.ast), scope_id, block.span, ctx) } /// Convert static block to expression which will be value of private field, @@ -175,7 +170,7 @@ impl ClassStaticBlock { scope_id: ScopeId, ctx: &mut TraverseCtx<'a>, ) -> Expression<'a> { - let expr = expr.take_in(ctx.ast.allocator); + let expr = expr.take_in(ctx.ast); // Remove the scope for the static block from the scope chain ctx.remove_scope_for_expression(scope_id, &expr); diff --git a/crates/oxc_transformer/src/jsx/jsx_impl.rs b/crates/oxc_transformer/src/jsx/jsx_impl.rs index 135cad6096022..a1330c07079ca 100644 --- a/crates/oxc_transformer/src/jsx/jsx_impl.rs +++ b/crates/oxc_transformer/src/jsx/jsx_impl.rs @@ -499,7 +499,7 @@ impl<'a> Traverse<'a> for JsxImpl<'a, '_> { if !matches!(expr, Expression::JSXElement(_) | Expression::JSXFragment(_)) { return; } - *expr = match expr.take_in(ctx.ast.allocator) { + *expr = match expr.take_in(ctx.ast) { Expression::JSXElement(e) => self.transform_jsx_element(e, ctx), Expression::JSXFragment(e) => self.transform_jsx(e.span, None, e.unbox().children, ctx), _ => unreachable!(), diff --git a/crates/oxc_transformer/src/jsx/refresh.rs b/crates/oxc_transformer/src/jsx/refresh.rs index a05bd4d722fb2..6cb156a3c8e5a 100644 --- a/crates/oxc_transformer/src/jsx/refresh.rs +++ b/crates/oxc_transformer/src/jsx/refresh.rs @@ -139,7 +139,7 @@ impl<'a, 'ctx> ReactRefresh<'a, 'ctx> { impl<'a> Traverse<'a> for ReactRefresh<'a, '_> { fn enter_program(&mut self, program: &mut Program<'a>, ctx: &mut TraverseCtx<'a>) { let mut new_statements = ctx.ast.vec_with_capacity(program.body.len() * 2); - for mut statement in program.body.take_in(ctx.ast.allocator) { + for mut statement in program.body.take_in(ctx.ast) { let next_statement = self.process_statement(&mut statement, ctx); new_statements.push(statement); if let Some(assignment_expression) = next_statement { @@ -252,7 +252,7 @@ impl<'a> Traverse<'a> for ReactRefresh<'a, '_> { Some((binding_identifier.clone(), arguments.clone_in(ctx.ast.allocator))); } - arguments.insert(0, Argument::from(expr.take_in(ctx.ast.allocator))); + arguments.insert(0, Argument::from(expr.take_in(ctx.ast))); *expr = ctx.ast.expression_call( SPAN, binding.create_read_expression(ctx), @@ -505,7 +505,7 @@ impl<'a> ReactRefresh<'a, '_> { SPAN, AssignmentOperator::Assign, self.create_registration(ctx.ast.atom(inferred_name), ctx), - expr.take_in(ctx.ast.allocator), + expr.take_in(ctx.ast), ); } diff --git a/crates/oxc_transformer/src/lib.rs b/crates/oxc_transformer/src/lib.rs index f6f0835a9b120..976b5c16e00f5 100644 --- a/crates/oxc_transformer/src/lib.rs +++ b/crates/oxc_transformer/src/lib.rs @@ -528,7 +528,7 @@ impl<'a> Traverse<'a> for TransformerImpl<'a, '_> { let Statement::ExpressionStatement(expr_stmt) = stmt else { continue; }; - let expression = Some(expr_stmt.expression.take_in(ctx.ast.allocator)); + let expression = Some(expr_stmt.expression.take_in(ctx.ast)); *stmt = ctx.ast.statement_return(SPAN, expression); return; } diff --git a/crates/oxc_transformer/src/proposals/explicit_resource_management.rs b/crates/oxc_transformer/src/proposals/explicit_resource_management.rs index bb7c7b63d5ab7..7f75663d029b2 100644 --- a/crates/oxc_transformer/src/proposals/explicit_resource_management.rs +++ b/crates/oxc_transformer/src/proposals/explicit_resource_management.rs @@ -129,7 +129,7 @@ impl<'a> Traverse<'a> for ExplicitResourceManagement<'a, '_> { body.body.insert(0, using_stmt); } else { // `for (const _x of y) x();` -> `for (const _x of y) { using x = _x; x(); }` - let old_body = for_of_stmt.body.take_in(ctx.ast.allocator); + let old_body = for_of_stmt.body.take_in(ctx.ast); let new_body = ctx.ast.vec_from_array([using_stmt, old_body]); for_of_stmt.body = ctx.ast.statement_block_with_scope_id(SPAN, new_body, scope_id); @@ -303,7 +303,7 @@ impl<'a> Traverse<'a> for ExplicitResourceManagement<'a, '_> { return; } - let program_body = program.body.take_in(ctx.ast.allocator); + let program_body = program.body.take_in(ctx.ast); let (mut program_body, inner_block): ( ArenaVec<'a, Statement<'a>>, @@ -413,7 +413,7 @@ impl<'a> Traverse<'a> for ExplicitResourceManagement<'a, '_> { return (program_body, inner_block); } - let export_specifiers = match decl.take_in(ctx.ast.allocator) { + let export_specifiers = match decl.take_in(ctx.ast) { Declaration::ClassDeclaration(class_decl) => { let class_binding = class_decl.id.as_ref().unwrap(); let class_binding_name = class_binding.name; @@ -660,7 +660,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> { )), false, )), - stmt.take_in(ctx.ast.allocator), + stmt.take_in(ctx.ast), ]); ctx.ast.block_statement_with_scope_id(SPAN, vec, block_stmt_sid) @@ -755,7 +755,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> { let using_ctx = using_ctx?; - let mut stmts = stmts.take_in(ctx.ast.allocator); + let mut stmts = stmts.take_in(ctx.ast); // `var _usingCtx = babelHelpers.usingCtx();` let callee = self.ctx.helper_load(Helper::UsingCtx, ctx); diff --git a/crates/oxc_transformer/src/typescript/annotations.rs b/crates/oxc_transformer/src/typescript/annotations.rs index 37f25a8930d69..433b3a09f0ebc 100644 --- a/crates/oxc_transformer/src/typescript/annotations.rs +++ b/crates/oxc_transformer/src/typescript/annotations.rs @@ -199,7 +199,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> { fn enter_chain_element(&mut self, element: &mut ChainElement<'a>, ctx: &mut TraverseCtx<'a>) { if let ChainElement::TSNonNullExpression(e) = element { - *element = match e.expression.get_inner_expression_mut().take_in(ctx.ast.allocator) { + *element = match e.expression.get_inner_expression_mut().take_in(ctx.ast) { Expression::CallExpression(call_expr) => ChainElement::CallExpression(call_expr), expr @ match_member_expression!(Expression) => { ChainElement::from(expr.into_member_expression()) @@ -240,7 +240,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> { fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { if expr.is_typescript_syntax() { let inner_expr = expr.get_inner_expression_mut(); - *expr = inner_expr.take_in(ctx.ast.allocator); + *expr = inner_expr.take_in(ctx.ast); } } @@ -253,7 +253,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> { match expr.get_inner_expression_mut() { // `foo!++` to `foo++` inner_expr @ Expression::Identifier(_) => { - let inner_expr = inner_expr.take_in(ctx.ast.allocator); + let inner_expr = inner_expr.take_in(ctx.ast); let Expression::Identifier(ident) = inner_expr else { unreachable!(); }; @@ -261,7 +261,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> { } // `foo.bar!++` to `foo.bar++` inner_expr @ match_member_expression!(Expression) => { - let inner_expr = inner_expr.take_in(ctx.ast.allocator); + let inner_expr = inner_expr.take_in(ctx.ast); let member_expr = inner_expr.into_member_expression(); *target = SimpleAssignmentTarget::from(member_expr); } @@ -281,7 +281,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> { if let Some(expr) = target.get_expression_mut() { let inner_expr = expr.get_inner_expression_mut(); if inner_expr.is_member_expression() { - let inner_expr = inner_expr.take_in(ctx.ast.allocator); + let inner_expr = inner_expr.take_in(ctx.ast); let member_expr = inner_expr.into_member_expression(); *target = AssignmentTarget::from(member_expr); } @@ -425,7 +425,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> { _ => None, }; if let Some(span) = consequent_span { - let consequent = stmt.consequent.take_in(ctx.ast.allocator); + let consequent = stmt.consequent.take_in(ctx.ast); stmt.consequent = Self::create_block_with_statement(consequent, span, ctx); } diff --git a/crates/oxc_transformer/src/typescript/class.rs b/crates/oxc_transformer/src/typescript/class.rs index 077f542cee55a..4424a2e14f7c4 100644 --- a/crates/oxc_transformer/src/typescript/class.rs +++ b/crates/oxc_transformer/src/typescript/class.rs @@ -117,7 +117,7 @@ impl<'a> TypeScript<'a, '_> { // When `remove_class_fields_without_initializer` is true, the property without initializer // would be removed in the `transform_class_on_exit`. We need to make sure the computed key // keeps and is evaluated in the same order as the original class field in static block. - computed_key_assignments.push(key.take_in(ctx.ast.allocator)); + computed_key_assignments.push(key.take_in(ctx.ast)); } } } @@ -287,11 +287,11 @@ impl<'a> TypeScript<'a, '_> { // No temp var is created for these. let new_key = if self.ctx.key_needs_temp_var(key, ctx) { let (assignment, ident) = - self.ctx.create_computed_key_temp_var(key.take_in(ctx.ast.allocator), ctx); + self.ctx.create_computed_key_temp_var(key.take_in(ctx.ast), ctx); computed_key_assignments.push(assignment); ident } else { - key.take_in(ctx.ast.allocator) + key.take_in(ctx.ast) }; ctx.ast.member_expression_computed( @@ -360,7 +360,7 @@ impl<'a> TypeScript<'a, '_> { if let Some(key) = key.as_expression_mut() { // If the key is already an expression, we need to create a new expression sequence // to insert the assignments into. - let original_key = key.take_in(ctx.ast.allocator); + let original_key = key.take_in(ctx.ast); let new_key = ctx.ast.expression_sequence( SPAN, ctx.ast.vec_from_iter( diff --git a/crates/oxc_transformer/src/typescript/enum.rs b/crates/oxc_transformer/src/typescript/enum.rs index 913edc5e3955c..35ddc3a18a09a 100644 --- a/crates/oxc_transformer/src/typescript/enum.rs +++ b/crates/oxc_transformer/src/typescript/enum.rs @@ -230,7 +230,7 @@ impl<'a> TypeScriptEnum<'a> { match constant_value { None => { prev_constant_value = None; - let mut new_initializer = initializer.take_in(ast.allocator); + let mut new_initializer = initializer.take_in(ast); IdentifierReferenceRename::new( param_binding.name, diff --git a/crates/oxc_transformer/src/typescript/module.rs b/crates/oxc_transformer/src/typescript/module.rs index 74cc9076ef69a..9e085dc58029d 100644 --- a/crates/oxc_transformer/src/typescript/module.rs +++ b/crates/oxc_transformer/src/typescript/module.rs @@ -74,7 +74,7 @@ impl<'a> TypeScriptModule<'a, '_> { }; let left = AssignmentTarget::from(SimpleAssignmentTarget::from(module_exports)); - let right = export_assignment.expression.take_in(ctx.ast.allocator); + let right = export_assignment.expression.take_in(ctx.ast); let assignment_expr = ctx.ast.expression_assignment(SPAN, AssignmentOperator::Assign, left, right); ctx.ast.statement_expression(SPAN, assignment_expr) diff --git a/crates/oxc_transformer/src/typescript/namespace.rs b/crates/oxc_transformer/src/typescript/namespace.rs index a75e2b4ab6f82..ff816a9e3bb1f 100644 --- a/crates/oxc_transformer/src/typescript/namespace.rs +++ b/crates/oxc_transformer/src/typescript/namespace.rs @@ -42,7 +42,7 @@ impl<'a> Traverse<'a> for TypeScriptNamespace<'a, '_> { // every time a namespace declaration is encountered. let mut new_stmts = ctx.ast.vec(); - for stmt in program.body.take_in(ctx.ast.allocator) { + for stmt in program.body.take_in(ctx.ast) { match stmt { Statement::TSModuleDeclaration(decl) => { if !self.allow_namespaces { @@ -448,7 +448,7 @@ impl<'a> TypeScriptNamespace<'a, '_> { false, )) .into(), - init.take_in(ctx.ast.allocator), + init.take_in(ctx.ast), ), ); } diff --git a/crates/oxc_transformer_plugins/src/module_runner_transform.rs b/crates/oxc_transformer_plugins/src/module_runner_transform.rs index b6816b27ed50e..aa61a63cb7b0e 100644 --- a/crates/oxc_transformer_plugins/src/module_runner_transform.rs +++ b/crates/oxc_transformer_plugins/src/module_runner_transform.rs @@ -250,7 +250,7 @@ impl<'a> ModuleRunnerTransform<'a> { /// Transform `import(source, ...arguments)` to `__vite_ssr_dynamic_import__(source, ...arguments)`. #[inline] fn transform_dynamic_import(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { - let Expression::ImportExpression(import_expr) = expr.take_in(ctx.ast.allocator) else { + let Expression::ImportExpression(import_expr) = expr.take_in(ctx.ast) else { unreachable!(); };