diff --git a/crates/oxc_ast/src/ast_builder_impl.rs b/crates/oxc_ast/src/ast_builder_impl.rs
index 44ec41e8519be..c625ad5d11c93 100644
--- a/crates/oxc_ast/src/ast_builder_impl.rs
+++ b/crates/oxc_ast/src/ast_builder_impl.rs
@@ -1,8 +1,8 @@
 #![warn(missing_docs)]
 
-use std::{borrow::Cow, mem};
+use std::borrow::Cow;
 
-use oxc_allocator::{Allocator, Box, FromIn, IntoIn, String, Vec};
+use oxc_allocator::{Allocator, Box, FromIn, IntoIn, String, TakeIn, Vec};
 use oxc_span::{Atom, SPAN, Span};
 use oxc_syntax::{number::NumberBase, operator::UnaryOperator, scope::ScopeId};
 
@@ -101,121 +101,9 @@ impl<'a> AstBuilder<'a> {
         }
     }
 
-    /// Moves the expression out by replacing it with an [`Expression::NullLiteral`].
-    #[inline]
-    pub fn move_expression(self, expr: &mut Expression<'a>) -> Expression<'a> {
-        let null_expr = self.expression_null_literal(SPAN);
-        mem::replace(expr, null_expr)
-    }
-
-    /// Moves the statement out by replacing it with a [`Statement::EmptyStatement`].
-    #[inline]
-    pub fn move_statement(self, stmt: &mut Statement<'a>) -> Statement<'a> {
-        let empty_stmt = self.empty_statement(SPAN);
-        mem::replace(stmt, Statement::EmptyStatement(self.alloc(empty_stmt)))
-    }
-
-    /// Moves the assignment target out by replacing it with a dummy
-    /// [`AssignmentTarget::AssignmentTargetIdentifier`] with no name and an empty [`Span`].
-    #[inline]
-    pub fn move_assignment_target(self, target: &mut AssignmentTarget<'a>) -> AssignmentTarget<'a> {
-        let dummy =
-            self.simple_assignment_target_assignment_target_identifier(SPAN, Atom::from(""));
-        mem::replace(target, dummy.into())
-    }
-
-    /// Moves the property key out by replacing it with a [`PropertyKey::NullLiteral`].
-    pub fn move_property_key(self, key: &mut PropertyKey<'a>) -> PropertyKey<'a> {
-        let null_expr = PropertyKey::from(self.expression_null_literal(SPAN));
-        mem::replace(key, null_expr)
-    }
-
-    /// Move a declaration out by replacing it with an empty [`Declaration::VariableDeclaration`].
-    #[inline]
-    pub fn move_declaration(self, decl: &mut Declaration<'a>) -> Declaration<'a> {
-        let empty_decl =
-            self.declaration_variable(SPAN, VariableDeclarationKind::Var, self.vec(), false);
-        mem::replace(decl, empty_decl)
-    }
-
-    /// Move a variable declaration out by replacing it with an empty [`VariableDeclaration`].
-    #[inline]
-    pub fn move_variable_declaration(
-        self,
-        decl: &mut VariableDeclaration<'a>,
-    ) -> VariableDeclaration<'a> {
-        let empty_decl =
-            self.variable_declaration(SPAN, VariableDeclarationKind::Var, self.vec(), false);
-        mem::replace(decl, empty_decl)
-    }
-
-    /// Move a formal parameters out by replacing it with an empty [`FormalParameters`].
-    #[inline]
-    pub fn move_formal_parameters(self, params: &mut FormalParameters<'a>) -> FormalParameters<'a> {
-        let empty_params = self.formal_parameters(SPAN, params.kind, self.vec(), NONE);
-        mem::replace(params, empty_params)
-    }
-
-    /// Move a function body out by replacing it with an empty [`FunctionBody`].
-    #[inline]
-    pub fn move_function_body(self, body: &mut FunctionBody<'a>) -> FunctionBody<'a> {
-        let empty_body = self.function_body(SPAN, self.vec(), self.vec());
-        mem::replace(body, empty_body)
-    }
-
-    /// Move a function out by replacing it with an empty [`Function`].
-    #[inline]
-    pub fn move_function(self, function: &mut Function<'a>) -> Function<'a> {
-        let params =
-            self.formal_parameters(SPAN, FormalParameterKind::FormalParameter, self.vec(), NONE);
-        let empty_function = self.function(
-            SPAN,
-            FunctionType::FunctionDeclaration,
-            None,
-            false,
-            false,
-            false,
-            NONE,
-            NONE,
-            params,
-            NONE,
-            NONE,
-        );
-        mem::replace(function, empty_function)
-    }
-
-    /// Move a class out by replacing it with an empty [`Class`].
-    pub fn move_class(self, class: &mut Class<'a>) -> Class<'a> {
-        let empty_class = self.class(
-            SPAN,
-            ClassType::ClassDeclaration,
-            self.vec(),
-            None,
-            NONE,
-            None,
-            NONE,
-            None,
-            self.class_body(SPAN, self.vec()),
-            false,
-            false,
-        );
-        mem::replace(class, empty_class)
-    }
-
-    /// Move an array element out by replacing it with an [`ArrayExpressionElement::Elision`].
-    pub fn move_array_expression_element(
-        self,
-        element: &mut ArrayExpressionElement<'a>,
-    ) -> ArrayExpressionElement<'a> {
-        let elision = self.array_expression_element_elision(SPAN);
-        mem::replace(element, elision)
-    }
-
-    /// Take the contents of a arena-allocated [`Vec`], leaving an empty [`Vec`] in its place.
-    /// This is akin to [`std::mem::take`].
-    #[inline]
-    pub fn move_vec<T>(self, vec: &mut Vec<'a, T>) -> Vec<'a, T> {
-        mem::replace(vec, self.vec())
+    /// Take the AST node and substitute a dummy node in its place.
+    pub fn take<T: TakeIn<'a>>(self, value: &mut T) -> T {
+        value.take_in(self.allocator)
     }
 
     /* ---------- Constructors ---------- */
diff --git a/crates/oxc_isolated_declarations/src/module.rs b/crates/oxc_isolated_declarations/src/module.rs
index b04ca2047f065..ac3e1b76deb2d 100644
--- a/crates/oxc_isolated_declarations/src/module.rs
+++ b/crates/oxc_isolated_declarations/src/module.rs
@@ -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(self.ast.take(declaration));
                 }
             }
         });
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 7609a9b0b8c0a..1a29cb175a5a3 100644
--- a/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs
+++ b/crates/oxc_minifier/src/peephole/convert_to_dotted_properties.rs
@@ -18,7 +18,7 @@ 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);
+            let object = ctx.ast.take(&mut e.object);
             *expr = MemberExpression::StaticMemberExpression(
                 ctx.ast.alloc_static_member_expression(e.span, object, property, e.optional),
             );
diff --git a/crates/oxc_minifier/src/peephole/fold_constants.rs b/crates/oxc_minifier/src/peephole/fold_constants.rs
index 21c3f066978b6..8992888e63726 100644
--- a/crates/oxc_minifier/src/peephole/fold_constants.rs
+++ b/crates/oxc_minifier/src/peephole/fold_constants.rs
@@ -131,7 +131,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(ctx.ast.take(&mut logical_expr.left));
             } else if !left.may_have_side_effects(&ctx) {
                 let should_keep_indirect_access =
                     Self::should_keep_indirect_access(&logical_expr.right, ctx);
@@ -146,19 +146,19 @@ impl<'a> PeepholeOptimizations {
                                 None,
                                 NumberBase::Decimal,
                             ),
-                            ctx.ast.move_expression(&mut logical_expr.right),
+                            ctx.ast.take(&mut logical_expr.right),
                         ]),
                     ));
                 }
                 // (FALSE || x) => x
                 // (TRUE && x) => x
-                return Some(ctx.ast.move_expression(&mut logical_expr.right));
+                return Some(ctx.ast.take(&mut logical_expr.right));
             }
             // 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 = ctx.ast.take(&mut logical_expr.left);
+            let right = ctx.ast.take(&mut logical_expr.right);
             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 +173,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 = ctx.ast.take(&mut left_child.left);
+                            let right = ctx.ast.take(&mut logical_expr.right);
                             let logic_expr = ctx.ast.expression_logical(
                                 logical_expr.span,
                                 left,
@@ -203,8 +203,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),
+                        ctx.ast.take(&mut logical_expr.left),
+                        ctx.ast.take(&mut logical_expr.right),
                     ]);
                     ctx.ast.expression_sequence(logical_expr.span, expressions)
                 } else {
@@ -221,12 +221,12 @@ impl<'a> PeepholeOptimizations {
                                     None,
                                     NumberBase::Decimal,
                                 ),
-                                ctx.ast.move_expression(&mut logical_expr.right),
+                                ctx.ast.take(&mut logical_expr.right),
                             ]),
                         ));
                     }
                     // nullish condition => this expression evaluates to the right side.
-                    ctx.ast.move_expression(&mut logical_expr.right)
+                    ctx.ast.take(&mut logical_expr.right)
                 })
             }
             ValueType::Number
@@ -247,12 +247,12 @@ impl<'a> PeepholeOptimizations {
                                 None,
                                 NumberBase::Decimal,
                             ),
-                            ctx.ast.move_expression(&mut logical_expr.left),
+                            ctx.ast.take(&mut logical_expr.left),
                         ]),
                     ));
                 }
                 // non-nullish condition => this expression evaluates to the left side.
-                Some(ctx.ast.move_expression(&mut logical_expr.left))
+                Some(ctx.ast.take(&mut logical_expr.left))
             }
             ValueType::Undetermined => None,
         }
@@ -390,14 +390,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 = ctx.ast.take(&mut left_binary_expr.left);
                     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 = ctx.ast.take(&mut left_binary_expr.left);
                     return Some(ctx.ast.expression_binary(e.span, left, e.operator, new_right));
                 }
             }
@@ -436,7 +436,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(ctx.ast.take(left_expr));
             }
 
             // "`${x}y` + 'z'" => "`${x}yz`"
@@ -452,7 +452,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(ctx.ast.take(left_expr));
             }
         } else if let Expression::TemplateLiteral(right) = right_expr {
             // "'x' + `y${z}`" => "`xy${z}`"
@@ -470,17 +470,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(ctx.ast.take(right_expr));
             }
         }
 
         // 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(ctx.ast.take(right_expr));
         } 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(ctx.ast.take(left_expr));
         }
 
         None
