refactor(transformer, minifier): replace AstBuilder::move_xxxx meth…

…ods with `TakeIn` trait (#10170)

Pure refactor, `TakeIn` trait is exactly used for these cases, we don't need an indirect call for `move_xxx`.

crates/oxc_isolated_declarations/src/module.rs

@@ -1,4 +1,4 @@
-use oxc_allocator::{Box as ArenaBox, CloneIn, Vec as ArenaVec};
+use oxc_allocator::{Box as ArenaBox, CloneIn, TakeIn, Vec as ArenaVec};
 use oxc_ast::{NONE, ast::*};
 use oxc_span::{Atom, GetSpan, SPAN};
 
@@ -167,7 +167,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(self.ast.move_declaration(declaration));
+                    *stmt = Statement::from(declaration.take_in(self.ast.allocator));
                 }
             }
         });

crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs

@@ -1,3 +1,4 @@
+use oxc_allocator::TakeIn;
 use oxc_ast::ast::*;
 use oxc_syntax::identifier::is_identifier_name;
 
@@ -18,10 +19,13 @@ impl<'a> LatePeepholeOptimizations {
         let Expression::StringLiteral(s) = &e.expression else { return };
         if is_identifier_name(&s.value) {
             let property = ctx.ast.identifier_name(s.span, s.value);
-            let object = ctx.ast.move_expression(&mut e.object);
-            *expr = MemberExpression::StaticMemberExpression(
-                ctx.ast.alloc_static_member_expression(e.span, object, property, e.optional),
-            );
+            *expr =
+                MemberExpression::StaticMemberExpression(ctx.ast.alloc_static_member_expression(
+                    e.span,
+                    e.object.take_in(ctx.ast.allocator),
+                    property,
+                    e.optional,
+                ));
             return;
         }
         let v = s.value.as_str();

crates/oxc_minifier/src/peephole/fold_constants.rs

@@ -1,3 +1,4 @@
+use oxc_allocator::TakeIn;
 use oxc_ast::ast::*;
 use oxc_ecmascript::{
     ToJsString,
@@ -131,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(ctx.ast.move_expression(&mut logical_expr.left));
+                return Some(logical_expr.left.take_in(ctx.ast.allocator));
             } else if !left.may_have_side_effects(&ctx) {
                 let should_keep_indirect_access =
                     Self::should_keep_indirect_access(&logical_expr.right, ctx);
@@ -146,19 +147,19 @@ impl<'a> PeepholeOptimizations {
                                 None,
                                 NumberBase::Decimal,
                             ),
-                            ctx.ast.move_expression(&mut logical_expr.right),
+                            logical_expr.right.take_in(ctx.ast.allocator),
                         ]),
                     ));
                 }
                 // (FALSE || x) => x
                 // (TRUE && x) => x
-                return Some(ctx.ast.move_expression(&mut logical_expr.right));
+                return Some(logical_expr.right.take_in(ctx.ast.allocator));
             }
             // 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 = ctx.ast.move_expression(&mut logical_expr.left);
-            let right = ctx.ast.move_expression(&mut logical_expr.right);
+            let left = logical_expr.left.take_in(ctx.ast.allocator);
+            let right = logical_expr.right.take_in(ctx.ast.allocator);
             let vec = ctx.ast.vec_from_array([left, right]);
             let sequence_expr = ctx.ast.expression_sequence(logical_expr.span, vec);
             return Some(sequence_expr);
@@ -173,8 +174,8 @@ impl<'a> PeepholeOptimizations {
                         if !right_boolean && left_child_op.is_or()
                             || right_boolean && left_child_op.is_and()
                         {
-                            let left = ctx.ast.move_expression(&mut left_child.left);
-                            let right = ctx.ast.move_expression(&mut logical_expr.right);
+                            let left = left_child.left.take_in(ctx.ast.allocator);
+                            let right = logical_expr.right.take_in(ctx.ast.allocator);
                             let logic_expr = ctx.ast.expression_logical(
                                 logical_expr.span,
                                 left,
@@ -203,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([
-                        ctx.ast.move_expression(&mut logical_expr.left),
-                        ctx.ast.move_expression(&mut logical_expr.right),
+                        logical_expr.left.take_in(ctx.ast.allocator),
+                        logical_expr.right.take_in(ctx.ast.allocator),
                     ]);
                     ctx.ast.expression_sequence(logical_expr.span, expressions)
                 } else {
@@ -221,12 +222,12 @@ impl<'a> PeepholeOptimizations {
                                     None,
                                     NumberBase::Decimal,
                                 ),
-                                ctx.ast.move_expression(&mut logical_expr.right),
+                                logical_expr.right.take_in(ctx.ast.allocator),
                             ]),
                         ));
                     }
                     // nullish condition => this expression evaluates to the right side.
-                    ctx.ast.move_expression(&mut logical_expr.right)
+                    logical_expr.right.take_in(ctx.ast.allocator)
                 })
             }
             ValueType::Number
@@ -247,12 +248,12 @@ impl<'a> PeepholeOptimizations {
                                 None,
                                 NumberBase::Decimal,
                             ),
-                            ctx.ast.move_expression(&mut logical_expr.left),
+                            logical_expr.left.take_in(ctx.ast.allocator),
                         ]),
                     ));
                 }
                 // non-nullish condition => this expression evaluates to the left side.
-                Some(ctx.ast.move_expression(&mut logical_expr.left))
+                Some(logical_expr.left.take_in(ctx.ast.allocator))
             }
             ValueType::Undetermined => None,
         }
@@ -390,14 +391,14 @@ impl<'a> PeepholeOptimizations {
                     let span = Span::new(left_binary_expr.right.span().start, e.right.span().end);
                     let value = left_str.into_owned() + &right_str;
                     let right = ctx.ast.expression_string_literal(span, value, None);
-                    let left = ctx.ast.move_expression(&mut left_binary_expr.left);
+                    let left = left_binary_expr.left.take_in(ctx.ast.allocator);
                     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 = ctx.ast.move_expression(&mut left_binary_expr.left);
+                    let left = left_binary_expr.left.take_in(ctx.ast.allocator);
                     return Some(ctx.ast.expression_binary(e.span, left, e.operator, new_right));
                 }
             }
@@ -436,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(ctx.ast.move_expression(left_expr));
+                return Some(left_expr.take_in(ctx.ast.allocator));
             }
 
             // "`${x}y` + 'z'" => "`${x}yz`"
@@ -452,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(ctx.ast.move_expression(left_expr));
+                return Some(left_expr.take_in(ctx.ast.allocator));
             }
         } else if let Expression::TemplateLiteral(right) = right_expr {
             // "'x' + `y${z}`" => "`xy${z}`"
@@ -470,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(ctx.ast.move_expression(right_expr));
+                return Some(right_expr.take_in(ctx.ast.allocator));
             }
         }
 
         // 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(ctx.ast.move_expression(right_expr));
+            return Some(right_expr.take_in(ctx.ast.allocator));
         } else if Self::evaluates_to_empty_string(right_expr)
             && left_expr.value_type(&ctx).is_string()
         {
-            return Some(ctx.ast.move_expression(left_expr));
+            return Some(left_expr.take_in(ctx.ast.allocator));
         }
 
         None
@@ -522,7 +523,7 @@ impl<'a> PeepholeOptimizations {
 
         Some(ctx.ast.expression_binary(
             e.span,
-            ctx.ast.move_expression(expr_to_move),
+            expr_to_move.take_in(ctx.ast.allocator),
             op,
             ctx.value_to_expr(Span::new(left.right.span().start, e.right.span().end), v),
         ))