feat(allocator): replace allocator_ap2's Vec with Vec2

Author: Dunqing

crates/oxc_allocator/src/clone_in.rs

@@ -55,7 +55,7 @@ where
     }
 }
 
-impl<'new_alloc, T, C> CloneIn<'new_alloc> for Vec<'_, T>
+impl<'new_alloc, T, C: 'new_alloc> CloneIn<'new_alloc> for Vec<'_, T>
 where
     T: CloneIn<'new_alloc, Cloned = C>,
 {

crates/oxc_allocator/src/string.rs

@@ -104,15 +104,18 @@ impl<'alloc> String<'alloc> {
     /// Caller must ensure this `Vec<u8>` comprises a valid UTF-8 string.
     //
     // `#[inline(always)]` because this is a no-op at runtime
+    #[expect(clippy::needless_pass_by_value)]
     #[inline(always)]
     pub unsafe fn from_utf8_unchecked(bytes: Vec<'alloc, u8>) -> String<'alloc> {
         // Cannot use `bumpalo::String::from_utf8_unchecked` because it takes a `bumpalo::collections::Vec`,
         // and our inner `Vec` type is `allocator_api2::vec::Vec`.
         // SAFETY: Conversion is safe because both types store data in arena in same way.
         // Lifetime of returned `String` is same as lifetime of original `Vec<u8>`.
         unsafe {
-            let inner = ManuallyDrop::into_inner(bytes.0);
-            let (ptr, len, capacity, bump) = inner.into_raw_parts_with_alloc();
+            let ptr = bytes.as_mut_ptr();
+            let len = bytes.len();
+            let capacity = bytes.capacity();
+            let bump = bytes.bump();
             Self(ManuallyDrop::new(BumpaloString::from_raw_parts_in(ptr, len, capacity, bump)))
         }
     }

crates/oxc_allocator/src/vec.rs

@@ -11,12 +11,10 @@ use std::{
     hash::{Hash, Hasher},
     mem::ManuallyDrop,
     ops,
-    ptr::NonNull,
     slice::SliceIndex,
 };
 
-use allocator_api2::vec::Vec as InnerVec;
-use bumpalo::Bump;
+use crate::vec2::Vec as InnerVec;
 #[cfg(any(feature = "serialize", test))]
 use oxc_estree::{ESTree, Serializer as ESTreeSerializer};
 #[cfg(any(feature = "serialize", test))]
@@ -37,7 +35,7 @@ use crate::{Allocator, Box};
 /// Static checks make this impossible to do. [`Vec::new_in`] and all other methods which create
 /// a [`Vec`] will refuse to compile if called with a [`Drop`] type.
 #[derive(PartialEq, Eq)]
-pub struct Vec<'alloc, T>(pub(crate) ManuallyDrop<InnerVec<T, &'alloc Bump>>);
+pub struct Vec<'alloc, T>(pub(crate) ManuallyDrop<InnerVec<'alloc, T>>);
 
 /// SAFETY: Not actually safe, but for enabling `Send` for downstream crates.
 unsafe impl<T> Send for Vec<'_, T> {}
@@ -168,43 +166,43 @@ impl<'alloc, T> Vec<'alloc, T> {
         Self(ManuallyDrop::new(vec))
     }
 
-    /// Converts the vector into [`Box<[T]>`][owned slice].
-    ///
-    /// Any excess capacity the vector has will not be included in the slice.
-    /// The excess memory will be leaked in the arena (i.e. not reused by another allocation).
-    ///
-    /// # Examples
-    /// ```
-    /// use oxc_allocator::{Allocator, Vec};
-    ///
-    /// let allocator = Allocator::default();
-    /// let mut v = Vec::with_capacity_in(10, &allocator);
-    /// v.extend([1, 2, 3]);
-    /// let b = v.into_boxed_slice();
-    ///
-    /// assert_eq!(&*b, &[1, 2, 3]);
-    /// assert_eq!(b.len(), 3);
-    /// ```
-    ///
-    /// [owned slice]: Box
-    #[inline]
-    pub fn into_boxed_slice(self) -> Box<'alloc, [T]> {
-        let inner = ManuallyDrop::into_inner(self.0);
-        let slice = inner.leak();
-        let ptr = NonNull::from(slice);
-        // SAFETY: `ptr` points to a valid slice `[T]`.
-        // `allocator_api2::vec::Vec::leak` consumes the inner `Vec` without dropping it.
-        // Lifetime of returned `Box<'alloc, [T]>` is same as lifetime of consumed `Vec<'alloc, T>`,
-        // so data in the `Box` must be valid for its lifetime.
-        // `Vec` uniquely owned the data, and we have consumed the `Vec`, so the new `Box` has
-        // unique ownership of the data (no aliasing).
-        // `ptr` was created from a `&mut [T]`.
-        unsafe { Box::from_non_null(ptr) }
-    }
+    // /// Converts the vector into [`Box<[T]>`][owned slice].
+    // ///
+    // /// Any excess capacity the vector has will not be included in the slice.
+    // /// The excess memory will be leaked in the arena (i.e. not reused by another allocation).
+    // ///
+    // /// # Examples
+    // /// ```
+    // /// use oxc_allocator::{Allocator, Vec};
+    // ///
+    // /// let allocator = Allocator::default();
+    // /// let mut v = Vec::with_capacity_in(10, &allocator);
+    // /// v.extend([1, 2, 3]);
+    // /// let b = v.into_boxed_slice();
+    // ///
+    // /// assert_eq!(&*b, &[1, 2, 3]);
+    // /// assert_eq!(b.len(), 3);
+    // /// ```
+    // ///
+    // /// [owned slice]: Box
+    // #[inline]
+    // pub fn into_boxed_slice(self) -> Box<'alloc, [T]> {
+    //     let inner = ManuallyDrop::into_inner(self.0);
+    //     let slice = inner.leak();
+    //     let ptr = NonNull::from(slice);
+    //     // SAFETY: `ptr` points to a valid slice `[T]`.
+    //     // `allocator_api2::vec::Vec::leak` consumes the inner `Vec` without dropping it.
+    //     // Lifetime of returned `Box<'alloc, [T]>` is same as lifetime of consumed `Vec<'alloc, T>`,
+    //     // so data in the `Box` must be valid for its lifetime.
+    //     // `Vec` uniquely owned the data, and we have consumed the `Vec`, so the new `Box` has
+    //     // unique ownership of the data (no aliasing).
+    //     // `ptr` was created from a `&mut [T]`.
+    //     unsafe { Box::from_non_null(ptr) }
+    // }
 }
 