@@ -522,7 +522,7 @@ impl<'a> PeepholeOptimizations {
 
         Some(ctx.ast.expression_binary(
             e.span,
-            ctx.ast.move_expression(expr_to_move),
+            ctx.ast.take(expr_to_move),
             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 b96cf4b15e1ad..8b0b18f0d69b6 100644
--- a/crates/oxc_minifier/src/peephole/minimize_conditional_expression.rs
+++ b/crates/oxc_minifier/src/peephole/minimize_conditional_expression.rs
@@ -32,15 +32,15 @@ impl<'a> PeepholeOptimizations {
             Expression::SequenceExpression(sequence_expr) => {
                 if sequence_expr.expressions.len() > 1 {
                     let span = expr.span();
-                    let mut sequence = ctx.ast.move_expression(&mut expr.test);
+                    let mut sequence = ctx.ast.take(&mut expr.test);
                     let Expression::SequenceExpression(sequence_expr) = &mut sequence else {
                         unreachable!()
                     };
                     let expr = self.minimize_conditional(
                         span,
                         sequence_expr.expressions.pop().unwrap(),
-                        ctx.ast.move_expression(&mut expr.consequent),
-                        ctx.ast.move_expression(&mut expr.alternate),
+                        ctx.ast.take(&mut expr.consequent),
+                        ctx.ast.take(&mut expr.alternate),
                         ctx,
                     );
                     sequence_expr.expressions.push(expr);
@@ -50,9 +50,9 @@ impl<'a> PeepholeOptimizations {
             // "!a ? b : c" => "a ? c : b"
             Expression::UnaryExpression(test_expr) => {
                 if test_expr.operator.is_not() {
-                    let test = ctx.ast.move_expression(&mut test_expr.argument);
-                    let consequent = ctx.ast.move_expression(&mut expr.alternate);
-                    let alternate = ctx.ast.move_expression(&mut expr.consequent);
+                    let test = ctx.ast.take(&mut test_expr.argument);
+                    let consequent = ctx.ast.take(&mut expr.alternate);
+                    let alternate = ctx.ast.take(&mut expr.consequent);
                     return Some(
                         self.minimize_conditional(expr.span, test, consequent, alternate, ctx),
                     );
@@ -65,8 +65,8 @@ impl<'a> PeepholeOptimizations {
                         return Some(self.join_with_left_associative_op(
                             expr.span,
                             LogicalOperator::Or,
-                            ctx.ast.move_expression(&mut expr.test),
-                            ctx.ast.move_expression(&mut expr.alternate),
+                            ctx.ast.take(&mut expr.test),
+                            ctx.ast.take(&mut expr.alternate),
                             ctx,
                         ));
                     }
@@ -77,8 +77,8 @@ impl<'a> PeepholeOptimizations {
                         return Some(self.join_with_left_associative_op(
                             expr.span,
                             LogicalOperator::And,
-                            ctx.ast.move_expression(&mut expr.test),
-                            ctx.ast.move_expression(&mut expr.consequent),
+                            ctx.ast.take(&mut expr.test),
+                            ctx.ast.take(&mut expr.consequent),
                             ctx,
                         ));
                     }
@@ -91,9 +91,9 @@ impl<'a> PeepholeOptimizations {
                     BinaryOperator::Inequality | BinaryOperator::StrictInequality
                 ) {
                     test_expr.operator = test_expr.operator.equality_inverse_operator().unwrap();
-                    let test = ctx.ast.move_expression(&mut expr.test);
-                    let consequent = ctx.ast.move_expression(&mut expr.consequent);
-                    let alternate = ctx.ast.move_expression(&mut expr.alternate);
+                    let test = ctx.ast.take(&mut expr.test);
+                    let consequent = ctx.ast.take(&mut expr.consequent);
+                    let alternate = ctx.ast.take(&mut expr.alternate);
                     return Some(
                         self.minimize_conditional(expr.span, test, alternate, consequent, ctx),
                     );
@@ -109,13 +109,13 @@ impl<'a> PeepholeOptimizations {
         {
             match (left.value, right.value) {
                 (true, false) => {
-                    let test = ctx.ast.move_expression(&mut expr.test);
+                    let test = ctx.ast.take(&mut expr.test);
                     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 = ctx.ast.move_expression(&mut expr.test);
+                    let test = ctx.ast.take(&mut expr.test);
                     let test = self.minimize_not(expr.span, test, ctx);
                     return Some(test);
                 }
@@ -131,12 +131,12 @@ impl<'a> PeepholeOptimizations {
                     self.join_with_left_associative_op(
                         expr.test.span(),
                         LogicalOperator::And,
-                        ctx.ast.move_expression(&mut expr.test),
-                        ctx.ast.move_expression(&mut consequent.test),
+                        ctx.ast.take(&mut expr.test),
+                        ctx.ast.take(&mut consequent.test),
                         ctx,
                     ),
-                    ctx.ast.move_expression(&mut consequent.consequent),
-                    ctx.ast.move_expression(&mut consequent.alternate),
+                    ctx.ast.take(&mut consequent.consequent),
+                    ctx.ast.take(&mut consequent.alternate),
                 ));
             }
         }
@@ -149,12 +149,12 @@ impl<'a> PeepholeOptimizations {
                     self.join_with_left_associative_op(
                         expr.test.span(),
                         LogicalOperator::Or,
-                        ctx.ast.move_expression(&mut expr.test),
-                        ctx.ast.move_expression(&mut alternate.test),
+                        ctx.ast.take(&mut expr.test),
+                        ctx.ast.take(&mut alternate.test),
                         ctx,
                     ),
-                    ctx.ast.move_expression(&mut expr.consequent),
-                    ctx.ast.move_expression(&mut alternate.alternate),
+                    ctx.ast.take(&mut expr.consequent),
+                    ctx.ast.take(&mut alternate.alternate),
                 ));
             }
         }
@@ -170,11 +170,11 @@ impl<'a> PeepholeOptimizations {
                         self.join_with_left_associative_op(
                             expr.test.span(),
                             LogicalOperator::Or,
-                            ctx.ast.move_expression(&mut expr.test),
-                            ctx.ast.move_expression(&mut alternate.expressions[0]),
+                            ctx.ast.take(&mut expr.test),
+                            ctx.ast.take(&mut alternate.expressions[0]),
                             ctx,
                         ),
-                        ctx.ast.move_expression(&mut expr.consequent),
+                        ctx.ast.take(&mut expr.consequent),
                     ]),
                 ));
             }
@@ -191,11 +191,11 @@ impl<'a> PeepholeOptimizations {
                         self.join_with_left_associative_op(
                             expr.test.span(),
                             LogicalOperator::And,
-                            ctx.ast.move_expression(&mut expr.test),
-                            ctx.ast.move_expression(&mut consequent.expressions[0]),
+                            ctx.ast.take(&mut expr.test),
+                            ctx.ast.take(&mut consequent.expressions[0]),
                             ctx,
                         ),
-                        ctx.ast.move_expression(&mut expr.alternate),
+                        ctx.ast.take(&mut expr.alternate),
                     ]),
                 ));
             }
@@ -209,12 +209,12 @@ impl<'a> PeepholeOptimizations {
                     self.join_with_left_associative_op(
                         expr.test.span(),
                         LogicalOperator::And,
-                        ctx.ast.move_expression(&mut expr.test),
-                        ctx.ast.move_expression(&mut logical_expr.left),
+                        ctx.ast.take(&mut expr.test),
+                        ctx.ast.take(&mut logical_expr.left),
                         ctx,
                     ),
                     LogicalOperator::Or,
-                    ctx.ast.move_expression(&mut expr.alternate),
+                    ctx.ast.take(&mut expr.alternate),
                 ));
             }
         }
@@ -229,12 +229,12 @@ impl<'a> PeepholeOptimizations {
                     self.join_with_left_associative_op(
                         expr.test.span(),
                         LogicalOperator::Or,
-                        ctx.ast.move_expression(&mut expr.test),
-                        ctx.ast.move_expression(&mut logical_expr.left),
+                        ctx.ast.take(&mut expr.test),
+                        ctx.ast.take(&mut logical_expr.left),
                         ctx,
                     ),
                     LogicalOperator::And,
-                    ctx.ast.move_expression(&mut expr.consequent),
+                    ctx.ast.take(&mut expr.consequent),
                 ));
             }
         }
@@ -261,25 +261,25 @@ impl<'a> PeepholeOptimizations {
                 if matches!(consequent.arguments[0], Argument::SpreadElement(_))
                     && matches!(alternate.arguments[0], Argument::SpreadElement(_))
                 {
-                    let callee = ctx.ast.move_expression(&mut consequent.callee);
+                    let callee = ctx.ast.take(&mut consequent.callee);
                     let consequent_first_arg = {
                         let Argument::SpreadElement(el) = &mut consequent.arguments[0] else {
                             unreachable!()
                         };
-                        ctx.ast.move_expression(&mut el.argument)
+                        ctx.ast.take(&mut el.argument)
                     };
                     let alternate_first_arg = {
                         let Argument::SpreadElement(el) = &mut alternate.arguments[0] else {
                             unreachable!()
                         };
-                        ctx.ast.move_expression(&mut el.argument)
+                        ctx.ast.take(&mut el.argument)
                     };
                     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(),
-                            ctx.ast.move_expression(&mut expr.test),
+                            ctx.ast.take(&mut expr.test),
                             consequent_first_arg,
                             alternate_first_arg,
                         ),
