XXX: Token::is_reserved_ident -> is_reserved

To match `Ident::is_reserved`.

Author: nnethercote

compiler/rustc_ast/src/token.rs

@@ -292,7 +292,7 @@ impl LitKind {
 pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
     let ident_token = Token::new(Ident(name, is_raw), span);
 
-    !ident_token.is_reserved_ident()
+    !ident_token.is_reserved()
         || ident_token.is_path_segment_keyword()
         || [
             kw::Async,
@@ -324,7 +324,7 @@ pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: IdentIsRaw) -> boo
 fn ident_can_begin_type(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
     let ident_token = Token::new(Ident(name, is_raw), span);
 
-    !ident_token.is_reserved_ident()
+    !ident_token.is_reserved()
         || ident_token.is_path_segment_keyword()
         || [sym::underscore, kw::For, kw::Impl, kw::Fn, kw::Unsafe, kw::Extern, kw::Typeof, kw::Dyn]
             .contains(&name)
@@ -896,7 +896,7 @@ impl Token {
             || self.is_qpath_start()
             || self.is_whole_path()
             || self.is_path_segment_keyword()
-            || self.is_ident() && !self.is_reserved_ident()
+            || self.is_ident() && !self.is_reserved()
     }
 
     /// Returns `true` if the token is a given keyword, `kw`.
@@ -932,8 +932,8 @@ impl Token {
         self.is_non_raw_ident_where(Ident::is_unused_keyword)
     }
 
-    /// Returns `true` if the token is either a special identifier or a keyword.
-    pub fn is_reserved_ident(&self) -> bool {
+    /// Returns `true` if the token is either a reserved identifier or a keyword.
+    pub fn is_reserved(&self) -> bool {
         self.is_non_raw_ident_where(Ident::is_reserved)
     }
 

compiler/rustc_ast/src/tokenstream.rs

@@ -369,9 +369,9 @@ impl TokenStream {
                     (
                         TokenTree::Token(token_left, Spacing::Alone),
                         TokenTree::Token(token_right, _),
-                    ) if ((token_left.is_ident() && !token_left.is_reserved_ident())
+                    ) if ((token_left.is_ident() && !token_left.is_reserved())
                         || token_left.is_lit())
-                        && ((token_right.is_ident() && !token_right.is_reserved_ident())
+                        && ((token_right.is_ident() && !token_right.is_reserved())
                             || token_right.is_lit()) =>
                     {
                         token_left.span

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -2789,7 +2789,7 @@ impl<'a> Parser<'a> {
             return first_pat;
         }
         if !matches!(first_pat.kind, PatKind::Ident(_, _, None) | PatKind::Path(..))
-            || !self.look_ahead(1, |token| token.is_ident() && !token.is_reserved_ident())
+            || !self.look_ahead(1, |token| token.is_ident() && !token.is_reserved())
         {
             let mut snapshot_type = self.create_snapshot_for_diagnostic();
             snapshot_type.bump(); // `:`

compiler/rustc_parse/src/parser/expr.rs

@@ -3587,7 +3587,7 @@ impl<'a> Parser<'a> {
                     }
 
                     if let Some((ident, _)) = self.token.ident()
-                        && !self.token.is_reserved_ident()
+                        && !self.token.is_reserved()
                         && self.look_ahead(1, |t| {
                             AssocOp::from_token(t).is_some()
                                 || matches!(
@@ -3750,7 +3750,7 @@ impl<'a> Parser<'a> {
             let is_shorthand = !this.look_ahead(1, |t| t == &token::Colon || t == &token::Eq);
             // Proactively check whether parsing the field will be incorrect.
             let is_wrong = this.token.is_ident()
-                && !this.token.is_reserved_ident()
+                && !this.token.is_reserved()
                 && !this.look_ahead(1, |t| {
                     t == &token::Colon
                         || t == &token::Eq

compiler/rustc_parse/src/parser/mod.rs

@@ -722,7 +722,7 @@ impl<'a> Parser<'a> {
 
     /// Is the given keyword `kw` followed by a non-reserved identifier?
     fn is_kw_followed_by_ident(&self, kw: Symbol) -> bool {
-        self.token.is_keyword(kw) && self.look_ahead(1, |t| t.is_ident() && !t.is_reserved_ident())
+        self.token.is_keyword(kw) && self.look_ahead(1, |t| t.is_ident() && !t.is_reserved())
     }
 
     #[inline]

compiler/rustc_parse/src/parser/pat.rs

@@ -178,7 +178,7 @@ impl<'a> Parser<'a> {
         let mut first_pat = match self.parse_pat_no_top_alt(expected, syntax_loc) {
             Ok(pat) => pat,
             Err(err)
-                if self.token.is_reserved_ident()
+                if self.token.is_reserved()
                     && !self.token.is_keyword(kw::In)
                     && !self.token.is_keyword(kw::If) =>
             {

compiler/rustc_parse/src/parser/path.rs

@@ -124,7 +124,7 @@ impl<'a> Parser<'a> {
     /// ```
     fn recover_colon_before_qpath_proj(&mut self) -> bool {
         if !self.check_noexpect(&TokenKind::Colon)
-            || self.look_ahead(1, |t| !t.is_ident() || t.is_reserved_ident())
+            || self.look_ahead(1, |t| !t.is_ident() || t.is_reserved())
         {
             return false;
         }
@@ -251,7 +251,7 @@ impl<'a> Parser<'a> {
                 if style == PathStyle::Expr
                     && self.may_recover()
                     && self.token == token::Colon
-                    && self.look_ahead(1, |token| token.is_ident() && !token.is_reserved_ident())
+                    && self.look_ahead(1, |token| token.is_ident() && !token.is_reserved())
                 {
                     // Emit a special error message for `a::b:c` to help users
                     // otherwise, `a: c` might have meant to introduce a new binding
@@ -334,9 +334,7 @@ impl<'a> Parser<'a> {
                     self.expect_gt().map_err(|mut err| {
                         // Try to recover a `:` into a `::`
                         if self.token == token::Colon
-                            && self.look_ahead(1, |token| {
-                                token.is_ident() && !token.is_reserved_ident()
-                            })
+                            && self.look_ahead(1, |token| token.is_ident() && !token.is_reserved())
                         {
                             err.cancel();
                             err = self.dcx().create_err(PathSingleColon {

compiler/rustc_parse/src/parser/ty.rs

@@ -786,7 +786,7 @@ impl<'a> Parser<'a> {
         while self.can_begin_bound()
             || (self.may_recover()
                 && (self.token.can_begin_type()
-                    || (self.token.is_reserved_ident() && !self.token.is_keyword(kw::Where))))
+                    || (self.token.is_reserved() && !self.token.is_keyword(kw::Where))))
         {
             if self.token.is_keyword(kw::Dyn) {
                 // Account for `&dyn Trait + dyn Other`.