Struct GcScope 

pub struct GcScope<'s> { /* private fields */ }

Handle to a GC scope, used to:

1. reference the scope state
2. manage lifetime of the scope, pop the scope when the handle is dropped

Methods from Deref<Target = GcScopeState<'s>>

pub fn partition_id(&self) -> GcPartitionId

pub fn stack_id(&self) -> GcScopeStackId

pub fn heap(&self) -> &GcHeap

pub fn heap_mut(&mut self) -> &mut GcHeap

pub fn depth(&self) -> u32

pub fn count(&self) -> usize

pub fn parent(&self) -> Option<(&GcScopeState<'_>, u32)>

get parent scope, and its level.

pub fn alloc_local<T: GcNode>( &self, payload: T, ) -> Result<Gc<'s, T>, (GcError, T)>

alloc a local node in scope.

Examples found in repository

examples/gc_node_usage.rs (line 33)

fn alloc_static(
    heap: &mut GcHeap,
    stack_id: GcScopeStackId,
    value: i32,
) -> GcResult<GcRef<StaticNode>> {
    heap.with_new_scope(stack_id, |ctx| {
        let r = ctx
            .alloc_local(StaticNode { _value: value })
            .map_err(|(err, _)| err)
            .map(|gc| gc.into_raw());
        ctx.clear();
        r
    })
}

fn alloc_other(
    heap: &mut GcHeap,
    stack_id: GcScopeStackId,
    value: i32,
) -> GcResult<GcRef<OtherNode>> {
    heap.with_new_scope(stack_id, |ctx| {
        let r = ctx
            .alloc_local(OtherNode { _value: value })
            .map_err(|(err, _)| err)
            .map(|gc| gc.into_raw());
        ctx.clear();
        r
    })
}

pub fn add_non_local(&self, node: NonNull<GcHead>) -> bool

pub fn remove_node(&self, node: NonNull<GcHead>) -> bool

Remove a LOCAL node from this scope’s cache and clear its LOCAL flag.

This is the inverse of add_node: it undoes the LOCAL protection that was granted when the node was allocated in this scope. After this call, the node is no longer protected by this scope and will be traced by GC solely through other GC references.

Returns true if the node was found and removed from this scope’s cache. Returns false if the node was not in this scope’s cache (e.g., it was already promoted, or belongs to a different scope).

Safety

The caller must ensure the node is still alive and valid. This method does NOT check whether the node is the current promote node; the caller (e.g., ScopedContext::throw) is responsible for ensuring the node is not the promote target.

pub fn contains(&self, node: NonNull<GcHead>) -> bool

pub fn promote_node_to( &self, node: NonNull<GcHead>, target: &GcScopeState<'_>, ) -> bool

Move a node from this scope’s cache to the target scope’s cache.

The node retains its LOCAL flag — it is simply transferred from one scope’s protection to another’s. This is used when a return value needs to be moved from a child scope to its parent scope before the child scope is destroyed.

Returns true if the node was found in this scope and moved. Returns false if the node was not in this scope’s cache (e.g., it is a root node, or already belongs to another scope).

pub fn clear(&self)

Examples found in repository

examples/gc_node_usage.rs (line 36)

fn alloc_static(
    heap: &mut GcHeap,
    stack_id: GcScopeStackId,
    value: i32,
) -> GcResult<GcRef<StaticNode>> {
    heap.with_new_scope(stack_id, |ctx| {
        let r = ctx
            .alloc_local(StaticNode { _value: value })
            .map_err(|(err, _)| err)
            .map(|gc| gc.into_raw());
        ctx.clear();
        r
    })
}

fn alloc_other(
    heap: &mut GcHeap,
    stack_id: GcScopeStackId,
    value: i32,
) -> GcResult<GcRef<OtherNode>> {
    heap.with_new_scope(stack_id, |ctx| {
        let r = ctx
            .alloc_local(OtherNode { _value: value })
            .map_err(|(err, _)| err)
            .map(|gc| gc.into_raw());
        ctx.clear();
        r
    })
}

Trait Implementations

impl<'s> Debug for GcScope<'s>

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

Formats the value using the given formatter.

impl<'s> Deref for GcScope<'s>

type Target = GcScopeState<'s>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'s> DerefMut for GcScope<'s>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'s> Drop for GcScope<'s>

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.