3 pub use Nonterminal::*;
8 use crate::util::case::Case;
10 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
11 use rustc_data_structures::sync::Lrc;
12 use rustc_macros::HashStable_Generic;
13 use rustc_span::symbol::{kw, sym};
14 use rustc_span::symbol::{Ident, Symbol};
15 use rustc_span::{self, edition::Edition, Span, DUMMY_SP};
19 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
20 pub enum CommentKind {
25 #[derive(Clone, PartialEq, Encodable, Decodable, Hash, Debug, Copy)]
26 #[derive(HashStable_Generic)]
40 /// Describes how a sequence of token trees is delimited.
41 /// Cannot use `proc_macro::Delimiter` directly because this
42 /// structure should implement some additional traits.
43 /// The `None` variant is also renamed to `Invisible` to be
44 /// less confusing and better convey the semantics.
45 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
46 #[derive(Encodable, Decodable, Hash, HashStable_Generic)]
55 /// An invisible delimiter, that may, for example, appear around tokens coming from a
56 /// "macro variable" `$var`. It is important to preserve operator priorities in cases like
57 /// `$var * 3` where `$var` is `1 + 2`.
58 /// Invisible delimiters might not survive roundtrip of a token stream through a string.
62 // Note that the suffix is *not* considered when deciding the `LitKind` in this
63 // type. This means that float literals like `1f32` are classified by this type
64 // as `Int`. Only upon conversion to `ast::LitKind` will such a literal be
65 // given the `Float` kind.
66 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
68 Bool, // AST only, must never appear in a `Token`
71 Integer, // e.g. `1`, `1u8`, `1f32`
72 Float, // e.g. `1.`, `1.0`, `1e3f32`
74 StrRaw(u8), // raw string delimited by `n` hash symbols
76 ByteStrRaw(u8), // raw byte string delimited by `n` hash symbols
81 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
85 pub suffix: Option<Symbol>,
89 pub fn new(kind: LitKind, symbol: Symbol, suffix: Option<Symbol>) -> Lit {
90 Lit { kind, symbol, suffix }
93 /// Returns `true` if this is semantically a float literal. This includes
94 /// ones like `1f32` that have an `Integer` kind but a float suffix.
95 pub fn is_semantic_float(&self) -> bool {
97 LitKind::Float => true,
98 LitKind::Integer => match self.suffix {
99 Some(sym) => sym == sym::f32 || sym == sym::f64,
106 /// Keep this in sync with `Token::can_begin_literal_or_bool` excluding unary negation.
107 pub fn from_token(token: &Token) -> Option<Lit> {
108 match token.uninterpolate().kind {
109 Ident(name, false) if name.is_bool_lit() => {
110 Some(Lit::new(Bool, name, None))
112 Literal(token_lit) => Some(token_lit),
114 if let NtExpr(expr) | NtLiteral(expr) = &**nt
115 && let ast::ExprKind::Lit(token_lit) = expr.kind =>
124 impl fmt::Display for Lit {
125 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
126 let Lit { kind, symbol, suffix } = *self;
128 Byte => write!(f, "b'{}'", symbol)?,
129 Char => write!(f, "'{}'", symbol)?,
130 Str => write!(f, "\"{}\"", symbol)?,
133 "r{delim}\"{string}\"{delim}",
134 delim = "#".repeat(n as usize),
137 ByteStr => write!(f, "b\"{}\"", symbol)?,
138 ByteStrRaw(n) => write!(
140 "br{delim}\"{string}\"{delim}",
141 delim = "#".repeat(n as usize),
144 Integer | Float | Bool | Err => write!(f, "{}", symbol)?,
147 if let Some(suffix) = suffix {
148 write!(f, "{}", suffix)?;
156 /// An English article for the literal token kind.
157 pub fn article(self) -> &'static str {
159 Integer | Err => "an",
164 pub fn descr(self) -> &'static str {
166 Bool => panic!("literal token contains `Lit::Bool`"),
169 Integer => "integer",
171 Str | StrRaw(..) => "string",
172 ByteStr | ByteStrRaw(..) => "byte string",
177 pub(crate) fn may_have_suffix(self) -> bool {
178 matches!(self, Integer | Float | Err)
182 pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: bool) -> bool {
183 let ident_token = Token::new(Ident(name, is_raw), span);
185 !ident_token.is_reserved_ident()
186 || ident_token.is_path_segment_keyword()
212 fn ident_can_begin_type(name: Symbol, span: Span, is_raw: bool) -> bool {
213 let ident_token = Token::new(Ident(name, is_raw), span);
215 !ident_token.is_reserved_ident()
216 || ident_token.is_path_segment_keyword()
217 || [kw::Underscore, kw::For, kw::Impl, kw::Fn, kw::Unsafe, kw::Extern, kw::Typeof, kw::Dyn]
221 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
223 /* Expression-operator symbols. */
238 /* Structural symbols */
254 /// Used by proc macros for representing lifetimes, not generated by lexer right now.
256 /// An opening delimiter (e.g., `{`).
257 OpenDelim(Delimiter),
258 /// A closing delimiter (e.g., `}`).
259 CloseDelim(Delimiter),
264 /// Identifier token.
265 /// Do not forget about `NtIdent` when you want to match on identifiers.
266 /// It's recommended to use `Token::(ident,uninterpolate,uninterpolated_span)` to
267 /// treat regular and interpolated identifiers in the same way.
268 Ident(Symbol, /* is_raw */ bool),
269 /// Lifetime identifier token.
270 /// Do not forget about `NtLifetime` when you want to match on lifetime identifiers.
271 /// It's recommended to use `Token::(lifetime,uninterpolate,uninterpolated_span)` to
272 /// treat regular and interpolated lifetime identifiers in the same way.
275 /// An embedded AST node, as produced by a macro. This only exists for
276 /// historical reasons. We'd like to get rid of it, for multiple reasons.
277 /// - It's conceptually very strange. Saying a token can contain an AST
278 /// node is like saying, in natural language, that a word can contain a
280 /// - It requires special handling in a bunch of places in the parser.
281 /// - It prevents `Token` from implementing `Copy`.
282 /// It adds complexity and likely slows things down. Please don't add new
283 /// occurrences of this token kind!
284 Interpolated(Lrc<Nonterminal>),
286 /// A doc comment token.
287 /// `Symbol` is the doc comment's data excluding its "quotes" (`///`, `/**`, etc)
288 /// similarly to symbols in string literal tokens.
289 DocComment(CommentKind, ast::AttrStyle, Symbol),
294 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
301 pub fn lit(kind: LitKind, symbol: Symbol, suffix: Option<Symbol>) -> TokenKind {
302 Literal(Lit::new(kind, symbol, suffix))
305 /// An approximation to proc-macro-style single-character operators used by rustc parser.
306 /// If the operator token can be broken into two tokens, the first of which is single-character,
307 /// then this function performs that operation, otherwise it returns `None`.
308 pub fn break_two_token_op(&self) -> Option<(TokenKind, TokenKind)> {
314 AndAnd => (BinOp(And), BinOp(And)),
315 OrOr => (BinOp(Or), BinOp(Or)),
316 BinOp(Shl) => (Lt, Lt),
317 BinOp(Shr) => (Gt, Gt),
318 BinOpEq(Plus) => (BinOp(Plus), Eq),
319 BinOpEq(Minus) => (BinOp(Minus), Eq),
320 BinOpEq(Star) => (BinOp(Star), Eq),
321 BinOpEq(Slash) => (BinOp(Slash), Eq),
322 BinOpEq(Percent) => (BinOp(Percent), Eq),
323 BinOpEq(Caret) => (BinOp(Caret), Eq),
324 BinOpEq(And) => (BinOp(And), Eq),
325 BinOpEq(Or) => (BinOp(Or), Eq),
326 BinOpEq(Shl) => (Lt, Le),
327 BinOpEq(Shr) => (Gt, Ge),
328 DotDot => (Dot, Dot),
329 DotDotDot => (Dot, DotDot),
330 ModSep => (Colon, Colon),
331 RArrow => (BinOp(Minus), Gt),
332 LArrow => (Lt, BinOp(Minus)),
333 FatArrow => (Eq, Gt),
338 /// Returns tokens that are likely to be typed accidentally instead of the current token.
339 /// Enables better error recovery when the wrong token is found.
340 pub fn similar_tokens(&self) -> Option<Vec<TokenKind>> {
342 Comma => Some(vec![Dot, Lt, Semi]),
343 Semi => Some(vec![Colon, Comma]),
344 FatArrow => Some(vec![Eq, RArrow]),
349 pub fn should_end_const_arg(&self) -> bool {
350 matches!(self, Gt | Ge | BinOp(Shr) | BinOpEq(Shr))
355 pub fn new(kind: TokenKind, span: Span) -> Self {
359 /// Some token that will be thrown away later.
360 pub fn dummy() -> Self {
361 Token::new(TokenKind::Question, DUMMY_SP)
364 /// Recovers a `Token` from an `Ident`. This creates a raw identifier if necessary.
365 pub fn from_ast_ident(ident: Ident) -> Self {
366 Token::new(Ident(ident.name, ident.is_raw_guess()), ident.span)
369 /// For interpolated tokens, returns a span of the fragment to which the interpolated
370 /// token refers. For all other tokens this is just a regular span.
371 /// It is particularly important to use this for identifiers and lifetimes
372 /// for which spans affect name resolution and edition checks.
373 /// Note that keywords are also identifiers, so they should use this
374 /// if they keep spans or perform edition checks.
375 pub fn uninterpolated_span(&self) -> Span {
377 Interpolated(nt) => nt.span(),
382 pub fn is_range_separator(&self) -> bool {
383 [DotDot, DotDotDot, DotDotEq].contains(&self.kind)
386 pub fn is_op(&self) -> bool {
388 Eq | Lt | Le | EqEq | Ne | Ge | Gt | AndAnd | OrOr | Not | Tilde | BinOp(_)
389 | BinOpEq(_) | At | Dot | DotDot | DotDotDot | DotDotEq | Comma | Semi | Colon
390 | ModSep | RArrow | LArrow | FatArrow | Pound | Dollar | Question | SingleQuote => true,
392 OpenDelim(..) | CloseDelim(..) | Literal(..) | DocComment(..) | Ident(..)
393 | Lifetime(..) | Interpolated(..) | Eof => false,
397 pub fn is_like_plus(&self) -> bool {
398 matches!(self.kind, BinOp(Plus) | BinOpEq(Plus))
401 /// Returns `true` if the token can appear at the start of an expression.
402 pub fn can_begin_expr(&self) -> bool {
403 match self.uninterpolate().kind {
404 Ident(name, is_raw) =>
405 ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
406 OpenDelim(..) | // tuple, array or block
407 Literal(..) | // literal
408 Not | // operator not
409 BinOp(Minus) | // unary minus
410 BinOp(Star) | // dereference
411 BinOp(Or) | OrOr | // closure
412 BinOp(And) | // reference
413 AndAnd | // double reference
414 // DotDotDot is no longer supported, but we need some way to display the error
415 DotDot | DotDotDot | DotDotEq | // range notation
416 Lt | BinOp(Shl) | // associated path
417 ModSep | // global path
418 Lifetime(..) | // labeled loop
419 Pound => true, // expression attributes
420 Interpolated(ref nt) => matches!(**nt, NtLiteral(..) |
428 /// Returns `true` if the token can appear at the start of an pattern.
430 /// Shamelessly borrowed from `can_begin_expr`, only used for diagnostics right now.
431 pub fn can_begin_pattern(&self) -> bool {
432 match self.uninterpolate().kind {
433 Ident(name, is_raw) =>
434 ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
435 | OpenDelim(Delimiter::Bracket | Delimiter::Parenthesis) // tuple or array
436 | Literal(..) // literal
437 | BinOp(Minus) // unary minus
438 | BinOp(And) // reference
439 | AndAnd // double reference
440 // DotDotDot is no longer supported
441 | DotDot | DotDotDot | DotDotEq // ranges
442 | Lt | BinOp(Shl) // associated path
443 | ModSep => true, // global path
444 Interpolated(ref nt) => matches!(**nt, NtLiteral(..) |
452 /// Returns `true` if the token can appear at the start of a type.
453 pub fn can_begin_type(&self) -> bool {
454 match self.uninterpolate().kind {
455 Ident(name, is_raw) =>
456 ident_can_begin_type(name, self.span, is_raw), // type name or keyword
457 OpenDelim(Delimiter::Parenthesis) | // tuple
458 OpenDelim(Delimiter::Bracket) | // array
460 BinOp(Star) | // raw pointer
461 BinOp(And) | // reference
462 AndAnd | // double reference
463 Question | // maybe bound in trait object
464 Lifetime(..) | // lifetime bound in trait object
465 Lt | BinOp(Shl) | // associated path
466 ModSep => true, // global path
467 Interpolated(ref nt) => matches!(**nt, NtTy(..) | NtPath(..)),
472 /// Returns `true` if the token can appear at the start of a const param.
473 pub fn can_begin_const_arg(&self) -> bool {
475 OpenDelim(Delimiter::Brace) => true,
476 Interpolated(ref nt) => matches!(**nt, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
477 _ => self.can_begin_literal_maybe_minus(),
481 /// Returns `true` if the token can appear at the start of a generic bound.
482 pub fn can_begin_bound(&self) -> bool {
484 || self.is_lifetime()
485 || self.is_keyword(kw::For)
487 || self == &OpenDelim(Delimiter::Parenthesis)
490 /// Returns `true` if the token can appear at the start of an item.
491 pub fn can_begin_item(&self) -> bool {
515 /// Returns `true` if the token is any literal.
516 pub fn is_lit(&self) -> bool {
517 matches!(self.kind, Literal(..))
520 /// Returns `true` if the token is any literal, a minus (which can prefix a literal,
521 /// for example a '-42', or one of the boolean idents).
523 /// In other words, would this token be a valid start of `parse_literal_maybe_minus`?
525 /// Keep this in sync with and `Lit::from_token`, excluding unary negation.
526 pub fn can_begin_literal_maybe_minus(&self) -> bool {
527 match self.uninterpolate().kind {
528 Literal(..) | BinOp(Minus) => true,
529 Ident(name, false) if name.is_bool_lit() => true,
530 Interpolated(ref nt) => match &**nt {
531 NtLiteral(_) => true,
532 NtExpr(e) => match &e.kind {
533 ast::ExprKind::Lit(_) => true,
534 ast::ExprKind::Unary(ast::UnOp::Neg, e) => {
535 matches!(&e.kind, ast::ExprKind::Lit(_))
545 /// A convenience function for matching on identifiers during parsing.
546 /// Turns interpolated identifier (`$i: ident`) or lifetime (`$l: lifetime`) token
547 /// into the regular identifier or lifetime token it refers to,
548 /// otherwise returns the original token.
549 pub fn uninterpolate(&self) -> Cow<'_, Token> {
551 Interpolated(nt) => match **nt {
552 NtIdent(ident, is_raw) => {
553 Cow::Owned(Token::new(Ident(ident.name, is_raw), ident.span))
555 NtLifetime(ident) => Cow::Owned(Token::new(Lifetime(ident.name), ident.span)),
556 _ => Cow::Borrowed(self),
558 _ => Cow::Borrowed(self),
562 /// Returns an identifier if this token is an identifier.
564 pub fn ident(&self) -> Option<(Ident, /* is_raw */ bool)> {
565 // We avoid using `Token::uninterpolate` here because it's slow.
567 &Ident(name, is_raw) => Some((Ident::new(name, self.span), is_raw)),
568 Interpolated(nt) => match **nt {
569 NtIdent(ident, is_raw) => Some((ident, is_raw)),
576 /// Returns a lifetime identifier if this token is a lifetime.
578 pub fn lifetime(&self) -> Option<Ident> {
579 // We avoid using `Token::uninterpolate` here because it's slow.
581 &Lifetime(name) => Some(Ident::new(name, self.span)),
582 Interpolated(nt) => match **nt {
583 NtLifetime(ident) => Some(ident),
590 /// Returns `true` if the token is an identifier.
591 pub fn is_ident(&self) -> bool {
592 self.ident().is_some()
595 /// Returns `true` if the token is a lifetime.
596 pub fn is_lifetime(&self) -> bool {
597 self.lifetime().is_some()
600 /// Returns `true` if the token is an identifier whose name is the given
602 pub fn is_ident_named(&self, name: Symbol) -> bool {
603 self.ident().map_or(false, |(ident, _)| ident.name == name)
606 /// Returns `true` if the token is an interpolated path.
607 fn is_path(&self) -> bool {
608 if let Interpolated(nt) = &self.kind && let NtPath(..) = **nt {
615 /// Would `maybe_whole_expr` in `parser.rs` return `Ok(..)`?
616 /// That is, is this a pre-parsed expression dropped into the token stream
617 /// (which happens while parsing the result of macro expansion)?
618 pub fn is_whole_expr(&self) -> bool {
619 if let Interpolated(nt) = &self.kind
620 && let NtExpr(_) | NtLiteral(_) | NtPath(_) | NtBlock(_) = **nt
628 /// Is the token an interpolated block (`$b:block`)?
629 pub fn is_whole_block(&self) -> bool {
630 if let Interpolated(nt) = &self.kind && let NtBlock(..) = **nt {
637 /// Returns `true` if the token is either the `mut` or `const` keyword.
638 pub fn is_mutability(&self) -> bool {
639 self.is_keyword(kw::Mut) || self.is_keyword(kw::Const)
642 pub fn is_qpath_start(&self) -> bool {
643 self == &Lt || self == &BinOp(Shl)
646 pub fn is_path_start(&self) -> bool {
648 || self.is_qpath_start()
650 || self.is_path_segment_keyword()
651 || self.is_ident() && !self.is_reserved_ident()
654 /// Returns `true` if the token is a given keyword, `kw`.
655 pub fn is_keyword(&self, kw: Symbol) -> bool {
656 self.is_non_raw_ident_where(|id| id.name == kw)
659 /// Returns `true` if the token is a given keyword, `kw` or if `case` is `Insensitive` and this token is an identifier equal to `kw` ignoring the case.
660 pub fn is_keyword_case(&self, kw: Symbol, case: Case) -> bool {
662 || (case == Case::Insensitive
663 && self.is_non_raw_ident_where(|id| {
664 id.name.as_str().to_lowercase() == kw.as_str().to_lowercase()
668 pub fn is_path_segment_keyword(&self) -> bool {
669 self.is_non_raw_ident_where(Ident::is_path_segment_keyword)
672 /// Returns true for reserved identifiers used internally for elided lifetimes,
673 /// unnamed method parameters, crate root module, error recovery etc.
674 pub fn is_special_ident(&self) -> bool {
675 self.is_non_raw_ident_where(Ident::is_special)
678 /// Returns `true` if the token is a keyword used in the language.
679 pub fn is_used_keyword(&self) -> bool {
680 self.is_non_raw_ident_where(Ident::is_used_keyword)
683 /// Returns `true` if the token is a keyword reserved for possible future use.
684 pub fn is_unused_keyword(&self) -> bool {
685 self.is_non_raw_ident_where(Ident::is_unused_keyword)
688 /// Returns `true` if the token is either a special identifier or a keyword.
689 pub fn is_reserved_ident(&self) -> bool {
690 self.is_non_raw_ident_where(Ident::is_reserved)
693 /// Returns `true` if the token is the identifier `true` or `false`.
694 pub fn is_bool_lit(&self) -> bool {
695 self.is_non_raw_ident_where(|id| id.name.is_bool_lit())
698 pub fn is_numeric_lit(&self) -> bool {
701 Literal(Lit { kind: LitKind::Integer, .. }) | Literal(Lit { kind: LitKind::Float, .. })
705 /// Returns `true` if the token is a non-raw identifier for which `pred` holds.
706 pub fn is_non_raw_ident_where(&self, pred: impl FnOnce(Ident) -> bool) -> bool {
708 Some((id, false)) => pred(id),
713 pub fn glue(&self, joint: &Token) -> Option<Token> {
714 let kind = match self.kind {
715 Eq => match joint.kind {
720 Lt => match joint.kind {
724 BinOp(Minus) => LArrow,
727 Gt => match joint.kind {
733 Not => match joint.kind {
737 BinOp(op) => match joint.kind {
739 BinOp(And) if op == And => AndAnd,
740 BinOp(Or) if op == Or => OrOr,
741 Gt if op == Minus => RArrow,
744 Dot => match joint.kind {
749 DotDot => match joint.kind {
754 Colon => match joint.kind {
758 SingleQuote => match joint.kind {
759 Ident(name, false) => Lifetime(Symbol::intern(&format!("'{}", name))),
763 Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | BinOpEq(..) | At | DotDotDot
764 | DotDotEq | Comma | Semi | ModSep | RArrow | LArrow | FatArrow | Pound | Dollar
765 | Question | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..)
766 | Lifetime(..) | Interpolated(..) | DocComment(..) | Eof => return None,
769 Some(Token::new(kind, self.span.to(joint.span)))
773 impl PartialEq<TokenKind> for Token {
775 fn eq(&self, rhs: &TokenKind) -> bool {
780 #[derive(Clone, Encodable, Decodable)]
781 /// For interpolation during macro expansion.
782 pub enum Nonterminal {
783 NtItem(P<ast::Item>),
784 NtBlock(P<ast::Block>),
785 NtStmt(P<ast::Stmt>),
787 NtExpr(P<ast::Expr>),
789 NtIdent(Ident, /* is_raw */ bool),
791 NtLiteral(P<ast::Expr>),
792 /// Stuff inside brackets for attributes
793 NtMeta(P<ast::AttrItem>),
794 NtPath(P<ast::Path>),
795 NtVis(P<ast::Visibility>),
798 #[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable)]
799 pub enum NonterminalKind {
804 /// Keep track of whether the user used `:pat_param` or `:pat` and we inferred it from the
805 /// edition of the span. This is used for diagnostics.
820 impl NonterminalKind {
821 /// The `edition` closure is used to get the edition for the given symbol. Doing
822 /// `span.edition()` is expensive, so we do it lazily.
825 edition: impl FnOnce() -> Edition,
826 ) -> Option<NonterminalKind> {
828 sym::item => NonterminalKind::Item,
829 sym::block => NonterminalKind::Block,
830 sym::stmt => NonterminalKind::Stmt,
831 sym::pat => match edition() {
832 Edition::Edition2015 | Edition::Edition2018 => {
833 NonterminalKind::PatParam { inferred: true }
835 Edition::Edition2021 | Edition::Edition2024 => NonterminalKind::PatWithOr,
837 sym::pat_param => NonterminalKind::PatParam { inferred: false },
838 sym::expr => NonterminalKind::Expr,
839 sym::ty => NonterminalKind::Ty,
840 sym::ident => NonterminalKind::Ident,
841 sym::lifetime => NonterminalKind::Lifetime,
842 sym::literal => NonterminalKind::Literal,
843 sym::meta => NonterminalKind::Meta,
844 sym::path => NonterminalKind::Path,
845 sym::vis => NonterminalKind::Vis,
846 sym::tt => NonterminalKind::TT,
850 fn symbol(self) -> Symbol {
852 NonterminalKind::Item => sym::item,
853 NonterminalKind::Block => sym::block,
854 NonterminalKind::Stmt => sym::stmt,
855 NonterminalKind::PatParam { inferred: false } => sym::pat_param,
856 NonterminalKind::PatParam { inferred: true } | NonterminalKind::PatWithOr => sym::pat,
857 NonterminalKind::Expr => sym::expr,
858 NonterminalKind::Ty => sym::ty,
859 NonterminalKind::Ident => sym::ident,
860 NonterminalKind::Lifetime => sym::lifetime,
861 NonterminalKind::Literal => sym::literal,
862 NonterminalKind::Meta => sym::meta,
863 NonterminalKind::Path => sym::path,
864 NonterminalKind::Vis => sym::vis,
865 NonterminalKind::TT => sym::tt,
870 impl fmt::Display for NonterminalKind {
871 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
872 write!(f, "{}", self.symbol())
877 pub fn span(&self) -> Span {
879 NtItem(item) => item.span,
880 NtBlock(block) => block.span,
881 NtStmt(stmt) => stmt.span,
882 NtPat(pat) => pat.span,
883 NtExpr(expr) | NtLiteral(expr) => expr.span,
885 NtIdent(ident, _) | NtLifetime(ident) => ident.span,
886 NtMeta(attr_item) => attr_item.span(),
887 NtPath(path) => path.span,
888 NtVis(vis) => vis.span,
893 impl PartialEq for Nonterminal {
894 fn eq(&self, rhs: &Self) -> bool {
896 (NtIdent(ident_lhs, is_raw_lhs), NtIdent(ident_rhs, is_raw_rhs)) => {
897 ident_lhs == ident_rhs && is_raw_lhs == is_raw_rhs
899 (NtLifetime(ident_lhs), NtLifetime(ident_rhs)) => ident_lhs == ident_rhs,
900 // FIXME: Assume that all "complex" nonterminal are not equal, we can't compare them
901 // correctly based on data from AST. This will prevent them from matching each other
902 // in macros. The comparison will become possible only when each nonterminal has an
903 // attached token stream from which it was parsed.
909 impl fmt::Debug for Nonterminal {
910 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
912 NtItem(..) => f.pad("NtItem(..)"),
913 NtBlock(..) => f.pad("NtBlock(..)"),
914 NtStmt(..) => f.pad("NtStmt(..)"),
915 NtPat(..) => f.pad("NtPat(..)"),
916 NtExpr(..) => f.pad("NtExpr(..)"),
917 NtTy(..) => f.pad("NtTy(..)"),
918 NtIdent(..) => f.pad("NtIdent(..)"),
919 NtLiteral(..) => f.pad("NtLiteral(..)"),
920 NtMeta(..) => f.pad("NtMeta(..)"),
921 NtPath(..) => f.pad("NtPath(..)"),
922 NtVis(..) => f.pad("NtVis(..)"),
923 NtLifetime(..) => f.pad("NtLifetime(..)"),
928 impl<CTX> HashStable<CTX> for Nonterminal
930 CTX: crate::HashStableContext,
932 fn hash_stable(&self, _hcx: &mut CTX, _hasher: &mut StableHasher) {
933 panic!("interpolated tokens should not be present in the HIR")
937 // Some types are used a lot. Make sure they don't unintentionally get bigger.
938 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
941 use rustc_data_structures::static_assert_size;
942 // tidy-alphabetical-start
943 static_assert_size!(Lit, 12);
944 static_assert_size!(LitKind, 2);
945 static_assert_size!(Nonterminal, 16);
946 static_assert_size!(Token, 24);
947 static_assert_size!(TokenKind, 16);
948 // tidy-alphabetical-end