Struct Box

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

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) -> Box<'_, T>

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() -> Box<'_, T>

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> Box<'_, T>

where T: ?Sized,

pub fn into_non_null(boxed: Box<'_, T>) -> NonNull<T>

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

Trait Implementations

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

where T: ?Sized,

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

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

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

where T: ?Sized,

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, ) -> <Box<'_, T> as CloneIn<'new_alloc>>::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, ) -> <Box<'_, T> as CloneIn<'new_alloc>>::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> ContentEq for Box<'_, T>

where T: ContentEq,

Blanket implementation for oxc_allocator::Box types

fn content_eq(&self, other: &Box<'_, T>) -> bool

This method tests for contents of self and other to be equal.

fn content_ne(&self, other: &Self) -> bool

This method tests for contents of self and other not to be equal. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

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

where T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

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

where T: ?Sized,

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

Mutably dereferences the value.

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

where T: Display + ?Sized,

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

Formats the value using the given formatter.

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

where T: Dummy<'a>,

fn dummy(allocator: &'a Allocator) -> Box<'a, T>

Create a dummy Box.

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

where T: ESTree,

fn serialize<S>(&self, serializer: S)

where S: Serializer,

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

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

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

where T: Hash,

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

where H: Hasher,

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<T> Serialize for Box<'_, T>

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.