@@ -290,16 +290,16 @@ impl<'a> PeepholeOptimizations {
                 if !matches!(consequent.arguments[0], Argument::SpreadElement(_))
                     && !matches!(alternate.arguments[0], Argument::SpreadElement(_))
                 {
-                    let callee = ctx.ast.move_expression(&mut consequent.callee);
+                    let callee = ctx.ast.take(&mut consequent.callee);
 
                     let consequent_first_arg =
-                        ctx.ast.move_expression(consequent.arguments[0].to_expression_mut());
+                        ctx.ast.take(consequent.arguments[0].to_expression_mut());
                     let alternate_first_arg =
-                        ctx.ast.move_expression(alternate.arguments[0].to_expression_mut());
+                        ctx.ast.take(alternate.arguments[0].to_expression_mut());
                     let mut args = std::mem::replace(&mut consequent.arguments, ctx.ast.vec());
                     let cond_expr = self.minimize_conditional(
                         expr.test.span(),
-                        ctx.ast.move_expression(&mut expr.test),
+                        ctx.ast.take(&mut expr.test),
                         consequent_first_arg,
                         alternate_first_arg,
                         ctx,
@@ -353,9 +353,9 @@ impl<'a> PeepholeOptimizations {
                         if maybe_same_id_expr.is_specific_id(&target_id_name) {
                             return Some(ctx.ast.expression_logical(
                                 expr.span,
-                                ctx.ast.move_expression(value_expr),
+                                ctx.ast.take(value_expr),
                                 LogicalOperator::Coalesce,
-                                ctx.ast.move_expression(if is_negate {
+                                ctx.ast.take(if is_negate {
                                     &mut expr.alternate
                                 } else {
                                     &mut expr.consequent
@@ -378,9 +378,7 @@ impl<'a> PeepholeOptimizations {
                                 expr_to_inject_optional_chaining,
                                 ctx,
                             ) {
-                                return Some(
-                                    ctx.ast.move_expression(expr_to_inject_optional_chaining),
-                                );
+                                return Some(ctx.ast.take(expr_to_inject_optional_chaining));
                             }
                         }
                     }
@@ -391,14 +389,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(ctx.ast.move_expression(&mut expr.consequent));
+                return Some(ctx.ast.take(&mut expr.consequent));
             }
 
             // "a ? b : b" => "a, b"
-            let expressions = ctx.ast.vec_from_array([
-                ctx.ast.move_expression(&mut expr.test),
-                ctx.ast.move_expression(&mut expr.consequent),
-            ]);
+            let expressions = ctx
+                .ast
+                .vec_from_array([ctx.ast.take(&mut expr.test), ctx.ast.take(&mut expr.consequent)]);
             return Some(ctx.ast.expression_sequence(expr.span, expressions));
         }
 
@@ -436,15 +433,15 @@ impl<'a> PeepholeOptimizations {
         }
         let cond_expr = self.minimize_conditional(
             expr.span,
-            ctx.ast.move_expression(&mut expr.test),
-            ctx.ast.move_expression(&mut consequent.right),
-            ctx.ast.move_expression(&mut alternate.right),
+            ctx.ast.take(&mut expr.test),
+            ctx.ast.take(&mut consequent.right),
+            ctx.ast.take(&mut alternate.right),
             ctx,
         );
         Some(ctx.ast.expression_assignment(
             expr.span,
             consequent.operator,
-            ctx.ast.move_assignment_target(&mut alternate.left),
+            ctx.ast.take(&mut alternate.left),
             cond_expr,
         ))
     }
@@ -467,7 +464,7 @@ impl<'a> PeepholeOptimizations {
             if !matches!(expr, Expression::ChainExpression(_)) {
                 *expr = ctx.ast.expression_chain(
                     expr.span(),
-                    ctx.ast.move_expression(expr).into_chain_element().unwrap(),
+                    ctx.ast.take(expr).into_chain_element().unwrap(),
                 );
             }
             true
@@ -487,7 +484,7 @@ impl<'a> PeepholeOptimizations {
             Expression::StaticMemberExpression(e) => {
                 if e.object.is_specific_id(target_id_name) {
                     e.optional = true;
-                    e.object = ctx.ast.move_expression(expr_to_inject);
+                    e.object = ctx.ast.take(expr_to_inject);
                     return true;
                 }
                 if Self::inject_optional_chaining_if_matched_inner(
@@ -502,7 +499,7 @@ impl<'a> PeepholeOptimizations {
             Expression::ComputedMemberExpression(e) => {
                 if e.object.is_specific_id(target_id_name) {
                     e.optional = true;
-                    e.object = ctx.ast.move_expression(expr_to_inject);
+                    e.object = ctx.ast.take(expr_to_inject);
                     return true;
                 }
                 if Self::inject_optional_chaining_if_matched_inner(
@@ -517,7 +514,7 @@ impl<'a> PeepholeOptimizations {
             Expression::CallExpression(e) => {
                 if e.callee.is_specific_id(target_id_name) {
                     e.optional = true;
-                    e.callee = ctx.ast.move_expression(expr_to_inject);
+                    e.callee = ctx.ast.take(expr_to_inject);
                     return true;
                 }
                 if Self::inject_optional_chaining_if_matched_inner(
@@ -533,7 +530,7 @@ impl<'a> PeepholeOptimizations {
                 ChainElement::StaticMemberExpression(e) => {
                     if e.object.is_specific_id(target_id_name) {
                         e.optional = true;
-                        e.object = ctx.ast.move_expression(expr_to_inject);
+                        e.object = ctx.ast.take(expr_to_inject);
                         return true;
                     }
                     if Self::inject_optional_chaining_if_matched_inner(
@@ -548,7 +545,7 @@ impl<'a> PeepholeOptimizations {
                 ChainElement::ComputedMemberExpression(e) => {
                     if e.object.is_specific_id(target_id_name) {
                         e.optional = true;
-                        e.object = ctx.ast.move_expression(expr_to_inject);
+                        e.object = ctx.ast.take(expr_to_inject);
                         return true;
                     }
                     if Self::inject_optional_chaining_if_matched_inner(
@@ -563,7 +560,7 @@ impl<'a> PeepholeOptimizations {
                 ChainElement::CallExpression(e) => {
                     if e.callee.is_specific_id(target_id_name) {
                         e.optional = true;
-                        e.callee = ctx.ast.move_expression(expr_to_inject);
+                        e.callee = ctx.ast.take(expr_to_inject);
                         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 8d2a2dbabec2f..33647a2688096 100644
--- a/crates/oxc_minifier/src/peephole/minimize_conditions.rs
+++ b/crates/oxc_minifier/src/peephole/minimize_conditions.rs
@@ -85,9 +85,9 @@ impl<'a> PeepholeOptimizations {
         loop {
             if let Expression::LogicalExpression(logical_expr) = &mut b {
                 if logical_expr.operator == op {
-                    let right = ctx.ast.move_expression(&mut logical_expr.left);
+                    let right = ctx.ast.take(&mut logical_expr.left);
                     a = self.join_with_left_associative_op(span, op, a, right, ctx);
-                    b = ctx.ast.move_expression(&mut logical_expr.right);
+                    b = ctx.ast.take(&mut logical_expr.right);
                     continue;
                 }
             }
@@ -144,9 +144,9 @@ impl<'a> PeepholeOptimizations {
                     _ => return None,
                 }
                 Some(if b.value {
-                    ctx.ast.move_expression(&mut e.left)
+                    ctx.ast.take(&mut e.left)
                 } else {
-                    let argument = ctx.ast.move_expression(&mut e.left);
+                    let argument = ctx.ast.take(&mut e.left);
                     ctx.ast.expression_unary(e.span, UnaryOperator::LogicalNot, argument)
                 })
             }
@@ -208,7 +208,7 @@ impl<'a> PeepholeOptimizations {
 
         let new_op = logical_expr.operator.to_assignment_operator();
         expr.operator = new_op;
-        expr.right = ctx.ast.move_expression(&mut logical_expr.right);
+        expr.right = ctx.ast.take(&mut logical_expr.right);
         true
     }
 
@@ -230,7 +230,7 @@ impl<'a> PeepholeOptimizations {
         }
 
         expr.operator = new_op;
-        expr.right = ctx.ast.move_expression(&mut binary_expr.right);
+        expr.right = ctx.ast.take(&mut binary_expr.right);
         true
     }
 
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 ac8bf877b5fff..4ed4ff3d4d93e 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
@@ -34,7 +34,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 = ctx.ast.move_expression(&mut u2.argument);
+                        let mut e = ctx.ast.take(&mut u2.argument);
                         self.try_fold_expr_in_boolean_context(&mut e, ctx);
                         *expr = e;
                         return true;
@@ -46,7 +46,7 @@ impl<'a> PeepholeOptimizations {
                     && matches!(&e.right, Expression::NumericLiteral(lit) if lit.value == 0.0)
                     && e.left.is_int32_or_uint32(&ctx) =>
             {
-                let argument = ctx.ast.move_expression(&mut e.left);
+                let argument = ctx.ast.take(&mut e.left);
                 *expr = if matches!(
                     e.operator,
                     BinaryOperator::StrictInequality | BinaryOperator::Inequality
@@ -65,7 +65,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 = ctx.ast.move_expression(&mut e.left);
+                    *expr = ctx.ast.take(&mut e.left);
                     return true;
                 }
             }
@@ -75,7 +75,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 = ctx.ast.move_expression(&mut e.left);
+                    *expr = ctx.ast.take(&mut e.left);
                     return true;
                 }
             }
@@ -84,8 +84,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 = ctx.ast.move_expression(&mut e.alternate);
-                    let left = ctx.ast.move_expression(&mut e.test);
+                    let right = ctx.ast.take(&mut e.alternate);
+                    let left = ctx.ast.take(&mut e.test);
                     let span = e.span;
                     let (op, left) = if boolean {
                         // "if (anything1 ? truthyNoSideEffects : anything2)" => "if (anything1 || anything2)"
@@ -98,8 +98,8 @@ impl<'a> PeepholeOptimizations {
                     return true;
                 }
                 if let Some(boolean) = e.alternate.get_side_free_boolean_value(&ctx) {
-                    let left = ctx.ast.move_expression(&mut e.test);
-                    let right = ctx.ast.move_expression(&mut e.consequent);
+                    let left = ctx.ast.take(&mut e.test);
+                    let right = ctx.ast.take(&mut e.consequent);
                     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 ff85df67620f3..807577c673907 100644
--- a/crates/oxc_minifier/src/peephole/minimize_for_statement.rs
+++ b/crates/oxc_minifier/src/peephole/minimize_for_statement.rs
@@ -36,9 +36,9 @@ impl<'a> PeepholeOptimizations {
             }
 
             let span = for_stmt.body.span();
-            let (first, body) = match ctx.ast.move_statement(&mut for_stmt.body) {
+            let (first, body) = match ctx.ast.take(&mut for_stmt.body) {
                 Statement::BlockStatement(mut block_stmt) => (
-                    ctx.ast.move_statement(block_stmt.body.get_mut(0).unwrap()),
+                    ctx.ast.take(block_stmt.body.get_mut(0).unwrap()),
                     Some(Statement::BlockStatement(block_stmt)),
                 ),
                 stmt => (stmt, None),
@@ -46,7 +46,7 @@ impl<'a> PeepholeOptimizations {
 
             let Statement::IfStatement(mut if_stmt) = first else { unreachable!() };
 
-            let expr = match ctx.ast.move_expression(&mut if_stmt.test) {
+            let expr = match ctx.ast.take(&mut if_stmt.test) {
                 Expression::UnaryExpression(unary_expr) if unary_expr.operator.is_not() => {
                     unary_expr.unbox().argument
                 }
@@ -54,7 +54,7 @@ impl<'a> PeepholeOptimizations {
             };
 
             if let Some(test) = &mut for_stmt.test {
-                let left = ctx.ast.move_expression(test);
+                let left = ctx.ast.take(test);
                 let mut logical_expr =
                     ctx.ast.logical_expression(test.span(), left, LogicalOperator::And, expr);
                 *test = Self::try_fold_and_or(&mut logical_expr, ctx)
@@ -78,9 +78,9 @@ impl<'a> PeepholeOptimizations {
             }
 
             let span = for_stmt.body.span();
-            let (first, body) = match ctx.ast.move_statement(&mut for_stmt.body) {
+            let (first, body) = match ctx.ast.take(&mut for_stmt.body) {
                 Statement::BlockStatement(mut block_stmt) => (
-                    ctx.ast.move_statement(block_stmt.body.get_mut(0).unwrap()),
+                    ctx.ast.take(block_stmt.body.get_mut(0).unwrap()),
                     Some(Statement::BlockStatement(block_stmt)),
                 ),
                 stmt => (stmt, None),
@@ -88,10 +88,10 @@ impl<'a> PeepholeOptimizations {
 
             let Statement::IfStatement(mut if_stmt) = first else { unreachable!() };
 
-            let expr = ctx.ast.move_expression(&mut if_stmt.test);
+            let expr = ctx.ast.take(&mut if_stmt.test);
 
             if let Some(test) = &mut for_stmt.test {
-                let left = ctx.ast.move_expression(test);
+                let left = ctx.ast.take(test);
                 let mut logical_expr =
                     ctx.ast.logical_expression(test.span(), left, LogicalOperator::And, expr);
                 *test = Self::try_fold_and_or(&mut logical_expr, ctx)
@@ -100,7 +100,7 @@ impl<'a> PeepholeOptimizations {
                 for_stmt.test = Some(expr);
             }
 
-            let consequent = ctx.ast.move_statement(&mut if_stmt.consequent);
+            let consequent = ctx.ast.take(&mut if_stmt.consequent);
             for_stmt.body = Self::drop_first_statement(span, body, Some(consequent), ctx);
             state.changed = true;
         }
@@ -119,7 +119,7 @@ impl<'a> PeepholeOptimizations {
                 } else if block_stmt.body.len() == 2
                     && !Self::statement_cares_about_scope(&block_stmt.body[1])
                 {
-                    return ctx.ast.move_statement(&mut block_stmt.body[1]);
+                    return ctx.ast.take(&mut block_stmt.body[1]);
                 } 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 d70909ebc6c01..f82e06c63db3b 100644
--- a/crates/oxc_minifier/src/peephole/minimize_if_statement.rs
+++ b/crates/oxc_minifier/src/peephole/minimize_if_statement.rs
@@ -26,17 +26,17 @@ impl<'a> PeepholeOptimizations {
                     // "if (a) b();" => "a && b();"
                     e => (LogicalOperator::And, e),
                 };
-                let a = ctx.ast.move_expression(e);
-                let b = ctx.ast.move_expression(&mut expr_stmt.expression);
+                let a = ctx.ast.take(e);
+                let b = ctx.ast.take(&mut expr_stmt.expression);
                 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 = ctx.ast.move_expression(&mut if_stmt.test);
-                let consequent = ctx.ast.move_expression(&mut expr_stmt.expression);
-                let alternate = ctx.ast.move_expression(&mut alternate_expr_stmt.expression);
+                let test = ctx.ast.take(&mut if_stmt.test);
+                let consequent = ctx.ast.take(&mut expr_stmt.expression);
+                let alternate = ctx.ast.take(&mut alternate_expr_stmt.expression);
                 let expr =
                     self.minimize_conditional(if_stmt.span, test, consequent, alternate, ctx);
                 return Some(ctx.ast.statement_expression(if_stmt.span, expr));
@@ -46,7 +46,7 @@ impl<'a> PeepholeOptimizations {
                 || if_stmt.alternate.as_ref().is_some_and(Self::is_statement_empty)
             {
                 // "if (a) {}" => "a;"
-                let mut expr = ctx.ast.move_expression(&mut if_stmt.test);
+                let mut expr = ctx.ast.take(&mut if_stmt.test);
                 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 {
@@ -58,8 +58,8 @@ impl<'a> PeepholeOptimizations {
                     // "if (a) {} else b();" => "a || b();"
                     e => (LogicalOperator::Or, e),
                 };
-                let a = ctx.ast.move_expression(e);
-                let b = ctx.ast.move_expression(&mut expr_stmt.expression);
+                let a = ctx.ast.take(e);
+                let b = ctx.ast.take(&mut expr_stmt.expression);
                 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 {
@@ -67,8 +67,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 = ctx.ast.move_expression(&mut unary_expr.argument);
-                        if_stmt.consequent = ctx.ast.move_statement(stmt);
+                        if_stmt.test = ctx.ast.take(&mut unary_expr.argument);
+                        if_stmt.consequent = ctx.ast.take(stmt);
                         if_stmt.alternate = None;
                         state.changed = true;
                     }
@@ -76,10 +76,10 @@ impl<'a> PeepholeOptimizations {
                     _ => {
                         if_stmt.test = self.minimize_not(
                             if_stmt.test.span(),
-                            ctx.ast.move_expression(&mut if_stmt.test),
+                            ctx.ast.take(&mut if_stmt.test),
                             ctx,
                         );
-                        if_stmt.consequent = ctx.ast.move_statement(stmt);
+                        if_stmt.consequent = ctx.ast.take(stmt);
                         if_stmt.alternate = None;
                         self.try_minimize_if(if_stmt, state, ctx);
                         state.changed = true;
@@ -93,7 +93,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 = ctx.ast.move_expression(&mut unary_expr.argument);
+                        if_stmt.test = ctx.ast.take(&mut unary_expr.argument);
                         std::mem::swap(&mut if_stmt.consequent, alternate);
                         self.wrap_to_avoid_ambiguous_else(if_stmt, state, ctx);
                         state.changed = true;
@@ -105,8 +105,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 = ctx.ast.move_expression(&mut if_stmt.test);
-                        let b = ctx.ast.move_expression(&mut if2_stmt.test);
+                        let a = ctx.ast.take(&mut if_stmt.test);
+                        let b = ctx.ast.take(&mut if2_stmt.test);
                         if_stmt.test = self.join_with_left_associative_op(
                             if_stmt.test.span(),
                             LogicalOperator::And,
@@ -114,7 +114,7 @@ impl<'a> PeepholeOptimizations {
                             b,
                             ctx,
                         );
-                        if_stmt.consequent = ctx.ast.move_statement(&mut if2_stmt.consequent);
+                        if_stmt.consequent = ctx.ast.take(&mut if2_stmt.consequent);
                         state.changed = true;
                     }
                 }
@@ -138,7 +138,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(ctx.ast.move_statement(&mut if_stmt.consequent)),
+                        ctx.ast.vec1(ctx.ast.take(&mut if_stmt.consequent)),
                         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 27b74f9370b3e..5a421bddceeae 100644
--- a/crates/oxc_minifier/src/peephole/minimize_logical_expression.rs
+++ b/crates/oxc_minifier/src/peephole/minimize_logical_expression.rs
@@ -64,7 +64,7 @@ impl<'a> PeepholeOptimizations {
         .map(|new_expr| {
             ctx.ast.expression_logical(
                 expr.span,
-                ctx.ast.move_expression(&mut left.left),
+                ctx.ast.take(&mut left.left),
                 expr.operator,
                 new_expr,
             )
@@ -141,7 +141,7 @@ impl<'a> PeepholeOptimizations {
         };
         Some(ctx.ast.expression_binary(
             span,
-            ctx.ast.move_expression(left_non_value_expr),
+            ctx.ast.take(left_non_value_expr),
             replace_op,
             ctx.ast.expression_null_literal(null_expr_span),
         ))
@@ -225,6 +225,6 @@ impl<'a> PeepholeOptimizations {
         }
         assignment_expr.span = expr.span;
         assignment_expr.operator = new_op;
-        Some(ctx.ast.move_expression(&mut expr.right))
+        Some(ctx.ast.take(&mut expr.right))
     }
 }
diff --git a/crates/oxc_minifier/src/peephole/minimize_not_expression.rs b/crates/oxc_minifier/src/peephole/minimize_not_expression.rs
index 89cbe76c3c2dd..3d3248dc3490f 100644
--- a/crates/oxc_minifier/src/peephole/minimize_not_expression.rs
+++ b/crates/oxc_minifier/src/peephole/minimize_not_expression.rs
@@ -34,7 +34,7 @@ impl<'a> PeepholeOptimizations {
             Expression::UnaryExpression(e)
                 if e.operator.is_not() && e.argument.value_type(&ctx).is_boolean() =>
             {
-                Some(ctx.ast.move_expression(&mut e.argument))
+                Some(ctx.ast.take(&mut e.argument))
             }
             // `!(a == b)` => `a != b`
             // `!(a != b)` => `a == b`
@@ -42,17 +42,13 @@ impl<'a> PeepholeOptimizations {
             // `!(a !== b)` => `a === b`
             Expression::BinaryExpression(e) if e.operator.is_equality() => {
                 e.operator = e.operator.equality_inverse_operator().unwrap();
-                Some(ctx.ast.move_expression(&mut expr.argument))
+                Some(ctx.ast.take(&mut expr.argument))
             }
             // "!(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(),
-                        ctx.ast.move_expression(last_expr),
-                        ctx,
-                    );
-                    return Some(ctx.ast.move_expression(&mut expr.argument));
+                    *last_expr = self.minimize_not(last_expr.span(), ctx.ast.take(last_expr), ctx);
+                    return Some(ctx.ast.take(&mut expr.argument));
                 }
                 None
             }
diff --git a/crates/oxc_minifier/src/peephole/minimize_statements.rs b/crates/oxc_minifier/src/peephole/minimize_statements.rs
index 9cf4af713a454..899b6661e9bdb 100644
--- a/crates/oxc_minifier/src/peephole/minimize_statements.rs
+++ b/crates/oxc_minifier/src/peephole/minimize_statements.rs
@@ -41,7 +41,7 @@ impl<'a> PeepholeOptimizations {
         let mut keep_var = KeepVar::new(ctx.ast);
         let mut new_stmts = ctx.ast.vec_from_iter(stmts.drain(..));
         for i in 0..new_stmts.len() {
-            let stmt = ctx.ast.move_statement(&mut new_stmts[i]);
+            let stmt = ctx.ast.take(&mut new_stmts[i]);
             if is_control_flow_dead
                 && !stmt.is_module_declaration()
                 && !matches!(stmt.as_declaration(), Some(Declaration::FunctionDeclaration(_)))
@@ -158,8 +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 =
-                                        ctx.ast.move_expression(&mut unary_expr.argument);
+                                    prev_if.test = ctx.ast.take(&mut unary_expr.argument);
                                     std::mem::swap(&mut left, &mut right);
                                 }
                             }
@@ -176,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,
-                                    ctx.ast.move_expression(&mut prev_if.test),
+                                    ctx.ast.take(&mut prev_if.test),
                                     left,
                                     right,
                                     ctx,
@@ -246,8 +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 =
-                                        ctx.ast.move_expression(&mut unary_expr.argument);
+                                    prev_if.test = ctx.ast.take(&mut unary_expr.argument);
                                     std::mem::swap(&mut left, &mut right);
                                 }
                             }
@@ -264,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,
-                                    ctx.ast.move_expression(&mut prev_if.test),
+                                    ctx.ast.take(&mut prev_if.test),
                                     left,
                                     right,
                                     ctx,
@@ -344,8 +342,8 @@ impl<'a> PeepholeOptimizations {
         b: &mut Expression<'a>,
         ctx: Ctx<'a, '_>,
     ) -> Expression<'a> {
-        let a = ctx.ast.move_expression(a);
-        let b = ctx.ast.move_expression(b);
+        let a = ctx.ast.take(a);
+        let b = ctx.ast.take(b);
         if let Expression::SequenceExpression(mut sequence_expr) = a {
             // `(a, b); c`
             sequence_expr.expressions.push(b);
@@ -451,8 +449,8 @@ impl<'a> PeepholeOptimizations {
                     if_stmt.test = self.join_with_left_associative_op(
                         if_stmt.test.span(),
                         LogicalOperator::Or,
-                        ctx.ast.move_expression(&mut prev_if_stmt.test),
-                        ctx.ast.move_expression(&mut if_stmt.test),
+                        ctx.ast.take(&mut prev_if_stmt.test),
+                        ctx.ast.take(&mut if_stmt.test),
                         ctx,
                     );
                     result.pop();
@@ -519,7 +517,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 = ctx.ast.move_expression(&mut if_stmt.test);
+                    let test = ctx.ast.take(&mut if_stmt.test);
                     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 {
@@ -623,9 +621,8 @@ impl<'a> PeepholeOptimizations {
                         state.changed = true;
                     }
                 } else {
-                    for_stmt.init = Some(ForStatementInit::from(
-                        ctx.ast.move_expression(&mut prev_expr_stmt.expression),
-                    ));
+                    for_stmt.init =
+                        Some(ForStatementInit::from(ctx.ast.take(&mut prev_expr_stmt.expression)));
                     result.pop();
                     state.changed = true;
                 }
@@ -644,7 +641,7 @@ impl<'a> PeepholeOptimizations {
                         }
                     }
                 } else if prev_var_decl.kind.is_var() {
-                    let var_decl = ctx.ast.move_variable_declaration(prev_var_decl);
+                    let var_decl = ctx.ast.take(&mut **prev_var_decl);
                     for_stmt.init =
                         Some(ForStatementInit::VariableDeclaration(ctx.ast.alloc(var_decl)));
                     result.pop();
@@ -712,7 +709,7 @@ impl<'a> PeepholeOptimizations {
                         {
                             if id.name == decl_id.name {
                                 for_in_stmt.left = ForStatementLeft::VariableDeclaration(
-                                    ctx.ast.alloc(ctx.ast.move_variable_declaration(prev_var_decl)),
+                                    ctx.ast.alloc(ctx.ast.take(prev_var_decl)),
                                 );
                                 result.pop();
                                 state.changed = true;
@@ -752,7 +749,7 @@ impl<'a> PeepholeOptimizations {
                     {
                         if id.name == decl_id.name {
                             for_of_stmt.left = ForStatementLeft::VariableDeclaration(
-                                ctx.ast.alloc(ctx.ast.move_variable_declaration(prev_var_decl)),
+                                ctx.ast.alloc(ctx.ast.take(prev_var_decl)),
                             );
                             result.pop();
                             state.changed = true;
diff --git a/crates/oxc_minifier/src/peephole/normalize.rs b/crates/oxc_minifier/src/peephole/normalize.rs
index e3c087e98a213..4190ff4ed4f7a 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 = ctx.ast.move_expression(&mut paren_expr.expression);
+            *expr = ctx.ast.take(&mut paren_expr.expression);
         }
         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) = ctx.ast.move_statement(stmt) else { return };
+        let Statement::WhileStatement(while_stmt) = ctx.ast.take(stmt) 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 bcf6a00f08c22..9c2fab7ee4ea6 100644
--- a/crates/oxc_minifier/src/peephole/remove_dead_code.rs
+++ b/crates/oxc_minifier/src/peephole/remove_dead_code.rs
@@ -226,17 +226,17 @@ impl<'a, 'b> PeepholeOptimizations {
                 }
                 return Some(ctx.ast.statement_if(
                     if_stmt.span,
-                    ctx.ast.move_expression(&mut if_stmt.test),
-                    ctx.ast.move_statement(&mut if_stmt.consequent),
-                    if_stmt.alternate.as_mut().map(|alternate| ctx.ast.move_statement(alternate)),
+                    ctx.ast.take(&mut if_stmt.test),
+                    ctx.ast.take(&mut if_stmt.consequent),
+                    if_stmt.alternate.as_mut().map(|alternate| ctx.ast.take(alternate)),
                 ));
             }
             return Some(if boolean {
-                ctx.ast.move_statement(&mut if_stmt.consequent)
+                ctx.ast.take(&mut if_stmt.consequent)
             } else {
                 if_stmt.alternate.as_mut().map_or_else(
                     || ctx.ast.statement_empty(if_stmt.span),
-                    |alternate| ctx.ast.move_statement(alternate),
+                    |alternate| ctx.ast.take(alternate),
                 )
             });
         }
@@ -279,10 +279,9 @@ impl<'a, 'b> PeepholeOptimizations {
                         if let Some(var_decl) = &mut var_decl {
                             var_decl
                                 .declarations
-                                .splice(0..0, ctx.ast.move_vec(&mut var_init.declarations));
+                                .splice(0..0, ctx.ast.take(&mut var_init.declarations));
                         } else {
-                            var_decl =
-                                Some(ctx.ast.alloc(ctx.ast.move_variable_declaration(var_init)));
+                            var_decl = Some(ctx.ast.alloc(ctx.ast.take(var_init)));
                         }
                     }
                     Some(var_decl.map_or_else(
@@ -400,23 +399,16 @@ impl<'a, 'b> PeepholeOptimizations {
                 // "(a, true) ? b : c" => "a, b"
                 let exprs = ctx.ast.vec_from_array([
                     {
-                        let mut test = ctx.ast.move_expression(&mut expr.test);
+                        let mut test = ctx.ast.take(&mut expr.test);
                         self.remove_unused_expression(&mut test, state, ctx);
                         test
                     },
-                    ctx.ast.move_expression(if v {
-                        &mut expr.consequent
-                    } else {
-                        &mut expr.alternate
-                    }),
+                    ctx.ast.take(if v { &mut expr.consequent } else { &mut expr.alternate }),
                 ]);
                 ctx.ast.expression_sequence(expr.span, exprs)
             } else {
-                let result_expr = ctx.ast.move_expression(if v {
-                    &mut expr.consequent
-                } else {
-                    &mut expr.alternate
-                });
+                let result_expr =
+                    ctx.ast.take(if v { &mut expr.consequent } else { &mut expr.alternate });
 
                 let should_keep_as_sequence_expr =
                     Self::should_keep_indirect_access(&result_expr, ctx);
diff --git a/crates/oxc_minifier/src/peephole/remove_unused_expression.rs b/crates/oxc_minifier/src/peephole/remove_unused_expression.rs
index f56ea0ddeaaed..c43e27c4cc6c6 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 = ctx.ast.move_expression(&mut unary_expr.argument);
+                *e = ctx.ast.take(&mut unary_expr.argument);
                 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 = ctx.ast.move_expression(&mut unary_expr.argument);
+                    *e = ctx.ast.take(&mut unary_expr.argument);
                     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 = ctx.ast.move_expression(&mut logical_expr.left);
+            *e = ctx.ast.take(&mut logical_expr.left);
             state.changed = true;
             return false;
         }
@@ -129,7 +129,7 @@ impl<'a> PeepholeOptimizations {
                                 logical_right,
                                 ctx,
                             ) {
-                                *e = ctx.ast.move_expression(logical_right);
+                                *e = ctx.ast.take(logical_right);
                                 state.changed = true;
                                 return false;
                             }
@@ -160,7 +160,7 @@ impl<'a> PeepholeOptimizations {
                                 {
                                     assignment_expr.span = *logical_span;
                                     assignment_expr.operator = AssignmentOperator::LogicalNullish;
-                                    *e = ctx.ast.move_expression(logical_right);
+                                    *e = ctx.ast.take(logical_right);
                                     state.changed = true;
                                     return false;
                                 }
@@ -168,9 +168,9 @@ impl<'a> PeepholeOptimizations {
 
                             *e = ctx.ast.expression_logical(
                                 *logical_span,
-                                ctx.ast.move_expression(new_left_hand_expr),
+                                ctx.ast.take(new_left_hand_expr),
                                 LogicalOperator::Coalesce,
-                                ctx.ast.move_expression(logical_right),
+                                ctx.ast.take(logical_right),
                             );
                             state.changed = true;
                             return false;
@@ -490,7 +490,7 @@ impl<'a> PeepholeOptimizations {
             if test {
                 return true;
             }
-            *e = ctx.ast.move_expression(&mut conditional_expr.test);
+            *e = ctx.ast.take(&mut conditional_expr.test);
             state.changed = true;
             return false;
         }
@@ -500,8 +500,8 @@ impl<'a> PeepholeOptimizations {
             *e = self.join_with_left_associative_op(
                 conditional_expr.span,
                 LogicalOperator::Or,
-                ctx.ast.move_expression(&mut conditional_expr.test),
-                ctx.ast.move_expression(&mut conditional_expr.alternate),
+                ctx.ast.take(&mut conditional_expr.test),
+                ctx.ast.take(&mut conditional_expr.alternate),
                 ctx,
             );
             state.changed = true;
@@ -513,8 +513,8 @@ impl<'a> PeepholeOptimizations {
             *e = self.join_with_left_associative_op(
                 conditional_expr.span,
                 LogicalOperator::And,
-                ctx.ast.move_expression(&mut conditional_expr.test),
-                ctx.ast.move_expression(&mut conditional_expr.consequent),
+                ctx.ast.take(&mut conditional_expr.test),
+                ctx.ast.take(&mut conditional_expr.consequent),
                 ctx,
             );
             state.changed = true;
@@ -548,12 +548,12 @@ impl<'a> PeepholeOptimizations {
                 match (left, right) {
                     (true, true) => true,
                     (true, false) => {
-                        *e = ctx.ast.move_expression(&mut binary_expr.right);
+                        *e = ctx.ast.take(&mut binary_expr.right);
                         state.changed = true;
                         false
                     }
                     (false, true) => {
-                        *e = ctx.ast.move_expression(&mut binary_expr.left);
+                        *e = ctx.ast.take(&mut binary_expr.left);
                         state.changed = true;
                         false
                     }
@@ -561,8 +561,8 @@ impl<'a> PeepholeOptimizations {
                         *e = ctx.ast.expression_sequence(
                             binary_expr.span,
                             ctx.ast.vec_from_array([
-                                ctx.ast.move_expression(&mut binary_expr.left),
-                                ctx.ast.move_expression(&mut binary_expr.right),
+                                ctx.ast.take(&mut binary_expr.left),
+                                ctx.ast.take(&mut binary_expr.right),
                             ]),
                         );
                         state.changed = true;
@@ -605,7 +605,7 @@ impl<'a> PeepholeOptimizations {
             if right_as_primitive.is_symbol() == Some(false)
                 && !binary_expr.right.may_have_side_effects(&ctx)
             {
-                *e = ctx.ast.move_expression(&mut binary_expr.left);
+                *e = ctx.ast.take(&mut binary_expr.left);
                 state.changed = true;
                 return true;
             }
@@ -666,19 +666,19 @@ impl<'a> PeepholeOptimizations {
                     if f.expression {
                         // Replace "(() => foo())()" with "foo()"
                         let expr = f.get_expression_mut().unwrap();
-                        *e = ctx.ast.move_expression(expr);
+                        *e = ctx.ast.take(expr);
                         return self.remove_unused_expression(e, state, ctx);
                     }
                     match &mut f.body.statements[0] {
                         Statement::ExpressionStatement(expr_stmt) => {
                             // Replace "(() => { foo() })" with "foo()"
-                            *e = ctx.ast.move_expression(&mut expr_stmt.expression);
+                            *e = ctx.ast.take(&mut expr_stmt.expression);
                             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 = ctx.ast.move_expression(argument);
+                                *e = ctx.ast.take(argument);
                                 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 bea857fa511f7..6e215be8713e7 100644
--- a/crates/oxc_minifier/src/peephole/replace_known_methods.rs
+++ b/crates/oxc_minifier/src/peephole/replace_known_methods.rs
@@ -387,20 +387,16 @@ impl<'a> PeepholeOptimizations {
 
         let wrap_with_unary_plus_if_needed = |expr: &mut Expression<'a>| {
             if expr.value_type(&ctx).is_number() {
-                ctx.ast.move_expression(expr)
+                ctx.ast.take(expr)
             } else {
-                ctx.ast.expression_unary(
-                    SPAN,
-                    UnaryOperator::UnaryPlus,
-                    ctx.ast.move_expression(expr),
-                )
+                ctx.ast.expression_unary(SPAN, UnaryOperator::UnaryPlus, ctx.ast.take(expr))
             }
         };
 
         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
-            ctx.ast.move_expression(first_arg),
+            ctx.ast.take(first_arg),
             BinaryOperator::Exponential,
             wrap_with_unary_plus_if_needed(second_arg),
         ))
@@ -610,10 +606,10 @@ impl<'a> PeepholeOptimizations {
 
         *node = ctx.ast.expression_call(
             original_span,
-            ctx.ast.move_expression(new_root_callee),
+            ctx.ast.take(new_root_callee),
             Option::<TSTypeParameterInstantiation>::None,
             ctx.ast.vec_from_iter(
-                collected_arguments.into_iter().rev().flat_map(|arg| ctx.ast.move_vec(arg)),
+                collected_arguments.into_iter().rev().flat_map(|arg| ctx.ast.take(arg)),
             ),
             false,
         );
@@ -675,13 +671,13 @@ impl<'a> PeepholeOptimizations {
                 }
 
                 if args.is_empty() {
-                    Some(ctx.ast.move_expression(object))
+                    Some(ctx.ast.take(object))
                 } else if can_merge_until.is_some() {
                     Some(ctx.ast.expression_call(
                         span,
-                        ctx.ast.move_expression(callee),
+                        ctx.ast.take(callee),
                         Option::<TSTypeParameterInstantiation>::None,
-                        ctx.ast.move_vec(args),
+                        ctx.ast.take(args),
                         false,
                     ))
                 } else {
@@ -955,7 +951,7 @@ impl<'a> PeepholeOptimizations {
                     s.span = span;
                     s.value = ctx.ast.atom(&c.to_string());
                     s.raw = None;
-                    Some(ctx.ast.move_expression(object))
+                    Some(ctx.ast.take(object))
                 } 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 70a9694518966..15bf171657af6 100644
