4 pub use Nonterminal::*;
9 use crate::tokenstream::TokenTree;
11 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
12 use rustc_data_structures::sync::Lrc;
13 use rustc_macros::HashStable_Generic;
14 use rustc_span::symbol::{kw, sym};
15 use rustc_span::symbol::{Ident, Symbol};
16 use rustc_span::{self, edition::Edition, Span, DUMMY_SP};
20 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
21 pub enum CommentKind {
26 #[derive(Clone, PartialEq, Encodable, Decodable, Hash, Debug, Copy)]
27 #[derive(HashStable_Generic)]
41 /// A delimiter token.
42 #[derive(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Debug, Copy)]
43 #[derive(HashStable_Generic)]
45 /// A round parenthesis (i.e., `(` or `)`).
47 /// A square bracket (i.e., `[` or `]`).
49 /// A curly brace (i.e., `{` or `}`).
51 /// An empty delimiter.
55 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
57 Bool, // AST only, must never appear in a `Token`
63 StrRaw(u16), // raw string delimited by `n` hash symbols
65 ByteStrRaw(u16), // raw byte string delimited by `n` hash symbols
70 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
74 pub suffix: Option<Symbol>,
77 impl fmt::Display for Lit {
78 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
79 let Lit { kind, symbol, suffix } = *self;
81 Byte => write!(f, "b'{}'", symbol)?,
82 Char => write!(f, "'{}'", symbol)?,
83 Str => write!(f, "\"{}\"", symbol)?,
86 "r{delim}\"{string}\"{delim}",
87 delim = "#".repeat(n as usize),
90 ByteStr => write!(f, "b\"{}\"", symbol)?,
91 ByteStrRaw(n) => write!(
93 "br{delim}\"{string}\"{delim}",
94 delim = "#".repeat(n as usize),
97 Integer | Float | Bool | Err => write!(f, "{}", symbol)?,
100 if let Some(suffix) = suffix {
101 write!(f, "{}", suffix)?;
109 /// An English article for the literal token kind.
110 pub fn article(self) -> &'static str {
112 Integer | Err => "an",
117 pub fn descr(self) -> &'static str {
119 Bool => panic!("literal token contains `Lit::Bool`"),
122 Integer => "integer",
124 Str | StrRaw(..) => "string",
125 ByteStr | ByteStrRaw(..) => "byte string",
130 crate fn may_have_suffix(self) -> bool {
131 matches!(self, Integer | Float | Err)
136 pub fn new(kind: LitKind, symbol: Symbol, suffix: Option<Symbol>) -> Lit {
137 Lit { kind, symbol, suffix }
141 pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: bool) -> bool {
142 let ident_token = Token::new(Ident(name, is_raw), span);
144 !ident_token.is_reserved_ident()
145 || ident_token.is_path_segment_keyword()
171 fn ident_can_begin_type(name: Symbol, span: Span, is_raw: bool) -> bool {
172 let ident_token = Token::new(Ident(name, is_raw), span);
174 !ident_token.is_reserved_ident()
175 || ident_token.is_path_segment_keyword()
176 || [kw::Underscore, kw::For, kw::Impl, kw::Fn, kw::Unsafe, kw::Extern, kw::Typeof, kw::Dyn]
180 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
182 /* Expression-operator symbols. */
197 /* Structural symbols */
213 /// Used by proc macros for representing lifetimes, not generated by lexer right now.
215 /// An opening delimiter (e.g., `{`).
216 OpenDelim(DelimToken),
217 /// A closing delimiter (e.g., `}`).
218 CloseDelim(DelimToken),
223 /// Identifier token.
224 /// Do not forget about `NtIdent` when you want to match on identifiers.
225 /// It's recommended to use `Token::(ident,uninterpolate,uninterpolated_span)` to
226 /// treat regular and interpolated identifiers in the same way.
227 Ident(Symbol, /* is_raw */ bool),
228 /// Lifetime identifier token.
229 /// Do not forget about `NtLifetime` when you want to match on lifetime identifiers.
230 /// It's recommended to use `Token::(lifetime,uninterpolate,uninterpolated_span)` to
231 /// treat regular and interpolated lifetime identifiers in the same way.
234 Interpolated(Lrc<Nonterminal>),
236 /// A doc comment token.
237 /// `Symbol` is the doc comment's data excluding its "quotes" (`///`, `/**`, etc)
238 /// similarly to symbols in string literal tokens.
239 DocComment(CommentKind, ast::AttrStyle, Symbol),
244 // `TokenKind` is used a lot. Make sure it doesn't unintentionally get bigger.
245 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
246 rustc_data_structures::static_assert_size!(TokenKind, 16);
248 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
255 pub fn lit(kind: LitKind, symbol: Symbol, suffix: Option<Symbol>) -> TokenKind {
256 Literal(Lit::new(kind, symbol, suffix))
259 // An approximation to proc-macro-style single-character operators used by rustc parser.
260 // If the operator token can be broken into two tokens, the first of which is single-character,
261 // then this function performs that operation, otherwise it returns `None`.
262 pub fn break_two_token_op(&self) -> Option<(TokenKind, TokenKind)> {
268 AndAnd => (BinOp(And), BinOp(And)),
269 OrOr => (BinOp(Or), BinOp(Or)),
270 BinOp(Shl) => (Lt, Lt),
271 BinOp(Shr) => (Gt, Gt),
272 BinOpEq(Plus) => (BinOp(Plus), Eq),
273 BinOpEq(Minus) => (BinOp(Minus), Eq),
274 BinOpEq(Star) => (BinOp(Star), Eq),
275 BinOpEq(Slash) => (BinOp(Slash), Eq),
276 BinOpEq(Percent) => (BinOp(Percent), Eq),
277 BinOpEq(Caret) => (BinOp(Caret), Eq),
278 BinOpEq(And) => (BinOp(And), Eq),
279 BinOpEq(Or) => (BinOp(Or), Eq),
280 BinOpEq(Shl) => (Lt, Le),
281 BinOpEq(Shr) => (Gt, Ge),
282 DotDot => (Dot, Dot),
283 DotDotDot => (Dot, DotDot),
284 ModSep => (Colon, Colon),
285 RArrow => (BinOp(Minus), Gt),
286 LArrow => (Lt, BinOp(Minus)),
287 FatArrow => (Eq, Gt),
292 /// Returns tokens that are likely to be typed accidentally instead of the current token.
293 /// Enables better error recovery when the wrong token is found.
294 pub fn similar_tokens(&self) -> Option<Vec<TokenKind>> {
296 Comma => Some(vec![Dot, Lt, Semi]),
297 Semi => Some(vec![Colon, Comma]),
302 pub fn should_end_const_arg(&self) -> bool {
303 matches!(self, Gt | Ge | BinOp(Shr) | BinOpEq(Shr))
308 pub fn new(kind: TokenKind, span: Span) -> Self {
312 /// Some token that will be thrown away later.
313 pub fn dummy() -> Self {
314 Token::new(TokenKind::Question, DUMMY_SP)
317 /// Recovers a `Token` from an `Ident`. This creates a raw identifier if necessary.
318 pub fn from_ast_ident(ident: Ident) -> Self {
319 Token::new(Ident(ident.name, ident.is_raw_guess()), ident.span)
322 /// Return this token by value and leave a dummy token in its place.
323 pub fn take(&mut self) -> Self {
324 mem::replace(self, Token::dummy())
327 /// For interpolated tokens, returns a span of the fragment to which the interpolated
328 /// token refers. For all other tokens this is just a regular span.
329 /// It is particularly important to use this for identifiers and lifetimes
330 /// for which spans affect name resolution and edition checks.
331 /// Note that keywords are also identifiers, so they should use this
332 /// if they keep spans or perform edition checks.
333 pub fn uninterpolated_span(&self) -> Span {
335 Interpolated(nt) => nt.span(),
340 pub fn is_op(&self) -> bool {
354 pub fn is_like_plus(&self) -> bool {
355 matches!(self.kind, BinOp(Plus) | BinOpEq(Plus))
358 /// Returns `true` if the token can appear at the start of an expression.
359 pub fn can_begin_expr(&self) -> bool {
360 match self.uninterpolate().kind {
361 Ident(name, is_raw) =>
362 ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
363 OpenDelim(..) | // tuple, array or block
364 Literal(..) | // literal
365 Not | // operator not
366 BinOp(Minus) | // unary minus
367 BinOp(Star) | // dereference
368 BinOp(Or) | OrOr | // closure
369 BinOp(And) | // reference
370 AndAnd | // double reference
371 // DotDotDot is no longer supported, but we need some way to display the error
372 DotDot | DotDotDot | DotDotEq | // range notation
373 Lt | BinOp(Shl) | // associated path
374 ModSep | // global path
375 Lifetime(..) | // labeled loop
376 Pound => true, // expression attributes
377 Interpolated(ref nt) => matches!(**nt, NtLiteral(..) |
385 /// Returns `true` if the token can appear at the start of a type.
386 pub fn can_begin_type(&self) -> bool {
387 match self.uninterpolate().kind {
388 Ident(name, is_raw) =>
389 ident_can_begin_type(name, self.span, is_raw), // type name or keyword
390 OpenDelim(Paren) | // tuple
391 OpenDelim(Bracket) | // array
393 BinOp(Star) | // raw pointer
394 BinOp(And) | // reference
395 AndAnd | // double reference
396 Question | // maybe bound in trait object
397 Lifetime(..) | // lifetime bound in trait object
398 Lt | BinOp(Shl) | // associated path
399 ModSep => true, // global path
400 Interpolated(ref nt) => matches!(**nt, NtTy(..) | NtPath(..)),
405 /// Returns `true` if the token can appear at the start of a const param.
406 pub fn can_begin_const_arg(&self) -> bool {
408 OpenDelim(Brace) => true,
409 Interpolated(ref nt) => matches!(**nt, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
410 _ => self.can_begin_literal_maybe_minus(),
414 /// Returns `true` if the token can appear at the start of a generic bound.
415 pub fn can_begin_bound(&self) -> bool {
417 || self.is_lifetime()
418 || self.is_keyword(kw::For)
420 || self == &OpenDelim(Paren)
423 /// Returns `true` if the token is any literal.
424 pub fn is_lit(&self) -> bool {
425 matches!(self.kind, Literal(..))
428 /// Returns `true` if the token is any literal, a minus (which can prefix a literal,
429 /// for example a '-42', or one of the boolean idents).
431 /// In other words, would this token be a valid start of `parse_literal_maybe_minus`?
433 /// Keep this in sync with and `Lit::from_token`, excluding unary negation.
434 pub fn can_begin_literal_maybe_minus(&self) -> bool {
435 match self.uninterpolate().kind {
436 Literal(..) | BinOp(Minus) => true,
437 Ident(name, false) if name.is_bool_lit() => true,
438 Interpolated(ref nt) => match &**nt {
439 NtLiteral(_) => true,
440 NtExpr(e) => match &e.kind {
441 ast::ExprKind::Lit(_) => true,
442 ast::ExprKind::Unary(ast::UnOp::Neg, e) => {
443 matches!(&e.kind, ast::ExprKind::Lit(_))
453 // A convenience function for matching on identifiers during parsing.
454 // Turns interpolated identifier (`$i: ident`) or lifetime (`$l: lifetime`) token
455 // into the regular identifier or lifetime token it refers to,
456 // otherwise returns the original token.
457 pub fn uninterpolate(&self) -> Cow<'_, Token> {
459 Interpolated(nt) => match **nt {
460 NtIdent(ident, is_raw) => {
461 Cow::Owned(Token::new(Ident(ident.name, is_raw), ident.span))
463 NtLifetime(ident) => Cow::Owned(Token::new(Lifetime(ident.name), ident.span)),
464 _ => Cow::Borrowed(self),
466 _ => Cow::Borrowed(self),
470 /// Returns an identifier if this token is an identifier.
471 pub fn ident(&self) -> Option<(Ident, /* is_raw */ bool)> {
472 let token = self.uninterpolate();
474 Ident(name, is_raw) => Some((Ident::new(name, token.span), is_raw)),
479 /// Returns a lifetime identifier if this token is a lifetime.
480 pub fn lifetime(&self) -> Option<Ident> {
481 let token = self.uninterpolate();
483 Lifetime(name) => Some(Ident::new(name, token.span)),
488 /// Returns `true` if the token is an identifier.
489 pub fn is_ident(&self) -> bool {
490 self.ident().is_some()
493 /// Returns `true` if the token is a lifetime.
494 pub fn is_lifetime(&self) -> bool {
495 self.lifetime().is_some()
498 /// Returns `true` if the token is a identifier whose name is the given
500 pub fn is_ident_named(&self, name: Symbol) -> bool {
501 self.ident().map_or(false, |(ident, _)| ident.name == name)
504 /// Returns `true` if the token is an interpolated path.
505 fn is_path(&self) -> bool {
506 if let Interpolated(ref nt) = self.kind {
507 if let NtPath(..) = **nt {
514 /// Would `maybe_whole_expr` in `parser.rs` return `Ok(..)`?
515 /// That is, is this a pre-parsed expression dropped into the token stream
516 /// (which happens while parsing the result of macro expansion)?
517 pub fn is_whole_expr(&self) -> bool {
518 if let Interpolated(ref nt) = self.kind {
519 if let NtExpr(_) | NtLiteral(_) | NtPath(_) | NtIdent(..) | NtBlock(_) = **nt {
527 // Is the token an interpolated block (`$b:block`)?
528 pub fn is_whole_block(&self) -> bool {
529 if let Interpolated(ref nt) = self.kind {
530 if let NtBlock(..) = **nt {
537 /// Returns `true` if the token is either the `mut` or `const` keyword.
538 pub fn is_mutability(&self) -> bool {
539 self.is_keyword(kw::Mut) || self.is_keyword(kw::Const)
542 pub fn is_qpath_start(&self) -> bool {
543 self == &Lt || self == &BinOp(Shl)
546 pub fn is_path_start(&self) -> bool {
548 || self.is_qpath_start()
550 || self.is_path_segment_keyword()
551 || self.is_ident() && !self.is_reserved_ident()
554 /// Returns `true` if the token is a given keyword, `kw`.
555 pub fn is_keyword(&self, kw: Symbol) -> bool {
556 self.is_non_raw_ident_where(|id| id.name == kw)
559 pub fn is_path_segment_keyword(&self) -> bool {
560 self.is_non_raw_ident_where(Ident::is_path_segment_keyword)
563 // Returns true for reserved identifiers used internally for elided lifetimes,
564 // unnamed method parameters, crate root module, error recovery etc.
565 pub fn is_special_ident(&self) -> bool {
566 self.is_non_raw_ident_where(Ident::is_special)
569 /// Returns `true` if the token is a keyword used in the language.
570 pub fn is_used_keyword(&self) -> bool {
571 self.is_non_raw_ident_where(Ident::is_used_keyword)
574 /// Returns `true` if the token is a keyword reserved for possible future use.
575 pub fn is_unused_keyword(&self) -> bool {
576 self.is_non_raw_ident_where(Ident::is_unused_keyword)
579 /// Returns `true` if the token is either a special identifier or a keyword.
580 pub fn is_reserved_ident(&self) -> bool {
581 self.is_non_raw_ident_where(Ident::is_reserved)
584 /// Returns `true` if the token is the identifier `true` or `false`.
585 pub fn is_bool_lit(&self) -> bool {
586 self.is_non_raw_ident_where(|id| id.name.is_bool_lit())
589 /// Returns `true` if the token is a non-raw identifier for which `pred` holds.
590 pub fn is_non_raw_ident_where(&self, pred: impl FnOnce(Ident) -> bool) -> bool {
592 Some((id, false)) => pred(id),
597 pub fn glue(&self, joint: &Token) -> Option<Token> {
598 let kind = match self.kind {
599 Eq => match joint.kind {
604 Lt => match joint.kind {
608 BinOp(Minus) => LArrow,
611 Gt => match joint.kind {
617 Not => match joint.kind {
621 BinOp(op) => match joint.kind {
623 BinOp(And) if op == And => AndAnd,
624 BinOp(Or) if op == Or => OrOr,
625 Gt if op == Minus => RArrow,
628 Dot => match joint.kind {
633 DotDot => match joint.kind {
638 Colon => match joint.kind {
642 SingleQuote => match joint.kind {
643 Ident(name, false) => Lifetime(Symbol::intern(&format!("'{}", name))),
647 Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | BinOpEq(..) | At | DotDotDot
648 | DotDotEq | Comma | Semi | ModSep | RArrow | LArrow | FatArrow | Pound | Dollar
649 | Question | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..)
650 | Lifetime(..) | Interpolated(..) | DocComment(..) | Eof => return None,
653 Some(Token::new(kind, self.span.to(joint.span)))
657 impl PartialEq<TokenKind> for Token {
658 fn eq(&self, rhs: &TokenKind) -> bool {
663 #[derive(Clone, Encodable, Decodable)]
664 /// For interpolation during macro expansion.
665 pub enum Nonterminal {
666 NtItem(P<ast::Item>),
667 NtBlock(P<ast::Block>),
670 NtExpr(P<ast::Expr>),
672 NtIdent(Ident, /* is_raw */ bool),
674 NtLiteral(P<ast::Expr>),
675 /// Stuff inside brackets for attributes
676 NtMeta(P<ast::AttrItem>),
678 NtVis(ast::Visibility),
682 // `Nonterminal` is used a lot. Make sure it doesn't unintentionally get bigger.
683 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
684 rustc_data_structures::static_assert_size!(Nonterminal, 48);
686 #[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable)]
687 pub enum NonterminalKind {
692 /// Keep track of whether the user used `:pat2018` or `:pat` and we inferred it from the
693 /// edition of the span. This is used for diagnostics.
697 /// Keep track of whether the user used `:pat2018` or `:pat` and we inferred it from the
698 /// edition of the span. This is used for diagnostics.
712 impl NonterminalKind {
713 /// The `edition` closure is used to get the edition for the given symbol. Doing
714 /// `span.edition()` is expensive, so we do it lazily.
717 edition: impl FnOnce() -> Edition,
718 ) -> Option<NonterminalKind> {
720 sym::item => NonterminalKind::Item,
721 sym::block => NonterminalKind::Block,
722 sym::stmt => NonterminalKind::Stmt,
723 sym::pat => match edition() {
724 Edition::Edition2015 | Edition::Edition2018 => {
725 NonterminalKind::Pat2018 { inferred: true }
727 Edition::Edition2021 => NonterminalKind::Pat2021 { inferred: true },
729 sym::pat2018 => NonterminalKind::Pat2018 { inferred: false },
730 sym::pat2021 => NonterminalKind::Pat2021 { inferred: false },
731 sym::expr => NonterminalKind::Expr,
732 sym::ty => NonterminalKind::Ty,
733 sym::ident => NonterminalKind::Ident,
734 sym::lifetime => NonterminalKind::Lifetime,
735 sym::literal => NonterminalKind::Literal,
736 sym::meta => NonterminalKind::Meta,
737 sym::path => NonterminalKind::Path,
738 sym::vis => NonterminalKind::Vis,
739 sym::tt => NonterminalKind::TT,
743 fn symbol(self) -> Symbol {
745 NonterminalKind::Item => sym::item,
746 NonterminalKind::Block => sym::block,
747 NonterminalKind::Stmt => sym::stmt,
748 NonterminalKind::Pat2018 { inferred: false } => sym::pat2018,
749 NonterminalKind::Pat2021 { inferred: false } => sym::pat2021,
750 NonterminalKind::Pat2018 { inferred: true }
751 | NonterminalKind::Pat2021 { inferred: true } => sym::pat,
752 NonterminalKind::Expr => sym::expr,
753 NonterminalKind::Ty => sym::ty,
754 NonterminalKind::Ident => sym::ident,
755 NonterminalKind::Lifetime => sym::lifetime,
756 NonterminalKind::Literal => sym::literal,
757 NonterminalKind::Meta => sym::meta,
758 NonterminalKind::Path => sym::path,
759 NonterminalKind::Vis => sym::vis,
760 NonterminalKind::TT => sym::tt,
765 impl fmt::Display for NonterminalKind {
766 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
767 write!(f, "{}", self.symbol())
772 pub fn span(&self) -> Span {
774 NtItem(item) => item.span,
775 NtBlock(block) => block.span,
776 NtStmt(stmt) => stmt.span,
777 NtPat(pat) => pat.span,
778 NtExpr(expr) | NtLiteral(expr) => expr.span,
780 NtIdent(ident, _) | NtLifetime(ident) => ident.span,
781 NtMeta(attr_item) => attr_item.span(),
782 NtPath(path) => path.span,
783 NtVis(vis) => vis.span,
784 NtTT(tt) => tt.span(),
788 /// This nonterminal looks like some specific enums from
789 /// `proc-macro-hack` and `procedural-masquerade` crates.
790 /// We need to maintain some special pretty-printing behavior for them due to incorrect
791 /// asserts in old versions of those crates and their wide use in the ecosystem.
792 /// See issue #73345 for more details.
793 /// FIXME(#73933): Remove this eventually.
794 pub fn pretty_printing_compatibility_hack(&self) -> bool {
795 let item = match self {
796 NtItem(item) => item,
797 NtStmt(stmt) => match &stmt.kind {
798 ast::StmtKind::Item(item) => item,
804 let name = item.ident.name;
805 if name == sym::ProceduralMasqueradeDummyType || name == sym::ProcMacroHack {
806 if let ast::ItemKind::Enum(enum_def, _) = &item.kind {
807 if let [variant] = &*enum_def.variants {
808 return variant.ident.name == sym::Input;
816 impl PartialEq for Nonterminal {
817 fn eq(&self, rhs: &Self) -> bool {
819 (NtIdent(ident_lhs, is_raw_lhs), NtIdent(ident_rhs, is_raw_rhs)) => {
820 ident_lhs == ident_rhs && is_raw_lhs == is_raw_rhs
822 (NtLifetime(ident_lhs), NtLifetime(ident_rhs)) => ident_lhs == ident_rhs,
823 (NtTT(tt_lhs), NtTT(tt_rhs)) => tt_lhs == tt_rhs,
824 // FIXME: Assume that all "complex" nonterminal are not equal, we can't compare them
825 // correctly based on data from AST. This will prevent them from matching each other
826 // in macros. The comparison will become possible only when each nonterminal has an
827 // attached token stream from which it was parsed.
833 impl fmt::Debug for Nonterminal {
834 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
836 NtItem(..) => f.pad("NtItem(..)"),
837 NtBlock(..) => f.pad("NtBlock(..)"),
838 NtStmt(..) => f.pad("NtStmt(..)"),
839 NtPat(..) => f.pad("NtPat(..)"),
840 NtExpr(..) => f.pad("NtExpr(..)"),
841 NtTy(..) => f.pad("NtTy(..)"),
842 NtIdent(..) => f.pad("NtIdent(..)"),
843 NtLiteral(..) => f.pad("NtLiteral(..)"),
844 NtMeta(..) => f.pad("NtMeta(..)"),
845 NtPath(..) => f.pad("NtPath(..)"),
846 NtTT(..) => f.pad("NtTT(..)"),
847 NtVis(..) => f.pad("NtVis(..)"),
848 NtLifetime(..) => f.pad("NtLifetime(..)"),
853 impl<CTX> HashStable<CTX> for Nonterminal
855 CTX: crate::HashStableContext,
857 fn hash_stable(&self, _hcx: &mut CTX, _hasher: &mut StableHasher) {
858 panic!("interpolated tokens should not be present in the HIR")