Struct TokenAndSpan 

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

Available on crate features __ecma and __parser only.

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

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: 40 bytes