Auto merge of rust-lang#62376 - Mark-Simulacrum:1.38-nightly, r=alexc…

…richton

Switch master to 1.38

src/bootstrap/channel.rs

@@ -13,7 +13,7 @@ use build_helper::output;
 use crate::Build;
 
 // The version number
-pub const CFG_RELEASE_NUM: &str = "1.37.0";
+pub const CFG_RELEASE_NUM: &str = "1.38.0";
 
 pub struct GitInfo {
     inner: Option<Info>,

src/liballoc/alloc.rs

@@ -15,8 +15,7 @@ extern "Rust" {
     // them from the `#[global_allocator]` attribute if there is one, or uses the
     // default implementations in libstd (`__rdl_alloc` etc in `src/libstd/alloc.rs`)
     // otherwise.
-    #[cfg_attr(bootstrap, allocator)]
-    #[cfg_attr(not(bootstrap), rustc_allocator)]
+    #[rustc_allocator]
     #[rustc_allocator_nounwind]
     fn __rust_alloc(size: usize, align: usize) -> *mut u8;
     #[rustc_allocator_nounwind]

src/liballoc/lib.rs

@@ -79,7 +79,6 @@
 #![feature(coerce_unsized)]
 #![feature(dispatch_from_dyn)]
 #![feature(core_intrinsics)]
-#![cfg_attr(bootstrap, feature(custom_attribute))]
 #![feature(dropck_eyepatch)]
 #![feature(exact_size_is_empty)]
 #![feature(fmt_internals)]

src/libcore/ffi.rs

@@ -302,7 +302,6 @@ impl<T> sealed_trait::VaArgSafe for *const T {}
            reason = "the `c_variadic` feature has not been properly tested on \
                      all supported platforms",
            issue = "44930")]
-#[cfg(not(bootstrap))]
 impl<'f> VaListImpl<'f> {
     /// Advance to the next arg.
     #[inline]
@@ -324,7 +323,6 @@ impl<'f> VaListImpl<'f> {
            reason = "the `c_variadic` feature has not been properly tested on \
                      all supported platforms",
            issue = "44930")]
