Enum wast::lexer::Token

pub enum Token<'a> {
    LineComment(&'a str),
    BlockComment(&'a str),
    Whitespace(&'a str),
    LParen(&'a str),
    RParen(&'a str),
    String(WasmString<'a>),
    Id(&'a str),
    Keyword(&'a str),
    Reserved(&'a str),
    Integer(Integer<'a>),
    Float(Float<'a>),
}

A fragment of source lex’d from an input string.

This enumeration contains all kinds of fragments, including comments and whitespace. For most cases you’ll probably ignore these and simply look at tokens.

Variants

LineComment(&'a str)

A line comment, preceded with ;;

BlockComment(&'a str)

A block comment, surrounded by (; and ;). Note that these can be nested.

Whitespace(&'a str)

A fragment of source that represents whitespace.

LParen(&'a str)

A left-parenthesis, including the source text for where it comes from.

RParen(&'a str)

A right-parenthesis, including the source text for where it comes from.

String(WasmString<'a>)

A string literal, which is actually a list of bytes.

Id(&'a str)

An identifier (like $foo).

All identifiers start with $ and the payload here is the original source text.

Keyword(&'a str)

A keyword, or something that starts with an alphabetic character.

The payload here is the original source text.

Reserved(&'a str)

A reserved series of idchar symbols. Unknown what this is meant to be used for, you’ll probably generate an error about an unexpected token.

Integer(Integer<'a>)

An integer.

Float(Float<'a>)

A float.

Implementations

impl<'a> Token<'a>

pub fn src(&self) -> &'a str

Returns the original source text for this token.

Trait Implementations

impl<'a> Debug for Token<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<Token<'a>> for Token<'a>

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