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 into_non_null(boxed: Self) -> NonNull<T>

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

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<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>> Dummy<'a> for Box<'a, T>

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

Create a dummy Box.

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.