--- a/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs
+++ b/crates/oxc_minifier/src/peephole/substitute_alternate_syntax.rs
@@ -244,8 +244,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| ctx.ast.move_expression(arg));
+                    let return_stmt_arg = ret_stmt.argument.as_mut().map(|arg| ctx.ast.take(arg));
                     if let Some(arg) = return_stmt_arg {
                         *body = ctx.ast.statement_expression(arg.span(), arg);
                         arrow_expr.expression = true;
@@ -288,14 +287,13 @@ impl<'a> PeepholeOptimizations {
         };
         if let Expression::Identifier(ident) = &unary_expr.argument {
             if ctx.is_global_reference(ident) {
-                let left = ctx.ast.move_expression(&mut expr.left);
+                let left = ctx.ast.take(&mut expr.left);
                 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) = ctx.ast.move_expression(&mut expr.left)
-        else {
+        let Expression::UnaryExpression(unary_expr) = ctx.ast.take(&mut expr.left) else {
             unreachable!()
         };
         let right = ctx.ast.void_0(expr.right.span());
@@ -330,7 +328,7 @@ impl<'a> PeepholeOptimizations {
             return None;
         }
 
-        Some(ctx.ast.move_expression(&mut expr.argument))
+        Some(ctx.ast.take(&mut expr.argument))
     }
 
     /// For `+a - n` => `a - n` (assuming n is a number)
