Struct Arena 

pub struct Arena {
    bump: Bump,
}

Bump-allocator arena owning all AST node storage for a single parse.

Methods that allocate return references whose lifetime is tied to &self; consumers commonly re-bind that lifetime as the parsed tree’s 'src parameter.

Fields

bump: Bump

Implementations

impl Arena

pub fn new() -> Self

Empty arena.

pub fn with_capacity(capacity: usize) -> Self

Empty arena with at least capacity bytes pre-reserved. Use when the source size is known to be large — e.g., the lex driver might call Arena::with_capacity(source.len() / 4) to avoid early growth allocations on a multi-MB document.

pub fn alloc<T>(&self, value: T) -> &T

Allocate value in the arena, returning a borrowed reference that is valid for &self’s lifetime.

pub fn alloc_str(&self, s: &str) -> &str

Allocate a copy of s in the arena. Used when the lex layer produces a new (synthesised or rewritten) string that does not directly point into the source buffer.

pub fn alloc_slice_copy<T: Copy>(&self, slice: &[T]) -> &[T]

Allocate a slice copy of slice in the arena. Restricted to Copy types because the borrowed AST contains only Copy data (refs, primitives, Copy enums) — see the borrowed module docs.

pub fn alloc_slice_fill_iter<T, I>(&self, iter: I) -> &[T]

where I: IntoIterator<Item = T>, I::IntoIter: ExactSizeIterator,

Allocate a slice from an iterator. Useful for assembling a Content::Segments payload from a builder loop.

pub fn allocated_bytes(&self) -> usize

Bytes currently allocated to chunks (committed memory). For diagnostic / benchmarking use only.

pub fn bump(&self) -> &Bump

Borrow the inner [Bump] allocator. Used by structures that need to hold their own arena-backed storage (e.g. the super::Interner’s probe table, which is itself a BumpVec allocated inside the arena).

pub fn reset(&mut self)

Drop every allocation without releasing the underlying chunks. The next alloc* call reuses the same memory pages — saving the mmap syscall a fresh Arena::new would pay.

&mut self enforces at compile time that no live borrow into the arena exists at reset time: every alloc-returned &T borrows from &self, so a caller holding such a reference can never simultaneously call &mut self. Trying to do so is a borrow-checker error, not a runtime UAF.

Used by long-running workers (rayon parallel corpus sweep, the LSP daemon, etc.) that parse many documents in succession and would otherwise pay one mmap per parse.

pub fn reset_with_hint(&mut self, target_capacity: usize)

Reset and pre-size: drop every allocation, then ensure the retained chunk capacity is at least target_capacity bytes before returning.

Behaviour:

• When the arena’s existing chunk capacity already meets the target, this is identical to Arena::reset — no syscall, no fresh allocation.
• When the target exceeds current capacity, the underlying bump is replaced with a freshly-allocated one of at least target_capacity bytes. The previous chunks are released to the system allocator; the new bump mmaps one chunk at the requested size.

The replace path costs one mmap per growth event, not per parse. Steady-state workloads (corpus sweep on similar-sized docs) hit the no-op fast path after the first parse on each worker thread; only docs whose AST exceeds the high-water mark pay the syscall. Compared to plain Arena::reset + chunk-grow-on-demand, the cost is identical (same number of mmaps) but moved out of the parse hot path: the syscall fires before lex_into_arena rather than inside it, removing one source of intra-parse latency variance.

Used by long-running workers (rayon corpus sweep, LSP daemon) that have a per-source size hint available — typically source.len() * 4 for the borrowed AST shape.

Trait Implementations

impl Debug for Arena

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

Formats the value using the given formatter.

impl Default for Arena

fn default() -> Arena

Returns the “default value” for a type.