diff --git a/crates/oxc_ast/src/generated/derive_clone_in.rs b/crates/oxc_ast/src/generated/derive_clone_in.rs
index 033bfcc329ea9..b73b273fbe7f3 100644
--- a/crates/oxc_ast/src/generated/derive_clone_in.rs
+++ b/crates/oxc_ast/src/generated/derive_clone_in.rs
@@ -4,16 +4,16 @@
 use crate::ast::*;
 use oxc_allocator::{Allocator, CloneIn};
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for BooleanLiteral {
+impl<'alloc> CloneIn<'alloc> for BooleanLiteral {
     type Cloned = BooleanLiteral;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         BooleanLiteral { span: self.span.clone_in(alloc), value: self.value.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for NullLiteral {
+impl<'alloc> CloneIn<'alloc> for NullLiteral {
     type Cloned = NullLiteral;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         NullLiteral { span: self.span.clone_in(alloc) }
     }
 }
@@ -59,9 +59,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for RegExp<'old_alloc> {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for EmptyObject {
+impl<'alloc> CloneIn<'alloc> for EmptyObject {
     type Cloned = EmptyObject;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         EmptyObject
     }
 }
@@ -194,9 +194,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for LabelIdentifier<'old_alloc>
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for ThisExpression {
+impl<'alloc> CloneIn<'alloc> for ThisExpression {
     type Cloned = ThisExpression;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         ThisExpression { span: self.span.clone_in(alloc) }
     }
 }
@@ -284,9 +284,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for ArrayExpressionElement<'old
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for Elision {
+impl<'alloc> CloneIn<'alloc> for Elision {
     type Cloned = Elision;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         Elision { span: self.span.clone_in(alloc) }
     }
 }
@@ -400,9 +400,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for PropertyKey<'old_alloc> {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for PropertyKind {
+impl<'alloc> CloneIn<'alloc> for PropertyKind {
     type Cloned = PropertyKind;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Init => Self::Cloned::Init,
             Self::Get => Self::Cloned::Get,
@@ -910,9 +910,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for SequenceExpression<'old_all
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for Super {
+impl<'alloc> CloneIn<'alloc> for Super {
     type Cloned = Super;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         Super { span: self.span.clone_in(alloc) }
     }
 }
@@ -1081,9 +1081,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for VariableDeclaration<'old_al
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for VariableDeclarationKind {
+impl<'alloc> CloneIn<'alloc> for VariableDeclarationKind {
     type Cloned = VariableDeclarationKind;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Var => Self::Cloned::Var,
             Self::Const => Self::Cloned::Const,
@@ -1116,9 +1116,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for UsingDeclaration<'old_alloc
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for EmptyStatement {
+impl<'alloc> CloneIn<'alloc> for EmptyStatement {
     type Cloned = EmptyStatement;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         EmptyStatement { span: self.span.clone_in(alloc) }
     }
 }
@@ -1421,9 +1421,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for CatchParameter<'old_alloc>
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for DebuggerStatement {
+impl<'alloc> CloneIn<'alloc> for DebuggerStatement {
     type Cloned = DebuggerStatement;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         DebuggerStatement { span: self.span.clone_in(alloc) }
     }
 }
@@ -1527,9 +1527,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for Function<'old_alloc> {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for FunctionType {
+impl<'alloc> CloneIn<'alloc> for FunctionType {
     type Cloned = FunctionType;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::FunctionDeclaration => Self::Cloned::FunctionDeclaration,
             Self::FunctionExpression => Self::Cloned::FunctionExpression,
@@ -1565,9 +1565,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for FormalParameter<'old_alloc>
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for FormalParameterKind {
+impl<'alloc> CloneIn<'alloc> for FormalParameterKind {
     type Cloned = FormalParameterKind;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::FormalParameter => Self::Cloned::FormalParameter,
             Self::UniqueFormalParameters => Self::Cloned::UniqueFormalParameters,
@@ -1635,9 +1635,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for Class<'old_alloc> {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for ClassType {
+impl<'alloc> CloneIn<'alloc> for ClassType {
     type Cloned = ClassType;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::ClassDeclaration => Self::Cloned::ClassDeclaration,
             Self::ClassExpression => Self::Cloned::ClassExpression,
@@ -1684,9 +1684,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for MethodDefinition<'old_alloc
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for MethodDefinitionType {
+impl<'alloc> CloneIn<'alloc> for MethodDefinitionType {
     type Cloned = MethodDefinitionType;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::MethodDefinition => Self::Cloned::MethodDefinition,
             Self::TSAbstractMethodDefinition => Self::Cloned::TSAbstractMethodDefinition,
@@ -1716,9 +1716,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for PropertyDefinition<'old_all
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for PropertyDefinitionType {
+impl<'alloc> CloneIn<'alloc> for PropertyDefinitionType {
     type Cloned = PropertyDefinitionType;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::PropertyDefinition => Self::Cloned::PropertyDefinition,
             Self::TSAbstractPropertyDefinition => Self::Cloned::TSAbstractPropertyDefinition,
@@ -1726,9 +1726,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for PropertyDefinitionType {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for MethodDefinitionKind {
+impl<'alloc> CloneIn<'alloc> for MethodDefinitionKind {
     type Cloned = MethodDefinitionKind;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Constructor => Self::Cloned::Constructor,
             Self::Method => Self::Cloned::Method,
@@ -1778,9 +1778,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for ModuleDeclaration<'old_allo
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for AccessorPropertyType {
+impl<'alloc> CloneIn<'alloc> for AccessorPropertyType {
     type Cloned = AccessorPropertyType;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::AccessorProperty => Self::Cloned::AccessorProperty,
             Self::TSAbstractAccessorProperty => Self::Cloned::TSAbstractAccessorProperty,
@@ -2288,9 +2288,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSTypeOperator<'old_alloc>
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSTypeOperatorOperator {
+impl<'alloc> CloneIn<'alloc> for TSTypeOperatorOperator {
     type Cloned = TSTypeOperatorOperator;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Keyof => Self::Cloned::Keyof,
             Self::Unique => Self::Cloned::Unique,
@@ -2414,100 +2414,100 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSTupleElement<'old_alloc>
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSAnyKeyword {
+impl<'alloc> CloneIn<'alloc> for TSAnyKeyword {
     type Cloned = TSAnyKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSAnyKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSStringKeyword {
+impl<'alloc> CloneIn<'alloc> for TSStringKeyword {
     type Cloned = TSStringKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSStringKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSBooleanKeyword {
+impl<'alloc> CloneIn<'alloc> for TSBooleanKeyword {
     type Cloned = TSBooleanKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSBooleanKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSNumberKeyword {
+impl<'alloc> CloneIn<'alloc> for TSNumberKeyword {
     type Cloned = TSNumberKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSNumberKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSNeverKeyword {
+impl<'alloc> CloneIn<'alloc> for TSNeverKeyword {
     type Cloned = TSNeverKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSNeverKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSIntrinsicKeyword {
+impl<'alloc> CloneIn<'alloc> for TSIntrinsicKeyword {
     type Cloned = TSIntrinsicKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSIntrinsicKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSUnknownKeyword {
+impl<'alloc> CloneIn<'alloc> for TSUnknownKeyword {
     type Cloned = TSUnknownKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSUnknownKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSNullKeyword {
+impl<'alloc> CloneIn<'alloc> for TSNullKeyword {
     type Cloned = TSNullKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSNullKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSUndefinedKeyword {
+impl<'alloc> CloneIn<'alloc> for TSUndefinedKeyword {
     type Cloned = TSUndefinedKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSUndefinedKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSVoidKeyword {
+impl<'alloc> CloneIn<'alloc> for TSVoidKeyword {
     type Cloned = TSVoidKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSVoidKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSSymbolKeyword {
+impl<'alloc> CloneIn<'alloc> for TSSymbolKeyword {
     type Cloned = TSSymbolKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSSymbolKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSThisType {
+impl<'alloc> CloneIn<'alloc> for TSThisType {
     type Cloned = TSThisType;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSThisType { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSObjectKeyword {
+impl<'alloc> CloneIn<'alloc> for TSObjectKeyword {
     type Cloned = TSObjectKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSObjectKeyword { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSBigIntKeyword {
+impl<'alloc> CloneIn<'alloc> for TSBigIntKeyword {
     type Cloned = TSBigIntKeyword;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         TSBigIntKeyword { span: self.span.clone_in(alloc) }
     }
 }
@@ -2593,9 +2593,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSTypeAliasDeclaration<'old
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSAccessibility {
+impl<'alloc> CloneIn<'alloc> for TSAccessibility {
     type Cloned = TSAccessibility;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Private => Self::Cloned::Private,
             Self::Protected => Self::Cloned::Protected,
@@ -2693,9 +2693,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSCallSignatureDeclaration<
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSMethodSignatureKind {
+impl<'alloc> CloneIn<'alloc> for TSMethodSignatureKind {
     type Cloned = TSMethodSignatureKind;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Method => Self::Cloned::Method,
             Self::Get => Self::Cloned::Get,
@@ -2793,9 +2793,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSModuleDeclaration<'old_al
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSModuleDeclarationKind {
+impl<'alloc> CloneIn<'alloc> for TSModuleDeclarationKind {
     type Cloned = TSModuleDeclarationKind;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Global => Self::Cloned::Global,
             Self::Module => Self::Cloned::Module,
@@ -2961,9 +2961,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSMappedType<'old_alloc> {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSMappedTypeModifierOperator {
+impl<'alloc> CloneIn<'alloc> for TSMappedTypeModifierOperator {
     type Cloned = TSMappedTypeModifierOperator;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::True => Self::Cloned::True,
             Self::Plus => Self::Cloned::Plus,
@@ -3100,9 +3100,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for TSInstantiationExpression<'
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for ImportOrExportKind {
+impl<'alloc> CloneIn<'alloc> for ImportOrExportKind {
     type Cloned = ImportOrExportKind;
-    fn clone_in(&self, _: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, _: &'alloc Allocator) -> Self::Cloned {
         match self {
             Self::Value => Self::Cloned::Value,
             Self::Type => Self::Cloned::Type,
@@ -3132,9 +3132,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSDocNonNullableType<'old_a
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSDocUnknownType {
+impl<'alloc> CloneIn<'alloc> for JSDocUnknownType {
     type Cloned = JSDocUnknownType;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         JSDocUnknownType { span: self.span.clone_in(alloc) }
     }
 }
@@ -3183,16 +3183,16 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSXFragment<'old_alloc> {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSXOpeningFragment {
+impl<'alloc> CloneIn<'alloc> for JSXOpeningFragment {
     type Cloned = JSXOpeningFragment;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         JSXOpeningFragment { span: self.span.clone_in(alloc) }
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSXClosingFragment {
+impl<'alloc> CloneIn<'alloc> for JSXClosingFragment {
     type Cloned = JSXClosingFragment;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         JSXClosingFragment { span: self.span.clone_in(alloc) }
     }
 }
@@ -3321,9 +3321,9 @@ impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSXExpression<'old_alloc> {
     }
 }
 
-impl<'old_alloc, 'new_alloc> CloneIn<'new_alloc> for JSXEmptyExpression {
+impl<'alloc> CloneIn<'alloc> for JSXEmptyExpression {
     type Cloned = JSXEmptyExpression;
-    fn clone_in(&self, alloc: &'new_alloc Allocator) -> Self::Cloned {
+    fn clone_in(&self, alloc: &'alloc Allocator) -> Self::Cloned {
         JSXEmptyExpression { span: self.span.clone_in(alloc) }
     }
 }