Auto merge of #121591 - matthiaskrgr:rollup-8wfhh3v, r=matthiaskrgr

Rollup of 9 pull requests

Successful merges:

 - #119590 (Stabilize `cfg_target_abi`)
 - #120805 (make non-PartialEq-typed consts as patterns a hard error)
 - #121060 (Add newtypes for bool fields/params/return types)
 - #121284 (Add test cases for inlining compiler-private items)
 - #121324 (pattern_analysis: factor out unspecialization)
 - #121409 (Prevent cycle in implied predicates computation)
 - #121513 (Fix sgx unit test compilation)
 - #121570 (Make most bootstrap step types !Copy)
 - #121586 (Don't use `unwrap()` in `ArrayIntoIter` lint when typeck fails)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_ast/src/token.rs

@@ -107,7 +107,7 @@ impl Lit {
  /// Keep this in sync with `Token::can_begin_literal_or_bool` excluding unary negation.
  pub fn from_token(token: &Token) -> Option<Lit> {
  match token.uninterpolate().kind {
- Ident(name, false) if name.is_bool_lit() => Some(Lit::new(Bool, name, None)),
+ Ident(name, IdentIsRaw::No) if name.is_bool_lit() => Some(Lit::new(Bool, name, None)),
  Literal(token_lit) => Some(token_lit),
  Interpolated(ref nt)
  if let NtExpr(expr) | NtLiteral(expr) = &nt.0
@@ -183,7 +183,7 @@ impl LitKind {
  }
 }
 
-pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: bool) -> bool {
+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()
@@ -214,7 +214,7 @@ pub fn ident_can_begin_expr(name: Symbol, span: Span, is_raw: bool) -> bool {
  .contains(&name)
 }
 
-fn ident_can_begin_type(name: Symbol, span: Span, is_raw: bool) -> bool {
+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()
@@ -223,6 +223,24 @@ fn ident_can_begin_type(name: Symbol, span: Span, is_raw: bool) -> bool {
  .contains(&name)
 }
 
+#[derive(PartialEq, Encodable, Decodable, Debug, Copy, Clone, HashStable_Generic)]
+pub enum IdentIsRaw {
+ No,
+ Yes,
+}
+
+impl From<bool> for IdentIsRaw {
+ fn from(b: bool) -> Self {
+ if b { Self::Yes } else { Self::No }
+ }
+}
+
+impl From<IdentIsRaw> for bool {
+ fn from(is_raw: IdentIsRaw) -> bool {
+ matches!(is_raw, IdentIsRaw::Yes)
+ }
+}
+
 // SAFETY: due to the `Clone` impl below, all fields of all variants other than
 // `Interpolated` must impl `Copy`.
 #[derive(PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
@@ -298,7 +316,7 @@ pub enum TokenKind {
  /// Do not forget about `NtIdent` when you want to match on identifiers.
  /// It's recommended to use `Token::(ident,uninterpolate,uninterpolated_span)` to
  /// treat regular and interpolated identifiers in the same way.
- Ident(Symbol, /* is_raw */ bool),
+ Ident(Symbol, IdentIsRaw),
  /// Lifetime identifier token.
  /// Do not forget about `NtLifetime` when you want to match on lifetime identifiers.
  /// It's recommended to use `Token::(lifetime,uninterpolate,uninterpolated_span)` to
@@ -411,7 +429,7 @@ impl Token {
 
  /// Recovers a `Token` from an `Ident`. This creates a raw identifier if necessary.
  pub fn from_ast_ident(ident: Ident) -> Self {
- Token::new(Ident(ident.name, ident.is_raw_guess()), ident.span)
+ Token::new(Ident(ident.name, ident.is_raw_guess().into()), ident.span)
  }
 
  /// For interpolated tokens, returns a span of the fragment to which the interpolated
@@ -567,7 +585,7 @@ impl Token {
  pub fn can_begin_literal_maybe_minus(&self) -> bool {
  match self.uninterpolate().kind {
  Literal(..) | BinOp(Minus) => true,
- Ident(name, false) if name.is_bool_lit() => true,
+ Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
  Interpolated(ref nt) => match &nt.0 {
  NtLiteral(_) => true,
  NtExpr(e) => match &e.kind {
@@ -602,7 +620,7 @@ impl Token {
 
  /// Returns an identifier if this token is an identifier.
  #[inline]
- pub fn ident(&self) -> Option<(Ident, /* is_raw */ bool)> {
+ pub fn ident(&self) -> Option<(Ident, IdentIsRaw)> {
  // We avoid using `Token::uninterpolate` here because it's slow.
  match &self.kind {
  &Ident(name, is_raw) => Some((Ident::new(name, self.span), is_raw)),
@@ -755,7 +773,7 @@ impl Token {
  /// 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(Ident) -> bool) -> bool {
  match self.ident() {
- Some((id, false)) => pred(id),
+ Some((id, IdentIsRaw::No)) => pred(id),
  _ => false,
  }
  }
@@ -806,7 +824,7 @@ impl Token {
  _ => return None,
  },
  SingleQuote => match joint.kind {
- Ident(name, false) => Lifetime(Symbol::intern(&format!("'{name}"))),
+ Ident(name, IdentIsRaw::No) => Lifetime(Symbol::intern(&format!("'{name}"))),
  _ => return None,
  },
 
@@ -836,7 +854,7 @@ pub enum Nonterminal {
  NtPat(P<ast::Pat>),
  NtExpr(P<ast::Expr>),
  NtTy(P<ast::Ty>),
- NtIdent(Ident, /* is_raw */ bool),
+ NtIdent(Ident, IdentIsRaw),
  NtLifetime(Ident),
  NtLiteral(P<ast::Expr>),
  /// Stuff inside brackets for attributes

compiler/rustc_ast/src/tokenstream.rs

@@ -656,7 +656,7 @@ impl TokenStream {
  DelimSpacing::new(Spacing::JointHidden, Spacing::Alone),
  Delimiter::Bracket,
  [
- TokenTree::token_alone(token::Ident(sym::doc, false), span),
+ TokenTree::token_alone(token::Ident(sym::doc, token::IdentIsRaw::No), 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

@@ -185,7 +185,7 @@ fn space_between(tt1: &TokenTree, tt2: &TokenTree) -> bool {
 
  // IDENT + `!`: `println!()`, but `if !x { ... }` needs a space after the `if`
  (Tok(Token { kind: Ident(sym, is_raw), span }, _), Tok(Token { kind: Not, .. }, _))
- if !Ident::new(*sym, *span).is_reserved() || *is_raw =>
+ if !Ident::new(*sym, *span).is_reserved() || matches!(is_raw, IdentIsRaw::Yes) =>
  {
  false
  }
@@ -197,7 +197,7 @@ fn space_between(tt1: &TokenTree, tt2: &TokenTree) -> bool {
  || *sym == kw::Fn
  || *sym == kw::SelfUpper
  || *sym == kw::Pub
- || *is_raw =>
+ || matches!(is_raw, IdentIsRaw::Yes) =>
  {
  false
  }
@@ -731,7 +731,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  token::NtBlock(e) => self.block_to_string(e),
  token::NtStmt(e) => self.stmt_to_string(e),
  token::NtPat(e) => self.pat_to_string(e),
- token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(*e, *is_raw).to_string(),
+ &token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(e, is_raw.into()).to_string(),
  token::NtLifetime(e) => e.to_string(),
  token::NtLiteral(e) => self.expr_to_string(e),
  token::NtVis(e) => self.vis_to_string(e),
@@ -795,7 +795,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
 
  /* Name components */
  token::Ident(s, is_raw) => {
- IdentPrinter::new(s, is_raw, convert_dollar_crate).to_string().into()
+ IdentPrinter::new(s, is_raw.into(), convert_dollar_crate).to_string().into()
  }
  token::Lifetime(s) => s.to_string().into(),
 

compiler/rustc_builtin_macros/src/asm.rs

@@ -1,3 +1,4 @@
+use ast::token::IdentIsRaw;
 use rustc_ast as ast;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter};
@@ -416,7 +417,7 @@ fn parse_reg<'a>(
 ) -> PResult<'a, ast::InlineAsmRegOrRegClass> {
  p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
  let result = match p.token.uninterpolate().kind {
- token::Ident(name, false) => ast::InlineAsmRegOrRegClass::RegClass(name),
+ token::Ident(name, IdentIsRaw::No) => ast::InlineAsmRegOrRegClass::RegClass(name),
  token::Literal(token::Lit { kind: token::LitKind::Str, symbol, suffix: _ }) => {
  *explicit_reg = true;
  ast::InlineAsmRegOrRegClass::Reg(symbol)

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -1,7 +1,6 @@
 use rustc_ast::{
  ptr::P,
- token,
- token::Delimiter,
+ token::{self, Delimiter, IdentIsRaw},
  tokenstream::{DelimSpan, TokenStream, TokenTree},
  BinOpKind, BorrowKind, DelimArgs, Expr, ExprKind, ItemKind, MacCall, MethodCall, Mutability,
  Path, PathSegment, Stmt, StructRest, UnOp, UseTree, UseTreeKind, DUMMY_NODE_ID,
@@ -170,7 +169,10 @@ impl<'cx, 'a> Context<'cx, 'a> {
  ];
  let captures = self.capture_decls.iter().flat_map(|cap| {
  [
- TokenTree::token_joint_hidden(token::Ident(cap.ident.name, false), cap.ident.span),
+ TokenTree::token_joint_hidden(
+ token::Ident(cap.ident.name, IdentIsRaw::No),
+ cap.ident.span,
+ ),
  TokenTree::token_alone(token::Comma, self.span),
  ]
  });

compiler/rustc_builtin_macros/src/deriving/decodable.rs

@@ -198,7 +198,7 @@ where
  match fields {
  Unnamed(fields, is_tuple) => {
  let path_expr = cx.expr_path(outer_pat_path);
- if !*is_tuple {
+ if matches!(is_tuple, IsTuple::No) {
  path_expr
  } else {
  let fields = fields

compiler/rustc_builtin_macros/src/deriving/default.rs

@@ -62,8 +62,8 @@ fn default_struct_substructure(
  let default_call = |span| cx.expr_call_global(span, default_ident.clone(), ThinVec::new());
 
  let expr = match summary {
- Unnamed(_, false) => cx.expr_ident(trait_span, substr.type_ident),
- Unnamed(fields, true) => {
+ Unnamed(_, IsTuple::No) => cx.expr_ident(trait_span, substr.type_ident),
+ Unnamed(fields, IsTuple::Yes) => {
  let exprs = fields.iter().map(|sp| default_call(*sp)).collect();
  cx.expr_call_ident(trait_span, substr.type_ident, exprs)
  }

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -286,10 +286,16 @@ pub struct FieldInfo {
  pub other_selflike_exprs: Vec<P<Expr>>,
 }
 
+#[derive(Copy, Clone)]
+pub enum IsTuple {
+ No,
+ Yes,
+}
+
 /// Fields for a static method
 pub enum StaticFields {
  /// Tuple and unit structs/enum variants like this.
- Unnamed(Vec<Span>, bool /*is tuple*/),
+ Unnamed(Vec<Span>, IsTuple),
  /// Normal structs/struct variants.
  Named(Vec<(Ident, Span)>),
 }
@@ -1439,7 +1445,10 @@ impl<'a> TraitDef<'a> {
  }
  }
 
- let is_tuple = matches!(struct_def, ast::VariantData::Tuple(..));
+ let is_tuple = match struct_def {
+ ast::VariantData::Tuple(..) => IsTuple::Yes,
+ _ => IsTuple::No,
+ };
  match (just_spans.is_empty(), named_idents.is_empty()) {
  (false, false) => cx
  .dcx()

compiler/rustc_builtin_macros/src/format.rs

@@ -10,6 +10,7 @@ use rustc_ast::{
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, DiagnosticBuilder, MultiSpan, PResult, SingleLabelManySpans};
 use rustc_expand::base::{self, *};
+use rustc_parse::parser::Recovered;
 use rustc_parse_format as parse;
 use rustc_span::symbol::{Ident, Symbol};
 use rustc_span::{BytePos, InnerSpan, Span};
@@ -111,9 +112,8 @@ fn parse_args<'a>(ecx: &mut ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<
  _ => return Err(err),
  }
  }
- Ok(recovered) => {
- assert!(recovered);
- }
+ Ok(Recovered::Yes) => (),
+ Ok(Recovered::No) => unreachable!(),
  }
  }
  first = false;

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -2106,65 +2106,72 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
  return Ok(args[0].immediate());
  }
 
+ #[derive(Copy, Clone)]
+ enum Sign {
+ Unsigned,
+ Signed,
+ }
+ use Sign::*;
+
  enum Style {
  Float,
- Int(/* is signed? */ bool),
+ Int(Sign),
  Unsupported,
  }
 
  let (in_style, in_width) = match in_elem.kind() {
  // vectors of pointer-sized integers should've been
  // disallowed before here, so this unwrap is safe.
  ty::Int(i) => (
- Style::Int(true),
+ Style::Int(Signed),
  i.normalize(bx.tcx().sess.target.pointer_width).bit_width().unwrap(),
  ),
  ty::Uint(u) => (
- Style::Int(false),
+ Style::Int(Unsigned),
  u.normalize(bx.tcx().sess.target.pointer_width).bit_width().unwrap(),
  ),
  ty::Float(f) => (Style::Float, f.bit_width()),
  _ => (Style::Unsupported, 0),
  };
  let (out_style, out_width) = match out_elem.kind() {
  ty::Int(i) => (
- Style::Int(true),
+ Style::Int(Signed),
  i.normalize(bx.tcx().sess.target.pointer_width).bit_width().unwrap(),
  ),
  ty::Uint(u) => (
- Style::Int(false),
+ Style::Int(Unsigned),
  u.normalize(bx.tcx().sess.target.pointer_width).bit_width().unwrap(),
  ),
  ty::Float(f) => (Style::Float, f.bit_width()),
  _ => (Style::Unsupported, 0),
  };
 
  match (in_style, out_style) {
- (Style::Int(in_is_signed), Style::Int(_)) => {
+ (Style::Int(sign), Style::Int(_)) => {
  return Ok(match in_width.cmp(&out_width) {
  Ordering::Greater => bx.trunc(args[0].immediate(), llret_ty),
  Ordering::Equal => args[0].immediate(),
- Ordering::Less => {
- if in_is_signed {
- bx.sext(args[0].immediate(), llret_ty)
- } else {
- bx.zext(args[0].immediate(), llret_ty)
- }
- }
+ Ordering::Less => match sign {
+ Sign::Signed => bx.sext(args[0].immediate(), llret_ty),
+ Sign::Unsigned => bx.zext(args[0].immediate(), llret_ty),
+ },
  });
  }
- (Style::Int(in_is_signed), Style::Float) => {
- return Ok(if in_is_signed {
- bx.sitofp(args[0].immediate(), llret_ty)
- } else {
- bx.uitofp(args[0].immediate(), llret_ty)
- });
+ (Style::Int(Sign::Signed), Style::Float) => {
+ return Ok(bx.sitofp(args[0].immediate(), llret_ty));
  }
- (Style::Float, Style::Int(out_is_signed)) => {
- return Ok(match (out_is_signed, name == sym::simd_as) {
- (false, false) => bx.fptoui(args[0].immediate(), llret_ty),
- (true, false) => bx.fptosi(args[0].immediate(), llret_ty),
- (_, true) => bx.cast_float_to_int(out_is_signed, args[0].immediate(), llret_ty),
+ (Style::Int(Sign::Unsigned), Style::Float) => {
+ return Ok(bx.uitofp(args[0].immediate(), llret_ty));
+ }
+ (Style::Float, Style::Int(sign)) => {
+ return Ok(match (sign, name == sym::simd_as) {
+ (Sign::Unsigned, false) => bx.fptoui(args[0].immediate(), llret_ty),
+ (Sign::Signed, false) => bx.fptosi(args[0].immediate(), llret_ty),
+ (_, true) => bx.cast_float_to_int(
+ matches!(sign, Sign::Signed),
+ args[0].immediate(),
+ llret_ty,
+ ),
  });
  }
  (Style::Float, Style::Float) => {

compiler/rustc_expand/src/mbe/macro_check.rs

@@ -107,7 +107,7 @@
 use crate::errors;
 use crate::mbe::{KleeneToken, TokenTree};
 
-use rustc_ast::token::{Delimiter, Token, TokenKind};
+use rustc_ast::token::{Delimiter, IdentIsRaw, Token, TokenKind};
 use rustc_ast::{NodeId, DUMMY_NODE_ID};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{DiagnosticMessage, MultiSpan};
@@ -409,7 +409,7 @@ fn check_nested_occurrences(
  match (state, tt) {
  (
  NestedMacroState::Empty,
- &TokenTree::Token(Token { kind: TokenKind::Ident(name, false), .. }),
+ &TokenTree::Token(Token { kind: TokenKind::Ident(name, IdentIsRaw::No), .. }),
  ) => {
  if name == kw::MacroRules {
  state = NestedMacroState::MacroRules;