Trait Finalize 

pub trait Finalize {
    // Provided method
    fn finalize(&self) { ... }
}

The Finalize trait, which needs to be implemented on garbage-collected objects to define finalization logic.

Provided Methods

fn finalize(&self)

Implementations on Foreign Types

impl Finalize for bool

impl Finalize for char

impl Finalize for f32

impl Finalize for f64

impl Finalize for i8

impl Finalize for i16

impl Finalize for i32

impl Finalize for i64

impl Finalize for i128

impl Finalize for isize

impl Finalize for u8

impl Finalize for u16

impl Finalize for u32

impl Finalize for u64

impl Finalize for u128

impl Finalize for ()

impl Finalize for usize

impl Finalize for Box<str>

impl Finalize for Rc<str>

impl Finalize for String

impl Finalize for NonZero<i8>

impl Finalize for NonZero<i16>

impl Finalize for NonZero<i32>

impl Finalize for NonZero<i64>

impl Finalize for NonZero<i128>

impl Finalize for NonZero<isize>

impl Finalize for NonZero<u8>

impl Finalize for NonZero<u16>

impl Finalize for NonZero<u32>

impl Finalize for NonZero<u64>

impl Finalize for NonZero<u128>

impl Finalize for NonZero<usize>

impl Finalize for AtomicBool

impl Finalize for AtomicI8

impl Finalize for AtomicI16

impl Finalize for AtomicI32

impl Finalize for AtomicI64

impl Finalize for AtomicIsize

impl Finalize for AtomicU8

impl Finalize for AtomicU16

impl Finalize for AtomicU32

impl Finalize for AtomicU64

impl Finalize for AtomicUsize

impl Finalize for Path

impl Finalize for PathBuf

impl<A> Finalize for (A,)

impl<A, B> Finalize for (A, B)

impl<A, B, C> Finalize for (A, B, C)

impl<A, B, C, D> Finalize for (A, B, C, D)

impl<A, B, C, D, E> Finalize for (A, B, C, D, E)

impl<A, B, C, D, E, F> Finalize for (A, B, C, D, E, F)

impl<A, B, C, D, E, F, G> Finalize for (A, B, C, D, E, F, G)

impl<A, B, C, D, E, F, G, H> Finalize for (A, B, C, D, E, F, G, H)

impl<A, B, C, D, E, F, G, H, I> Finalize for (A, B, C, D, E, F, G, H, I)

impl<A, B, C, D, E, F, G, H, I, J> Finalize for (A, B, C, D, E, F, G, H, I, J)

impl<A, B, C, D, E, F, G, H, I, J, K> Finalize for (A, B, C, D, E, F, G, H, I, J, K)

impl<A, B, C, D, E, F, G, H, I, J, K, L> Finalize for (A, B, C, D, E, F, G, H, I, J, K, L)

impl<K, V> Finalize for BTreeMap<K, V>

where K: Trace, V: Trace,

impl<K, V, S> Finalize for HashMap<K, V, S>

where K: Eq + Hash + Trace, V: Trace, S: BuildHasher,

impl<Ret> Finalize for fn() -> Ret

impl<Ret> Finalize for extern "C" fn() -> Ret

impl<Ret> Finalize for unsafe fn() -> Ret

impl<Ret> Finalize for unsafe extern "C" fn() -> Ret

impl<Ret, A> Finalize for fn(A) -> Ret

impl<Ret, A> Finalize for extern "C" fn(A) -> Ret

impl<Ret, A> Finalize for extern "C" fn(A, ...) -> Ret

impl<Ret, A> Finalize for unsafe fn(A) -> Ret

impl<Ret, A> Finalize for unsafe extern "C" fn(A) -> Ret

impl<Ret, A> Finalize for unsafe extern "C" fn(A, ...) -> Ret

impl<Ret, A, B> Finalize for fn(A, B) -> Ret

impl<Ret, A, B> Finalize for extern "C" fn(A, B) -> Ret

impl<Ret, A, B> Finalize for extern "C" fn(A, B, ...) -> Ret

impl<Ret, A, B> Finalize for unsafe fn(A, B) -> Ret

impl<Ret, A, B> Finalize for unsafe extern "C" fn(A, B) -> Ret

impl<Ret, A, B> Finalize for unsafe extern "C" fn(A, B, ...) -> Ret

impl<Ret, A, B, C> Finalize for fn(A, B, C) -> Ret

impl<Ret, A, B, C> Finalize for extern "C" fn(A, B, C) -> Ret

impl<Ret, A, B, C> Finalize for extern "C" fn(A, B, C, ...) -> Ret

impl<Ret, A, B, C> Finalize for unsafe fn(A, B, C) -> Ret

impl<Ret, A, B, C> Finalize for unsafe extern "C" fn(A, B, C) -> Ret

impl<Ret, A, B, C> Finalize for unsafe extern "C" fn(A, B, C, ...) -> Ret

impl<Ret, A, B, C, D> Finalize for fn(A, B, C, D) -> Ret

impl<Ret, A, B, C, D> Finalize for extern "C" fn(A, B, C, D) -> Ret

