Struct TokenAndSpan

pub struct TokenAndSpan {
    pub token: Token,
    pub had_line_break: bool,
    pub span: Span,
}

Fields

token: Token

had_line_break: bool

Had a line break before this token?

span: Span

Trait Implementations

impl Clone for TokenAndSpan

fn clone(&self) -> TokenAndSpan

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TokenAndSpan

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

Formats the value using the given formatter.

impl NextTokenAndSpan for TokenAndSpan

type Token = Token

fn token(&self) -> &<TokenAndSpan as NextTokenAndSpan>::Token

fn span(&self) -> Span

fn had_line_break(&self) -> bool

impl PartialEq for TokenAndSpan

fn eq(&self, other: &TokenAndSpan) -> 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 Spanned for TokenAndSpan

fn span(&self) -> Span

Get span of self.

fn span_lo(&self) -> BytePos

fn span_hi(&self) -> BytePos

impl TokenAndSpan for TokenAndSpan

type Token = Token

fn new(token: Token, span: Span, had_line_break: bool) -> TokenAndSpan

fn token(&self) -> &Token

fn take_token(self) -> Token

fn had_line_break(&self) -> bool

fn span(&self) -> Span

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 TokenAndSpan