Auto merge of rust-lang#3326 - rust-lang:rustup-2024-02-26, r=RalfJung

Automatic Rustup

also fixes rust-lang/miri#3308

.github/workflows/ci.yml

@@ -65,9 +65,20 @@ jobs:
  - name: x86_64-gnu-tools
  os: ubuntu-20.04-16core-64gb
  env: {}
+ defaults:
+ run:
+ shell: "${{ contains(matrix.os, 'windows') && 'msys2 {0}' || 'bash' }}"
  timeout-minutes: 600
  runs-on: "${{ matrix.os }}"
  steps:
+ - if: "contains(matrix.os, 'windows')"
+ uses: msys2/setup-msys2@v2.22.0
+ with:
+ msystem: "${{ contains(matrix.name, 'i686') && 'mingw32' || 'mingw64' }}"
+ update: false
+ release: true
+ path-type: inherit
+ install: "make dos2unix diffutils\n"
  - name: disable git crlf conversion
  run: git config --global core.autocrlf false
  - name: checkout the source code
@@ -461,9 +472,20 @@ jobs:
  RUST_CONFIGURE_ARGS: "--build=x86_64-pc-windows-msvc --enable-extended --enable-profiler"
  SCRIPT: python x.py dist bootstrap --include-default-paths
  os: windows-2019-8core-32gb
+ defaults:
+ run:
+ shell: "${{ contains(matrix.os, 'windows') && 'msys2 {0}' || 'bash' }}"
  timeout-minutes: 600
  runs-on: "${{ matrix.os }}"
  steps:
+ - if: "contains(matrix.os, 'windows')"
+ uses: msys2/setup-msys2@v2.22.0
+ with:
+ msystem: "${{ contains(matrix.name, 'i686') && 'mingw32' || 'mingw64' }}"
+ update: false
+ release: true
+ path-type: inherit
+ install: "make dos2unix diffutils\n"
  - name: disable git crlf conversion
  run: git config --global core.autocrlf false
  - name: checkout the source code
@@ -589,9 +611,20 @@ jobs:
  env:
  CODEGEN_BACKENDS: "llvm,cranelift"
  os: ubuntu-20.04-16core-64gb
+ defaults:
+ run:
+ shell: "${{ contains(matrix.os, 'windows') && 'msys2 {0}' || 'bash' }}"
  timeout-minutes: 600
  runs-on: "${{ matrix.os }}"
  steps:
+ - if: "contains(matrix.os, 'windows')"
+ uses: msys2/setup-msys2@v2.22.0
+ with:
+ msystem: "${{ contains(matrix.name, 'i686') && 'mingw32' || 'mingw64' }}"
+ update: false
+ release: true
+ path-type: inherit
+ install: "make dos2unix diffutils\n"
  - name: disable git crlf conversion
  run: git config --global core.autocrlf false
  - name: checkout the source code

Cargo.lock

@@ -4101,6 +4101,7 @@ dependencies = [
  "rustc_target",
  "rustc_trait_selection",
  "rustc_type_ir",
+ "smallvec",
  "tracing",
  "unicode-security",
 ]

INSTALL.md

@@ -145,10 +145,9 @@ toolchain.
 
 1. Download the latest [MSYS2 installer][msys2] and go through the installer.
 
-2. Run `mingw32_shell.bat` or `mingw64_shell.bat` from the MSYS2 installation
- directory (e.g. `C:\msys64`), depending on whether you want 32-bit or 64-bit
- Rust. (As of the latest version of MSYS2 you have to run `msys2_shell.cmd
- -mingw32` or `msys2_shell.cmd -mingw64` from the command line instead.)
+2. Start a MINGW64 or MINGW32 shell (depending on whether you want 32-bit
+ or 64-bit Rust) either from your start menu, or by running `mingw64.exe`
+ or `mingw32.exe` from your MSYS2 installation directory (e.g. `C:\msys64`).
 
 3. From this terminal, install the required tools:
 
@@ -157,8 +156,7 @@ toolchain.
  pacman -Sy pacman-mirrors
 
  # Install build tools needed for Rust. If you're building a 32-bit compiler,
- # then replace "x86_64" below with "i686". If you've already got Git, Python,
- # or CMake installed and in PATH you can remove them from this list.
+ # then replace "x86_64" below with "i686". 
  # Note that it is important that you do **not** use the 'python2', 'cmake',
  # and 'ninja' packages from the 'msys2' subsystem.
  # The build has historically been known to fail with these packages.
@@ -175,9 +173,21 @@ toolchain.
 4. Navigate to Rust's source code (or clone it), then build it:
 
  ```sh
- python x.py setup user && python x.py build && python x.py install
+ python x.py setup dist && python x.py build && python x.py install
  ```
 
+If you want to use the native versions of Git, Python, or CMake you can remove
+them from the above pacman command and install them from another source. Make
+sure that they're in your Windows PATH, and edit the relevant `mingw[32|64].ini`
+file in your MSYS2 installation directory by uncommenting the line
+`MSYS2_PATH_TYPE=inherit` to include them in your MSYS2 PATH.
+
+Using Windows native Python can be helpful if you get errors when building LLVM.
+You may also want to use Git for Windows, as it is often *much* faster. Turning
+off real-time protection in the Windows Virus & Threat protections settings can
+also help with long run times (although note that it will automatically turn
+itself back on after some time).
+
 ### MSVC
 
 MSVC builds of Rust additionally require an installation of Visual Studio 2017

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;