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: LexResult<Atom>,
    },
    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: LexResult<Atom>

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 duplicate 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

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: Tokens<TokenAndSpan>> TokenFactory<'a, TokenAndSpan, I> for Token

const ABSTRACT: Self

const ACCESSOR: Self

const ANY: Self

const ARROW: Self = Self::Arrow

const AS: Self

const ASSERT: Self

const ASSERTS: Self

const ASYNC: Self

const AT: Self = Self::At

const AWAIT: Self

const BACKQUOTE: Self = Self::BackQuote

const BANG: Self = Self::Bang

const BIGINT: Self

const BIT_AND: Self

const BIT_AND_EQ: Self

const BIT_OR: Self

const BIT_OR_EQ: Self

const BOOLEAN: Self

const BREAK: Self

const CASE: Self

const CATCH: Self

const CLASS: Self

const COLON: Self = Self::Colon

const COMMA: Self = Self::Comma

const CONST: Self

const CONTINUE: Self

const DEBUGGER: Self

const DECLARE: Self

const DEFAULT: Self

const DELETE: Self

const DIV: Self

const DIV_EQ: Self

const DO: Self

const DOLLAR_LBRACE: Self = Self::DollarLBrace

const DOT: Self = Self::Dot

const DOTDOTDOT: Self = Self::DotDotDot

const ELSE: Self

const ENUM: Self

const EOF: Self = Token::Eof

const EQUAL: Self

const EXP: Self

const EXPORT: Self

const EXP_EQ: Self

const EXTENDS: Self

const FALSE: Self

const FINALLY: Self

const FOR: Self

const FROM: Self

const FUNCTION: Self

const GET: Self

const GLOBAL: Self

const GREATER: Self

const GREATER_EQ: Self

const HASH: Self = Self::Hash

const IF: Self

const IMPLEMENTS: Self

const IMPORT: Self

const IN: Self

const INFER: Self

const INSTANCEOF: Self

const INTERFACE: Self

const INTRINSIC: Self

const IS: Self

const JSX_TAG_END: Self = Self::JSXTagEnd

const JSX_TAG_START: Self = Self::JSXTagStart

const KEYOF: Self

const LBRACE: Self = Self::LBrace

const LBRACKET: Self = Self::LBracket

const LESS: Self

const LESS_EQ: Self

const LET: Self

const LOGICAL_AND: Self

const LOGICAL_AND_EQ: Self

const LOGICAL_OR: Self

const LOGICAL_OR_EQ: Self

const LPAREN: Self = Self::LParen

const LSHIFT: Self

const LSHIFT_EQ: Self

const MINUS: Self

const MINUS_MINUS: Self = Self::MinusMinus

const MOD: Self

const MOD_EQ: Self

const MUL: Self

const MUL_EQ: Self

const NAMESPACE: Self

const NEVER: Self

const NEW: Self

const NULL: Self

const NULLISH_ASSIGN: Self

const NULLISH_COALESCING: Self

const NUMBER: Self

const OBJECT: Self

const OF: Self

const PACKAGE: Self

const PLUS: Self

const PLUS_PLUS: Self = Self::PlusPlus

const PRIVATE: Self

const PROTECTED: Self

const PUBLIC: Self

const QUESTION: Self = Token::QuestionMark

const RBRACE: Self = Self::RBrace

const RBRACKET: Self = Self::RBracket

const READONLY: Self

const REQUIRE: Self

const RETURN: Self

const RPAREN: Self = Self::RParen

const RSHIFT: Self

const RSHIFT_EQ: Self

const SATISFIES: Self

const SEMI: Self = Self::Semi

const SET: Self

const STATIC: Self

const STRING: Self

const SUPER: Self

const SWITCH: Self

const SYMBOL: Self

const TARGET: Self

const THIS: Self

const THROW: Self

const TILDE: Self = Self::Tilde

const TRUE: Self

const TRY: Self

const TYPE: Self

const TYPEOF: Self

const UNDEFINED: Self

const UNIQUE: Self

const UNKNOWN: Self

const USING: Self

const VAR: Self

const VOID: Self

const WHILE: Self

const WITH: Self

const YIELD: Self

const ZERO_FILL_RSHIFT: Self

const ZERO_FILL_RSHIFT_EQ: Self

type Buffer = Buffer<I>

type Lexer = Lexer<'a>

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

fn is_jsx_name(&self) -> bool

fn take_jsx_name(self, _: &mut Self::Buffer) -> Atom

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

fn template(cooked: LexResult<Atom>, raw: Atom, _: &mut Lexer<'a>) -> Self

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

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

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

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

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 Self::Buffer) -> Error

fn is_str(&self) -> bool

fn is_str_raw_content(&self, content: &str, _: &Self::Buffer) -> bool

fn take_str(self, _: &mut Self::Buffer) -> (Atom, Atom)

fn is_num(&self) -> bool

fn take_num(self, _: &mut Self::Buffer) -> (f64, Atom)

fn is_bigint(&self) -> bool

fn take_bigint(self, _: &mut Self::Buffer) -> (Box<BigIntValue>, Atom)

fn take_word(self, _: &Self::Buffer) -> Option<Atom>

fn is_unknown_ident(&self) -> bool

fn take_unknown_ident(self, _: &mut Self::Buffer) -> Atom

fn take_unknown_ident_ref<'b>(&'b self, _: &'b Self::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 Self::Buffer) -> (LexResult<Atom>, Atom)

fn jsx_text(value: Atom, raw: Atom, _: &mut Self::Lexer) -> Self

fn is_jsx_text(&self) -> bool

fn take_jsx_text(self, _: &mut Self::Buffer) -> (Atom, Atom)

fn starts_expr(&self) -> bool

fn to_string(&self, _: &Self::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 Self::Buffer) -> (Atom, Atom)

fn shebang(value: Atom, _: &mut Self::Lexer) -> Self

fn is_shebang(&self) -> bool

fn take_shebang(self, _: &mut Self::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

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes

Size for each variant:

• Word: 24 bytes
• Arrow: 0 bytes
• Hash: 0 bytes
• At: 0 bytes
• Dot: 0 bytes
• DotDotDot: 0 bytes
• Bang: 0 bytes
• LParen: 0 bytes
• RParen: 0 bytes
• LBracket: 0 bytes
• RBracket: 0 bytes
• LBrace: 0 bytes
• RBrace: 0 bytes
• Semi: 0 bytes
• Comma: 0 bytes
• BackQuote: 0 bytes
• Template: 24 bytes
• Colon: 0 bytes
• BinOp: 9 bytes
• AssignOp: 9 bytes
• DollarLBrace: 0 bytes
• QuestionMark: 0 bytes
• PlusPlus: 0 bytes
• MinusMinus: 0 bytes
• Tilde: 0 bytes
• Str: 24 bytes
• Regex: 24 bytes
• Num: 24 bytes
• BigInt: 24 bytes
• JSXName: 16 bytes
• JSXText: 24 bytes
• JSXTagStart: 0 bytes
• JSXTagEnd: 0 bytes
• Shebang: 16 bytes
• Error: 16 bytes
• Eof: 0 bytes