Bootstrap compiler update for 1.35 release

12 files changed, 20 insertions, 146 deletions

diff --git a/src/bootstrap/channel.rs b/src/bootstrap/channel.rs
index 0b2f62485c9..aa683161b65 100644
--- a/src/bootstrap/channel.rs
+++ b/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.34.0";
+pub const CFG_RELEASE_NUM: &str = "1.35.0";
 
 pub struct GitInfo {
     inner: Option<Info>,
diff --git a/src/liballoc/macros.rs b/src/liballoc/macros.rs
index eb341007851..dd128e096f9 100644
--- a/src/liballoc/macros.rs
+++ b/src/liballoc/macros.rs
@@ -34,8 +34,7 @@
 #[cfg(not(test))]
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(stage0), allow_internal_unstable(box_syntax))]
-#[cfg_attr(stage0, allow_internal_unstable)]
+#[allow_internal_unstable(box_syntax)]
 macro_rules! vec {
     ($elem:expr; $n:expr) => (
         $crate::vec::from_elem($elem, $n)
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index e6098b1b24c..75a33394e3d 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -1282,13 +1282,11 @@ extern "rust-intrinsic" {
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `saturating_add` method. For example,
     /// [`std::u32::saturating_add`](../../std/primitive.u32.html#method.saturating_add)
-    #[cfg(not(stage0))]
     pub fn saturating_add<T>(a: T, b: T) -> T;
     /// Computes `a - b`, while saturating at numeric bounds.
     /// The stabilized versions of this intrinsic are available on the integer
     /// primitives via the `saturating_sub` method. For example,
     /// [`std::u32::saturating_sub`](../../std/primitive.u32.html#method.saturating_sub)
-    #[cfg(not(stage0))]
     pub fn saturating_sub<T>(a: T, b: T) -> T;
 
     /// Returns the value of the discriminant for the variant in 'v',
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index fdbfa56000b..b052f59b0f5 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -1,7 +1,6 @@
 /// Entry point of thread panic. For details, see `std::macros`.
 #[macro_export]
-#[cfg_attr(not(stage0), allow_internal_unstable(core_panic, __rust_unstable_column))]
-#[cfg_attr(stage0, allow_internal_unstable)]
+#[allow_internal_unstable(core_panic, __rust_unstable_column)]
 #[stable(feature = "core", since = "1.6.0")]
 macro_rules! panic {
     () => (
@@ -422,8 +421,7 @@ macro_rules! write {
 /// ```
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(format_args_nl))]
+#[allow_internal_unstable(format_args_nl)]
 macro_rules! writeln {
     ($dst:expr) => (
         write!($dst, "\n")
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 29606cb1903..9b1ead7edd6 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -636,7 +636,7 @@ unsafe impl<T: ?Sized> Freeze for &mut T {}
 /// [`Pin<P>`]: ../pin/struct.Pin.html
 /// [`pin module`]: ../../std/pin/index.html
 #[stable(feature = "pin", since = "1.33.0")]
-#[cfg_attr(not(stage0), lang = "unpin")]
+#[lang = "unpin"]
 pub auto trait Unpin {}
 
 /// A marker type which does not implement `Unpin`.
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 6708a195f88..502e3de8c63 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -880,68 +880,15 @@ assert_eq!(", stringify!($SelfT), "::max_value().saturating_add(100), ", stringi
 "::max_value());",
 $EndFeature, "
 ```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[inline]
-            #[cfg(stage0)]
-            pub fn saturating_add(self, rhs: Self) -> Self {
-                match self.checked_add(rhs) {
-                    Some(x) => x,
-                    None if rhs >= 0 => Self::max_value(),
-                    None => Self::min_value(),
-                }
-            }
-
-        }
-
-        doc_comment! {
-            concat!("Saturating integer addition. Computes `self + rhs`, saturating at the numeric
-bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
-assert_eq!(", stringify!($SelfT), "::max_value().saturating_add(100), ", stringify!($SelfT),
-"::max_value());",
-$EndFeature, "
-```"),
 
             #[stable(feature = "rust1", since = "1.0.0")]
             #[rustc_const_unstable(feature = "const_saturating_int_methods")]
             #[inline]
-            #[cfg(not(stage0))]
             pub const fn saturating_add(self, rhs: Self) -> Self {
                 intrinsics::saturating_add(self, rhs)
             }
         }
 
-        doc_comment! {
-            concat!("Saturating integer subtraction. Computes `self - rhs`, saturating at the
-numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(127), -27);
-assert_eq!(", stringify!($SelfT), "::min_value().saturating_sub(100), ", stringify!($SelfT),
-"::min_value());",
-$EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[inline]
-            #[cfg(stage0)]
-            pub fn saturating_sub(self, rhs: Self) -> Self {
-                match self.checked_sub(rhs) {
-                    Some(x) => x,
-                    None if rhs >= 0 => Self::min_value(),
-                    None => Self::max_value(),
-                }
-            }
-        }
 
         doc_comment! {
             concat!("Saturating integer subtraction. Computes `self - rhs`, saturating at the
@@ -960,7 +907,6 @@ $EndFeature, "
             #[stable(feature = "rust1", since = "1.0.0")]
             #[rustc_const_unstable(feature = "const_saturating_int_methods")]
             #[inline]
-            #[cfg(not(stage0))]
             pub const fn saturating_sub(self, rhs: Self) -> Self {
                 intrinsics::saturating_sub(self, rhs)
             }
@@ -2784,34 +2730,10 @@ Basic usage:
 ", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
 assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, "
 ```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
-            #[inline]
-            #[cfg(stage0)]
-            pub fn saturating_add(self, rhs: Self) -> Self {
-                match self.checked_add(rhs) {
-                    Some(x) => x,
-                    None => Self::max_value(),
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer addition. Computes `self + rhs`, saturating at
-the numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
-assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, "
-```"),
 
             #[stable(feature = "rust1", since = "1.0.0")]
             #[rustc_const_unstable(feature = "const_saturating_int_methods")]
             #[inline]
-            #[cfg(not(stage0))]
             pub const fn saturating_add(self, rhs: Self) -> Self {
                 intrinsics::saturating_add(self, rhs)
             }
@@ -2830,32 +2752,8 @@ Basic usage:
 assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, "
 ```"),
             #[stable(feature = "rust1", since = "1.0.0")]
-            #[inline]
-            #[cfg(stage0)]
-            pub fn saturating_sub(self, rhs: Self) -> Self {
-                match self.checked_sub(rhs) {
-                    Some(x) => x,
-                    None => Self::min_value(),
-                }
-            }
-        }
-
-        doc_comment! {
-            concat!("Saturating integer subtraction. Computes `self - rhs`, saturating
-at the numeric bounds instead of overflowing.
-
-# Examples
-
-Basic usage:
-
-```
-", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(27), 73);
-assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, "
-```"),
-            #[stable(feature = "rust1", since = "1.0.0")]
             #[rustc_const_unstable(feature = "const_saturating_int_methods")]
             #[inline]
-            #[cfg(not(stage0))]
             pub const fn saturating_sub(self, rhs: Self) -> Self {
                 intrinsics::saturating_sub(self, rhs)
             }
diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs
index f9f20dcea9e..11e5b0adcc4 100644
--- a/src/libcore/pin.rs
+++ b/src/libcore/pin.rs
@@ -279,7 +279,7 @@ use ops::{Deref, DerefMut, Receiver, CoerceUnsized, DispatchFromDyn};
 // implementations, are allowed because they all only use `&P`, so they cannot move
 // the value behind `pointer`.
 #[stable(feature = "pin", since = "1.33.0")]
-#[cfg_attr(not(stage0), lang = "pin")]
+#[lang = "pin"]
 #[fundamental]
 #[repr(transparent)]
 #[derive(Copy, Clone, Hash, Eq, Ord)]
diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs
index d0ee5fa9e6b..04a49d25301 100644
--- a/src/libcore/sync/atomic.rs
+++ b/src/libcore/sync/atomic.rs
@@ -290,15 +290,11 @@ pub enum Ordering {
 /// [`AtomicBool`]: struct.AtomicBool.html
 #[cfg(target_has_atomic = "8")]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(stage0), rustc_deprecated(
+#[rustc_deprecated(
     since = "1.34.0",
     reason = "the `new` function is now preferred",
     suggestion = "AtomicBool::new(false)",
-))]
-#[cfg_attr(stage0, rustc_deprecated(
-    since = "1.34.0",
-    reason = "the `new` function is now preferred",
-))]
+)]
 pub const ATOMIC_BOOL_INIT: AtomicBool = AtomicBool::new(false);
 
 #[cfg(target_has_atomic = "8")]
@@ -1158,15 +1154,11 @@ macro_rules! atomic_int {
 
         /// An atomic integer initialized to `0`.
         #[$stable_init_const]
-        #[cfg_attr(stage0, rustc_deprecated(
-            since = "1.34.0",
-            reason = "the `new` function is now preferred",
-        ))]
-        #[cfg_attr(not(stage0), rustc_deprecated(
+        #[rustc_deprecated(
             since = "1.34.0",
             reason = "the `new` function is now preferred",
             suggestion = $atomic_new,
-        ))]
+        )]
         pub const $atomic_init: $atomic_type = $atomic_type::new(0);
 
         #[$stable]
diff --git a/src/librustc_data_structures/macros.rs b/src/librustc_data_structures/macros.rs
index af1f2910461..029e7267c82 100644
--- a/src/librustc_data_structures/macros.rs
+++ b/src/librustc_data_structures/macros.rs
@@ -1,8 +1,7 @@
 /// A simple static assertion macro. The first argument should be a unique
 /// ALL_CAPS identifier that describes the condition.
 #[macro_export]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(type_ascription))]
+#[allow_internal_unstable(type_ascription)]
 macro_rules! static_assert {
     ($name:ident: $test:expr) => {
         // Use the bool to access an array such that if the bool is false, the access
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 281641c3c12..9d0eb2e6b1c 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -53,8 +53,7 @@
 /// ```
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(__rust_unstable_column, libstd_sys_internals))]
+#[allow_internal_unstable(__rust_unstable_column, libstd_sys_internals)]
 macro_rules! panic {
     () => ({
         panic!("explicit panic")
@@ -112,8 +111,7 @@ macro_rules! panic {
 /// ```
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(print_internals))]
+#[allow_internal_unstable(print_internals)]
 macro_rules! print {
     ($($arg:tt)*) => ($crate::io::_print(format_args!($($arg)*)));
 }
@@ -145,8 +143,7 @@ macro_rules! print {
 /// ```
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(print_internals, format_args_nl))]
+#[allow_internal_unstable(print_internals, format_args_nl)]
 macro_rules! println {
     () => (print!("\n"));
     ($($arg:tt)*) => ({
@@ -177,8 +174,7 @@ macro_rules! println {
 /// ```
 #[macro_export]
 #[stable(feature = "eprint", since = "1.19.0")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(print_internals))]
+#[allow_internal_unstable(print_internals)]
 macro_rules! eprint {
     ($($arg:tt)*) => ($crate::io::_eprint(format_args!($($arg)*)));
 }
@@ -206,8 +202,7 @@ macro_rules! eprint {
 /// ```
 #[macro_export]
 #[stable(feature = "eprint", since = "1.19.0")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(print_internals, format_args_nl))]
+#[allow_internal_unstable(print_internals, format_args_nl)]
 macro_rules! eprintln {
     () => (eprint!("\n"));
     ($($arg:tt)*) => ({
@@ -330,8 +325,7 @@ macro_rules! dbg {
 /// A macro to await on an async call.
 #[macro_export]
 #[unstable(feature = "await_macro", issue = "50547")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(gen_future, generators))]
+#[allow_internal_unstable(gen_future, generators)]
 #[allow_internal_unsafe]
 macro_rules! r#await {
     ($e:expr) => { {
diff --git a/src/libstd/thread/local.rs b/src/libstd/thread/local.rs
index d1f53734d30..3a876e05ecc 100644
--- a/src/libstd/thread/local.rs
+++ b/src/libstd/thread/local.rs
@@ -126,8 +126,7 @@ impl<T: 'static> fmt::Debug for LocalKey<T> {
 /// [`std::thread::LocalKey`]: ../std/thread/struct.LocalKey.html
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(thread_local_internals))]
+#[allow_internal_unstable(thread_local_internals)]
 macro_rules! thread_local {
     // empty (base case for the recursion)
     () => {};
@@ -149,10 +148,7 @@ macro_rules! thread_local {
            reason = "should not be necessary",
            issue = "0")]
 #[macro_export]
-#[cfg_attr(stage0, allow_internal_unstable)]
-#[cfg_attr(not(stage0), allow_internal_unstable(
-    thread_local_internals, cfg_target_thread_local, thread_local,
-))]
+#[allow_internal_unstable(thread_local_internals, cfg_target_thread_local, thread_local)]
 #[allow_internal_unsafe]
 macro_rules! __thread_local_inner {
     (@key $(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $init:expr) => {
diff --git a/src/stage0.txt b/src/stage0.txt
index a93ee6bc604..274c0f90442 100644
--- a/src/stage0.txt
+++ b/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-02-17
+date: 2019-02-27
 rustc: beta
 cargo: beta