Enum cranelift_wasm::wasmparser::InterfaceType

pub enum InterfaceType<'a> {
    Primitive(PrimitiveInterfaceType),
    Record(Box<[(&'a str, InterfaceTypeRef)], Global>),
    Variant(Box<[VariantCase<'a>], Global>),
    List(InterfaceTypeRef),
    Tuple(Box<[InterfaceTypeRef], Global>),
    Flags(Box<[&'a str], Global>),
    Enum(Box<[&'a str], Global>),
    Union(Box<[InterfaceTypeRef], Global>),
    Option(InterfaceTypeRef),
    Expected {
        ok: InterfaceTypeRef,
        error: InterfaceTypeRef,
    },
}

Represents an interface type.

Variants

Primitive(PrimitiveInterfaceType)

The interface type is one of the primitive types.

Record(Box<[(&'a str, InterfaceTypeRef)], 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(InterfaceTypeRef)

The type is a list of the given interface type.

Tuple(Box<[InterfaceTypeRef], Global>)

The type is a tuple of the given interface 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<[InterfaceTypeRef], Global>)

The type is a union of the given interface types.

Option(InterfaceTypeRef)

The type is an option of the given interface type.

Expected

Fields

ok: InterfaceTypeRef

The type returned for success.

error: InterfaceTypeRef

The type returned for failure.

The type is an expected type.

Trait Implementations

impl<'a> Clone for InterfaceType<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for InterfaceType<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<InterfaceType<'a>> for InterfaceType<'a>

fn eq(&self, other: &InterfaceType<'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 InterfaceType<'a>

impl<'a> StructuralEq for InterfaceType<'a>

impl<'a> StructuralPartialEq for InterfaceType<'a>