Struct GCLock 

pub struct GCLock<'ast, 'ctx> { /* private fields */ }

A way to view the Context.

Provides the user the ability to create new nodes and dereference NodeRc.

At most one is allowed to be active in any thread at any time. This is to ensure no &Node can be shared between Contexts.

Implementations

impl<'ast, 'ctx> GCLock<'ast, 'ctx>

pub fn new(ctx: &'ctx mut Context<'ast>) -> Self

Panics

Will panic if there is already an active GCLock on this thread.

pub fn alloc<'s>(&'s self, n: Node<'s>) -> &'s Node<'s>

Allocate a node in the ctx.

pub fn ctx(&self) -> &Context<'ast>

Return a reference to the owning Context.

pub fn atom_bytes<V: Into<Vec<u8>> + AsRef<[u8]>>(&self, value: V) -> AtomBytes

Add a byte-string to the identifier table.

pub fn bytes(&self, ident: AtomBytes) -> &[u8]

Obtain the contents of an atom from the atom table.

pub fn bytes_str_lossy(&self, ident: AtomBytes) -> &str

Obtain the contents of an atom as a string, substituting U+FFFD for anything unrepresentable. This is the usual way to print an identifier’s name: gc.bytes_str_lossy(id.name.get()). See AtomTable::bytes_str_lossy.

pub fn try_bytes_str(&self, ident: AtomBytes) -> Option<&str>

Obtain the contents of an atom as a string, or None if it holds an unpaired surrogate — a legal JS string value with no UTF-8 form. This is the right accessor for string-literal values, where substituting U+FFFD would silently corrupt the program’s data. Note a surrogate pair, which is how an astral character is stored, comes back as Some. See AtomTable::try_bytes_str.

impl<'ast, 'ctx> GCLock<'ast, 'ctx>

pub unsafe fn alloc_scope<'s>(&'s self) -> AllocationScope<'s, 'ast, 'ctx>

Open an allocation scope: everything allocated between this call and the returned guard’s drop is reclaimed at drop (nodes and list elements). Mirrors the C++ AllocationScope discipline the PreParse pass uses (JSParserImpl.cpp:516-560).

Safety

The caller must guarantee that when the guard drops:

• no &Node, NodeList, &NodeListElement, or interior reference into an allocation made after this call survives — the storage is freed and any such reference dangles; and
• no NodeRc points into those allocations (debug-asserted).

If the Context ran gc() before this pass, in-scope allocations may be served from the free list at pre-watermark positions; those escape reclamation harmlessly (unreferenced until the next gc()).

Trait Implementations

impl Drop for GCLock<'_, '_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.