[−][src]Trait wast::parser::Parse

pub trait Parse<'a>: Sized {
    fn parse(parser: Parser<'a>) -> Result<Self>;
}

A trait for parsing a fragment of syntax in a recursive descent fashion.

The Parse trait is main abstraction you'll be working with when defining custom parser or custom syntax for your WebAssembly text format (or when using the official format items). Almost all items in the ast module implement the Parse trait, and you'll commonly use this with:

  • The top-level parse function to parse an entire input.
  • The intermediate Parser::parse function to parse an item out of an input stream and then parse remaining items.

Implementation of Parse take a Parser as input and will mutate the parser as they parse syntax. Once a token is consume it cannot be "un-consumed". Utilities such as Parser::peek and Parser::lookahead1 can be used to determine what to parse next.

When to parse ( and )?

Conventionally types are not responsible for parsing their own ( and ) tokens which surround the type. For example WebAssembly imports look like:

(import "foo" "bar" (func (type 0)))

but the Import type parser looks like:

impl<'a> Parse<'a> for Import<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        parser.parse::<kw::import>()?;
        // ...
    }
}

It is assumed here that the ( and ) tokens which surround an import statement in the WebAssembly text format are parsed by the parent item parsing Import.

Note that this is just a convention, so it's not necessarily required for all types. It's recommended that your types stick to this convention where possible to avoid nested calls to Parser::parens or accidentally trying to parse too many parenthesis.

Examples

Let's say you want to define your own WebAssembly text format which only contains imports and functions. You also require all imports to be listed before all functions. An example Parse implementation might look like:

use wast::{Import, Func, kw};
use wast::parser::{Parser, Parse, Result};

// Fields of a WebAssembly which only allow imports and functions, and all
// imports must come before all the functions
struct OnlyImportsAndFunctions<'a> {
    imports: Vec<Import<'a>>,
    functions: Vec<Func<'a>>,
}

impl<'a> Parse<'a> for OnlyImportsAndFunctions<'a> {
    fn parse(parser: Parser<'a>) -> Result<Self> {
        // While the second token is `import` (the first is `(`, so we care
        // about the second) we parse an `ast::ModuleImport` inside of
        // parentheses. The `parens` function here ensures that what we
        // parse inside of it is surrounded by `(` and `)`.
        let mut imports = Vec::new();
        while parser.peek2::<kw::import>() {
            let import = parser.parens(|p| p.parse())?;
            imports.push(import);
        }

        // Afterwards we assume everything else is a function. Note that
        // `parse` here is a generic function and type inference figures out
        // that we're parsing functions here and imports above.
        let mut functions = Vec::new();
        while !parser.is_empty() {
            let func = parser.parens(|p| p.parse())?;
            functions.push(func);
        }

        Ok(OnlyImportsAndFunctions { imports, functions })
    }
}

Required methods

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

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

This method will mutate the state of parser after attempting to parse an instance of Self. If an error happens then it is likely fatal and there is no guarantee of how many tokens have been consumed from parser.

As recommended in the documentation of Parse, implementations of this function should not start out by parsing ( and ) tokens, but rather parents calling recursive parsers should parse the ( and ) tokens for their child item that's being parsed.

Errors

This function will return an error if Self could not be parsed. Note that creating an Error is not exactly a cheap operation, so Error is typically fatal and propagated all the way back to the top parse call site.

Loading content...

Implementations on Foreign Types

impl<'a> Parse<'a> for Option<NameAnnotation<'a>>[src]

impl<'a> Parse<'a> for u8[src]

impl<'a> Parse<'a> for (u8, Span)[src]

impl<'a> Parse<'a> for u16[src]

impl<'a> Parse<'a> for (u16, Span)[src]

impl<'a> Parse<'a> for u32[src]

impl<'a> Parse<'a> for (u32, Span)[src]

impl<'a> Parse<'a> for u64[src]

impl<'a> Parse<'a> for (u64, Span)[src]

impl<'a> Parse<'a> for i8[src]

impl<'a> Parse<'a> for (i8, Span)[src]

impl<'a> Parse<'a> for i16[src]

impl<'a> Parse<'a> for (i16, Span)[src]

impl<'a> Parse<'a> for i32[src]

impl<'a> Parse<'a> for (i32, Span)[src]

impl<'a> Parse<'a> for i64[src]

impl<'a> Parse<'a> for (i64, Span)[src]

impl<'a> Parse<'a> for &'a [u8][src]

impl<'a> Parse<'a> for &'a str[src]

impl<'_> Parse<'_> for String[src]

impl<'a, T: Peek + Parse<'a>> Parse<'a> for Option<T>[src]

Loading content...

Implementors

impl<'a> Parse<'a> for AssertExpression<'a>[src]

impl<'a> Parse<'a> for CustomPlace[src]

impl<'a> Parse<'a> for CustomPlaceAnchor[src]

impl<'a> Parse<'a> for ElemPayload<'a>[src]

impl<'a> Parse<'a> for EventType<'a>[src]

