Struct script::dom::bindings::import::module::jsapi::JS::PersistentRooted

#[repr(C)]
pub struct PersistentRooted {
    pub _address: u8,
}

A copyable, assignable global GC root type with arbitrary lifetime, an infallible constructor, and automatic unrooting on destruction.

These roots can be used in heap-allocated data structures, so they are not associated with any particular JSContext or stack. They are registered with the JSRuntime itself, without locking. Initialization may take place on construction, or in two phases if the no-argument constructor is called followed by init().

Note that you must not use an PersistentRooted in an object owned by a JS object:

Whenever one object whose lifetime is decided by the GC refers to another such object, that edge must be traced only if the owning JS object is traced. This applies not only to JS objects (which obviously are managed by the GC) but also to C++ objects owned by JS objects.

If you put a PersistentRooted in such a C++ object, that is almost certainly a leak. When a GC begins, the referent of the PersistentRooted is treated as live, unconditionally (because a PersistentRooted is a root), even if the JS object that owns it is unreachable. If there is any path from that referent back to the JS object, then the C++ object containing the PersistentRooted will not be destructed, and the whole blob of objects will not be freed, even if there are no references to them from the outside.

In the context of Firefox, this is a severe restriction: almost everything in Firefox is owned by some JS object or another, so using PersistentRooted in such objects would introduce leaks. For these kinds of edges, Heap or TenuredHeap would be better types. It’s up to the implementor of the type containing Heap or TenuredHeap members to make sure their referents get marked when the object itself is marked.

Fields

_address: u8

Trait Implementations

impl Clone for PersistentRooted

fn clone(&self) -> PersistentRooted

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PersistentRooted

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

Formats the value using the given formatter.

impl PartialEq for PersistentRooted

fn eq(&self, other: &PersistentRooted) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for PersistentRooted

impl StructuralPartialEq for PersistentRooted