Enum Token

pub enum Token {
    Word(Word),
    Arrow,
    Hash,
    At,
    Dot,
    DotDotDot,
    Bang,
    LParen,
    RParen,
    LBracket,
    RBracket,
    LBrace,
    RBrace,
    Semi,
    Comma,
    BackQuote,
    Template {
        raw: Atom,
        cooked: Result<Atom, Error>,
    },
    Colon,
    BinOp(BinOpToken),
    AssignOp(AssignOp),
    DollarLBrace,
    QuestionMark,
    PlusPlus,
    MinusMinus,
    Tilde,
    Str {
        value: Atom,
        raw: Atom,
    },
    Regex(Atom, Atom),
    Num {
        value: f64,
        raw: Atom,
    },
    BigInt {
        value: Box<BigInt>,
        raw: Atom,
    },
    JSXName {
        name: Atom,
    },
    JSXText {
        value: Atom,
        raw: Atom,
    },
    JSXTagStart,
    JSXTagEnd,
    Shebang(Atom),
    Error(Error),
    Eof,
}

Variants

Word(Word)

Identifier, “null”, “true”, “false”.

Contains null and ``

Arrow

‘=>’

Hash

‘#’

At

‘@’

Dot

‘.’

DotDotDot

‘…’

Bang

‘!’

LParen

‘(’

RParen

‘)’

LBracket

[

RBracket

‘]’

LBrace

‘{’

RBrace

‘}’

Semi

‘;’

Comma

‘,’

BackQuote

