Enum witnext::Type

pub enum Type {
    Record(RecordDatatype),
    Variant(Variant),
    Handle(HandleDatatype),
    List(TypeRef),
    Pointer(TypeRef),
    ConstPointer(TypeRef),
    Buffer(Buffer),
    Builtin(BuiltinType),
}

Structure of all possible interface types.

Note that this is intended to match the interface types proposal itself. Currently this is relatively close to that with just a few *.witx extensions for now.

Variants

Record(RecordDatatype)

A structure with named field.

Variant(Variant)

An enumeration where a value is one of a number of variants.

Handle(HandleDatatype)

A “handle” which is an un-forgeable reference. Today this is an i32 where a module can’t forge and use integers it was not already given access to.

List(TypeRef)

A list of a type, stored in linear memory.

Note that lists of char are specialized to indicate strings.

Pointer(TypeRef)

A witx-specific type representing a raw mutable pointer into linear memory

ConstPointer(TypeRef)

A witx-specific type representing a raw const pointer into linear memory

Buffer(Buffer)

A buffer type representing a window in memory

Builtin(BuiltinType)

A builtin base-case type.

Implementations

impl Type

pub fn kind(&self) -> &'static str

Returns a human-readable string to describe this type.

pub fn all_bits_valid(&self) -> bool

Returns whether the in-memory representation of this type will always be valid regardless of the value of all the bits in memory.

This is only true for numerical types, pointers, and records of these values. This is used for canonical lifting/lowering of lists.

pub fn type_equal(&self, other: &Type) -> bool

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl Eq for Type

impl Hash for Type

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Layout for Type

fn mem_size_align(&self, export: bool) -> SizeAlign

fn mem_size(&self, export: bool) -> usize

fn mem_align(&self, export: bool) -> usize

impl PartialEq<Type> for Type

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for Type

impl StructuralPartialEq for Type