Enum wasmtime::HeapType

source ·
pub enum HeapType {
Show 13 variants Extern, NoExtern, Func, ConcreteFunc(FuncType), NoFunc, Any, Eq, I31, Array, ConcreteArray(ArrayType), Struct, ConcreteStruct(StructType), None,
}
Expand description

The heap types that can Wasm can have references to.

§Subtyping Hierarchy

Wasm has three different heap type hierarchies:

  1. Function types
  2. External types
  3. Internal types

Each hierarchy has a top type (the common supertype of which everything else in its hierarchy is a subtype of) and a bottom type (the common subtype of which everything else in its hierarchy is supertype of).

§Function Types Hierarchy

The top of the function types hierarchy is func; the bottom is nofunc. In between are all the concrete function types.

                         func
                      /  /  \  \
     ,----------------  /    \  -------------------------.
    /                  /      \                           \
   |              ,----        -----------.                |
   |              |                       |                |
   |              |                       |                |
(func)    (func (param i32))    (func (param i32 i32))    ...
   |              |                       |                |
   |              |                       |                |
   |              `---.        ,----------'                |
    \                  \      /                           /
     `---------------.  \    /  ,------------------------'
                      \  \  /  /
                        nofunc

Additionally, some concrete function types are sub- or supertypes of other concrete function types, if that was declared in their definition. For simplicity, this isn’t depicted in the diagram above.

§External

The top of the external types hierarchy is extern; the bottom is noextern. There are no concrete types in this hierarchy.

 extern
   |
noextern

§Internal

The top of the internal types hierarchy is any; the bottom is none. The eq type is the common supertype of all types that can be compared for equality. The struct and array types are the common supertypes of all concrete struct and array types respectively. The i31 type represents unboxed 31-bit integers.

                                  any
                                 / | \
   ,----------------------------'  |  `--------------------------.
  /                                |                              \
 |                        .--------'                               |
 |                        |                                        |
 |                      struct                                   array
 |                     /  |   \                                 /  |   \