@@ -386,9 +384,9 @@ impl<'a> PeepholeOptimizations {
 
         let mut new_left = ctx.ast.expression_logical(
             expr.span,
-            ctx.ast.move_expression(&mut expr.left),
+            ctx.ast.take(&mut expr.left),
             expr.operator,
-            ctx.ast.move_expression(&mut right.left),
+            ctx.ast.take(&mut right.left),
         );
 
         {
@@ -402,7 +400,7 @@ impl<'a> PeepholeOptimizations {
             expr.span,
             new_left,
             expr.operator,
-            ctx.ast.move_expression(&mut right.right),
+            ctx.ast.take(&mut right.right),
         ))
     }
 
@@ -458,7 +456,7 @@ impl<'a> PeepholeOptimizations {
         .map(|new_expr| {
             ctx.ast.expression_logical(
                 expr.span,
-                ctx.ast.move_expression(&mut left.left),
+                ctx.ast.take(&mut left.left),
                 expr.operator,
                 new_expr,
             )
@@ -578,15 +576,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) {
-                (
-                    ctx.ast.move_expression(&mut e.left),
-                    ctx.ast.expression_null_literal(e.right.span()),
-                )
+                (ctx.ast.take(&mut e.left), ctx.ast.expression_null_literal(e.right.span()))
             } else if ctx.is_expression_undefined(&e.left) {
-                (
-                    ctx.ast.move_expression(&mut e.right),
-                    ctx.ast.expression_null_literal(e.left.span()),
-                )
+                (ctx.ast.take(&mut e.right), ctx.ast.expression_null_literal(e.left.span()))
             } else {
                 return None;
             };
@@ -688,7 +680,7 @@ impl<'a> PeepholeOptimizations {
             "Boolean" => match arg {
                 None => Some(ctx.ast.expression_boolean_literal(span, false)),
                 Some(arg) => {
-                    let mut arg = ctx.ast.move_expression(arg);
+                    let mut arg = ctx.ast.take(arg);
                     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))
@@ -707,7 +699,7 @@ impl<'a> PeepholeOptimizations {
                             span,
                             ctx.ast.expression_string_literal(call_expr.span, "", None),
                             BinaryOperator::Addition,
-                            ctx.ast.move_expression(arg),
+                            ctx.ast.take(arg),
                         ))
                     }
                 }
@@ -724,8 +716,7 @@ impl<'a> PeepholeOptimizations {
             // `BigInt(1n)` -> `1n`
             "BigInt" => match arg {
                 None => None,
-                Some(arg) => matches!(arg, Expression::BigIntLiteral(_))
-                    .then(|| ctx.ast.move_expression(arg)),
+                Some(arg) => matches!(arg, Expression::BigIntLiteral(_)).then(|| ctx.ast.take(arg)),
             },
             _ => None,
         }
@@ -797,20 +788,19 @@ impl<'a> PeepholeOptimizations {
                             }
                         }
                         let callee = ctx.ast.expression_identifier(n.span, "Array");
-                        let args = ctx.ast.move_vec(args);
+                        let args = ctx.ast.take(args);
                         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(ctx.ast.move_expression(arg)));
+                        let elements =
+                            ctx.ast.vec1(ArrayExpressionElement::from(ctx.ast.take(arg)));
                         Some(ctx.ast.expression_array(span, elements, None))
                     }
                     // `new Array(x)` -> `Array(x)`
                     else {
                         let callee = ctx.ast.expression_identifier(span, "Array");
-                        let args = ctx.ast.move_vec(args);
+                        let args = ctx.ast.take(args);
                         Some(ctx.ast.expression_call(span, callee, NONE, args, false))
                     }
                 } else {
@@ -818,7 +808,7 @@ impl<'a> PeepholeOptimizations {
                     let elements = ctx.ast.vec_from_iter(
                         args.iter_mut()
                             .filter_map(|arg| arg.as_expression_mut())
-                            .map(|arg| ArrayExpressionElement::from(ctx.ast.move_expression(arg))),
+                            .map(|arg| ArrayExpressionElement::from(ctx.ast.take(arg))),
                     );
                     Some(ctx.ast.expression_array(span, elements, None))
                 }
