Introduce helper Token::non_raw_ident

Author: fmease

compiler/rustc_ast/src/token.rs

@@ -920,43 +920,43 @@ impl Token {
 
     /// Returns `true` if the token is a given keyword, `kw`.
     pub fn is_keyword(&self, kw: Symbol) -> bool {
-        self.is_non_raw_ident_where(|id| id.name == kw)
+        self.non_raw_ident().is_some_and(|id| id.name == kw)
     }
 
     /// 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.
     pub fn is_keyword_case(&self, kw: Symbol, case: Case) -> bool {
         self.is_keyword(kw)
             || (case == Case::Insensitive
-                && self.is_non_raw_ident_where(|id| {
+                && self.non_raw_ident().is_some_and(|id| {
                     // Do an ASCII case-insensitive match, because all keywords are ASCII.
                     id.name.as_str().eq_ignore_ascii_case(kw.as_str())
                 }))
     }
 
     pub fn is_path_segment_keyword(&self) -> bool {
-        self.is_non_raw_ident_where(sp::Ident::is_path_segment_keyword)
+        self.non_raw_ident().is_some_and(sp::Ident::is_path_segment_keyword)
     }
 
     /// Returns true for reserved identifiers used internally for elided lifetimes,
     /// unnamed method parameters, crate root module, error recovery etc.
     pub fn is_special_ident(&self) -> bool {
-        self.is_non_raw_ident_where(sp::Ident::is_special)
+        self.non_raw_ident().is_some_and(sp::Ident::is_special)
     }
 
     /// Returns `true` if the token is a keyword used in the language.
     pub fn is_used_keyword(&self) -> bool {
-        self.is_non_raw_ident_where(sp::Ident::is_used_keyword)
+        self.non_raw_ident().is_some_and(sp::Ident::is_used_keyword)
     }
 
     /// Returns `true` if the token is a keyword reserved for possible future use.
     pub fn is_unused_keyword(&self) -> bool {
-        self.is_non_raw_ident_where(sp::Ident::is_unused_keyword)
+        self.non_raw_ident().is_some_and(sp::Ident::is_unused_keyword)
     }
 
     /// Returns `true` if the token is either a special identifier or a keyword.
     pub fn is_reserved_ident(&self) -> bool {
-        self.is_non_raw_ident_where(sp::Ident::is_reserved)
+        self.non_raw_ident().is_some_and(sp::Ident::is_reserved)
     }
 
     pub fn is_non_reserved_ident(&self) -> bool {
@@ -975,7 +975,7 @@ impl Token {
 
     /// Returns `true` if the token is the identifier `true` or `false`.
     pub fn is_bool_lit(&self) -> bool {
-        self.is_non_raw_ident_where(|id| id.name.is_bool_lit())
+        self.non_raw_ident().is_some_and(|id| id.name.is_bool_lit())
     }
 
     pub fn is_numeric_lit(&self) -> bool {
@@ -990,11 +990,11 @@ impl Token {
         matches!(self.kind, Literal(Lit { kind: LitKind::Integer, .. }))
     }
 
-    /// Returns `true` if the token is a non-raw identifier for which `pred` holds.
-    pub fn is_non_raw_ident_where(&self, pred: impl FnOnce(sp::Ident) -> bool) -> bool {
+    /// Returns an identifier if this token is a non-raw identifier.
+    pub fn non_raw_ident(&self) -> Option<sp::Ident> {
         match self.ident() {
-            Some((id, IdentKind::Normal | IdentKind::ForcedKeyword)) => pred(id),
-            _ => false,
+            Some((id, IdentKind::Normal | IdentKind::ForcedKeyword)) => Some(id),
+            _ => None,
         }
     }
 

compiler/rustc_parse/src/parser/expr.rs

@@ -377,7 +377,7 @@ impl<'a> Parser<'a> {
         // Recover from `and` and `or` which are mistaken for `&&` and `||` respectively.
         if self.may_recover()
             && op.is_none()
-            && let Some((ident, IdentKind::Normal | IdentKind::ForcedKeyword)) = self.token.ident()
+            && let Some(ident) = self.token.non_raw_ident()
         {
             let (op, sub): (_, fn(_) -> _) = match ident.name {
                 sym::and => (BinOpKind::And, diagnostics::InvalidLogicalOperatorSub::Conjunction),
@@ -685,9 +685,8 @@ impl<'a> Parser<'a> {
                 // Check for typo of `'a: loop { break 'a }` with a missing `'`.
                 if let ExprKind::Path(None, ast::Path { segments, .. }) = &lhs.kind
                     && let [segment] = segments.as_slice()
-                    && self.token.is_non_raw_ident_where(|id| {
-                        matches!(id.name, kw::For | kw::Loop | kw::While)
-                    })
+                    && let Some(ident) = self.token.non_raw_ident()
+                    && let kw::For | kw::Loop | kw::While = ident.name
                 {
                     let snapshot = self.create_snapshot_for_diagnostic();
                     let label = Label {

compiler/rustc_parse/src/parser/function.rs

@@ -1,4 +1,3 @@
-use ast::token::IdentKind;
 use rustc_ast as ast;
 use rustc_ast::ast::*;
 use rustc_ast::token::{self, InvisibleOrigin, MetaVarKind, TokenKind};
@@ -330,13 +329,13 @@ impl<'a> Parser<'a> {
                     // Two qualifiers `$qual $qual` is enough, e.g. `async unsafe`.
                     || (
                         (
-                            t.is_non_raw_ident_where(|i|
+                            t.non_raw_ident().is_some_and(|i|
                                 quals.iter().any(|exp| exp.kw == i.name)
                                     // Rule out 2015 `const async: T = val`.
                                     && i.is_reserved()
                             )
                             || case == Case::Insensitive
-                                && t.is_non_raw_ident_where(|i| quals.iter().any(|exp| {
+                                && t.non_raw_ident().is_some_and(|i| quals.iter().any(|exp| {
                                     exp.kw.as_str() == i.name.as_str().to_lowercase()
                                 }))
                         )
@@ -837,12 +836,10 @@ impl<'a> Parser<'a> {
     /// Returns the parsed optional self parameter and whether a self shortcut was used.
     fn parse_self_param(&mut self) -> PResult<'a, Option<Param>> {
         // Extract an identifier *after* having confirmed that the token is one.
-        let expect_self_ident = |this: &mut Self| match this.token.ident() {
-            Some((ident, IdentKind::Normal | IdentKind::ForcedKeyword)) => {
-                this.bump();
-                ident
-            }
-            _ => unreachable!(),
+        let expect_self_ident = |this: &mut Self| {
+            let ident = this.token.non_raw_ident().unwrap();
+            this.bump();
+            ident
         };
         // is lifetime `n` tokens ahead?
         let is_lifetime = |this: &Self, n| this.look_ahead(n, |t| t.is_lifetime());

compiler/rustc_parse/src/parser/item.rs

@@ -1072,7 +1072,7 @@ impl<'a> Parser<'a> {
         // However, we must avoid keywords that occur as binary operators.
         // Currently, the only applicable keyword is `as` (`default as Ty`).
         if self.check_keyword(exp!(Default))
-            && self.look_ahead(1, |t| t.is_non_raw_ident_where(|i| i.name != kw::As))
+            && self.look_ahead(1, |t| t.non_raw_ident().is_some_and(|i| i.name != kw::As))
         {
             self.psess.gated_spans.gate(sym::specialization, self.token.span);
             self.bump(); // `default`
@@ -1473,15 +1473,13 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_ident_or_underscore(&mut self) -> PResult<'a, Ident> {
-        match self.token.ident() {
-            Some((
-                ident @ Ident { name: kw::Underscore, .. },
-                IdentKind::Normal | IdentKind::ForcedKeyword,
-            )) => {
-                self.bump();
-                Ok(ident)
-            }
-            _ => self.parse_ident(),
+        if let Some(ident) = self.token.non_raw_ident()
+            && let kw::Underscore = ident.name
+        {
+            self.bump();
+            Ok(ident)
+        } else {
+            self.parse_ident()
         }
     }
 

compiler/rustc_parse/src/parser/mod.rs

@@ -558,7 +558,7 @@ impl<'a> Parser<'a> {
         if self.check_keyword(exp) {
             true
         } else if case == Case::Insensitive
-            && let Some((ident, IdentKind::Normal | IdentKind::ForcedKeyword)) = self.token.ident()
+            && let Some(ident) = self.token.non_raw_ident()
             // Do an ASCII case-insensitive match, because all keywords are ASCII.
             && ident.as_str().eq_ignore_ascii_case(exp.kw.as_str())
         {
@@ -590,7 +590,7 @@ impl<'a> Parser<'a> {
         if self.eat_keyword(exp) {
             true
         } else if case == Case::Insensitive
-            && let Some((ident, IdentKind::Normal | IdentKind::ForcedKeyword)) = self.token.ident()
+            && let Some(ident) = self.token.non_raw_ident()
             // Do an ASCII case-insensitive match, because all keywords are ASCII.
             && ident.as_str().eq_ignore_ascii_case(exp.kw.as_str())
         {

compiler/rustc_parse/src/parser/path.rs

@@ -1,6 +1,5 @@
 use std::mem;
 
-use ast::token::IdentKind;
 use rustc_ast::token::{self, MetaVarKind, Token, TokenKind};
 use rustc_ast::{
     self as ast, AngleBracketedArg, AngleBracketedArgs, AnonConst, AssocItemConstraint,
@@ -458,14 +457,13 @@ impl<'a> Parser<'a> {
     }
 
     pub(super) fn parse_path_segment_ident(&mut self) -> PResult<'a, Ident> {
-        match self.token.ident() {
-            Some((ident, IdentKind::Normal | IdentKind::ForcedKeyword))
-                if ident.is_path_segment_keyword() =>
-            {
-                self.bump();
-                Ok(ident)
-            }
-            _ => self.parse_ident(),
+        if let Some(ident) = self.token.non_raw_ident()
+            && ident.is_path_segment_keyword()
+        {
+            self.bump();
+            Ok(ident)
+        } else {
+            self.parse_ident()
         }
     }
 

compiler/rustc_parse/src/parser/stmt.rs

@@ -1022,7 +1022,7 @@ impl<'a> Parser<'a> {
                                         && self.look_ahead(1, |token| {
                                             token.is_metavar_block()
                                                 || token.kind == token::OpenBrace
-                                                || token.is_non_raw_ident_where(|id| {
+                                                || token.non_raw_ident().is_some_and(|id| {
                                                     matches!(
                                                         id.name,
                                                         kw::For | kw::Loop | kw::While