i31             ,-----'   |    '-----.                   ,-----'   |    `-----.
 |             /          |           \                 /          |           \
 |            |           |            |               |           |            |
 |        (struct)    (struct i32)    ...        (array i32)    (array i64)    ...
 |            |           |            |               |           |            |
 |             \          |           /                 \          |           /
  \             `-----.   |    ,-----'                   `-----.   |    ,-----'
   \                   \  |   /                                 \  |   /
    \                   \ |  /                                   \ |  /
     \                   \| /                                     \| /
      \                   |/                                       |/
       \                  |                                        |
        \                 |                                       /
         \                '--------.                             /
          \                        |                            /
           `--------------------.  |   ,-----------------------'
                                 \ |  /
                                  none

Additionally, concrete struct and array types can be subtypes of other concrete struct and array types respectively, if that was declared in their definitions. Once again, this is omitted from the above diagram for simplicity.

§Subtyping and Equality

HeapType does not implement Eq, because heap types have a subtyping relationship, and so 99.99% of the time you actually want to check whether one type matches (i.e. is a subtype of) another type. You can use the HeapType::matches method to perform these types of checks. If, however, you are in that 0.01% scenario where you need to check precise equality between types, you can use the HeapType::eq method.

Variants§

§

Extern

The abstract extern heap type represents external host data.

This is the top type for the external type hierarchy, and therefore is the common supertype of all external reference types.

§

NoExtern

The abstract noextern heap type represents the null external reference.

This is the bottom type for the external type hierarchy, and therefore is the common subtype of all external reference types.

§

Func

The abstract func heap type represents a reference to any kind of function.

This is the top type for the function references type hierarchy, and is therefore a supertype of every function reference.

§

ConcreteFunc(FuncType)

A reference to a function of a specific, concrete type.

These are subtypes of func and supertypes of nofunc.

§

NoFunc

The abstract nofunc heap type represents the null function reference.

This is the bottom type for the function references type hierarchy, and therefore nofunc is a subtype of all function reference types.

§

Any

The abstract any heap type represents all internal Wasm data.

This is the top type of the internal type hierarchy, and is therefore a supertype of all internal types (such as eq, i31, structs, and arrays).

§

Eq

The abstract eq heap type represenets all internal Wasm references that can be compared for equality.

This is a subtype of any and a supertype of i31, array, struct, and none heap types.

§

I31

The i31 heap type represents unboxed 31-bit integers.

This is a subtype of any and eq, and a supertype of none.

§

Array

The abstract array heap type represents a reference to any kind of array.

This is a subtype of any and eq, and a supertype of all concrete array types, as well as a supertype of the abstract none heap type.

§

ConcreteArray(ArrayType)

A reference to an array of a specific, concrete type.

These are subtypes of the array heap type (therefore also a subtype of any and eq) and supertypes of the none heap type.

§

Struct

The abstract struct heap type represents a reference to any kind of struct.

This is a subtype of any and eq, and a supertype of all concrete struct types, as well as a supertype of the abstract none heap type.

§

ConcreteStruct(StructType)

A reference to an struct of a specific, concrete type.

These are subtypes of the struct heap type (therefore also a subtype of any and eq) and supertypes of the none heap type.

§

None

The abstract none heap type represents the null internal reference.

This is the bottom type for the internal type hierarchy, and therefore none is a subtype of internal types.

Implementations§

source§

impl HeapType

source

pub fn is_extern(&self) -> bool

Is this the abstract extern heap type?

source

pub fn is_func(&self) -> bool

Is this the abstract func heap type?

source

pub fn is_no_func(&self) -> bool

Is this the abstract nofunc heap type?

source

pub fn is_any(&self) -> bool

Is this the abstract any heap type?

source

pub fn is_i31(&self) -> bool

Is this the abstract i31 heap type?

source

pub fn is_none(&self) -> bool

Is this the abstract none heap type?

source

pub fn is_abstract(&self) -> bool

Is this an abstract type?

Types that are not abstract are concrete, user-defined types.

source

pub fn is_concrete(&self) -> bool

Is this a concrete, user-defined heap type?

Types that are not concrete, user-defined types are abstract types.

source

pub fn is_concrete_func(&self) -> bool

Is this a concrete, user-defined function type?

source

pub fn as_concrete_func(&self) -> Option<&FuncType>

Get the underlying concrete, user-defined function type, if any.

Returns None if this is not a concrete function type.

source

pub fn unwrap_concrete_func(&self) -> &FuncType

Get the underlying concrete, user-defined type, panicking if this is not a concrete function type.

source

pub fn is_concrete_array(&self) -> bool

Is this a concrete, user-defined array type?

source

pub fn as_concrete_array(&self) -> Option<&ArrayType>

Get the underlying concrete, user-defined array type, if any.

Returns None for if this is not a concrete array type.

source

pub fn unwrap_concrete_array(&self) -> &ArrayType

Get the underlying concrete, user-defined type, panicking if this is not a concrete array type.

source

pub fn is_concrete_struct(&self) -> bool

Is this a concrete, user-defined struct type?

source

pub fn as_concrete_struct(&self) -> Option<&StructType>

Get the underlying concrete, user-defined struct type, if any.

Returns None for if this is not a concrete struct type.

source

pub fn unwrap_concrete_struct(&self) -> &StructType

Get the underlying concrete, user-defined type, panicking if this is not a concrete struct type.

source

pub fn top(&self) -> HeapType

Get the top type of this heap type’s type hierarchy.

The returned heap type is a supertype of all types in this heap type’s type hierarchy.

source

pub fn is_top(&self) -> bool

Is this the top type within its type hierarchy?

source

pub fn bottom(&self) -> HeapType

Get the bottom type of this heap type’s type hierarchy.

The returned heap type is a subtype of all types in this heap type’s type hierarchy.

source

pub fn is_bottom(&self) -> bool

Is this the bottom type within its type hierarchy?

source

pub fn matches(&self, other: &HeapType) -> bool

Does this heap type match the other heap type?

That is, is this heap type a subtype of the other?

§Panics

Panics if either type is associated with a different engine from the other.

source

pub fn eq(a: &HeapType, b: &HeapType) -> bool

Is heap type a precisely equal to heap type b?

Returns false even if a is a subtype of b or vice versa, if they are not exactly the same heap type.

§Panics

Panics if either type is associated with a different engine from the other.

Trait Implementations§

source§

impl Clone for HeapType

source§

fn clone(&self) -> HeapType

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for HeapType

source§

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

Formats the value using the given formatter. Read more
source§

impl Display for HeapType

source§

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

Formats the value using the given formatter. Read more
source§

impl From<ArrayType> for HeapType

source§

fn from(a: ArrayType) -> Self

Converts to this type from the input type.
source§

impl From<FuncType> for HeapType

source§

fn from(f: FuncType) -> Self

Converts to this type from the input type.
source§

impl From<StructType> for HeapType

source§

fn from(s: StructType) -> Self

Converts to this type from the input type.
source§

impl Hash for HeapType

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
source§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.