Rollup of 19 pull requests

compiler/rustc_ast/src/token.rs

@@ -231,7 +231,9 @@ impl Lit {
     /// `Parser::eat_token_lit` (excluding unary negation).
     pub fn from_token(token: &Token) -> Option<Lit> {
         match token.uninterpolate().kind {
-            Ident(name, IdentIsRaw::No) if name.is_bool_lit() => Some(Lit::new(Bool, name, None)),
+            Ident(name, IdentKind::Normal) if name.is_bool_lit() => {
+                Some(Lit::new(Bool, name, None))
+            }
             Literal(token_lit) => Some(token_lit),
             OpenInvisible(InvisibleOrigin::MetaVar(
                 MetaVarKind::Literal | MetaVarKind::Expr { .. },
@@ -307,11 +309,11 @@ impl LitKind {
     }
 }
 
-pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
+pub fn ident_can_begin_expr(name: Symbol, span: Span, kind: IdentKind) -> bool {
     // WARNING: Take care when modifying this function! It will change the stable(!) set of
     //          tokens that are allowed to match an `expr` nonterminal which is user observable.
 
-    let ident_token = Token::new(Ident(name, is_raw), span);
+    let ident_token = Token::new(Ident(name, kind), span);
 
     // FIXME: Remove `box` from this list given we officially no longer support box expressions
     //        (#108471) (needs lang FCP as it affects stable macro matching behavior).
@@ -344,11 +346,11 @@ pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: IdentIsRaw) -> boo
         .contains(&name)
 }
 
-fn ident_can_begin_type(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
+fn ident_can_begin_type(name: Symbol, span: Span, kind: IdentKind) -> bool {
     // WARNING: Take care when modifying this function! It will change the stable(!) set of
     //          tokens that are allowed to match an `ty` nonterminal which is user observable.
 
-    let ident_token = Token::new(Ident(name, is_raw), span);
+    let ident_token = Token::new(Ident(name, kind), span);
 
     !ident_token.is_reserved_ident()
         || ident_token.is_path_segment_keyword()
@@ -357,32 +359,26 @@ fn ident_can_begin_type(name: Symbol, span: Span, is_raw: IdentIsRaw) -> bool {
 }
 
 #[derive(PartialEq, Eq, Encodable, Decodable, Hash, Debug, Copy, Clone, StableHash)]
-pub enum IdentIsRaw {
-    No,
-    Yes,
+pub enum IdentKind {
+    Normal,
+    Raw,
 }
 
-impl IdentIsRaw {
+impl IdentKind {
     pub fn to_print_mode_ident(self) -> IdentPrintMode {
         match self {
-            IdentIsRaw::No => IdentPrintMode::Normal,
-            IdentIsRaw::Yes => IdentPrintMode::RawIdent,
+            IdentKind::Normal => IdentPrintMode::Normal,
+            IdentKind::Raw => IdentPrintMode::RawIdent,
         }
     }
     pub fn to_print_mode_lifetime(self) -> IdentPrintMode {
         match self {
-            IdentIsRaw::No => IdentPrintMode::Normal,
-            IdentIsRaw::Yes => IdentPrintMode::RawLifetime,
+            IdentKind::Normal => IdentPrintMode::Normal,
+            IdentKind::Raw => IdentPrintMode::RawLifetime,
         }
     }
 }
 
-impl From<bool> for IdentIsRaw {
-    fn from(b: bool) -> Self {
-        if b { Self::Yes } else { Self::No }
-    }
-}
-
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Encodable, Decodable, Debug, StableHash)]
 pub enum TokenKind {
     /* Expression-operator symbols. */
@@ -507,22 +503,22 @@ pub enum TokenKind {
     /// It's recommended to use `Token::{ident,uninterpolate}` and
     /// `Parser::token_uninterpolated_span` to treat regular and interpolated
     /// identifiers in the same way.
-    Ident(Symbol, IdentIsRaw),
+    Ident(Symbol, IdentKind),
     /// This identifier (and its span) is the identifier passed to the
     /// declarative macro. The span in the surrounding `Token` is the span of
     /// the `ident` metavariable in the macro's RHS.
-    NtIdent(sp::Ident, IdentIsRaw),
+    NtIdent(sp::Ident, IdentKind),
 
     /// Lifetime identifier token.
     /// Do not forget about `NtLifetime` when you want to match on lifetime identifiers.
     /// It's recommended to use `Token::{ident,uninterpolate}` and
     /// `Parser::token_uninterpolated_span` to treat regular and interpolated
     /// identifiers in the same way.
-    Lifetime(Symbol, IdentIsRaw),
+    Lifetime(Symbol, IdentKind),
     /// This identifier (and its span) is the lifetime passed to the
     /// declarative macro. The span in the surrounding `Token` is the span of
     /// the `lifetime` metavariable in the macro's RHS.
-    NtLifetime(sp::Ident, IdentIsRaw),
+    NtLifetime(sp::Ident, IdentKind),
 
     /// A doc comment token.
     /// `Symbol` is the doc comment's data excluding its "quotes" (`///`, `/**`, etc)
@@ -643,7 +639,8 @@ impl Token {
 
     /// Recovers a `Token` from an `Ident`. This creates a raw identifier if necessary.
     pub fn from_ast_ident(ident: sp::Ident) -> Self {
-        Token::new(Ident(ident.name, ident.is_raw_guess().into()), ident.span)
+        let kind = if ident.is_raw_guess() { IdentKind::Raw } else { IdentKind::Normal };
+        Token::new(Ident(ident.name, kind), ident.span)
     }
 
     pub fn is_range_separator(&self) -> bool {
@@ -674,8 +671,8 @@ impl Token {
         //          tokens that are allowed to match an `expr` nonterminal which is user observable.
 
         match self.uninterpolate().kind {
-            Ident(name, is_raw)              =>
-                ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
+            Ident(name, kind)                 =>
+                ident_can_begin_expr(name, self.span, kind), // value name or keyword
             OpenParen                         | // tuple
             OpenBrace                         | // block
             OpenBracket                       | // array
@@ -743,8 +740,8 @@ impl Token {
         //        object types (consider `use<>+` and `use<T> + Trait` for example).
 
         match self.uninterpolate().kind {
-            Ident(name, is_raw) =>
-                ident_can_begin_type(name, self.span, is_raw), // type name or keyword
+            Ident(name, kind) =>
+                ident_can_begin_type(name, self.span, kind), // type name or keyword
             OpenParen          // tuple
             | OpenBracket      // array
             | Bang             // never
@@ -766,7 +763,7 @@ impl Token {
     pub fn can_begin_const_arg(&self) -> bool {
         match self.kind {
             OpenBrace | Literal(..) | Minus => true,
-            Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
+            Ident(name, IdentKind::Normal) if name.is_bool_lit() => true,
             OpenInvisible(InvisibleOrigin::MetaVar(
                 MetaVarKind::Expr { .. } | MetaVarKind::Block | MetaVarKind::Literal,
             )) => true,
@@ -815,7 +812,7 @@ impl Token {
     pub fn can_begin_literal_maybe_minus(&self) -> bool {
         match self.uninterpolate().kind {
             Literal(..) | Minus => true,
-            Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
+            Ident(name, IdentKind::Normal) if name.is_bool_lit() => true,
             OpenInvisible(InvisibleOrigin::MetaVar(mv_kind)) => match mv_kind {
                 MetaVarKind::Literal => true,
                 MetaVarKind::Expr { can_begin_literal_maybe_minus, .. } => {
@@ -845,32 +842,32 @@ impl Token {
     /// otherwise returns the original token.
     pub fn uninterpolate(&self) -> Cow<'_, Token> {
         match self.kind {
-            NtIdent(ident, is_raw) => Cow::Owned(Token::new(Ident(ident.name, is_raw), ident.span)),
-            NtLifetime(ident, is_raw) => {
-                Cow::Owned(Token::new(Lifetime(ident.name, is_raw), ident.span))
+            NtIdent(ident, kind) => Cow::Owned(Token::new(Ident(ident.name, kind), ident.span)),
+            NtLifetime(ident, kind) => {
+                Cow::Owned(Token::new(Lifetime(ident.name, kind), ident.span))
             }
             _ => Cow::Borrowed(self),
         }
     }
 
     /// Returns an identifier if this token is an identifier.
     #[inline]
-    pub fn ident(&self) -> Option<(sp::Ident, IdentIsRaw)> {
+    pub fn ident(&self) -> Option<(sp::Ident, IdentKind)> {
         // We avoid using `Token::uninterpolate` here because it's slow.
         match self.kind {
-            Ident(name, is_raw) => Some((sp::Ident::new(name, self.span), is_raw)),
-            NtIdent(ident, is_raw) => Some((ident, is_raw)),
+            Ident(name, kind) => Some((sp::Ident::new(name, self.span), kind)),
+            NtIdent(ident, kind) => Some((ident, kind)),
             _ => None,
         }
     }
 
     /// Returns a lifetime identifier if this token is a lifetime.
     #[inline]
-    pub fn lifetime(&self) -> Option<(sp::Ident, IdentIsRaw)> {
+    pub fn lifetime(&self) -> Option<(sp::Ident, IdentKind)> {
         // We avoid using `Token::uninterpolate` here because it's slow.
         match self.kind {
-            Lifetime(name, is_raw) => Some((sp::Ident::new(name, self.span), is_raw)),
-            NtLifetime(ident, is_raw) => Some((ident, is_raw)),
+            Lifetime(name, kind) => Some((sp::Ident::new(name, self.span), kind)),
+            NtLifetime(ident, kind) => Some((ident, kind)),
             _ => None,
         }
     }
@@ -929,43 +926,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 {
@@ -974,13 +971,21 @@ impl Token {
 
     pub fn non_reserved_ident(&self) -> Option<sp::Ident> {
         self.ident()
-            .filter(|&(id, raw)| raw == IdentIsRaw::Yes || !sp::Ident::is_reserved(id))
+            .filter(|&(id, kind)| kind == IdentKind::Raw || !id.is_reserved())
             .map(|(id, _)| id)
     }
 
+    /// If this token is a non-raw identifier, return the identifier in question.
+    pub fn non_raw_ident(&self) -> Option<sp::Ident> {
+        match self.ident() {
+            Some((id, IdentKind::Normal)) => Some(id),
+            _ => None,
+        }
+    }
+
     /// 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 {
@@ -995,14 +1000,6 @@ 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 {
-        match self.ident() {
-            Some((id, IdentIsRaw::No)) => pred(id),
-            _ => false,
-        }
-    }
-
     /// Is this an invisible open delimiter at the start of a token sequence
     /// from an expanded metavar?
     pub fn is_metavar_seq(&self) -> Option<MetaVarKind> {
@@ -1076,8 +1073,8 @@ impl Token {
             (Colon, Colon) => PathSep,
             (Colon, _) => return None,
 
-            (SingleQuote, Ident(name, is_raw)) => {
-                Lifetime(Symbol::intern(&format!("'{name}")), *is_raw)
+            (SingleQuote, Ident(name, kind)) => {
+                Lifetime(Symbol::intern(&format!("'{name}")), *kind)
             }
             (SingleQuote, _) => return None,
 

compiler/rustc_ast/src/tokenstream.rs

@@ -793,7 +793,7 @@ impl TokenStream {
                 DelimSpacing::new(Spacing::JointHidden, Spacing::Alone),
                 Delimiter::Bracket,
                 [
-                    TokenTree::token_alone(token::Ident(sym::doc, token::IdentIsRaw::No), span),
+                    TokenTree::token_alone(token::Ident(sym::doc, token::IdentKind::Normal), span),
                     TokenTree::token_alone(token::Eq, span),
                     TokenTree::token_alone(
                         TokenKind::lit(token::StrRaw(num_of_hashes), data, None),

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -364,20 +364,18 @@ fn space_between(tt1: &TokenTree, tt2: &TokenTree) -> bool {
 
         // IDENT + `!`: `println!()`, but `if !x { ... }` needs a space after the `if`
         (
-            Tok(tk::Token { kind: tk::Ident(sym, is_raw), span }, _),
+            Tok(tk::Token { kind: tk::Ident(sym, kind), span }, _),
             Tok(tk::Token { kind: tk::Bang, .. }, _),
-        ) if !Ident::new(*sym, *span).is_reserved() || matches!(is_raw, tk::IdentIsRaw::Yes) => {
-            false
-        }
+        ) if !Ident::new(*sym, *span).is_reserved() || matches!(kind, tk::IdentKind::Raw) => false,
 
         // IDENT|`fn`|`Self`|`pub` + `(`: `f(3)`, `fn(x: u8)`, `Self()`, `pub(crate)`,
         //      but `let (a, b) = (1, 2)` needs a space after the `let`
-        (Tok(tk::Token { kind: tk::Ident(sym, is_raw), span }, _), Del(_, _, Parenthesis, _))
+        (Tok(tk::Token { kind: tk::Ident(sym, kind), span }, _), Del(_, _, Parenthesis, _))
             if !Ident::new(*sym, *span).is_reserved()
                 || *sym == kw::Fn
                 || *sym == kw::SelfUpper
                 || *sym == kw::Pub
-                || matches!(is_raw, tk::IdentIsRaw::Yes) =>
+                || matches!(kind, tk::IdentKind::Raw) =>
         {
             false
         }
@@ -1076,17 +1074,17 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             tk::Literal(lit) => literal_to_string(lit).into(),
 
             /* Name components */
-            tk::Ident(name, is_raw) => {
-                IdentPrinter::new(name, is_raw.to_print_mode_ident(), convert_dollar_crate)
+            tk::Ident(name, kind) => {
+                IdentPrinter::new(name, kind.to_print_mode_ident(), convert_dollar_crate)
                     .to_string()
                     .into()
             }
-            tk::NtIdent(ident, is_raw) => {
-                IdentPrinter::for_ast_ident(ident, is_raw.to_print_mode_ident()).to_string().into()
+            tk::NtIdent(ident, kind) => {
+                IdentPrinter::for_ast_ident(ident, kind.to_print_mode_ident()).to_string().into()
             }
 
-            tk::Lifetime(name, is_raw) | tk::NtLifetime(Ident { name, .. }, is_raw) => {
-                IdentPrinter::new(name, is_raw.to_print_mode_lifetime(), None).to_string().into()
+            tk::Lifetime(name, kind) | tk::NtLifetime(Ident { name, .. }, kind) => {
+                IdentPrinter::new(name, kind.to_print_mode_lifetime(), None).to_string().into()
             }
 
             /* Other */

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -1604,7 +1604,7 @@ impl<'a, G> Diagnostic<'a, G> for AttributeParseError<'_> {
         match &self.reason {
             AttributeParseErrorReason::ExpectedStringLiteral { byte_string } => {
                 if let Some(start_point_span) = byte_string {
-                    diag.span_suggestion(
+                    diag.span_suggestion_short(
                         *start_point_span,
                         "consider removing the prefix",
                         "",

compiler/rustc_borrowck/src/lib.rs

@@ -361,7 +361,6 @@ fn borrowck_collect_region_constraints<'tcx>(
         deferred_closure_requirements,
         polonius_context,
     } = type_check::type_check(
-        root_cx,
         &infcx,
         body,
         &promoted,