impl<Ret, A, B, C, D> Finalize for extern "C" fn(A, B, C, D, ...) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe fn(A, B, C, D) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe extern "C" fn(A, B, C, D) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

impl<Ret, A, B, C, D, E> Finalize for fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for extern "C" fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for extern "C" fn(A, B, C, D, E, ...) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe extern "C" fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for extern "C" fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for extern "C" fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

impl<T> Finalize for Option<T>

where T: Trace,

impl<T> Finalize for &'static T

where T: ?Sized,

impl<T> Finalize for Box<[T]>

where T: Trace,

impl<T> Finalize for Box<T>

where T: Trace + ?Sized,

impl<T> Finalize for BinaryHeap<T>

where T: Ord + Trace,

impl<T> Finalize for BTreeSet<T>

where T: Trace,

impl<T> Finalize for LinkedList<T>

where T: Eq + Hash + Trace,

impl<T> Finalize for VecDeque<T>

where T: Trace,

impl<T> Finalize for Rc<T>

where T: Trace + ?Sized,

impl<T> Finalize for Vec<T>

where T: Trace,

impl<T, E> Finalize for Result<T, E>

where T: Trace, E: Trace,

impl<T, S> Finalize for HashSet<T, S>

where T: Eq + Hash + Trace, S: BuildHasher,

impl<T, const N: usize> Finalize for [T; N]

where T: Trace,

Implementors

impl Finalize for Function

impl Finalize for JsValue

impl Finalize for BindingStatus

impl Finalize for ObjectKind

impl Finalize for DescriptorKind

impl Finalize for PropertyKey

impl Finalize for Const

impl Finalize for BindingPatternTypeArray

impl Finalize for BindingPatternTypeObject

impl Finalize for Declaration

impl Finalize for DeclarationList

impl Finalize for DeclarationPattern

impl Finalize for MethodDefinitionKind

impl Finalize for Node

impl Finalize for PropertyDefinition

impl Finalize for PropertyName

impl Finalize for TemplateElement

impl Finalize for AssignOp

impl Finalize for boa::syntax::ast::op::BinOp

impl Finalize for BitOp

impl Finalize for CompOp

impl Finalize for LogOp

impl Finalize for NumOp

impl Finalize for boa::syntax::ast::op::UnaryOp

impl Finalize for ArrayIterator

impl Finalize for Date

impl Finalize for BuiltInFunction

impl Finalize for Captures

impl Finalize for FunctionFlags

impl Finalize for MapIterator

impl Finalize for ForInIterator

impl Finalize for RegExpStringIterator

impl Finalize for RegExp

impl Finalize for SetIterator

impl Finalize for StringIterator

impl Finalize for DeclarativeEnvironmentRecord

impl Finalize for DeclarativeEnvironmentRecordBinding

impl Finalize for FunctionEnvironmentRecord

impl Finalize for GlobalEnvironmentRecord

impl Finalize for ObjectEnvironmentRecord

impl Finalize for JsObject

impl Finalize for boa::object::Object

impl Finalize for ObjectData

impl Finalize for PropertyMap

impl Finalize for Attribute

impl Finalize for PropertyDescriptor

impl Finalize for JsBigInt

impl Finalize for JsString

impl Finalize for JsSymbol

impl Finalize for ArrayDecl

impl Finalize for AwaitExpr

impl Finalize for Block

impl Finalize for Break

impl Finalize for Call

impl Finalize for ConditionalOp

impl Finalize for If

impl Finalize for ArrowFunctionDecl

impl Finalize for AsyncFunctionDecl

impl Finalize for AsyncFunctionExpr

impl Finalize for FunctionDecl

impl Finalize for FunctionExpr

impl Finalize for DeclarationPatternArray

impl Finalize for DeclarationPatternObject

impl Finalize for GetConstField

impl Finalize for GetField

impl Finalize for Identifier

impl Finalize for Continue

impl Finalize for DoWhileLoop

impl Finalize for ForInLoop

impl Finalize for ForLoop

impl Finalize for ForOfLoop

impl Finalize for WhileLoop

impl Finalize for New

impl Finalize for boa::syntax::ast::node::object::Object

impl Finalize for Assign

impl Finalize for boa::syntax::ast::node::operator::bin_op::BinOp

impl Finalize for boa::syntax::ast::node::operator::unary_op::UnaryOp

impl Finalize for Return

impl Finalize for Spread

impl Finalize for RcStatementList

impl Finalize for StatementList

impl Finalize for FormalParameter

impl Finalize for Case

impl Finalize for Switch

impl Finalize for TaggedTemplate

impl Finalize for TemplateLit

impl Finalize for Throw

impl Finalize for Catch

impl Finalize for Finally

impl Finalize for Try

impl<T> Finalize for Gc<T>

where T: Trace + ?Sized,

impl<T> Finalize for GcCell<T>

where T: Trace + ?Sized,

impl<V: Eq + Hash + Trace, S: BuildHasher> Finalize for OrderedSet<V, S>

impl<V: Trace, S: BuildHasher> Finalize for OrderedMap<V, S>