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

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