Struct WasmExnType

pub struct WasmExnType {
    pub func_ty: EngineOrModuleTypeIndex,
    pub fields: Box<[WasmFieldType]>,
}

WebAssembly exception type.

This “exception type” is not a Wasm language-level concept. Instead, it denotes an exception object signature – the types of the payload values.

In contrast, at the Wasm language level, exception objects are associated with specific tags, and these tags refer to their signatures (function types). However, tags are nominal: like memories and tables, a separate instance of a tag exists for every instance of the defining module, and these tag instances can be imported and exported. At runtime we handle tags like we do memories and tables, but these runtime instances do not exist in the type system here.

Because the Wasm type system does not have concrete exn types (i.e., the heap-type lattice has only top exn and bottom noexn), we are free to decide what we mean by “concrete type” here. Thus, we define an “exception type” to refer to the type-level signature. When a particular exception object is created in a store, it can be associated with a particular tag instance also in that store, and the compatibility is checked (the tag’s function type must match the function type in the associated WasmExnType).

Fields

func_ty: EngineOrModuleTypeIndex

The function type from which we get our signature. We hold this directly so that we can efficiently derive a FuncType without re-interning the field types.

fields: Box<[WasmFieldType]>

The fields (payload values) that make up this exception type.

While we could obtain these by looking up the func_ty above, we also need to be able to derive a GC object layout from this type descriptor without referencing other type descriptors; so we directly inline the information here.

Trait Implementations

impl Clone for WasmExnType

fn clone(&self) -> WasmExnType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WasmExnType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WasmExnType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for WasmExnType

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

Formats the value using the given formatter.

impl Hash for WasmExnType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for WasmExnType

fn eq(&self, other: &WasmExnType) -> 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 Serialize for WasmExnType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeTrace for WasmExnType

fn trace<F, E>(&self, func: &mut F) -> Result<(), E>

where F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,

Visit each edge.

fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>

where F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,

Visit each edge, mutably.

fn trace_engine_indices<F, E>(&self, func: &mut F) -> Result<(), E>

where F: FnMut(VMSharedTypeIndex) -> Result<(), E>,

Trace all VMSharedTypeIndex edges, ignoring other edges.

fn canonicalize_for_runtime_usage<F>(&mut self, module_to_engine: &mut F)

where F: FnMut(ModuleInternedTypeIndex) -> VMSharedTypeIndex,

Canonicalize self by rewriting all type references inside self from module-level interned type indices to engine-level interned type indices.

fn is_canonicalized_for_runtime_usage(&self) -> bool

Is this type canonicalized for runtime usage?

fn canonicalize_for_hash_consing<F>( &mut self, rec_group_range: Range<ModuleInternedTypeIndex>, module_to_engine: &mut F, )

where F: FnMut(ModuleInternedTypeIndex) -> VMSharedTypeIndex,

Canonicalize self by rewriting all type references inside self from module-level interned type indices to either engine-level interned type indices or recgroup-relative indices.

fn is_canonicalized_for_hash_consing(&self) -> bool

Is this type canonicalized for hash consing?

impl Eq for WasmExnType

impl StructuralPartialEq for WasmExnType