Bump bootstrap compiler to 1.33 beta

src/bootstrap/channel.rs

@@ -14,7 +14,7 @@ use crate::Build;
 use crate::config::Config;
 
 // The version number
-pub const CFG_RELEASE_NUM: &str = "1.33.0";
+pub const CFG_RELEASE_NUM: &str = "1.34.0";
 
 pub struct GitInfo {
  inner: Option<Info>,

src/bootstrap/dist.rs

@@ -226,7 +226,7 @@ fn make_win_dist(
  let trim_chars: &[_] = &[' ', '='];
  let value =
  line[(idx + 1)..]
- .trim_left_matches(trim_chars)
+ .trim_start_matches(trim_chars)
  .split(';')
  .map(PathBuf::from);
 

src/bootstrap/lib.rs

@@ -423,7 +423,7 @@ impl Build {
  Command::new(&build.initial_rustc).arg("--version").arg("--verbose"));
  let local_release = local_version_verbose
  .lines().filter(|x| x.starts_with("release:"))
- .next().unwrap().trim_left_matches("release:").trim();
+ .next().unwrap().trim_start_matches("release:").trim();
  let my_version = channel::CFG_RELEASE_NUM;
  if local_release.split('.').take(2).eq(my_version.split('.').take(2)) {
  build.verbose(&format!("auto-detected local-rebuild {}", local_release));

src/liballoc/benches/vec_deque_append.rs

@@ -1,4 +1,3 @@
-#![cfg_attr(stage0, feature(duration_as_u128))]
 use std::{collections::VecDeque, time::Instant};
 
 const VECDEQUE_LEN: i32 = 100000;

src/libcore/intrinsics.rs

@@ -692,7 +692,6 @@ extern "rust-intrinsic" {
 
  /// A guard for unsafe functions that cannot ever be executed if `T` is uninhabited:
  /// This will statically either panic, or do nothing.
- #[cfg(not(stage0))]
  pub fn panic_if_uninhabited<T>();
 
  /// Creates a value initialized to zero.

src/libcore/lib.rs

@@ -71,7 +71,6 @@
 #![feature(cfg_target_has_atomic)]
 #![feature(concat_idents)]
 #![feature(const_fn)]
-#![cfg_attr(stage0, feature(const_int_ops))]
 #![feature(const_fn_union)]
 #![feature(custom_attribute)]
 #![feature(doc_cfg)]
@@ -111,19 +110,17 @@
 #![feature(aarch64_target_feature)]
 #![feature(wasm_target_feature)]
 #![feature(avx512_target_feature)]
-#![cfg_attr(not(stage0), feature(cmpxchg16b_target_feature))]
+#![feature(cmpxchg16b_target_feature)]
 #![feature(const_slice_len)]
 #![feature(const_str_as_bytes)]
 #![feature(const_str_len)]
-#![cfg_attr(stage0, feature(const_let))]
-#![cfg_attr(stage0, feature(const_int_rotate))]
 #![feature(const_int_conversion)]
 #![feature(const_transmute)]
 #![feature(reverse_bits)]
 #![feature(non_exhaustive)]
 #![feature(structural_match)]
 #![feature(abi_unadjusted)]
-#![cfg_attr(not(stage0), feature(adx_target_feature))]
+#![feature(adx_target_feature)]
 
 #[prelude_import]
 #[allow(unused)]

src/libcore/mem.rs

@@ -492,7 +492,6 @@ pub const fn needs_drop<T>() -> bool {
 #[rustc_deprecated(since = "2.0.0", reason = "use `mem::MaybeUninit::zeroed` instead")]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub unsafe fn zeroed<T>() -> T {
- #[cfg(not(stage0))]
  intrinsics::panic_if_uninhabited::<T>();
  intrinsics::init()
 }
@@ -626,8 +625,6 @@ pub unsafe fn zeroed<T>() -> T {
 #[rustc_deprecated(since = "2.0.0", reason = "use `mem::MaybeUninit::uninitialized` instead")]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub unsafe fn uninitialized<T>() -> T {
- #[cfg(not(stage0))]
- intrinsics::panic_if_uninhabited::<T>();
  intrinsics::uninit()
 }
 
@@ -1132,7 +1129,6 @@ impl<T> MaybeUninit<T> {
  #[unstable(feature = "maybe_uninit", issue = "53491")]
  #[inline(always)]
  pub unsafe fn into_inner(self) -> T {
- #[cfg(not(stage0))]
  intrinsics::panic_if_uninhabited::<T>();
  ManuallyDrop::into_inner(self.value)
  }

src/libcore/num/bignum.rs

@@ -46,17 +46,6 @@ macro_rules! impl_full_ops {
  ($($ty:ty: add($addfn:path), mul/div($bigty:ident);)*) => (
  $(
  impl FullOps for $ty {
- #[cfg(stage0)]
- fn full_add(self, other: $ty, carry: bool) -> (bool, $ty) {
- // This cannot overflow; the output is between `0` and `2 * 2^nbits - 1`.
- // FIXME: will LLVM optimize this into ADC or similar?
- let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };
- let (v, carry2) = unsafe {
- intrinsics::add_with_overflow(v, if carry {1} else {0})
- };
- (carry1 || carry2, v)
- }
- #[cfg(not(stage0))]
  fn full_add(self, other: $ty, carry: bool) -> (bool, $ty) {
  // This cannot overflow; the output is between `0` and `2 * 2^nbits - 1`.
  // FIXME: will LLVM optimize this into ADC or similar?