Enum wasmtime_environ::wasmparser::ComponentDefinedType

pub enum ComponentDefinedType<'a> {
    Primitive(PrimitiveValType),
    Record(Box<[(&'a str, ComponentValType)], Global>),
    Variant(Box<[VariantCase<'a>], Global>),
    List(ComponentValType),
    Tuple(Box<[ComponentValType], Global>),
    Flags(Box<[&'a str], Global>),
    Enum(Box<[&'a str], Global>),
    Union(Box<[ComponentValType], Global>),
    Option(ComponentValType),
    Result {
        ok: Option<ComponentValType>,
        err: Option<ComponentValType>,
    },
    Own(u32),
    Borrow(u32),
}

Represents a defined type in a WebAssembly component.

Variants

Primitive(PrimitiveValType)

The type is one of the primitive value types.

Record(Box<[(&'a str, ComponentValType)], Global>)

The type is a record with the given fields.

Variant(Box<[VariantCase<'a>], Global>)

The type is a variant with the given cases.

List(ComponentValType)

The type is a list of the given value type.

Tuple(Box<[ComponentValType], Global>)

The type is a tuple of the given value types.

Flags(Box<[&'a str], Global>)

The type is flags with the given names.

Enum(Box<[&'a str], Global>)

The type is an enum with the given tags.

Union(Box<[ComponentValType], Global>)

The type is a union of the given value types.

Option(ComponentValType)

The type is an option of the given value type.

Result

Fields

ok: Option<ComponentValType>

The type returned for success.

err: Option<ComponentValType>

The type returned for failure.

The type is a result type.

Own(u32)

An owned handle to a resource.

Borrow(u32)

A borrowed handle to a resource.

Trait Implementations

impl<'a> Clone for ComponentDefinedType<'a>

fn clone(&self) -> ComponentDefinedType<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ComponentDefinedType<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<ComponentDefinedType<'a>> for ComponentDefinedType<'a>

fn eq(&self, other: &ComponentDefinedType<'a>) -> bool

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

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

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

impl<'a> Eq for ComponentDefinedType<'a>

impl<'a> StructuralEq for ComponentDefinedType<'a>

impl<'a> StructuralPartialEq for ComponentDefinedType<'a>