@@ -861,9 +851,9 @@ impl<'a> PeepholeOptimizations {
         } {
             Some(ctx.ast.expression_call(
                 e.span,
-                ctx.ast.move_expression(&mut e.callee),
+                ctx.ast.take(&mut e.callee),
                 NONE,
-                ctx.ast.move_vec(&mut e.arguments),
+                ctx.ast.take(&mut e.arguments),
                 false,
             ))
         } else {
@@ -988,22 +978,21 @@ impl<'a> PeepholeOptimizations {
                             ArrayExpressionElement::SpreadElement(spread_el) => {
                                 new_args.push(ctx.ast.argument_spread_element(
                                     spread_el.span,
-                                    ctx.ast.move_expression(&mut spread_el.argument),
+                                    ctx.ast.take(&mut spread_el.argument),
                                 ));
                             }
                             ArrayExpressionElement::Elision(elision) => {
                                 new_args.push(ctx.ast.void_0(elision.span).into());
                             }
                             match_expression!(ArrayExpressionElement) => {
-                                new_args
-                                    .push(ctx.ast.move_expression(el.to_expression_mut()).into());
+                                new_args.push(ctx.ast.take(el.to_expression_mut()).into());
                             }
                         }
                     }
                 } else {
                     new_args.push(ctx.ast.argument_spread_element(
                         spread_el.span,
-                        ctx.ast.move_expression(&mut spread_el.argument),
+                        ctx.ast.take(&mut spread_el.argument),
                     ));
                 }
             } else {
diff --git a/crates/oxc_parser/src/js/expression.rs b/crates/oxc_parser/src/js/expression.rs
index 7d8c04301de51..dd6c693e4a735 100644
--- a/crates/oxc_parser/src/js/expression.rs
+++ b/crates/oxc_parser/src/js/expression.rs
@@ -651,7 +651,7 @@ impl<'a> ParserImpl<'a> {
         if let Expression::TSInstantiationExpression(mut expr) = lhs {
             expr.expression = self.map_to_chain_expression(
                 expr.expression.span(),
-                self.ast.move_expression(&mut expr.expression),
+                self.ast.take(&mut expr.expression),
             );
             Ok(Expression::TSInstantiationExpression(expr))
         } else {
diff --git a/crates/oxc_transformer/src/common/arrow_function_converter.rs b/crates/oxc_transformer/src/common/arrow_function_converter.rs
index 91ea6a936bc97..9358254ec2b05 100644
--- a/crates/oxc_transformer/src/common/arrow_function_converter.rs
+++ b/crates/oxc_transformer/src/common/arrow_function_converter.rs
@@ -420,7 +420,7 @@ impl<'a> Traverse<'a> for ArrowFunctionConverter<'a> {
                     //   prop = (() => { return async () => {} })();
                     // }
                     // ```
-                    Some(wrap_expression_in_arrow_function_iife(ctx.ast.move_expression(expr), ctx))
+                    Some(wrap_expression_in_arrow_function_iife(ctx.ast.take(expr), ctx))
                 } else {
                     return;
                 }
@@ -445,8 +445,7 @@ impl<'a> Traverse<'a> for ArrowFunctionConverter<'a> {
                 return;
             }
 
-            let Expression::ArrowFunctionExpression(arrow_function_expr) =
-                ctx.ast.move_expression(expr)
+            let Expression::ArrowFunctionExpression(arrow_function_expr) = ctx.ast.take(expr)
             else {
                 unreachable!()
             };
@@ -746,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(ctx.ast.move_expression(&mut computed_member.expression));
-                ctx.ast.move_expression(&mut computed_member.object)
+                argument = Some(ctx.ast.take(&mut computed_member.expression));
+                ctx.ast.take(&mut computed_member.object)
             }
             MemberExpression::StaticMemberExpression(static_member) => {
                 if !static_member.object.is_super() {
@@ -756,7 +755,7 @@ impl<'a> ArrowFunctionConverter<'a> {
 
                 // Used to generate the name of the arrow function.
                 property = static_member.property.name.as_str();
-                ctx.ast.move_expression(expr)
+                ctx.ast.take(expr)
             }
             MemberExpression::PrivateFieldExpression(_) => {
                 // Private fields can't be accessed by `super`.
@@ -783,7 +782,7 @@ impl<'a> ArrowFunctionConverter<'a> {
         }
         // _value
         if let Some(assign_value) = assign_value {
-            arguments.push(Argument::from(ctx.ast.move_expression(assign_value)));
+            arguments.push(Argument::from(ctx.ast.take(assign_value)));
         }
         let call = ctx.ast.expression_call(SPAN, callee, NONE, arguments, false);
         Some(call)
@@ -820,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(ctx.ast.move_vec(&mut call.arguments));
+        arguments.extend(ctx.ast.take(&mut call.arguments));
 
         let property = ctx.ast.identifier_name(SPAN, "call");
         let callee = ctx.ast.member_expression_static(SPAN, object, property, false);
@@ -857,7 +856,7 @@ impl<'a> ArrowFunctionConverter<'a> {
             return None;
         }
 
-        let assignment_target = ctx.ast.move_assignment_target(&mut assignment.left);
+        let assignment_target = ctx.ast.take(&mut assignment.left);
         let mut assignment_expr = Expression::from(assignment_target.into_member_expression());
         self.transform_member_expression_for_super(
             &mut assignment_expr,
@@ -1317,7 +1316,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([self.ctx.ast.move_expression(expr), assignment]);
+        let exprs = self.ctx.ast.vec_from_array([self.ctx.ast.take(expr), 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 b34f868025d0f..32f63764fb313 100644
--- a/crates/oxc_transformer/src/decorator/legacy/metadata.rs
+++ b/crates/oxc_transformer/src/decorator/legacy/metadata.rs
@@ -371,7 +371,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 = ctx.ast.move_expression(&mut logical.right);
+                    let right = ctx.ast.take(&mut logical.right);
                     // `(_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 2336afebf8da4..38a52d8ffd0d6 100644
--- a/crates/oxc_transformer/src/decorator/legacy/mod.rs
+++ b/crates/oxc_transformer/src/decorator/legacy/mod.rs
@@ -431,7 +431,7 @@ impl<'a> LegacyDecorator<'a, '_> {
         // `class C {}` -> `let C = class {}`
         class.r#type = ClassType::ClassExpression;
         let initializer = Self::get_class_initializer(
-            Expression::ClassExpression(ctx.ast.alloc(ctx.ast.move_class(class))),
+            Expression::ClassExpression(ctx.ast.alloc(ctx.ast.take(class))),
             class_alias_binding.as_ref(),
             ctx,
         );
@@ -873,7 +873,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 = ctx.ast.move_expression(key.to_expression_mut());
+                let right = ctx.ast.take(key.to_expression_mut());
                 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 1b876ad0f942d..1fcde55962010 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 ctx.ast.move_expression(expr) {
+        let binary_expr = match ctx.ast.take(expr) {
             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,
-                ctx.ast.move_expression(&mut member_expr.object),
+                ctx.ast.take(&mut member_expr.object),
                 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 = ctx.ast.move_expression(prop);
+            let owned_prop = ctx.ast.take(prop);
             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(ctx.ast.move_expression(obj), temp_var_inits, ctx);
+        let binding = self.create_temp_var(ctx.ast.take(obj), 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 = ctx.ast.move_expression(&mut assign_expr.right);
+        let pow_right = ctx.ast.take(&mut assign_expr.right);
         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(ctx.ast.move_expression(expr));
+            temp_var_inits.push(ctx.ast.take(expr));
             *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 a557986528b4a..2a0036bf58465 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<Expression<'a>> {
         // We don't need to handle top-level await.
         if Self::is_inside_async_function(ctx) {
-            Some(ctx.ast.expression_yield(
-                SPAN,
-                false,
-                Some(ctx.ast.move_expression(&mut expr.argument)),
-            ))
+            Some(ctx.ast.expression_yield(SPAN, false, Some(ctx.ast.take(&mut expr.argument))))
         } else {
             None
         }
@@ -302,7 +298,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
         let body = wrapper_function.body.take().unwrap();
-        let params = ctx.alloc(ctx.ast.move_formal_parameters(&mut wrapper_function.params));
+        let params = ctx.alloc(ctx.ast.take(&mut *wrapper_function.params));
         let id = wrapper_function.id.take();
         let has_function_id = id.is_some();
 
@@ -390,8 +386,7 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
         }
 
         // Construct the IIFE
-        let callee =
-            Expression::FunctionExpression(ctx.alloc(ctx.ast.move_function(wrapper_function)));
+        let callee = Expression::FunctionExpression(ctx.alloc(ctx.ast.take(wrapper_function)));
         ctx.ast.expression_call_with_pure(SPAN, callee, NONE, ctx.ast.vec(), false, true)
     }
 
@@ -473,19 +468,19 @@ impl<'a, 'ctx> AsyncGeneratorExecutor<'a, 'ctx> {
         arrow: &mut ArrowFunctionExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
-        let mut body = ctx.ast.move_function_body(&mut arrow.body);
+        let mut body = ctx.ast.take(&mut *arrow.body);
 
         // If the arrow's expression is true, we need to wrap the only one expression with return statement.
         if arrow.expression {
             let statement = body.statements.first_mut().unwrap();
             let expression = match statement {
-                Statement::ExpressionStatement(es) => ctx.ast.move_expression(&mut es.expression),
+                Statement::ExpressionStatement(es) => ctx.ast.take(&mut es.expression),
                 _ => unreachable!(),
             };
             *statement = ctx.ast.statement_return(expression.span(), Some(expression));
         }
 
-        let params = ctx.alloc(ctx.ast.move_formal_parameters(&mut arrow.params));
+        let params = ctx.alloc(ctx.ast.take(&mut *arrow.params));
         let generator_function_id = arrow.scope_id();
         ctx.scoping_mut().scope_flags_mut(generator_function_id).remove(ScopeFlags::Arrow);
         let function_name = Self::infer_function_name_from_parent_node(ctx);
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 5ed0ecb373648..8e1c51ee2f548 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 = ctx.ast.move_assignment_target(left.to_assignment_target_mut());
+                let target = ctx.ast.take(left.to_assignment_target_mut());
                 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(ctx.ast.move_statement(stmt_body));
+                    statements.push(ctx.ast.take(stmt_body));
                 }
             }
             statements
         };
 
-        let iterator = ctx.ast.move_expression(&mut stmt.right);
+        let iterator = ctx.ast.take(&mut stmt.right);
         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 0d6c558cfeff2..e121b1a0bc781 100644
--- a/crates/oxc_transformer/src/es2018/async_generator_functions/mod.rs
+++ b/crates/oxc_transformer/src/es2018/async_generator_functions/mod.rs
@@ -164,7 +164,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
         }
 
         expr.argument.as_mut().map(|argument| {
-            let argument = Argument::from(ctx.ast.move_expression(argument));
+            let argument = Argument::from(ctx.ast.take(argument));
             let arguments = ctx.ast.vec1(argument);
             let mut argument =
                 self.ctx.helper_call_expr(Helper::AsyncIterator, SPAN, arguments, ctx);
@@ -199,7 +199,7 @@ impl<'a> AsyncGeneratorFunctions<'a, '_> {
             return None;
         }
 
-        let mut argument = ctx.ast.move_expression(&mut expr.argument);
+        let mut argument = ctx.ast.take(&mut expr.argument);
         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 7b00d8e93e6a0..1378229b54d40 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,
-            ctx.ast.move_assignment_target(&mut assign_expr.left),
+            ctx.ast.take(&mut assign_expr.left),
             reference_builder.create_read_expression(ctx),
         ));
 
@@ -403,7 +403,7 @@ impl<'a> ObjectRestSpread<'a, '_> {
                 break;
             }
         }
-        let mut expressions = ctx.ast.vec1(ctx.ast.move_expression(expr));
+        let mut expressions = ctx.ast.vec1(ctx.ast.take(expr));
         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,
-                    ctx.ast.move_assignment_target(pat),
+                    ctx.ast.take(pat),
                     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(spread_prop) = prop {
                 Self::make_object_spread(&mut call_expr, &mut props, transform_ctx, ctx);
-                let arg = ctx.ast.move_expression(&mut spread_prop.unbox().argument);
+                let arg = ctx.ast.take(&mut spread_prop.unbox().argument);
                 call_expr.as_mut().unwrap().arguments.push(Argument::from(arg));
             } else {
                 props.push(prop);
@@ -637,7 +637,7 @@ impl<'a> ObjectRestSpread<'a, '_> {
             return;
         }
         let target = left.to_assignment_target_mut();
-        let assign_left = ctx.ast.move_assignment_target(target);
+        let assign_left = ctx.ast.take(target);
         let flags = SymbolFlags::FunctionScopedVariable;
         let bound_identifier = ctx.generate_uid("ref", scope_id, flags);
         let id = bound_identifier.create_binding_pattern(ctx);
@@ -669,7 +669,7 @@ impl<'a> ObjectRestSpread<'a, '_> {
             (empty_stmt.span, ctx.ast.vec())
         } else {
             let span = stmt.span();
-            (span, ctx.ast.vec1(ctx.ast.move_statement(stmt)))
+            (span, ctx.ast.vec1(ctx.ast.take(stmt)))
         };
         *stmt = ctx.ast.statement_block_with_scope_id(span, stmts, scope_id);
         scope_id