impl<'a> Parse<'a> for ExportKind<'a>[src]

impl<'a> Parse<'a> for HeapType<'a>[src]

impl<'a> Parse<'a> for Index<'a>[src]

impl<'a> Parse<'a> for Instruction<'a>[src]

impl<'a> Parse<'a> for MemoryType[src]

impl<'a> Parse<'a> for ModuleField<'a>[src]

impl<'a> Parse<'a> for QuoteModule<'a>[src]

impl<'a> Parse<'a> for StorageType<'a>[src]

impl<'a> Parse<'a> for V128Const[src]

impl<'a> Parse<'a> for V128Pattern[src]

impl<'a> Parse<'a> for ValType<'a>[src]

impl<'a> Parse<'a> for WastDirective<'a>[src]

impl<'a> Parse<'a> for WastExecute<'a>[src]

impl<'a> Parse<'a> for custom[src]

impl<'a> Parse<'a> for name[src]

impl<'a> Parse<'a> for after[src]

impl<'a> Parse<'a> for alias[src]

impl<'a> Parse<'a> for any[src]

impl<'a> Parse<'a> for anyfunc[src]

impl<'a> Parse<'a> for anyref[src]

impl<'a> Parse<'a> for array[src]

impl<'a> Parse<'a> for assert_exhaustion[src]

impl<'a> Parse<'a> for assert_invalid[src]

impl<'a> Parse<'a> for assert_malformed[src]

impl<'a> Parse<'a> for assert_return[src]

impl<'a> Parse<'a> for assert_return_arithmetic_nan[src]

impl<'a> Parse<'a> for assert_return_arithmetic_nan_f32x4[src]

impl<'a> Parse<'a> for assert_return_arithmetic_nan_f64x2[src]

impl<'a> Parse<'a> for assert_return_canonical_nan[src]

impl<'a> Parse<'a> for assert_return_canonical_nan_f32x4[src]

impl<'a> Parse<'a> for assert_return_canonical_nan_f64x2[src]

impl<'a> Parse<'a> for assert_return_func[src]

impl<'a> Parse<'a> for assert_trap[src]

impl<'a> Parse<'a> for assert_unlinkable[src]

impl<'a> Parse<'a> for before[src]

impl<'a> Parse<'a> for binary[src]

impl<'a> Parse<'a> for block[src]

impl<'a> Parse<'a> for catch[src]

impl<'a> Parse<'a> for code[src]

impl<'a> Parse<'a> for data[src]

impl<'a> Parse<'a> for declare[src]

impl<'a> Parse<'a> for do[src]

impl<'a> Parse<'a> for elem[src]

impl<'a> Parse<'a> for else[src]

impl<'a> Parse<'a> for end[src]

impl<'a> Parse<'a> for eq[src]

impl<'a> Parse<'a> for eqref[src]

impl<'a> Parse<'a> for event[src]

impl<'a> Parse<'a> for exn[src]

impl<'a> Parse<'a> for exnref[src]

impl<'a> Parse<'a> for export[src]

impl<'a> Parse<'a> for extern[src]

impl<'a> Parse<'a> for externref[src]

impl<'a> Parse<'a> for f32[src]

impl<'a> Parse<'a> for f32x4[src]

impl<'a> Parse<'a> for f64[src]

impl<'a> Parse<'a> for f64x2[src]

impl<'a> Parse<'a> for field[src]

impl<'a> Parse<'a> for first[src]

impl<'a> Parse<'a> for func[src]

impl<'a> Parse<'a> for funcref[src]

impl<'a> Parse<'a> for get[src]

impl<'a> Parse<'a> for global[src]

impl<'a> Parse<'a> for i8[src]

impl<'a> Parse<'a> for i8x16[src]

impl<'a> Parse<'a> for i16[src]

impl<'a> Parse<'a> for i16x8[src]

impl<'a> Parse<'a> for i31[src]

impl<'a> Parse<'a> for i31ref[src]

impl<'a> Parse<'a> for i32[src]

impl<'a> Parse<'a> for i32x4[src]

impl<'a> Parse<'a> for i64[src]

impl<'a> Parse<'a> for i64x2[src]

impl<'a> Parse<'a> for if[src]

impl<'a> Parse<'a> for import[src]

impl<'a> Parse<'a> for instance[src]

impl<'a> Parse<'a> for instantiate[src]

impl<'a> Parse<'a> for invoke[src]

impl<'a> Parse<'a> for item[src]

impl<'a> Parse<'a> for last[src]

impl<'a> Parse<'a> for local[src]

impl<'a> Parse<'a> for loop[src]

impl<'a> Parse<'a> for memory[src]

impl<'a> Parse<'a> for module[src]

impl<'a> Parse<'a> for modulecode[src]

impl<'a> Parse<'a> for mut[src]

impl<'a> Parse<'a> for nan_arithmetic[src]

impl<'a> Parse<'a> for nan_canonical[src]

impl<'a> Parse<'a> for null[src]

