Enum Token

#[repr(u8)]
pub enum Token {
    LParen = 0,
    RParen = 1,
    LBrace = 2,
    RBrace = 3,
    LBracket = 4,
    RBracket = 5,
    Semi = 6,
    Comma = 7,
    Dot = 8,
    Colon = 9,
    QuestionMark = 10,
    Bang = 11,
    Tilde = 12,
    Plus = 13,
    Minus = 14,
    Asterisk = 15,
    Slash = 16,
    Percent = 17,
    Lt = 18,
    Gt = 19,
    Pipe = 20,
    Caret = 21,
    Ampersand = 22,
    Eq = 23,
    At = 24,
    Hash = 25,
    BackQuote = 26,
    Arrow = 27,
    DotDotDot = 28,
    PlusPlus = 29,
    MinusMinus = 30,
    PlusEq = 31,
    MinusEq = 32,
    MulEq = 33,
    DivEq = 34,
    ModEq = 35,
    LShiftEq = 36,
    RShiftEq = 37,
    ZeroFillRShiftEq = 38,
    BitOrEq = 39,
    BitXorEq = 40,
    BitAndEq = 41,
    ExpEq = 42,
    LogicalOrEq = 43,
    LogicalAndEq = 44,
    NullishEq = 45,
    OptionalChain = 46,
    EqEq = 47,
    NotEq = 48,
    EqEqEq = 49,
    NotEqEq = 50,
    LtEq = 51,
    GtEq = 52,
    LShift = 53,
    RShift = 54,
    ZeroFillRShift = 55,
    Exp = 56,
    LogicalOr = 57,
    LogicalAnd = 58,
    NullishCoalescing = 59,
    LessSlash = 60,
    DollarLBrace = 61,
    JSXTagStart = 62,
    JSXTagEnd = 63,
    Str = 64,
    Num = 65,
    BigInt = 66,
    Regex = 67,
    Template = 68,
    NoSubstitutionTemplateLiteral = 69,
    TemplateHead = 70,
    TemplateMiddle = 71,
    TemplateTail = 72,
    JSXName = 73,
    JSXText = 74,
    Ident = 75,
    Await = 76,
    Break = 77,
    Case = 78,
    Catch = 79,
    Class = 80,
    Const = 81,
    Continue = 82,
    Debugger = 83,
    Default = 84,
    Delete = 85,
    Do = 86,
    Else = 87,
    Export = 88,
    Extends = 89,
    False = 90,
    Finally = 91,
    For = 92,
    Function = 93,
    If = 94,
    Import = 95,
    In = 96,
    InstanceOf = 97,
    Let = 98,
    New = 99,
    Null = 100,
    Return = 101,
    Super = 102,
    Switch = 103,
    This = 104,
    Throw = 105,
    True = 106,
    Try = 107,
    TypeOf = 108,
    Var = 109,
    Void = 110,
    While = 111,
    With = 112,
    Yield = 113,
    Module = 114,
    Abstract = 115,
    Any = 116,
    As = 117,
    Asserts = 118,
    Assert = 119,
    Async = 120,
    Bigint = 121,
    Boolean = 122,
    Constructor = 123,
    Declare = 124,
    Enum = 125,
    From = 126,
    Get = 127,
    Global = 128,
    Implements = 129,
    Interface = 130,
    Intrinsic = 131,
    Is = 132,
    Keyof = 133,
    Namespace = 134,
    Never = 135,
    Number = 136,
    Object = 137,
    Of = 138,
    Out = 139,
    Override = 140,
    Package = 141,
    Private = 142,
    Protected = 143,
    Public = 144,
    Readonly = 145,
    Require = 146,
    Set = 147,
    Static = 148,
    String = 149,
    Symbol = 150,
    Type = 151,
    Undefined = 152,
    Unique = 153,
    Unknown = 154,
    Using = 155,
    Accessor = 156,
    Infer = 157,
    Satisfies = 158,
    Meta = 159,
    Target = 160,
    Shebang = 161,
    Error = 162,
    Eof = 163,
}

Variants

LParen = 0

(

RParen = 1

)

LBrace = 2

{

RBrace = 3

}