@@ -1151,7 +1151,7 @@ impl<'a> ReferenceBuilder<'a> {
         force_create_binding: bool,
         ctx: &mut TraverseCtx<'a>,
     ) -> Self {
-        let expr = ctx.ast.move_expression(expr);
+        let expr = ctx.ast.take(expr);
         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 ee12a8bd04c69..04e3619363d53 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) = ctx.ast.move_expression(expr) else {
+        let Expression::LogicalExpression(logical_expr) = ctx.ast.take(expr) else {
             unreachable!()
         };
 
diff --git a/crates/oxc_transformer/src/es2020/optional_chaining.rs b/crates/oxc_transformer/src/es2020/optional_chaining.rs
index 548e0908f0848..f553e67eb6b9a 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) = ctx.ast.move_expression(expr) else {
-            unreachable!()
-        };
+        let Expression::ChainExpression(chain_expr) = ctx.ast.take(expr) 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(ctx.ast.move_expression(expr), ctx)
+            wrap_expression_in_arrow_function_iife(ctx.ast.take(expr), 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(ctx.ast.move_expression(expr), ctx)
+            wrap_expression_in_arrow_function_iife(ctx.ast.take(expr), 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.
@@ -372,7 +370,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),
-                    ctx.ast.move_expression(object),
+                    ctx.ast.take(object),
                     ctx,
                 );
                 binding.create_read_expression(ctx)
@@ -486,7 +484,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 = ctx.ast.move_expression(callee);
+                                let callee = ctx.ast.take(callee);
                                 let property = ctx.ast.identifier_name(SPAN, "call");
                                 let member =
                                     ctx.ast.member_expression_static(SPAN, callee, property, false);
@@ -532,7 +530,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 = ctx.ast.move_expression(expr);
+                    let original_callee = ctx.ast.take(expr);
                     let expressions = ctx.ast.vec_from_array([zero, original_callee]);
                     *expr = ctx.ast.expression_sequence(SPAN, expressions);
                 }
@@ -649,7 +647,7 @@ impl<'a> OptionalChaining<'a, '_> {
                         // `(_foo = foo)`
                         *object = Self::create_assignment_expression(
                             binding.create_write_target(ctx),
-                            ctx.ast.move_expression(object),
+                            ctx.ast.take(object),
                             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 fb669bb1b6f31..82330586ef64f 100644
--- a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs
+++ b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs
@@ -125,7 +125,7 @@ impl<'a> LogicalAssignmentOperators<'a, '_> {
         };
 
         let assign_op = AssignmentOperator::Assign;
-        let right = ctx.ast.move_expression(&mut assignment_expr.right);
+        let right = ctx.ast.take(&mut assignment_expr.right);
         let right = ctx.ast.expression_assignment(SPAN, assign_op, assign_target, right);
 
         let logical_expr = ctx.ast.expression_logical(SPAN, left_expr, operator, right);