impl<'a> Parse<'a> for nullref[src]

impl<'a> Parse<'a> for offset[src]

impl<'a> Parse<'a> for param[src]

impl<'a> Parse<'a> for parent[src]

impl<'a> Parse<'a> for passive[src]

impl<'a> Parse<'a> for quote[src]

impl<'a> Parse<'a> for ref[src]

impl<'a> Parse<'a> for ref_func[src]

impl<'a> Parse<'a> for ref_null[src]

impl<'a> Parse<'a> for register[src]

impl<'a> Parse<'a> for result[src]

impl<'a> Parse<'a> for rtt[src]

impl<'a> Parse<'a> for shared[src]

impl<'a> Parse<'a> for start[src]

impl<'a> Parse<'a> for struct[src]

impl<'a> Parse<'a> for table[src]

impl<'a> Parse<'a> for then[src]

impl<'a> Parse<'a> for try[src]

impl<'a> Parse<'a> for type[src]

impl<'a> Parse<'a> for v128[src]

impl<'a> Parse<'a> for Alias<'a>[src]

impl<'a> Parse<'a> for ArrayType<'a>[src]

impl<'a> Parse<'a> for BlockType<'a>[src]

impl<'a> Parse<'a> for BrOnCast<'a>[src]

impl<'a> Parse<'a> for BrOnExn<'a>[src]

impl<'a> Parse<'a> for BrTableIndices<'a>[src]

impl<'a> Parse<'a> for CallIndirect<'a>[src]

impl<'a> Parse<'a> for Custom<'a>[src]

impl<'a> Parse<'a> for Data<'a>[src]

impl<'a> Parse<'a> for Elem<'a>[src]

impl<'a> Parse<'a> for Event<'a>[src]

impl<'a> Parse<'a> for Export<'a>[src]

impl<'a> Parse<'a> for ExportType<'a>[src]

impl<'a> Parse<'a> for Expression<'a>[src]

impl<'a> Parse<'a> for Float32[src]

impl<'a> Parse<'a> for Float64[src]

impl<'a> Parse<'a> for Func<'a>[src]

impl<'a> Parse<'a> for FuncBindType<'a>[src]

impl<'a> Parse<'a> for FunctionType<'a>[src]

impl<'a> Parse<'a> for FunctionTypeNoNames<'a>[src]

impl<'a> Parse<'a> for Global<'a>[src]

impl<'a> Parse<'a> for GlobalType<'a>[src]

impl<'a> Parse<'a> for I8x16Shuffle[src]

impl<'a> Parse<'a> for Id<'a>[src]

impl<'a> Parse<'a> for Import<'a>[src]

impl<'a> Parse<'a> for InlineExport<'a>[src]

impl<'a> Parse<'a> for InlineImport<'a>[src]

impl<'a> Parse<'a> for Instance<'a>[src]

impl<'a> Parse<'a> for InstanceType<'a>[src]

impl<'a> Parse<'a> for ItemSig<'a>[src]

impl<'a> Parse<'a> for LaneArg[src]

impl<'a> Parse<'a> for LetType<'a>[src]

impl<'a> Parse<'a> for Limits64[src]

impl<'a> Parse<'a> for Limits[src]

impl<'a> Parse<'a> for Memory<'a>[src]

impl<'a> Parse<'a> for MemoryArg<'a>[src]

impl<'a> Parse<'a> for MemoryCopy<'a>[src]

impl<'a> Parse<'a> for MemoryInit<'a>[src]

impl<'a> Parse<'a> for Module<'a>[src]

impl<'a> Parse<'a> for ModuleType<'a>[src]

impl<'a> Parse<'a> for NameAnnotation<'a>[src]

impl<'a> Parse<'a> for NestedModule<'a>[src]

impl<'a> Parse<'a> for RTTSub<'a>[src]

impl<'a> Parse<'a> for RefTest<'a>[src]

impl<'a> Parse<'a> for RefType<'a>[src]

impl<'a> Parse<'a> for SelectTypes<'a>[src]

impl<'a> Parse<'a> for StructAccess<'a>[src]

impl<'a> Parse<'a> for StructNarrow<'a>[src]

impl<'a> Parse<'a> for StructType<'a>[src]

impl<'a> Parse<'a> for Table<'a>[src]

impl<'a> Parse<'a> for TableArg<'a>[src]

impl<'a> Parse<'a> for TableCopy<'a>[src]

impl<'a> Parse<'a> for TableInit<'a>[src]

impl<'a> Parse<'a> for TableType<'a>[src]

impl<'a> Parse<'a> for Type<'a>[src]

impl<'a> Parse<'a> for Wast<'a>[src]

impl<'a> Parse<'a> for WastInvoke<'a>[src]

impl<'a> Parse<'a> for Wat<'a>[src]

impl<'a, T> Parse<'a> for NanPattern<T> where
    T: Parse<'a>, [src]

impl<'a, T: Peek + Parse<'a>> Parse<'a> for TypeUse<'a, T>[src]

Loading content...