‘`’

Template

Fields

raw: Atom

cooked: Result<Atom, Error>

Colon

‘:’

BinOp(BinOpToken)

AssignOp(AssignOp)

DollarLBrace

‘${’

QuestionMark

‘?’

PlusPlus

++

MinusMinus

--

Tilde

~

Str

String literal. Span of this token contains quote.

Fields

value: Atom

raw: Atom

Regex(Atom, Atom)

Regexp literal.

Num

TODO: Make Num as enum and separate decimal, binary, ..etc

Fields

value: f64

raw: Atom

BigInt

Fields

value: Box<BigInt>

raw: Atom

JSXName

Fields

name: Atom

JSXText

Fields

value: Atom

raw: Atom

JSXTagStart

JSXTagEnd

Shebang(Atom)

Error(Error)

Eof

Implementations

impl Token

pub fn kind(&self) -> TokenKind

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

This method is called only in the case of parsing failure.

impl PartialEq for Token

fn eq(&self, other: &Token) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, I> TokenFactory<'a, TokenAndSpan, I> for Token

where I: Tokens<TokenAndSpan>,

const ABSTRACT: Token

const ACCESSOR: Token

const ANY: Token

const ARROW: Token = Self::Arrow

const AS: Token

const ASSERT: Token

const ASSERTS: Token

const ASYNC: Token

const AT: Token = Self::At

const AWAIT: Token

const BACKQUOTE: Token = Self::BackQuote

const BANG: Token = Self::Bang

const BIGINT: Token

const BIT_AND: Token

const BIT_AND_EQ: Token

const BIT_OR: Token

const BIT_OR_EQ: Token

const BOOLEAN: Token

const BREAK: Token

const CASE: Token

const CATCH: Token

const CLASS: Token

const COLON: Token = Self::Colon

const COMMA: Token = Self::Comma

const CONST: Token

const CONTINUE: Token

const DEBUGGER: Token

const DECLARE: Token

const DEFAULT: Token

const DELETE: Token

const DIV: Token

const DIV_EQ: Token

const DO: Token

const DOLLAR_LBRACE: Token = Self::DollarLBrace

const DOT: Token = Self::Dot

const DOTDOTDOT: Token = Self::DotDotDot

const ELSE: Token

const ENUM: Token

const EOF: Token = Token::Eof

const EQUAL: Token

const EXP: Token

const EXPORT: Token

const EXP_EQ: Token

const EXTENDS: Token

const FALSE: Token

const FINALLY: Token

const FOR: Token

const FROM: Token

const FUNCTION: Token

const GET: Token

const GLOBAL: Token

const GREATER: Token

const GREATER_EQ: Token

const HASH: Token = Self::Hash

const IF: Token

const IMPLEMENTS: Token

const IMPORT: Token

const IN: Token

const INFER: Token

const INSTANCEOF: Token

const INTERFACE: Token

const INTRINSIC: Token

const IS: Token

const JSX_TAG_END: Token = Self::JSXTagEnd

const JSX_TAG_START: Token = Self::JSXTagStart

const KEYOF: Token

const LBRACE: Token = Self::LBrace

const LBRACKET: Token = Self::LBracket

const LESS: Token

const LESS_EQ: Token

const LET: Token

const LOGICAL_AND: Token

const LOGICAL_AND_EQ: Token

const LOGICAL_OR: Token

const LOGICAL_OR_EQ: Token

const LPAREN: Token = Self::LParen

const LSHIFT: Token

const LSHIFT_EQ: Token

const MINUS: Token

const MINUS_MINUS: Token = Self::MinusMinus

const MOD: Token

const MOD_EQ: Token

const MUL: Token

const MUL_EQ: Token

const NAMESPACE: Token

const NEVER: Token

const NEW: Token

const NULL: Token

const NULLISH_ASSIGN: Token

const NULLISH_COALESCING: Token

const NUMBER: Token

const OBJECT: Token

const OF: Token

const PACKAGE: Token

const PLUS: Token

const PLUS_PLUS: Token = Self::PlusPlus

const PRIVATE: Token

const PROTECTED: Token

const PUBLIC: Token

const QUESTION: Token = Token::QuestionMark

const RBRACE: Token = Self::RBrace

const RBRACKET: Token = Self::RBracket

const READONLY: Token

const REQUIRE: Token

const RETURN: Token

const RPAREN: Token = Self::RParen

const RSHIFT: Token

const RSHIFT_EQ: Token

const SATISFIES: Token

const SEMI: Token = Self::Semi

const SET: Token

const STATIC: Token

const STRING: Token

const SUPER: Token

const SWITCH: Token

const SYMBOL: Token

const TARGET: Token

const THIS: Token

const THROW: Token

const TILDE: Token = Self::Tilde

const TRUE: Token

const TRY: Token

const TYPE: Token

const TYPEOF: Token

const UNDEFINED: Token

const UNIQUE: Token

const UNKNOWN: Token

const USING: Token

const VAR: Token

const VOID: Token

const WHILE: Token

const WITH: Token

const YIELD: Token

const ZERO_FILL_RSHIFT: Token

const ZERO_FILL_RSHIFT_EQ: Token

type Buffer = Buffer<I>

type Lexer = Lexer<'a>

fn jsx_name(name: &'a str, lexer: &mut Lexer<'a>) -> Token

fn is_jsx_name(&self) -> bool

fn take_jsx_name( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> Atom

fn str(value: Atom, raw: Atom, _: &mut Lexer<'a>) -> Token

fn template(cooked: Result<Atom, Error>, raw: Atom, _: &mut Lexer<'a>) -> Token

fn regexp(content: Atom, flags: Atom, _: &mut Lexer<'a>) -> Token

fn num(value: f64, raw: Atom, _: &mut Lexer<'a>) -> Token

fn bigint(value: Box<BigInt>, raw: Atom, _: &mut Lexer<'a>) -> Token

fn unknown_ident(value: Atom, _: &mut Lexer<'a>) -> Token

fn is_word(&self) -> bool

fn is_reserved(&self, ctx: Context) -> bool

fn into_atom(self, _: &mut Lexer<'a>) -> Option<Atom>

fn is_error(&self) -> bool

fn take_error( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> Error

fn is_str(&self) -> bool

fn is_str_raw_content( &self, content: &str, _: &<Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> bool

fn take_str( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> (Atom, Atom)

fn is_num(&self) -> bool

fn take_num( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> (f64, Atom)

fn is_bigint(&self) -> bool

fn take_bigint( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> (Box<BigInt>, Atom)

fn take_word( self, _: &<Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> Option<Atom>

fn is_unknown_ident(&self) -> bool

fn take_unknown_ident( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> Atom

fn take_unknown_ident_ref<'b>( &'b self, _: &'b <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> &'b Atom

fn is_keyword(&self) -> bool

fn is_known_ident(&self) -> bool

fn take_known_ident(&self) -> Atom

fn is_regexp(&self) -> bool

fn is_template(&self) -> bool

fn take_template( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> (Result<Atom, Error>, Atom)

fn jsx_text( value: Atom, raw: Atom, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Lexer, ) -> Token

fn is_jsx_text(&self) -> bool

fn take_jsx_text( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> (Atom, Atom)

fn starts_expr(&self) -> bool

fn to_string( &self, _: &<Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> String

fn is_bin_op(&self) -> bool

fn as_assign_op(&self) -> Option<AssignOp>

fn as_bin_op(&self) -> Option<BinaryOp>

fn follows_keyword_let(&self) -> bool

fn is_assign_op(&self) -> bool

fn take_regexp( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> (Atom, Atom)

fn shebang( value: Atom, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Lexer, ) -> Token

fn is_shebang(&self) -> bool

fn take_shebang( self, _: &mut <Token as TokenFactory<'a, TokenAndSpan, I>>::Buffer, ) -> Atom

fn is_no_substitution_template_literal(&self) -> bool

fn is_template_head(&self) -> bool

fn is_less(&self) -> bool

fn is_less_eq(&self) -> bool

fn is_greater(&self) -> bool

fn is_colon(&self) -> bool

fn is_comma(&self) -> bool

fn is_equal(&self) -> bool

fn is_question(&self) -> bool

fn is_null(&self) -> bool

fn is_lshift(&self) -> bool

fn is_rshift(&self) -> bool

fn is_rshift_eq(&self) -> bool

fn is_greater_eq(&self) -> bool

fn is_true(&self) -> bool

fn is_false(&self) -> bool

fn is_enum(&self) -> bool

fn is_yield(&self) -> bool

fn is_let(&self) -> bool

fn is_var(&self) -> bool

fn is_static(&self) -> bool

fn is_extends(&self) -> bool

fn is_implements(&self) -> bool

fn is_interface(&self) -> bool

fn is_type(&self) -> bool

fn is_package(&self) -> bool

fn is_private(&self) -> bool

fn is_protected(&self) -> bool

fn is_public(&self) -> bool

fn is_readonly(&self) -> bool

fn is_await(&self) -> bool

fn is_break(&self) -> bool

fn is_continue(&self) -> bool

fn is_arrow(&self) -> bool

fn is_this(&self) -> bool

fn is_super(&self) -> bool

fn is_using(&self) -> bool

fn is_backquote(&self) -> bool

fn is_lparen(&self) -> bool

fn is_rparen(&self) -> bool

fn is_lbracket(&self) -> bool

fn is_rbracket(&self) -> bool

fn is_lbrace(&self) -> bool

fn is_rbrace(&self) -> bool

fn is_function(&self) -> bool

fn is_class(&self) -> bool

fn is_if(&self) -> bool

fn is_return(&self) -> bool

fn is_switch(&self) -> bool

fn is_throw(&self) -> bool

fn is_catch(&self) -> bool

fn is_finally(&self) -> bool

fn is_try(&self) -> bool

fn is_with(&self) -> bool

fn is_while(&self) -> bool

fn is_new(&self) -> bool

fn is_ident_ref(&self, ctx: Context) -> bool

fn is_import(&self) -> bool

fn is_export(&self) -> bool

fn is_dot(&self) -> bool

fn is_do(&self) -> bool

fn is_for(&self) -> bool

fn is_from(&self) -> bool

fn is_dotdotdot(&self) -> bool

fn is_plus(&self) -> bool

fn is_minus(&self) -> bool

fn is_bang(&self) -> bool

fn is_tilde(&self) -> bool

fn is_plus_plus(&self) -> bool

fn is_minus_minus(&self) -> bool

fn is_delete(&self) -> bool

fn is_typeof(&self) -> bool

fn is_of(&self) -> bool

fn is_void(&self) -> bool

fn is_hash(&self) -> bool

fn is_in(&self) -> bool

fn is_const(&self) -> bool

fn is_star(&self) -> bool

fn is_mod(&self) -> bool

fn is_semi(&self) -> bool

fn is_slash(&self) -> bool

fn is_slash_eq(&self) -> bool

fn is_jsx_tag_start(&self) -> bool

fn is_jsx_tag_end(&self) -> bool

fn is_asserts(&self) -> bool

fn is_is(&self) -> bool

fn is_as(&self) -> bool

fn is_satisfies(&self) -> bool

fn is_instanceof(&self) -> bool

fn is_async(&self) -> bool

fn is_case(&self) -> bool

fn is_default(&self) -> bool

fn is_debugger(&self) -> bool

fn is_bit_and(&self) -> bool

fn is_bit_or(&self) -> bool

fn is_exp(&self) -> bool

fn is_eof(&self) -> bool

impl StructuralPartialEq for Token