@@ -152,7 +152,7 @@ impl<'a> LogicalAssignmentOperators<'a, '_> {
         static_expr: &mut StaticMemberExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> (Expression<'a>, AssignmentTarget<'a>) {
-        let object = ctx.ast.move_expression(&mut static_expr.object);
+        let object = ctx.ast.take(&mut static_expr.object);
         let (object, object_ref) = self.ctx.duplicate_expression(object, true, ctx);
 
         let left_expr = Expression::from(ctx.ast.member_expression_static(
@@ -178,10 +178,10 @@ impl<'a> LogicalAssignmentOperators<'a, '_> {
         computed_expr: &mut ComputedMemberExpression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) -> (Expression<'a>, AssignmentTarget<'a>) {
-        let object = ctx.ast.move_expression(&mut computed_expr.object);
+        let object = ctx.ast.take(&mut computed_expr.object);
         let (object, object_ref) = self.ctx.duplicate_expression(object, true, ctx);
 
-        let expression = ctx.ast.move_expression(&mut computed_expr.expression);
+        let expression = ctx.ast.take(&mut computed_expr.expression);
         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 ff4f94e9e5309..cd9d057f316a0 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/class.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/class.rs
@@ -670,7 +670,7 @@ impl<'a> ClassProperties<'a, '_> {
             }
 
             // `_Class = class {}`
-            let class_expr = ctx.ast.move_expression(expr);
+            let class_expr = ctx.ast.take(expr);
             let assignment = create_assignment(binding, class_expr, ctx);
 
             if exprs.is_empty() && self.insert_after_exprs.is_empty() {
@@ -699,7 +699,7 @@ impl<'a> ClassProperties<'a, '_> {
                 return;
             }
 
-            let class_expr = ctx.ast.move_expression(expr);
+            let class_expr = ctx.ast.take(expr);
             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 3ff887886c8a1..2c4a45049901a 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 = ctx.ast.move_expression(key);
+        let original_key = ctx.ast.take(key);
         let (assignment, temp_var) = self.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 = ctx.ast.move_expression(key);
+        let original_key = ctx.ast.take(key);
         if key_needs_temp_var(&original_key, ctx) {
             let (assignment, ident) = self.create_computed_key_temp_var(original_key, ctx);
             if is_static {
@@ -137,7 +137,7 @@ impl<'a> ClassProperties<'a, '_> {
         }
 
         // Extract assignment from computed key and insert before class
-        let assignment = ctx.ast.move_property_key(&mut prop.key).into_expression();
+        let assignment = ctx.ast.take(&mut prop.key).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 b0c51e1738967..6c60161343e8d 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/constructor.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/constructor.rs
@@ -589,7 +589,7 @@ impl<'a> ConstructorParamsSuperReplacer<'a, '_> {
         });
 
         let ctx = &mut *self.ctx;
-        let super_call = ctx.ast.move_expression(expr);
+        let super_call = ctx.ast.take(expr);
         *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 b16175e4dc28b..86443a25efa25 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/private_field.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/private_field.rs
@@ -59,7 +59,7 @@ impl<'a> ClassProperties<'a, '_> {
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
         let span = field_expr.span;
-        let object = ctx.ast.move_expression(&mut field_expr.object);
+        let object = ctx.ast.take(&mut field_expr.object);
         let resolved = if is_assignment {
             match self.classes_stack.find_writeable_private_prop(&field_expr.field) {
                 Some(prop) => prop,
@@ -265,7 +265,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 = ctx.ast.move_expression(&mut field_expr.object);
+            let object = ctx.ast.take(&mut field_expr.object);
             call_expr.callee = Expression::from(Self::create_private_field_member_expr_loose(
                 object,
                 prop_binding,
@@ -332,7 +332,7 @@ impl<'a> ClassProperties<'a, '_> {
         let span = field_expr.span;
         // `(object.#method)()`
         //  ^^^^^^^^^^^^^^^^ is a parenthesized expression
-        let object = ctx.ast.move_expression(field_expr.object.get_inner_expression_mut());
+        let object = ctx.ast.take(field_expr.object.get_inner_expression_mut());
 
         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 = ctx.ast.move_expression(&mut field_expr.object);
+            let object = ctx.ast.take(&mut field_expr.object);
             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 = ctx.ast.move_expression(&mut assign_expr.right);
+                    let value = ctx.ast.take(&mut assign_expr.right);
                     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 = ctx.ast.move_expression(expr);
+                    let right = ctx.ast.take(expr);
                     *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 = ctx.ast.move_expression(&mut assign_expr.right);
+            let value = ctx.ast.take(&mut assign_expr.right);
 
             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 = ctx.ast.move_expression(&mut assign_expr.right);
+                let value = ctx.ast.take(&mut assign_expr.right);
 
                 // 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 = ctx.ast.move_expression(expr);
+                    let right = ctx.ast.take(expr);
                     // `_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 ctx.ast.move_expression(expr) {
+        let assign_expr = match ctx.ast.take(expr) {
             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 = ctx.ast.move_expression(&mut field_expr.object);
+            let object = ctx.ast.take(&mut field_expr.object);
             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 = ctx.ast.move_expression(field_expr.object.get_inner_expression_mut());
+        let object = ctx.ast.take(field_expr.object.get_inner_expression_mut());
 
         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 = ctx.ast.move_expression(expr);
+            let update_expr = ctx.ast.take(expr);
 
             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 = ctx.ast.move_expression(expr);
+            let update_expr = ctx.ast.take(expr);
 
             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 = ctx.ast.move_expression(object);
+            let owned_object = ctx.ast.take(object);
             *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 = ctx.ast.move_expression(callee);
+            call_expr.callee = ctx.ast.take(callee);
             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(ctx.ast.move_expression(object), ctx);
+        let (assignment, context) = self.duplicate_object(ctx.ast.take(object), ctx);
         *object = assignment;
-        let callee = ctx.ast.move_expression(&mut call_expr.callee);
+        let callee = ctx.ast.take(&mut call_expr.callee);
         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 = ctx.ast.move_expression(object.get_inner_expression_mut());
+        let mut owned_object = ctx.ast.take(object.get_inner_expression_mut());
 
         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) = ctx.ast.move_expression(expr) else {
-            unreachable!()
-        };
+        let Expression::ChainExpression(chain_expr) = ctx.ast.take(expr) else { unreachable!() };
         match chain_expr.unbox().expression {
             element @ match_member_expression!(ChainElement) => {
                 Expression::from(element.into_member_expression())
@@ -1571,10 +1569,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, ctx.ast.move_expression(object), ctx);
-                let (assignment, context) =
-                    self.duplicate_object(ctx.ast.move_expression(object), ctx);
+                *object = Self::wrap_conditional_check(result, ctx.ast.take(object), ctx);
+                let (assignment, context) = self.duplicate_object(ctx.ast.take(object), ctx);
                 *object = assignment;
                 context
             } else {
@@ -1583,11 +1579,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(ctx.ast.move_expression(object), ctx);
+                let (assignment, context) = self.duplicate_object(ctx.ast.take(object), ctx);
                 *object = assignment;
-                *callee =
-                    Self::wrap_conditional_check(result, ctx.ast.move_expression(callee), ctx);
+                *callee = Self::wrap_conditional_check(result, ctx.ast.take(callee), ctx);
                 context
             }
         } else {
@@ -1595,14 +1589,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(ctx.ast.move_expression(object), ctx);
+            let (assignment, context) = self.duplicate_object(ctx.ast.take(object), 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 = ctx.ast.move_expression(callee);
+        let owned_callee = ctx.ast.take(callee);
         Self::substitute_callee_and_insert_context(call, owned_callee, context, ctx);
         result
     }
@@ -1699,7 +1693,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;
-                    ctx.ast.move_expression(expr)
+                    ctx.ast.take(expr)
                 },
             );
         }
@@ -1759,7 +1753,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 = ctx.ast.move_expression(&mut field_expr.object);
+            let object = ctx.ast.take(&mut field_expr.object);
             let replacement = Self::create_private_field_member_expr_loose(
                 object,
                 prop_binding,
@@ -1849,7 +1843,7 @@ impl<'a> ClassProperties<'a, '_> {
         expr: &mut Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        let Expression::PrivateInExpression(private_in) = ctx.ast.move_expression(expr) else {
+        let Expression::PrivateInExpression(private_in) = ctx.ast.take(expr) else {
             unreachable!();
         };
 
diff --git a/crates/oxc_transformer/src/es2022/class_properties/private_method.rs b/crates/oxc_transformer/src/es2022/class_properties/private_method.rs
index 101e5026738ab..396938ed3c683 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/private_method.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/private_method.rs
@@ -46,7 +46,7 @@ impl<'a> ClassProperties<'a, '_> {
             return None;
         };
 
-        let mut function = ctx.ast.move_function(value);
+        let mut function = ctx.ast.take(&mut **value);
         let resolved_private_prop = if *kind == MethodDefinitionKind::Set {
             self.classes_stack.find_writeable_private_prop(ident)
         } else {
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 e5e037e5cee16..68ca21edaa477 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
@@ -87,7 +87,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(ctx.ast.move_vec(stmts), scope_id, block.span, ctx)
+        wrap_statements_in_arrow_function_iife(ctx.ast.take(stmts), scope_id, block.span, ctx)
     }
 
     fn convert_static_block_with_single_expression_to_expression(
@@ -104,7 +104,7 @@ impl<'a> ClassProperties<'a, '_> {
         // Delete scope for static block
         ctx.scoping_mut().delete_scope(scope_id);
 
-        ctx.ast.move_expression(expr)
+        ctx.ast.take(expr)
     }
 
     /// 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 027fb9ffd046c..ca1b454fe3c4e 100644
--- a/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs
+++ b/crates/oxc_transformer/src/es2022/class_properties/super_converter.rs
@@ -87,7 +87,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> {
         is_callee: bool,
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
-        let property = ctx.ast.move_expression(&mut member.expression);
+        let property = ctx.ast.take(&mut member.expression);
         self.create_super_prop_get(member.span, property, is_callee, ctx)
     }
 
@@ -202,7 +202,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> {
         expr: &mut Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        let Expression::AssignmentExpression(assign_expr) = ctx.ast.move_expression(expr) else {
+        let Expression::AssignmentExpression(assign_expr) = ctx.ast.take(expr) else {
             unreachable!()
         };
         let AssignmentExpression { span, operator, right: value, left } = assign_expr.unbox();
@@ -230,7 +230,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> {
         expr: &mut Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        let Expression::AssignmentExpression(assign_expr) = ctx.ast.move_expression(expr) else {
+        let Expression::AssignmentExpression(assign_expr) = ctx.ast.take(expr) else {
             unreachable!()
         };
         let AssignmentExpression { span, operator, right: value, left } = assign_expr.unbox();
@@ -365,7 +365,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> {
         expr: &mut Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        let Expression::UpdateExpression(mut update_expr) = ctx.ast.move_expression(expr) else {
+        let Expression::UpdateExpression(mut update_expr) = ctx.ast.take(expr) else {
             unreachable!()
         };
         let SimpleAssignmentTarget::StaticMemberExpression(member) = &mut update_expr.argument
@@ -428,7 +428,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> {
         expr: &mut Expression<'a>,
         ctx: &mut TraverseCtx<'a>,
     ) {
-        let Expression::UpdateExpression(mut update_expr) = ctx.ast.move_expression(expr) else {
+        let Expression::UpdateExpression(mut update_expr) = ctx.ast.take(expr) else {
             unreachable!()
         };
         let SimpleAssignmentTarget::ComputedMemberExpression(member) = &mut update_expr.argument
@@ -438,7 +438,7 @@ impl<'a> ClassPropertiesSuperConverter<'a, '_, '_> {
 
         let temp_var_name_base = get_var_name_from_node(member.as_ref());
 
-        let property = ctx.ast.move_expression(member.expression.get_inner_expression_mut());
+        let property = ctx.ast.take(member.expression.get_inner_expression_mut());
 
         *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 3b5b257e981d1..4b59094ec1519 100644
--- a/crates/oxc_transformer/src/es2022/class_static_block.rs
+++ b/crates/oxc_transformer/src/es2022/class_static_block.rs
@@ -158,7 +158,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(ctx.ast.move_vec(stmts), scope_id, block.span, ctx)
+        wrap_statements_in_arrow_function_iife(ctx.ast.take(stmts), scope_id, block.span, ctx)
     }
 
     /// Convert static block to expression which will be value of private field,
@@ -169,7 +169,7 @@ impl ClassStaticBlock {
         scope_id: ScopeId,
         ctx: &mut TraverseCtx<'a>,
     ) -> Expression<'a> {
-        let expr = ctx.ast.move_expression(expr);
+        let expr = ctx.ast.take(expr);
 
         // 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 6b6605da6eaf0..624d3d070b545 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 ctx.ast.move_expression(expr) {
+        *expr = match ctx.ast.take(expr) {
             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 d67f029a8e991..1edc229a240fc 100644
--- a/crates/oxc_transformer/src/jsx/refresh.rs
+++ b/crates/oxc_transformer/src/jsx/refresh.rs
@@ -250,7 +250,7 @@ impl<'a> Traverse<'a> for ReactRefresh<'a, '_> {
                 Some((binding_identifier.clone(), arguments.clone_in(ctx.ast.allocator)));
         }
 
-        arguments.insert(0, Argument::from(ctx.ast.move_expression(expr)));
+        arguments.insert(0, Argument::from(ctx.ast.take(expr)));
         *expr = ctx.ast.expression_call(
             SPAN,
             binding.create_read_expression(ctx),
@@ -503,7 +503,7 @@ impl<'a> ReactRefresh<'a, '_> {
                 SPAN,
                 AssignmentOperator::Assign,
                 self.create_registration(ctx.ast.atom(inferred_name), ctx),
-                ctx.ast.move_expression(expr),
+                ctx.ast.take(expr),
             );
         }
 
diff --git a/crates/oxc_transformer/src/lib.rs b/crates/oxc_transformer/src/lib.rs
index 211d5dad974ba..3b8a1a85dd0a2 100644
--- a/crates/oxc_transformer/src/lib.rs
+++ b/crates/oxc_transformer/src/lib.rs
@@ -530,7 +530,7 @@ impl<'a> Traverse<'a> for TransformerImpl<'a, '_> {
                 let Statement::ExpressionStatement(expr_stmt) = stmt else {
                     continue;
                 };
-                let expression = Some(ctx.ast.move_expression(&mut expr_stmt.expression));
+                let expression = Some(ctx.ast.take(&mut expr_stmt.expression));
                 *stmt = ctx.ast.statement_return(SPAN, expression);
                 return;
             }
diff --git a/crates/oxc_transformer/src/plugins/module_runner_transform.rs b/crates/oxc_transformer/src/plugins/module_runner_transform.rs
index 5a5828774399b..0c4cff830adfc 100644
--- a/crates/oxc_transformer/src/plugins/module_runner_transform.rs
+++ b/crates/oxc_transformer/src/plugins/module_runner_transform.rs
@@ -253,7 +253,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) = ctx.ast.move_expression(expr) else {
+        let Expression::ImportExpression(import_expr) = ctx.ast.take(expr) else {
             unreachable!();
         };
 
diff --git a/crates/oxc_transformer/src/proposals/explicit_resource_management.rs b/crates/oxc_transformer/src/proposals/explicit_resource_management.rs
index 48afc2b5f1911..2b3a28cd84155 100644
--- a/crates/oxc_transformer/src/proposals/explicit_resource_management.rs
+++ b/crates/oxc_transformer/src/proposals/explicit_resource_management.rs
@@ -125,7 +125,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 = ctx.ast.move_statement(&mut for_of_stmt.body);
+            let old_body = ctx.ast.take(&mut for_of_stmt.body);
 
             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);
@@ -224,7 +224,7 @@ impl<'a> Traverse<'a> for ExplicitResourceManagement<'a, '_> {
             return;
         }
 
-        let program_body = ctx.ast.move_vec(&mut program.body);
+        let program_body = ctx.ast.take(&mut program.body);
 
         let (mut program_body, inner_block): (
             ArenaVec<'a, Statement<'a>>,
@@ -333,7 +333,7 @@ impl<'a> Traverse<'a> for ExplicitResourceManagement<'a, '_> {
 
                             return (program_body, inner_block);
                         }
-                        let decl = ctx.ast.move_declaration(decl);
+                        let decl = ctx.ast.take(decl);
 
                         let export_specifiers = match decl {
                             Declaration::ClassDeclaration(class_decl) => {
@@ -579,7 +579,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> {
                     )),
                     false,
                 )),
-                ctx.ast.move_statement(stmt),
+                ctx.ast.take(stmt),
             ]);
 
             ctx.ast.block_statement_with_scope_id(SPAN, vec, block_stmt_sid)
@@ -678,7 +678,7 @@ impl<'a> ExplicitResourceManagement<'a, '_> {
 
         let using_ctx = using_ctx?;
 
-        let mut stmts = ctx.ast.move_vec(stmts);
+        let mut stmts = ctx.ast.take(stmts);
 
         // `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 0d5800348f604..f0cbac81b299c 100644
--- a/crates/oxc_transformer/src/typescript/annotations.rs
+++ b/crates/oxc_transformer/src/typescript/annotations.rs
@@ -203,7 +203,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 ctx.ast.move_expression(e.expression.get_inner_expression_mut()) {
+            *element = match ctx.ast.take(e.expression.get_inner_expression_mut()) {
                 Expression::CallExpression(call_expr) => ChainElement::CallExpression(call_expr),
                 expr @ match_member_expression!(Expression) => {
                     ChainElement::from(expr.into_member_expression())
@@ -248,7 +248,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 = ctx.ast.move_expression(inner_expr);
+            *expr = ctx.ast.take(inner_expr);
         }
     }
 
@@ -261,7 +261,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> {
             match expr.get_inner_expression_mut() {
                 // `foo!++` to `foo++`
                 inner_expr @ Expression::Identifier(_) => {
-                    let inner_expr = ctx.ast.move_expression(inner_expr);
+                    let inner_expr = ctx.ast.take(inner_expr);
                     let Expression::Identifier(ident) = inner_expr else {
                         unreachable!();
                     };
@@ -269,7 +269,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> {
                 }
                 // `foo.bar!++` to `foo.bar++`
                 inner_expr @ match_member_expression!(Expression) => {
-                    let inner_expr = ctx.ast.move_expression(inner_expr);
+                    let inner_expr = ctx.ast.take(inner_expr);
                     let member_expr = inner_expr.into_member_expression();
                     *target = SimpleAssignmentTarget::from(member_expr);
                 }
@@ -289,7 +289,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 = ctx.ast.move_expression(inner_expr);
+                let inner_expr = ctx.ast.take(inner_expr);
                 let member_expr = inner_expr.into_member_expression();
                 *target = AssignmentTarget::from(member_expr);
             }
@@ -481,7 +481,7 @@ impl<'a> Traverse<'a> for TypeScriptAnnotations<'a, '_> {
                 _ => None,
             };
             if let Some(span) = consequent_span {
-                let consequent = ctx.ast.move_statement(&mut stmt.consequent);
+                let consequent = ctx.ast.take(&mut stmt.consequent);
                 stmt.consequent = Self::create_block_with_statement(consequent, span, ctx);
             }
 
diff --git a/crates/oxc_transformer/src/typescript/enum.rs b/crates/oxc_transformer/src/typescript/enum.rs
index 1cc9ccf01c49e..8864d09ceae54 100644
--- a/crates/oxc_transformer/src/typescript/enum.rs
+++ b/crates/oxc_transformer/src/typescript/enum.rs
@@ -225,7 +225,7 @@ impl<'a> TypeScriptEnum<'a> {
                 let init = match constant_value {
                     None => {
                         prev_constant_value = None;
-                        let mut new_initializer = ast.move_expression(initializer);
+                        let mut new_initializer = ast.take(initializer);
 
                         IdentifierReferenceRename::new(
                             param_binding.name,
diff --git a/crates/oxc_transformer/src/typescript/module.rs b/crates/oxc_transformer/src/typescript/module.rs
index d9df9e23fd5f9..8a489f9bd97fe 100644
--- a/crates/oxc_transformer/src/typescript/module.rs
+++ b/crates/oxc_transformer/src/typescript/module.rs
@@ -73,7 +73,7 @@ impl<'a> TypeScriptModule<'a, '_> {
         };
 
         let left = AssignmentTarget::from(SimpleAssignmentTarget::from(module_exports));
-        let right = ctx.ast.move_expression(&mut export_assignment.expression);
+        let right = ctx.ast.take(&mut export_assignment.expression);
         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 c475234807078..d91e992f75f0a 100644
--- a/crates/oxc_transformer/src/typescript/namespace.rs
+++ b/crates/oxc_transformer/src/typescript/namespace.rs
@@ -49,7 +49,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 ctx.ast.move_vec(&mut program.body) {
+        for stmt in ctx.ast.take(&mut program.body) {
             match stmt {
                 Statement::TSModuleDeclaration(decl) => {
                     if !self.allow_namespaces {
@@ -430,7 +430,7 @@ impl<'a> TypeScriptNamespace<'a, '_> {
                                 false,
                             ))
                             .into(),
-                            ctx.ast.move_expression(init),
+                            ctx.ast.take(init),
                         ),
                     );
                 }