-impl<'alloc, T> ops::Deref for Vec<'alloc, T> {
-    type Target = InnerVec<T, &'alloc Bump>;
+impl<'alloc, T: 'alloc> ops::Deref for Vec<'alloc, T> {
+    type Target = InnerVec<'alloc, T>;
 
     #[inline]
     fn deref(&self) -> &Self::Target {
@@ -214,13 +212,13 @@ impl<'alloc, T> ops::Deref for Vec<'alloc, T> {
 
 impl<'alloc, T> ops::DerefMut for Vec<'alloc, T> {
     #[inline]
-    fn deref_mut(&mut self) -> &mut InnerVec<T, &'alloc Bump> {
+    fn deref_mut(&mut self) -> &mut InnerVec<'alloc, T> {
         &mut self.0
     }
 }
 
 impl<'alloc, T> IntoIterator for Vec<'alloc, T> {
-    type IntoIter = <InnerVec<T, &'alloc Bump> as IntoIterator>::IntoIter;
+    type IntoIter = <InnerVec<'alloc, T> as IntoIterator>::IntoIter;
     type Item = T;
 
     #[inline(always)]
@@ -353,18 +351,18 @@ mod test {
         }
     }
 
-    #[test]
-    fn vec_to_boxed_slice() {
-        let allocator = Allocator::default();
-        let mut v = Vec::with_capacity_in(10, &allocator);
-        v.extend([1, 2, 3]);
+    // #[test]
+    // fn vec_to_boxed_slice() {
+    //     let allocator = Allocator::default();
+    //     let mut v = Vec::with_capacity_in(10, &allocator);
+    //     v.extend([1, 2, 3]);
 
-        let b = v.into_boxed_slice();
-        // Check return value is an `oxc_allocator::Box`, not an `allocator_api2::boxed::Box`
-        let b: Box<[u8]> = b;
+    //     let b = v.into_boxed_slice();
+    //     // Check return value is an `oxc_allocator::Box`, not an `allocator_api2::boxed::Box`
+    //     let b: Box<[u8]> = b;
 
-        assert_eq!(&*b, &[1, 2, 3]);
-        // Check length of slice is equal to what `v.len()` was, not `v.capacity()`
-        assert_eq!(b.len(), 3);
-    }
+    //     assert_eq!(&*b, &[1, 2, 3]);
+    //     // Check length of slice is equal to what `v.len()` was, not `v.capacity()`
+    //     assert_eq!(b.len(), 3);
+    // }
 }

crates/oxc_isolated_declarations/src/declaration.rs

@@ -105,7 +105,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
     fn transform_ts_module_block(
         &mut self,
-        block: &ArenaBox<'a, TSModuleBlock<'a>>,
+        block: &'a ArenaBox<'a, TSModuleBlock<'a>>,
     ) -> ArenaBox<'a, TSModuleBlock<'a>> {
         // We need to enter a new scope for the module block, avoid add binding to the parent scope
         // TODO: doesn't have a scope_id!
@@ -117,7 +117,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
     pub(crate) fn transform_ts_module_declaration(
         &mut self,
-        decl: &ArenaBox<'a, TSModuleDeclaration<'a>>,
+        decl: &'a ArenaBox<'a, TSModuleDeclaration<'a>>,
     ) -> ArenaBox<'a, TSModuleDeclaration<'a>> {
         if decl.declare {
             return decl.clone_in(self.ast.allocator);
@@ -153,7 +153,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
     pub(crate) fn transform_declaration(
         &mut self,
-        decl: &Declaration<'a>,
+        decl: &'a Declaration<'a>,
         check_binding: bool,
     ) -> Option<Declaration<'a>> {
         match decl {

crates/oxc_isolated_declarations/src/lib.rs

@@ -79,7 +79,7 @@ impl<'a> IsolatedDeclarations<'a> {
     /// # Errors
     ///
     /// Returns `Vec<Error>` if any errors were collected during the transformation.
-    pub fn build(mut self, program: &Program<'a>) -> IsolatedDeclarationsReturn<'a> {
+    pub fn build(mut self, program: &'a Program<'a>) -> IsolatedDeclarationsReturn<'a> {
         self.internal_annotations = self
             .strip_internal
             .then(|| Self::build_internal_annotations(program))
@@ -132,7 +132,7 @@ impl<'a> IsolatedDeclarations<'a> {
 }
 
 impl<'a> IsolatedDeclarations<'a> {
-    fn transform_program(&mut self, program: &Program<'a>) -> ArenaVec<'a, Statement<'a>> {
+    fn transform_program(&mut self, program: &'a Program<'a>) -> ArenaVec<'a, Statement<'a>> {
         let has_import_or_export = program.body.iter().any(Statement::is_module_declaration);
 
         if has_import_or_export {
@@ -144,7 +144,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
     fn transform_program_without_module_declaration(
         &mut self,
-        stmts: &ArenaVec<'a, Statement<'a>>,
+        stmts: &'a ArenaVec<'a, Statement<'a>>,
     ) -> ArenaVec<'a, Statement<'a>> {
         self.report_error_for_expando_function(stmts);
 
@@ -166,7 +166,7 @@ impl<'a> IsolatedDeclarations<'a> {
 
     fn transform_statements_on_demand(
         &mut self,
-        stmts: &ArenaVec<'a, Statement<'a>>,
+        stmts: &'a ArenaVec<'a, Statement<'a>>,
     ) -> ArenaVec<'a, Statement<'a>> {
         self.report_error_for_expando_function(stmts);
 

crates/oxc_isolated_declarations/src/module.rs

@@ -7,7 +7,7 @@ use crate::{IsolatedDeclarations, diagnostics::default_export_inferred};
 impl<'a> IsolatedDeclarations<'a> {
     pub(crate) fn transform_export_named_declaration(
         &mut self,
-        prev_decl: &ExportNamedDeclaration<'a>,
+        prev_decl: &'a ExportNamedDeclaration<'a>,
     ) -> Option<ExportNamedDeclaration<'a>> {
         let decl = self.transform_declaration(prev_decl.declaration.as_ref()?, false)?;