-#[cfg(not(bootstrap))]
 impl<'f> Clone for VaListImpl<'f> {
     #[inline]
     fn clone(&self) -> Self {
@@ -340,7 +338,6 @@ impl<'f> Clone for VaListImpl<'f> {
            reason = "the `c_variadic` feature has not been properly tested on \
                      all supported platforms",
            issue = "44930")]
-#[cfg(not(bootstrap))]
 impl<'f> Drop for VaListImpl<'f> {
     fn drop(&mut self) {
         // FIXME: this should call `va_end`, but there's no clean way to
@@ -359,15 +356,12 @@ impl<'f> Drop for VaListImpl<'f> {
 extern "rust-intrinsic" {
     /// Destroy the arglist `ap` after initialization with `va_start` or
     /// `va_copy`.
-    #[cfg(not(bootstrap))]
     fn va_end(ap: &mut VaListImpl<'_>);
 
     /// Copies the current location of arglist `src` to the arglist `dst`.
-    #[cfg(not(bootstrap))]
     fn va_copy<'f>(dest: *mut VaListImpl<'f>, src: &VaListImpl<'f>);
 
     /// Loads an argument of type `T` from the `va_list` `ap` and increment the
     /// argument `ap` points to.
-    #[cfg(not(bootstrap))]
     fn va_arg<T: sealed_trait::VaArgSafe>(ap: &mut VaListImpl<'_>) -> T;
 }

src/libcore/future/future.rs

@@ -25,7 +25,7 @@ use crate::task::{Context, Poll};
 #[doc(spotlight)]
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 #[stable(feature = "futures_api", since = "1.36.0")]
-#[cfg_attr(not(bootstrap), lang = "future_trait")]
+#[lang = "future_trait"]
 pub trait Future {
     /// The type of value produced on completion.
     #[stable(feature = "futures_api", since = "1.36.0")]

src/libcore/intrinsics.rs

@@ -1052,16 +1052,12 @@ extern "rust-intrinsic" {
     pub fn fabsf64(x: f64) -> f64;
 
     /// Returns the minimum of two `f32` values.
-    #[cfg(not(bootstrap))]
     pub fn minnumf32(x: f32, y: f32) -> f32;
     /// Returns the minimum of two `f64` values.
-    #[cfg(not(bootstrap))]
     pub fn minnumf64(x: f64, y: f64) -> f64;
     /// Returns the maximum of two `f32` values.
-    #[cfg(not(bootstrap))]
     pub fn maxnumf32(x: f32, y: f32) -> f32;
     /// Returns the maximum of two `f64` values.
-    #[cfg(not(bootstrap))]
     pub fn maxnumf64(x: f64, y: f64) -> f64;
 
     /// Copies the sign from `y` to `x` for `f32` values.
@@ -1255,17 +1251,14 @@ extern "rust-intrinsic" {
 
     /// Returns the result of an unchecked addition, resulting in
     /// undefined behavior when `x + y > T::max_value()` or `x + y < T::min_value()`.
-    #[cfg(not(bootstrap))]
     pub fn unchecked_add<T>(x: T, y: T) -> T;
 
     /// Returns the result of an unchecked substraction, resulting in
     /// undefined behavior when `x - y > T::max_value()` or `x - y < T::min_value()`.
-    #[cfg(not(bootstrap))]
     pub fn unchecked_sub<T>(x: T, y: T) -> T;
 
     /// Returns the result of an unchecked multiplication, resulting in
     /// undefined behavior when `x * y > T::max_value()` or `x * y < T::min_value()`.
-    #[cfg(not(bootstrap))]
     pub fn unchecked_mul<T>(x: T, y: T) -> T;
 
     /// Performs rotate left.
@@ -1563,53 +1556,3 @@ pub unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize) {
     }
     write_bytes(dst, val, count)
 }
-
-// Simple bootstrap implementations of minnum/maxnum for stage0 compilation.
-
-/// Returns the minimum of two `f32` values.
-#[cfg(bootstrap)]
-pub fn minnumf32(x: f32, y: f32) -> f32 {
-    // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
-    // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
-    // is either x or y, canonicalized (this means results might differ among implementations).
-    // When either x or y is a signaling NaN, then the result is according to 6.2.
-    //
-    // Since we do not support sNaN in Rust yet, we do not need to handle them.
-    // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
-    // multiplying by 1.0. Should switch to the `canonicalize` when it works.
-    (if x < y || y != y { x } else { y }) * 1.0
-}
-
-/// Returns the minimum of two `f64` values.
-#[cfg(bootstrap)]
-pub fn minnumf64(x: f64, y: f64) -> f64 {
-    // Identical to the `f32` case.
-    (if x < y || y != y { x } else { y }) * 1.0
-}
-
-/// Returns the maximum of two `f32` values.
-#[cfg(bootstrap)]
-pub fn maxnumf32(x: f32, y: f32) -> f32 {
-    // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
-    // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
-    // is either x or y, canonicalized (this means results might differ among implementations).
-    // When either x or y is a signaling NaN, then the result is according to 6.2.
-    //
-    // Since we do not support sNaN in Rust yet, we do not need to handle them.
-    // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
-    // multiplying by 1.0. Should switch to the `canonicalize` when it works.
-    (if x < y || x != x { y } else { x }) * 1.0
-}
-
-/// Returns the maximum of two `f64` values.
-#[cfg(bootstrap)]
-pub fn maxnumf64(x: f64, y: f64) -> f64 {
-    // Identical to the `f32` case.
-    (if x < y || x != x { y } else { x }) * 1.0
-}
-
-/// For bootstrapping, implement unchecked_sub as just wrapping_sub.
-#[cfg(bootstrap)]
-pub unsafe fn unchecked_sub<T>(x: T, y: T) -> T {
-    sub_with_overflow(x, y).0
-}

src/libcore/lib.rs

@@ -99,7 +99,7 @@
 #![feature(staged_api)]
 #![feature(std_internals)]
 #![feature(stmt_expr_attributes)]
-#![cfg_attr(not(bootstrap), feature(transparent_unions))]
+#![feature(transparent_unions)]
 #![feature(unboxed_closures)]
 #![feature(unsized_locals)]
 #![feature(untagged_unions)]

src/libcore/mem/maybe_uninit.rs

@@ -207,7 +207,7 @@ use crate::mem::ManuallyDrop;
 #[allow(missing_debug_implementations)]
 #[stable(feature = "maybe_uninit", since = "1.36.0")]
 #[derive(Copy)]
-#[cfg_attr(not(bootstrap), repr(transparent))]
+#[repr(transparent)]
 pub union MaybeUninit<T> {
     uninit: (),
     value: ManuallyDrop<T>,

src/libcore/num/mod.rs

@@ -50,7 +50,7 @@ assert_eq!(size_of::<Option<core::num::", stringify!($Ty), ">>(), size_of::<", s
                 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
                 #[repr(transparent)]
                 #[rustc_layout_scalar_valid_range_start(1)]
-                #[cfg_attr(not(bootstrap), rustc_nonnull_optimization_guaranteed)]
+                #[rustc_nonnull_optimization_guaranteed]
                 pub struct $Ty($Int);
             }
 

src/libcore/ptr/non_null.rs

@@ -38,7 +38,7 @@ use crate::cmp::Ordering;
 #[stable(feature = "nonnull", since = "1.25.0")]
 #[repr(transparent)]
 #[rustc_layout_scalar_valid_range_start(1)]
-#[cfg_attr(not(bootstrap), rustc_nonnull_optimization_guaranteed)]
+#[rustc_nonnull_optimization_guaranteed]
 pub struct NonNull<T: ?Sized> {
     pointer: *const T,
 }

src/librustc_codegen_llvm/common.rs

@@ -170,6 +170,7 @@ impl CodegenCx<'ll, 'tcx> {
     pub fn const_get_real(&self, v: &'ll Value) -> Option<(f64, bool)> {
         unsafe {
             if self.is_const_real(v) {
+                #[allow(deprecated)]
                 let mut loses_info: llvm::Bool = ::std::mem::uninitialized();
                 let r = llvm::LLVMConstRealGetDouble(v, &mut loses_info);
                 let loses_info = if loses_info == 1 { true } else { false };

src/librustc_data_structures/macros.rs

@@ -1,7 +1,6 @@
 /// A simple static assertion macro.
 #[macro_export]
-#[cfg_attr(bootstrap, allow_internal_unstable(type_ascription, underscore_const_names))]
-#[cfg_attr(not(bootstrap), allow_internal_unstable(type_ascription))]
+#[allow_internal_unstable(type_ascription)]
 macro_rules! static_assert {
     ($test:expr) => {
         // Use the bool to access an array such that if the bool is false, the access
@@ -13,7 +12,6 @@ macro_rules! static_assert {
 
 /// Type size assertion. The first argument is a type and the second argument is its expected size.
 #[macro_export]
-#[cfg_attr(bootstrap, allow_internal_unstable(underscore_const_names))]
 macro_rules! static_assert_size {
     ($ty:ty, $size:expr) => {
         const _: [(); $size] = [(); ::std::mem::size_of::<$ty>()];

src/librustc_resolve/lib.rs

@@ -7,7 +7,6 @@
 #![feature(mem_take)]
 #![feature(nll)]
 #![feature(rustc_diagnostic_macros)]
-#![cfg_attr(bootstrap, feature(type_alias_enum_variants))]
 
 #![recursion_limit="256"]
 

src/libstd/io/util.rs

@@ -44,6 +44,7 @@ pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<
     where R: Read, W: Write
 {
     let mut buf = unsafe {
+        #[allow(deprecated)]
         let mut buf: [u8; super::DEFAULT_BUF_SIZE] = mem::uninitialized();
         reader.initializer().initialize(&mut buf);
         buf

src/libstd/sys/cloudabi/mod.rs

@@ -1,3 +1,5 @@
+#![allow(deprecated)] // mem::uninitialized
+
 use crate::io::ErrorKind;
 use crate::mem;
 

src/libstd/sys/sgx/mod.rs

@@ -3,6 +3,8 @@
 //! This module contains the facade (aka platform-specific) implementations of
 //! OS level functionality for Fortanix SGX.
 
+#![allow(deprecated)]
+
 use crate::io::ErrorKind;
 use crate::os::raw::c_char;
 use crate::sync::atomic::{AtomicBool, Ordering};

src/libsyntax/tokenstream.rs

@@ -59,17 +59,6 @@ where
     TokenStream: Send + Sync,
 {}
 
-// These are safe since we ensure that they hold for all fields in the `_dummy` function.
-//
-// These impls are only here because the compiler takes forever to compute the Send and Sync
-// bounds without them.
-// FIXME: Remove these impls when the compiler can compute the bounds quickly again.
-// See https://github.com/rust-lang/rust/issues/60846
-#[cfg(all(bootstrap, parallel_compiler))]
-unsafe impl Send for TokenTree {}
-#[cfg(all(bootstrap, parallel_compiler))]
-unsafe impl Sync for TokenTree {}
-
 impl TokenTree {
     /// Use this token tree as a matcher to parse given tts.
     pub fn parse(cx: &base::ExtCtxt<'_>, mtch: &[quoted::TokenTree], tts: TokenStream)

src/libterm/win.rs

@@ -108,6 +108,7 @@ impl<T: Write + Send + 'static> WinConsole<T> {
         let fg;
         let bg;
         unsafe {
+            #[allow(deprecated)]
             let mut buffer_info = ::std::mem::uninitialized();
             if GetConsoleScreenBufferInfo(GetStdHandle(-11i32 as DWORD), &mut buffer_info) != 0 {
                 fg = bits_to_color(buffer_info.wAttributes);

src/libunwind/build.rs

@@ -4,13 +4,11 @@ fn main() {
     println!("cargo:rerun-if-changed=build.rs");
     let target = env::var("TARGET").expect("TARGET was not set");
 
-    // FIXME: the not(bootstrap) part is needed because of the issue addressed by #62286,
-    // and could be removed once that change is in beta.
-    if cfg!(all(not(bootstrap), feature = "llvm-libunwind")) &&
+    if cfg!(feature = "llvm-libunwind") &&
         (target.contains("linux") ||
          target.contains("fuchsia")) {
         // Build the unwinding from libunwind C/C++ source code.
-        #[cfg(all(not(bootstrap), feature = "llvm-libunwind"))]
+        #[cfg(feature = "llvm-libunwind")]
         llvm_libunwind::compile();
     } else if target.contains("linux") {
         if target.contains("musl") {
@@ -44,7 +42,7 @@ fn main() {
     }
 }
 
-#[cfg(all(not(bootstrap), feature = "llvm-libunwind"))]
+#[cfg(feature = "llvm-libunwind")]
 mod llvm_libunwind {
     use std::env;
     use std::path::Path;

src/libunwind/libunwind.rs

@@ -67,7 +67,7 @@ pub enum _Unwind_Context {}
 
 pub type _Unwind_Exception_Cleanup_Fn = extern "C" fn(unwind_code: _Unwind_Reason_Code,
                                                       exception: *mut _Unwind_Exception);
-#[cfg_attr(all(not(bootstrap), feature = "llvm-libunwind"),
+#[cfg_attr(feature = "llvm-libunwind",
            link(name = "unwind", kind = "static"))]
 extern "C" {
     #[unwind(allowed)]
@@ -93,7 +93,7 @@ if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm
     }
     pub use _Unwind_Action::*;
 
-    #[cfg_attr(all(not(bootstrap), feature = "llvm-libunwind"),
+    #[cfg_attr(feature = "llvm-libunwind",
                link(name = "unwind", kind = "static"))]
     extern "C" {
         pub fn _Unwind_GetGR(ctx: *mut _Unwind_Context, reg_index: c_int) -> _Unwind_Word;
@@ -148,7 +148,7 @@ if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm
     pub const UNWIND_POINTER_REG: c_int = 12;
     pub const UNWIND_IP_REG: c_int = 15;
 
-    #[cfg_attr(all(not(bootstrap), feature = "llvm-libunwind"),
+    #[cfg_attr(feature = "llvm-libunwind",
                link(name = "unwind", kind = "static"))]
     extern "C" {
         fn _Unwind_VRS_Get(ctx: *mut _Unwind_Context,
@@ -212,7 +212,7 @@ if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm
 cfg_if::cfg_if! {
 if #[cfg(not(all(target_os = "ios", target_arch = "arm")))] {
     // Not 32-bit iOS
-    #[cfg_attr(all(not(bootstrap), feature = "llvm-libunwind"),
+    #[cfg_attr(feature = "llvm-libunwind",
                link(name = "unwind", kind = "static"))]
     extern "C" {
         #[unwind(allowed)]
@@ -223,7 +223,7 @@ if #[cfg(not(all(target_os = "ios", target_arch = "arm")))] {
     }
 } else {
     // 32-bit iOS uses SjLj and does not provide _Unwind_Backtrace()
-    #[cfg_attr(all(not(bootstrap), feature = "llvm-libunwind"),
+    #[cfg_attr(feature = "llvm-libunwind",
                link(name = "unwind", kind = "static"))]
     extern "C" {
         #[unwind(allowed)]

src/stage0.txt

@@ -12,7 +12,7 @@
 # source tarball for a stable release you'll likely see `1.x.0` for rustc and
 # `0.x.0` for Cargo where they were released on `date`.
 
-date: 2019-05-23
+date: 2019-07-04
 rustc: beta
 cargo: beta
 

src/test/run-make-fulldeps/sanitizer-memory/uninit.rs

@@ -1,6 +1,7 @@
 use std::mem;
 
 fn main() {
+    #[allow(deprecated)]
     let xs: [u8; 4] = unsafe { mem::uninitialized() };
     let y = xs[0] + xs[1];
 }

src/test/run-pass/for-loop-while/for-loop-has-unit-body.rs

@@ -2,6 +2,7 @@
 fn main() {
     // Check that the tail statement in the body unifies with something
     for _ in 0..3 {
+        #[allow(deprecated)]
         unsafe { std::mem::uninitialized() }
     }
 

src/test/run-pass/issues/issue-58212.rs

@@ -4,6 +4,7 @@ trait FromUnchecked {
 
 impl FromUnchecked for [u8; 1] {
     unsafe fn from_unchecked() {
+        #[allow(deprecated)]
         let mut array: Self = std::mem::uninitialized();
         let _ptr = &mut array as *mut [u8] as *mut u8;
     }

src/test/run-pass/panic-uninitialized-zeroed.rs

@@ -3,6 +3,7 @@
 // in a runtime panic.
 
 #![feature(never_type)]
+#![allow(deprecated)]
 
 use std::{mem, panic};