Struct Box 

pub struct Box<'alloc, T: ?Sized>(/* private fields */);

A Box without Drop, which stores its data in the arena allocator.

No Drops

Objects allocated into Oxc memory arenas are never Dropped. Memory is released in bulk when the allocator is dropped, without dropping the individual objects in the arena.

Therefore, it would produce a memory leak if you allocated Drop types into the arena which own memory allocations outside the arena.

Static checks make this impossible to do. Box::new_in will refuse to compile if called with a Drop type.

Implementations

impl<T> Box<'_, T>

pub fn new_in(value: T, allocator: &Allocator) -> Self

Put a value into a memory arena and get back a Box with ownership to the allocation.

Examples

use oxc_allocator::{Allocator, Box};

let arena = Allocator::default();
let in_arena: Box<i32> = Box::new_in(5, &arena);

pub const unsafe fn dangling() -> Self

Create a fake Box with a dangling pointer.

SAFETY

Safe to create, but must never be dereferenced, as does not point to a valid T. Only purpose is for mocking types without allocating for const assertions.

pub fn unbox(self) -> T

Take ownership of the value stored in this Box, consuming the box in the process.

Examples

use oxc_allocator::{Allocator, Box};

let arena = Allocator::default();

// Put `5` into the arena and on the heap.
let boxed: Box<i32> = Box::new_in(5, &arena);
// Move it back to the stack. `boxed` has been consumed.
let i = boxed.unbox();

assert_eq!(i, 5);

impl<T: ?Sized> Box<'_, T>

pub fn as_non_null(boxed: &Self) -> NonNull<T>

Get a NonNull pointer pointing to the Box’s contents.

The pointer is not valid for writes.

The caller must ensure that the Box outlives the pointer this function returns, or else it will end up dangling.

Example

use oxc_allocator::{Allocator, Box};

let allocator = Allocator::new();
let boxed = Box::new_in(123_u64, &allocator);
let ptr = Box::as_non_null(&boxed);

pub fn into_non_null(boxed: Self) -> NonNull<T>

Consume a Box and return a NonNull pointer to its contents.

pub const unsafe fn from_non_null(ptr: NonNull<T>) -> Self

Create a Box from a NonNull pointer.

SAFETY

• Pointer must point to a valid T.
• Pointer must point to within an Allocator.
• Caller must ensure that the pointer is valid for the lifetime of the Box.

impl<T> Box<'static, [T]>

pub fn new_empty_boxed_slice() -> Self

Create a new empty Box<[T]>.

This method does not allocate. The returned boxed slice is represented by a dangling, correctly-aligned pointer with length 0, similar to how Vec::new_in produces an empty vector.

impl<'a, T> Box<'a, [T]>

pub fn into_arena_slice(self) -> &'a [T]

Convert a boxed slice [Box<[T]>] into slice [&'a [T]].

The returned slice has the same lifetime as the allocator.

pub fn into_arena_slice_mut(self) -> &'a mut [T]

Convert a boxed slice [Box<[T]>] into mutable slice [&'a mut [T]].

The returned slice has the same lifetime as the allocator.

Trait Implementations

impl<T: ?Sized> AsMut<T> for Box<'_, T>

fn as_mut(&mut self) -> &mut T

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: ?Sized> AsRef<T> for Box<'_, T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<'new_alloc, T, C> CloneIn<'new_alloc> for Box<'_, [T]>

where T: CloneIn<'new_alloc, Cloned = C>,

type Cloned = Box<'new_alloc, [C]>

The type of the cloned object.

fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned

Clone self into the given allocator. allocator may be the same one that self is already in.

fn clone_in_with_semantic_ids( &self, allocator: &'new_alloc Allocator, ) -> Self::Cloned

Almost identical as clone_in, but for some special type, it will also clone the semantic ids. Please use this method only if you make sure semantic info is synced with the ast node.

impl<'new_alloc, T, C> CloneIn<'new_alloc> for Box<'_, T>

where T: CloneIn<'new_alloc, Cloned = C>,

type Cloned = Box<'new_alloc, C>

The type of the cloned object.

fn clone_in(&self, allocator: &'new_alloc Allocator) -> Self::Cloned

Clone self into the given allocator. allocator may be the same one that self is already in.

fn clone_in_with_semantic_ids( &self, allocator: &'new_alloc Allocator, ) -> Self::Cloned

Almost identical as clone_in, but for some special type, it will also clone the semantic ids. Please use this method only if you make sure semantic info is synced with the ast node.

impl<T: ?Sized + Debug> Debug for Box<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ?Sized> Deref for Box<'_, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: ?Sized> DerefMut for Box<'_, T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: ?Sized + Display> Display for Box<'_, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T> Dummy<'a> for Box<'a, [T]>

fn dummy(_allocator: &'a Allocator) -> Self

Create a dummy empty [Box<[T]>] boxed slice.

impl<'a, T: Dummy<'a>> Dummy<'a> for Box<'a, T>

fn dummy(allocator: &'a Allocator) -> Self

Create a dummy Box.

impl<'a, T: 'a> From<Vec<'a, T>> for Box<'a, [T]>

fn from(v: Vec<'a, T>) -> Box<'a, [T]>

Converts to this type from the input type.

impl<'a, T> FromIn<'a, T> for Box<'a, T>

fn from_in(value: T, allocator: &'a Allocator) -> Self

Converts to this type from the input type within the given allocator.

impl<T> GetAddress for Box<'_, T>

fn address(&self) -> Address

Get the memory address of a value allocated in the arena.

AST nodes in a Box in an arena are guaranteed to never move in memory, so this address acts as a unique identifier for the duration of the arena’s existence.

impl<T: Hash> Hash for Box<'_, T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T> TakeIn<'a> for Box<'a, [T]>

fn take_in<A: AllocatorAccessor<'a>>(&mut self, allocator_accessor: A) -> Self

Replace node with a dummy.

fn take_in_box<A: AllocatorAccessor<'a>>( &mut self, allocator_accessor: A, ) -> Box<'a, Self>

Replace node with a boxed dummy.