Enum wast::WastDirective

pub enum WastDirective<'a> {
    Module(Module<'a>),
    QuoteModule {
        span: Span,
        source: Vec<&'a [u8]>,
    },
    AssertMalformed {
        span: Span,
        module: QuoteModule<'a>,
        message: &'a str,
    },
    AssertInvalid {
        span: Span,
        module: Module<'a>,
        message: &'a str,
    },
    Register {
        span: Span,
        name: &'a str,
        module: Option<Id<'a>>,
    },
    Invoke(WastInvoke<'a>),
    AssertTrap {
        span: Span,
        exec: WastExecute<'a>,
        message: &'a str,
    },
    AssertReturn {
        span: Span,
        exec: WastExecute<'a>,
        results: Vec<AssertExpression<'a>>,
    },
    AssertExhaustion {
        span: Span,
        call: WastInvoke<'a>,
        message: &'a str,
    },
    AssertUnlinkable {
        span: Span,
        module: Module<'a>,
        message: &'a str,
    },
}

The different kinds of directives found in a *.wast file.

It’s not entirely clear to me what all of these are per se, but they’re only really interesting to test harnesses mostly.

Variants

Module(Module<'a>)

QuoteModule

Fields of QuoteModule

span: Spansource: Vec<&'a [u8]>

AssertMalformed

Fields of AssertMalformed

span: Spanmodule: QuoteModule<'a>message: &'a str

AssertInvalid

Fields of AssertInvalid

span: Spanmodule: Module<'a>message: &'a str

Register

Fields of Register

span: Spanname: &'a strmodule: Option<Id<'a>>

Invoke(WastInvoke<'a>)

AssertTrap

Fields of AssertTrap

span: Spanexec: WastExecute<'a>message: &'a str

AssertReturn

Fields of AssertReturn

span: Spanexec: WastExecute<'a>results: Vec<AssertExpression<'a>>

AssertExhaustion

Fields of AssertExhaustion

span: Spancall: WastInvoke<'a>message: &'a str

AssertUnlinkable

Fields of AssertUnlinkable

span: Spanmodule: Module<'a>message: &'a str

Implementations

impl WastDirective<'_>

pub fn span(&self) -> Span

Returns the location in the source that this directive was defined at

Trait Implementations

impl<'a> Parse<'a> for WastDirective<'a>

fn parse(parser: Parser<'a>) -> Result<Self>

Attempts to parse Self from parser, returning an error if it could not be parsed.