LBracket = 4

[

RBracket = 5

]

Semi = 6

;

Comma = 7

,

Dot = 8

.

Colon = 9

:

QuestionMark = 10

?

Bang = 11

!

Tilde = 12

~

Plus = 13

+

Minus = 14

-

Asterisk = 15

*

Slash = 16

/

Percent = 17

%

Lt = 18

<

Gt = 19

>

Pipe = 20

|

Caret = 21

^

Ampersand = 22

&

Eq = 23

=

At = 24

@

Hash = 25

#

BackQuote = 26

‘`’

Arrow = 27

=>

DotDotDot = 28

...

PlusPlus = 29

++

MinusMinus = 30

--

PlusEq = 31

+=

MinusEq = 32

-=

MulEq = 33

*=

DivEq = 34

/=

ModEq = 35

%=

LShiftEq = 36

<<=

RShiftEq = 37

>>=

ZeroFillRShiftEq = 38

>>>=

BitOrEq = 39

|=

BitXorEq = 40

^=

BitAndEq = 41

&=

ExpEq = 42

**=

LogicalOrEq = 43

||=

LogicalAndEq = 44

&&=

NullishEq = 45

??=

OptionalChain = 46

?.

EqEq = 47

==

NotEq = 48

!=

EqEqEq = 49

===

NotEqEq = 50

!==

LtEq = 51

<=

GtEq = 52

>=

LShift = 53

<<

RShift = 54

>>

ZeroFillRShift = 55

>>>

Exp = 56

**

LogicalOr = 57

||

LogicalAnd = 58

&&

NullishCoalescing = 59

??

LessSlash = 60

</

DollarLBrace = 61

${

JSXTagStart = 62

JSXTagEnd = 63

Str = 64

Num = 65

BigInt = 66

Regex = 67

Template = 68

NoSubstitutionTemplateLiteral = 69

TemplateHead = 70

TemplateMiddle = 71

TemplateTail = 72

JSXName = 73

JSXText = 74

Ident = 75

Await = 76

Break = 77

Case = 78

Catch = 79

Class = 80

Const = 81

Continue = 82

Debugger = 83

Default = 84

Delete = 85

Do = 86

Else = 87

Export = 88

Extends = 89

False = 90

Finally = 91

For = 92

Function = 93

If = 94

Import = 95

In = 96

InstanceOf = 97

Let = 98

New = 99

Null = 100

Return = 101

Super = 102

Switch = 103

This = 104

Throw = 105

True = 106

Try = 107

TypeOf = 108

Var = 109

Void = 110

While = 111

With = 112

Yield = 113

Module = 114

Abstract = 115

Any = 116

As = 117

Asserts = 118

Assert = 119

Async = 120

Bigint = 121

Boolean = 122

Constructor = 123

Declare = 124

Enum = 125

From = 126

Get = 127

Global = 128

Implements = 129

Interface = 130

Intrinsic = 131

Is = 132

Keyof = 133

Namespace = 134

Never = 135

Number = 136

Object = 137

Of = 138

Out = 139

Override = 140

Package = 141

Private = 142

Protected = 143

Public = 144

Readonly = 145

Require = 146

Set = 147

Static = 148

String = 149

Symbol = 150

Type = 151

Undefined = 152

Unique = 153

Unknown = 154

Using = 155

Accessor = 156

Infer = 157

Satisfies = 158

Meta = 159

Target = 160

Shebang = 161

Error = 162

Eof = 163

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

Formats the value using the given formatter.

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

const ABSTRACT: Self = Token::Abstract

const ACCESSOR: Self = Token::Accessor

const ANY: Self = Token::Any

const ARROW: Self = Token::Arrow

const AS: Self = Token::As

const ASSERT: Self = Token::Assert

const ASSERTS: Self = Token::Asserts

const ASYNC: Self = Token::Async

const AT: Self = Token::At

const AWAIT: Self = Token::Await

const BACKQUOTE: Self = Token::BackQuote

const BANG: Self = Self::Bang

const BIGINT: Self = Token::Bigint

const BIT_AND: Self = Self::Ampersand

const BIT_AND_EQ: Self = Self::BitAndEq

const BIT_OR: Self = Self::Pipe

const BIT_OR_EQ: Self = Self::BitOrEq

const BOOLEAN: Self = Token::Boolean

const BREAK: Self = Token::Break

const CASE: Self = Token::Case

const CATCH: Self = Token::Catch

const CLASS: Self = Self::Class

const COLON: Self = Self::Colon

const COMMA: Self = Token::Comma

const CONST: Self = Self::Const

const CONTINUE: Self = Token::Continue

const DEBUGGER: Self = Token::Debugger

const DECLARE: Self = Token::Declare

const DEFAULT: Self = Token::Default

const DELETE: Self = Self::Delete

const DIV: Self = Token::Slash

const DIV_EQ: Self = Token::DivEq

const DO: Self = Token::Do

const DOLLAR_LBRACE: Self = Token::DollarLBrace

const DOT: Self = Self::Dot

const DOTDOTDOT: Self = Self::DotDotDot

const ELSE: Self = Self::Else

const ENUM: Self = Token::Enum

const EOF: Self = Token::Eof

const EQUAL: Self = Token::Eq

const EXP: Self = Token::Exp

const EXPORT: Self = Token::Export

const EXP_EQ: Self = Token::ExpEq

const EXTENDS: Self = Token::Extends

const FALSE: Self = Token::False

const FINALLY: Self = Token::Finally

const FOR: Self = Token::For

const FROM: Self = Token::From

const FUNCTION: Self = Self::Function

const GET: Self = Token::Get

const GLOBAL: Self = Token::Global

const GREATER: Self = Token::Gt

const GREATER_EQ: Self = Token::GtEq

const HASH: Self = Self::Hash

const IF: Self = Self::If

const IMPLEMENTS: Self = Token::Implements

const IMPORT: Self = Self::Import

const IN: Self = Self::In

const INFER: Self = Token::Infer

const INSTANCEOF: Self = Token::InstanceOf

const INTERFACE: Self = Token::Interface

const INTRINSIC: Self = Token::Intrinsic

const IS: Self = Token::Is

const JSX_TAG_END: Self = Token::JSXTagEnd

const JSX_TAG_START: Self = Token::JSXTagStart

const KEYOF: Self = Token::Keyof

const LBRACE: Self = Self::LBrace

const LBRACKET: Self = Self::LBracket

const LESS: Self = Token::Lt

const LESS_EQ: Self = Token::LtEq

const LET: Self = Token::Let

const LOGICAL_AND: Self = Token::LogicalAnd

const LOGICAL_AND_EQ: Self = Self::LogicalAndEq

const LOGICAL_OR: Self = Token::LogicalOr

const LOGICAL_OR_EQ: Self = Self::LogicalOrEq

const LPAREN: Self = Self::LParen

const LSHIFT: Self = Token::LShift

const LSHIFT_EQ: Self = Token::LShiftEq

const MINUS: Self = Self::Minus

const MINUS_MINUS: Self = Self::MinusMinus

const MOD: Self = Token::Percent

const MOD_EQ: Self = Token::ModEq

const MUL: Self = Token::Asterisk

const MUL_EQ: Self = Token::MulEq

const NAMESPACE: Self = Token::Namespace

const NEVER: Self = Token::Never

const NEW: Self = Self::New

const NULL: Self = Token::Null

const NULLISH_ASSIGN: Self = Token::NullishEq

const NULLISH_COALESCING: Self = Token::NullishCoalescing

const NUMBER: Self = Token::Number

const OBJECT: Self = Token::Object

const OF: Self = Token::Of

const PACKAGE: Self = Token::Package

const PLUS: Self = Self::Plus

const PLUS_PLUS: Self = Self::PlusPlus

const PRIVATE: Self = Token::Private

const PROTECTED: Self = Token::Protected

const PUBLIC: Self = Token::Public

const QUESTION: Self = Token::QuestionMark

const RBRACE: Self = Self::RBrace

const RBRACKET: Self = Self::RBracket

const READONLY: Self = Token::Readonly

const REQUIRE: Self = Token::Require

const RETURN: Self = Token::Return

const RPAREN: Self = Self::RParen

const RSHIFT: Self = Token::RShift

const RSHIFT_EQ: Self = Token::RShiftEq

const SATISFIES: Self = Token::Satisfies

const SEMI: Self = Token::Semi

const SET: Self = Token::Set

const STATIC: Self = Token::Static

const STRING: Self = Token::String

const SUPER: Self = Self::Super

const SWITCH: Self = Token::Switch

const SYMBOL: Self = Token::Symbol

const TARGET: Self = Token::Target

const THIS: Self = Token::This

const THROW: Self = Token::Throw

const TILDE: Self = Self::Tilde

const TRUE: Self = Token::True

const TRY: Self = Token::Try

const TYPE: Self = Token::Type

const TYPEOF: Self = Self::TypeOf

const UNDEFINED: Self = Token::Undefined

const UNIQUE: Self = Token::Unique

const UNKNOWN: Self = Token::Unknown

const USING: Self = Self::Using

const VAR: Self = Self::Var

const VOID: Self = Self::Void

const WHILE: Self = Token::While

const WITH: Self = Token::With

const YIELD: Self = Token::Yield

const ZERO_FILL_RSHIFT: Self = Token::ZeroFillRShift

const ZERO_FILL_RSHIFT_EQ: Self = Token::ZeroFillRShiftEq

type Buffer = Buffer<I>

type Lexer = Lexer<'a>

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

fn is_jsx_name(&self) -> bool

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

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

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

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

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

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

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

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

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

fn is_error(&self) -> bool

fn take_error(self, buffer: &mut Self::Buffer) -> Error

fn is_str(&self) -> bool

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

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

fn is_num(&self) -> bool

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

fn is_bigint(&self) -> bool

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

fn is_word(&self) -> bool

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

fn is_unknown_ident(&self) -> bool

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

fn is_keyword(&self) -> bool

fn is_known_ident(&self) -> bool

fn take_known_ident(&self) -> Atom

fn is_regexp(&self) -> bool

fn take_unknown_ident_ref<'b>(&'b self, buffer: &'b Self::Buffer) -> &'b Atom

fn is_template(&self) -> bool

fn take_template(self, buffer: &mut Self::Buffer) -> (LexResult<Atom>, Atom)

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

fn is_jsx_text(&self) -> bool

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

fn starts_expr(&self) -> bool

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

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

fn is_shebang(&self) -> bool

fn take_shebang(self, buffer: &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 TokenKind for Token

fn is_dot(self) -> bool

fn is_bin_op(self) -> bool

fn is_semi(self) -> bool

fn is_template(self) -> bool

fn is_keyword(self) -> bool

fn is_colon(self) -> bool

fn is_lbrace(self) -> bool

fn is_rbrace(self) -> bool

fn is_lparen(self) -> bool

fn is_rparen(self) -> bool

fn is_keyword_fn(self) -> bool

fn is_keyword_return(self) -> bool

fn is_keyword_yield(self) -> bool

fn is_keyword_else(self) -> bool

fn is_keyword_class(self) -> bool

fn is_keyword_let(self) -> bool

fn is_keyword_var(self) -> bool

fn is_keyword_const(self) -> bool

fn is_keyword_if(self) -> bool

fn is_keyword_while(self) -> bool

fn is_keyword_for(self) -> bool

fn is_keyword_with(self) -> bool

fn is_lt(self) -> bool

fn is_gt(self) -> bool

fn is_arrow(self) -> bool

fn is_ident(self) -> bool

fn is_known_ident_of(self) -> bool

fn is_slash(self) -> bool

fn is_dollar_lbrace(self) -> bool

fn is_plus_plus(self) -> bool

fn is_minus_minus(self) -> bool

fn is_back_quote(self) -> bool

fn is_jsx_tag_start(self) -> bool

fn is_jsx_tag_end(self) -> bool

fn before_expr(self) -> bool

impl TokenType for Token

fn is_other_and_before_expr_is_false(self) -> bool

fn is_other_and_can_have_trailing_comment(self) -> bool

impl Copy for Token

impl Eq for Token

impl StructuralPartialEq for Token