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
=>
117 Some(token_lit
.clone())
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_op(&self) -> bool
{
384 Eq
| Lt
| Le
| EqEq
| Ne
| Ge
| Gt
| AndAnd
| OrOr
| Not
| Tilde
| BinOp(_
)
385 | BinOpEq(_
) | At
| Dot
| DotDot
| DotDotDot
| DotDotEq
| Comma
| Semi
| Colon
386 | ModSep
| RArrow
| LArrow
| FatArrow
| Pound
| Dollar
| Question
| SingleQuote
=> true,
388 OpenDelim(..) | CloseDelim(..) | Literal(..) | DocComment(..) | Ident(..)
389 | Lifetime(..) | Interpolated(..) | Eof
=> false,
393 pub fn is_like_plus(&self) -> bool
{
394 matches
!(self.kind
, BinOp(Plus
) | BinOpEq(Plus
))
397 /// Returns `true` if the token can appear at the start of an expression.
398 pub fn can_begin_expr(&self) -> bool
{
399 match self.uninterpolate().kind
{
400 Ident(name
, is_raw
) =>
401 ident_can_begin_expr(name
, self.span
, is_raw
), // value name or keyword
402 OpenDelim(..) | // tuple, array or block
403 Literal(..) | // literal
404 Not
| // operator not
405 BinOp(Minus
) | // unary minus
406 BinOp(Star
) | // dereference
407 BinOp(Or
) | OrOr
| // closure
408 BinOp(And
) | // reference
409 AndAnd
| // double reference
410 // DotDotDot is no longer supported, but we need some way to display the error
411 DotDot
| DotDotDot
| DotDotEq
| // range notation
412 Lt
| BinOp(Shl
) | // associated path
413 ModSep
| // global path
414 Lifetime(..) | // labeled loop
415 Pound
=> true, // expression attributes
416 Interpolated(ref nt
) => matches
!(**nt
, NtLiteral(..) |
424 /// Returns `true` if the token can appear at the start of an pattern.
426 /// Shamelessly borrowed from `can_begin_expr`, only used for diagnostics right now.
427 pub fn can_begin_pattern(&self) -> bool
{
428 match self.uninterpolate().kind
{
429 Ident(name
, is_raw
) =>
430 ident_can_begin_expr(name
, self.span
, is_raw
), // value name or keyword
431 | OpenDelim(Delimiter
::Bracket
| Delimiter
::Parenthesis
) // tuple or array
432 | Literal(..) // literal
433 | BinOp(Minus
) // unary minus
434 | BinOp(And
) // reference
435 | AndAnd
// double reference
436 // DotDotDot is no longer supported
437 | DotDot
| DotDotDot
| DotDotEq
// ranges
438 | Lt
| BinOp(Shl
) // associated path
439 | ModSep
=> true, // global path
440 Interpolated(ref nt
) => matches
!(**nt
, NtLiteral(..) |
448 /// Returns `true` if the token can appear at the start of a type.
449 pub fn can_begin_type(&self) -> bool
{
450 match self.uninterpolate().kind
{
451 Ident(name
, is_raw
) =>
452 ident_can_begin_type(name
, self.span
, is_raw
), // type name or keyword
453 OpenDelim(Delimiter
::Parenthesis
) | // tuple
454 OpenDelim(Delimiter
::Bracket
) | // array
456 BinOp(Star
) | // raw pointer
457 BinOp(And
) | // reference
458 AndAnd
| // double reference
459 Question
| // maybe bound in trait object
460 Lifetime(..) | // lifetime bound in trait object
461 Lt
| BinOp(Shl
) | // associated path
462 ModSep
=> true, // global path
463 Interpolated(ref nt
) => matches
!(**nt
, NtTy(..) | NtPath(..)),
468 /// Returns `true` if the token can appear at the start of a const param.
469 pub fn can_begin_const_arg(&self) -> bool
{
471 OpenDelim(Delimiter
::Brace
) => true,
472 Interpolated(ref nt
) => matches
!(**nt
, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
473 _
=> self.can_begin_literal_maybe_minus(),
477 /// Returns `true` if the token can appear at the start of a generic bound.
478 pub fn can_begin_bound(&self) -> bool
{
480 || self.is_lifetime()
481 || self.is_keyword(kw
::For
)
483 || self == &OpenDelim(Delimiter
::Parenthesis
)
486 /// Returns `true` if the token can appear at the start of an item.
487 pub fn can_begin_item(&self) -> bool
{
511 /// Returns `true` if the token is any literal.
512 pub fn is_lit(&self) -> bool
{
513 matches
!(self.kind
, Literal(..))
516 /// Returns `true` if the token is any literal, a minus (which can prefix a literal,
517 /// for example a '-42', or one of the boolean idents).
519 /// In other words, would this token be a valid start of `parse_literal_maybe_minus`?
521 /// Keep this in sync with and `Lit::from_token`, excluding unary negation.
522 pub fn can_begin_literal_maybe_minus(&self) -> bool
{
523 match self.uninterpolate().kind
{
524 Literal(..) | BinOp(Minus
) => true,
525 Ident(name
, false) if name
.is_bool_lit() => true,
526 Interpolated(ref nt
) => match &**nt
{
527 NtLiteral(_
) => true,
528 NtExpr(e
) => match &e
.kind
{
529 ast
::ExprKind
::Lit(_
) => true,
530 ast
::ExprKind
::Unary(ast
::UnOp
::Neg
, e
) => {
531 matches
!(&e
.kind
, ast
::ExprKind
::Lit(_
))
541 /// A convenience function for matching on identifiers during parsing.
542 /// Turns interpolated identifier (`$i: ident`) or lifetime (`$l: lifetime`) token
543 /// into the regular identifier or lifetime token it refers to,
544 /// otherwise returns the original token.
545 pub fn uninterpolate(&self) -> Cow
<'_
, Token
> {
547 Interpolated(nt
) => match **nt
{
548 NtIdent(ident
, is_raw
) => {
549 Cow
::Owned(Token
::new(Ident(ident
.name
, is_raw
), ident
.span
))
551 NtLifetime(ident
) => Cow
::Owned(Token
::new(Lifetime(ident
.name
), ident
.span
)),
552 _
=> Cow
::Borrowed(self),
554 _
=> Cow
::Borrowed(self),
558 /// Returns an identifier if this token is an identifier.
560 pub fn ident(&self) -> Option
<(Ident
, /* is_raw */ bool
)> {
561 // We avoid using `Token::uninterpolate` here because it's slow.
563 &Ident(name
, is_raw
) => Some((Ident
::new(name
, self.span
), is_raw
)),
564 Interpolated(nt
) => match **nt
{
565 NtIdent(ident
, is_raw
) => Some((ident
, is_raw
)),
572 /// Returns a lifetime identifier if this token is a lifetime.
574 pub fn lifetime(&self) -> Option
<Ident
> {
575 // We avoid using `Token::uninterpolate` here because it's slow.
577 &Lifetime(name
) => Some(Ident
::new(name
, self.span
)),
578 Interpolated(nt
) => match **nt
{
579 NtLifetime(ident
) => Some(ident
),
586 /// Returns `true` if the token is an identifier.
587 pub fn is_ident(&self) -> bool
{
588 self.ident().is_some()
591 /// Returns `true` if the token is a lifetime.
592 pub fn is_lifetime(&self) -> bool
{
593 self.lifetime().is_some()
596 /// Returns `true` if the token is an identifier whose name is the given
598 pub fn is_ident_named(&self, name
: Symbol
) -> bool
{
599 self.ident().map_or(false, |(ident
, _
)| ident
.name
== name
)
602 /// Returns `true` if the token is an interpolated path.
603 fn is_path(&self) -> bool
{
604 if let Interpolated(nt
) = &self.kind
&& let NtPath(..) = **nt
{
611 /// Would `maybe_whole_expr` in `parser.rs` return `Ok(..)`?
612 /// That is, is this a pre-parsed expression dropped into the token stream
613 /// (which happens while parsing the result of macro expansion)?
614 pub fn is_whole_expr(&self) -> bool
{
615 if let Interpolated(nt
) = &self.kind
616 && let NtExpr(_
) | NtLiteral(_
) | NtPath(_
) | NtBlock(_
) = **nt
624 /// Is the token an interpolated block (`$b:block`)?
625 pub fn is_whole_block(&self) -> bool
{
626 if let Interpolated(nt
) = &self.kind
&& let NtBlock(..) = **nt
{
633 /// Returns `true` if the token is either the `mut` or `const` keyword.
634 pub fn is_mutability(&self) -> bool
{
635 self.is_keyword(kw
::Mut
) || self.is_keyword(kw
::Const
)
638 pub fn is_qpath_start(&self) -> bool
{
639 self == &Lt
|| self == &BinOp(Shl
)
642 pub fn is_path_start(&self) -> bool
{
644 || self.is_qpath_start()
646 || self.is_path_segment_keyword()
647 || self.is_ident() && !self.is_reserved_ident()
650 /// Returns `true` if the token is a given keyword, `kw`.
651 pub fn is_keyword(&self, kw
: Symbol
) -> bool
{
652 self.is_non_raw_ident_where(|id
| id
.name
== kw
)
655 /// 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.
656 pub fn is_keyword_case(&self, kw
: Symbol
, case
: Case
) -> bool
{
658 || (case
== Case
::Insensitive
659 && self.is_non_raw_ident_where(|id
| {
660 id
.name
.as_str().to_lowercase() == kw
.as_str().to_lowercase()
664 pub fn is_path_segment_keyword(&self) -> bool
{
665 self.is_non_raw_ident_where(Ident
::is_path_segment_keyword
)
668 /// Returns true for reserved identifiers used internally for elided lifetimes,
669 /// unnamed method parameters, crate root module, error recovery etc.
670 pub fn is_special_ident(&self) -> bool
{
671 self.is_non_raw_ident_where(Ident
::is_special
)
674 /// Returns `true` if the token is a keyword used in the language.
675 pub fn is_used_keyword(&self) -> bool
{
676 self.is_non_raw_ident_where(Ident
::is_used_keyword
)
679 /// Returns `true` if the token is a keyword reserved for possible future use.
680 pub fn is_unused_keyword(&self) -> bool
{
681 self.is_non_raw_ident_where(Ident
::is_unused_keyword
)
684 /// Returns `true` if the token is either a special identifier or a keyword.
685 pub fn is_reserved_ident(&self) -> bool
{
686 self.is_non_raw_ident_where(Ident
::is_reserved
)
689 /// Returns `true` if the token is the identifier `true` or `false`.
690 pub fn is_bool_lit(&self) -> bool
{
691 self.is_non_raw_ident_where(|id
| id
.name
.is_bool_lit())
694 pub fn is_numeric_lit(&self) -> bool
{
697 Literal(Lit { kind: LitKind::Integer, .. }
) | Literal(Lit { kind: LitKind::Float, .. }
)
701 /// Returns `true` if the token is a non-raw identifier for which `pred` holds.
702 pub fn is_non_raw_ident_where(&self, pred
: impl FnOnce(Ident
) -> bool
) -> bool
{
704 Some((id
, false)) => pred(id
),
709 pub fn glue(&self, joint
: &Token
) -> Option
<Token
> {
710 let kind
= match self.kind
{
711 Eq
=> match joint
.kind
{
716 Lt
=> match joint
.kind
{
720 BinOp(Minus
) => LArrow
,
723 Gt
=> match joint
.kind
{
729 Not
=> match joint
.kind
{
733 BinOp(op
) => match joint
.kind
{
735 BinOp(And
) if op
== And
=> AndAnd
,
736 BinOp(Or
) if op
== Or
=> OrOr
,
737 Gt
if op
== Minus
=> RArrow
,
740 Dot
=> match joint
.kind
{
745 DotDot
=> match joint
.kind
{
750 Colon
=> match joint
.kind
{
754 SingleQuote
=> match joint
.kind
{
755 Ident(name
, false) => Lifetime(Symbol
::intern(&format
!("'{}", name
))),
759 Le
| EqEq
| Ne
| Ge
| AndAnd
| OrOr
| Tilde
| BinOpEq(..) | At
| DotDotDot
760 | DotDotEq
| Comma
| Semi
| ModSep
| RArrow
| LArrow
| FatArrow
| Pound
| Dollar
761 | Question
| OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..)
762 | Lifetime(..) | Interpolated(..) | DocComment(..) | Eof
=> return None
,
765 Some(Token
::new(kind
, self.span
.to(joint
.span
)))
769 impl PartialEq
<TokenKind
> for Token
{
771 fn eq(&self, rhs
: &TokenKind
) -> bool
{
776 #[derive(Clone, Encodable, Decodable)]
777 /// For interpolation during macro expansion.
778 pub enum Nonterminal
{
779 NtItem(P
<ast
::Item
>),
780 NtBlock(P
<ast
::Block
>),
781 NtStmt(P
<ast
::Stmt
>),
783 NtExpr(P
<ast
::Expr
>),
785 NtIdent(Ident
, /* is_raw */ bool
),
787 NtLiteral(P
<ast
::Expr
>),
788 /// Stuff inside brackets for attributes
789 NtMeta(P
<ast
::AttrItem
>),
790 NtPath(P
<ast
::Path
>),
791 NtVis(P
<ast
::Visibility
>),
794 #[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable)]
795 pub enum NonterminalKind
{
800 /// Keep track of whether the user used `:pat_param` or `:pat` and we inferred it from the
801 /// edition of the span. This is used for diagnostics.
816 impl NonterminalKind
{
817 /// The `edition` closure is used to get the edition for the given symbol. Doing
818 /// `span.edition()` is expensive, so we do it lazily.
821 edition
: impl FnOnce() -> Edition
,
822 ) -> Option
<NonterminalKind
> {
824 sym
::item
=> NonterminalKind
::Item
,
825 sym
::block
=> NonterminalKind
::Block
,
826 sym
::stmt
=> NonterminalKind
::Stmt
,
827 sym
::pat
=> match edition() {
828 Edition
::Edition2015
| Edition
::Edition2018
=> {
829 NonterminalKind
::PatParam { inferred: true }
831 Edition
::Edition2021
| Edition
::Edition2024
=> NonterminalKind
::PatWithOr
,
833 sym
::pat_param
=> NonterminalKind
::PatParam { inferred: false }
,
834 sym
::expr
=> NonterminalKind
::Expr
,
835 sym
::ty
=> NonterminalKind
::Ty
,
836 sym
::ident
=> NonterminalKind
::Ident
,
837 sym
::lifetime
=> NonterminalKind
::Lifetime
,
838 sym
::literal
=> NonterminalKind
::Literal
,
839 sym
::meta
=> NonterminalKind
::Meta
,
840 sym
::path
=> NonterminalKind
::Path
,
841 sym
::vis
=> NonterminalKind
::Vis
,
842 sym
::tt
=> NonterminalKind
::TT
,
846 fn symbol(self) -> Symbol
{
848 NonterminalKind
::Item
=> sym
::item
,
849 NonterminalKind
::Block
=> sym
::block
,
850 NonterminalKind
::Stmt
=> sym
::stmt
,
851 NonterminalKind
::PatParam { inferred: false }
=> sym
::pat_param
,
852 NonterminalKind
::PatParam { inferred: true }
| NonterminalKind
::PatWithOr
=> sym
::pat
,
853 NonterminalKind
::Expr
=> sym
::expr
,
854 NonterminalKind
::Ty
=> sym
::ty
,
855 NonterminalKind
::Ident
=> sym
::ident
,
856 NonterminalKind
::Lifetime
=> sym
::lifetime
,
857 NonterminalKind
::Literal
=> sym
::literal
,
858 NonterminalKind
::Meta
=> sym
::meta
,
859 NonterminalKind
::Path
=> sym
::path
,
860 NonterminalKind
::Vis
=> sym
::vis
,
861 NonterminalKind
::TT
=> sym
::tt
,
866 impl fmt
::Display
for NonterminalKind
{
867 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
868 write
!(f
, "{}", self.symbol())
873 pub fn span(&self) -> Span
{
875 NtItem(item
) => item
.span
,
876 NtBlock(block
) => block
.span
,
877 NtStmt(stmt
) => stmt
.span
,
878 NtPat(pat
) => pat
.span
,
879 NtExpr(expr
) | NtLiteral(expr
) => expr
.span
,
881 NtIdent(ident
, _
) | NtLifetime(ident
) => ident
.span
,
882 NtMeta(attr_item
) => attr_item
.span(),
883 NtPath(path
) => path
.span
,
884 NtVis(vis
) => vis
.span
,
889 impl PartialEq
for Nonterminal
{
890 fn eq(&self, rhs
: &Self) -> bool
{
892 (NtIdent(ident_lhs
, is_raw_lhs
), NtIdent(ident_rhs
, is_raw_rhs
)) => {
893 ident_lhs
== ident_rhs
&& is_raw_lhs
== is_raw_rhs
895 (NtLifetime(ident_lhs
), NtLifetime(ident_rhs
)) => ident_lhs
== ident_rhs
,
896 // FIXME: Assume that all "complex" nonterminal are not equal, we can't compare them
897 // correctly based on data from AST. This will prevent them from matching each other
898 // in macros. The comparison will become possible only when each nonterminal has an
899 // attached token stream from which it was parsed.
905 impl fmt
::Debug
for Nonterminal
{
906 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
908 NtItem(..) => f
.pad("NtItem(..)"),
909 NtBlock(..) => f
.pad("NtBlock(..)"),
910 NtStmt(..) => f
.pad("NtStmt(..)"),
911 NtPat(..) => f
.pad("NtPat(..)"),
912 NtExpr(..) => f
.pad("NtExpr(..)"),
913 NtTy(..) => f
.pad("NtTy(..)"),
914 NtIdent(..) => f
.pad("NtIdent(..)"),
915 NtLiteral(..) => f
.pad("NtLiteral(..)"),
916 NtMeta(..) => f
.pad("NtMeta(..)"),
917 NtPath(..) => f
.pad("NtPath(..)"),
918 NtVis(..) => f
.pad("NtVis(..)"),
919 NtLifetime(..) => f
.pad("NtLifetime(..)"),
924 impl<CTX
> HashStable
<CTX
> for Nonterminal
926 CTX
: crate::HashStableContext
,
928 fn hash_stable(&self, _hcx
: &mut CTX
, _hasher
: &mut StableHasher
) {
929 panic
!("interpolated tokens should not be present in the HIR")
933 // Some types are used a lot. Make sure they don't unintentionally get bigger.
934 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
937 use rustc_data_structures
::static_assert_size
;
938 // tidy-alphabetical-start
939 static_assert_size
!(Lit
, 12);
940 static_assert_size
!(LitKind
, 2);
941 static_assert_size
!(Nonterminal
, 16);
942 static_assert_size
!(Token
, 24);
943 static_assert_size
!(TokenKind
, 16);
944 // tidy-alphabetical-end