crates/oxc_allocator/src/boxed.rs:176

• The comment above into_bump_slice/into_bump_slice_mut says this is a no-op because "Box<[T]> and &[T]/&mut [T] have the same layout", but the code is not converting between those types—it’s extending a reference lifetime via mem::transmute. This is misleading and makes the safety rationale harder to audit.

Adjust the comment to describe the real invariant being relied upon (arena-backed storage + consuming self) rather than layout equivalence.

    //
    // `#[inline(always)]` because this is a no-op. `Box<[T]>` and `&[T]` have the same layout.
    #[expect(clippy::inline_always)]
    #[inline(always)]
    pub fn into_bump_slice(self) -> &'a [T] {
        let r = self.as_ref();
        // Extend lifetime of reference to lifetime of the allocator.
        // SAFETY: `self` is consumed by this method, so there cannot be any mutable references to it.
        // The reference lives until the allocator is dropped or reset (`'a` lifetime).
        // Don't need `mem::forget(self)` here, because `Box` does not implement `Drop`.
        unsafe { mem::transmute::<&[T], &'a [T]>(r) }
    }

crates/oxc_allocator/src/boxed.rs:198

• Same as into_bump_slice: the comment cites Box<[T]> / &mut [T] layout equivalence, but the key operation is unsafe lifetime extension of the &mut [T] produced by as_mut(). Rewording would avoid implying the safety relies on a layout guarantee.

    //
    // `#[inline(always)]` because this is a no-op. `Box<[T]>` and `&mut [T]` have the same layout.
    #[expect(clippy::inline_always)]
    #[inline(always)]
    pub fn into_bump_slice_mut(mut self) -> &'a mut [T] {

crates/oxc_allocator/src/boxed.rs:215

• The SAFETY comment says the pointer comes from "an empty slice allocated from Box::new_empty_boxed_slice", but new_empty_boxed_slice intentionally does not allocate (it uses a dangling, aligned pointer with len=0). Consider rewording this to avoid implying an allocation happened and to clarify why NonNull<[T]>::as_ref() is still sound for the empty-slice representation.

        // SAFETY: `self.0` is always a unique reference allocated from a `Bump` in `Box::new_in`,
        // or an empty slice allocated from `Box::new_empty_boxed_slice`
        unsafe { self.0.as_ref() }

crates/oxc_allocator/src/boxed.rs:224

• Same as above: the SAFETY comment mentions an "empty slice allocated" by new_empty_boxed_slice, but that constructor is explicitly non-allocating. Rewording this will make the aliasing/validity reasoning around as_mut() for empty slices easier to audit.

        // SAFETY: `self.0` is always a unique reference allocated from a `Bump` in `Box::new_in`,
        // or an empty slice allocated from `Box::new_empty_boxed_slice`
        unsafe { self.0.as_mut() }

crates/oxc_allocator/src/boxed.rs:182

• The inline comment says this is a no-op because Box<[T]> and &[T] have the same layout, but the implementation is actually taking a &[T] via as_ref() and then extending its lifetime. The layout claim is at best incidental here and could be misleading; consider rewording to emphasize that this is a runtime no-op aside from the unsafe lifetime extension.

    //
    // `#[inline(always)]` because this is a no-op. `Box<[T]>` and `&[T]` have the same layout.
    #[expect(clippy::inline_always)]
    #[inline(always)]
    pub fn into_bump_slice(self) -> &'a [T] {