Bump to 1.23 and update bootstrap

This commit updates the bootstrap compiler, bumps the version to 1.23, updates
Cargo, updates books, and updates crates.io dependencies

src/bootstrap/channel.rs

@@ -24,7 +24,7 @@ use Build;
 use config::Config;
 
 // The version number
-pub const CFG_RELEASE_NUM: &str = "1.22.0";
+pub const CFG_RELEASE_NUM: &str = "1.23.0";
 
 // An optional number to put after the label, e.g. '.2' -> '-beta.2'
 // Be sure to make this starts with a dot to conform to semver pre-release

src/doc/book

@@ -1 +1 @@
-Subproject commit 08e79609ce88583fa7286157dfe497486a09fabe
+Subproject commit 808f482db94391fca1e04a9692b59e9eda8cfef9

src/doc/nomicon

@@ -1 +1 @@
-Subproject commit 0ee3f7265e9d09746d901cef6f1f300baff1d923
+Subproject commit 1625e0b8c870891b84b0969777a974bf87be579b

src/libcore/cell.rs

@@ -329,7 +329,7 @@ impl<T> Cell<T> {
     /// let c = Cell::new(5);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_cell_new"))]
+    #[rustc_const_unstable(feature = "const_cell_new")]
     #[inline]
     pub const fn new(value: T) -> Cell<T> {
         Cell {
@@ -544,7 +544,7 @@ impl<T> RefCell<T> {
     /// let c = RefCell::new(5);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_refcell_new"))]
+    #[rustc_const_unstable(feature = "const_refcell_new")]
     #[inline]
     pub const fn new(value: T) -> RefCell<T> {
         RefCell {
@@ -1190,7 +1190,7 @@ impl<T> UnsafeCell<T> {
     /// let uc = UnsafeCell::new(5);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_unsafe_cell_new"))]
+    #[rustc_const_unstable(feature = "const_unsafe_cell_new")]
     #[inline]
     pub const fn new(value: T) -> UnsafeCell<T> {
         UnsafeCell { value: value }

src/libcore/intrinsics.rs

@@ -1383,17 +1383,5 @@ extern "rust-intrinsic" {
     /// }
     /// # } }
     /// ```
-    #[cfg(not(stage0))]
     pub fn align_offset(ptr: *const (), align: usize) -> usize;
 }
-
-#[cfg(stage0)]
-/// remove me after the next release
-pub unsafe fn align_offset(ptr: *const (), align: usize) -> usize {
-    let offset = ptr as usize % align;
-    if offset == 0 {
-        0
-    } else {
-        align - offset
-    }
-}

src/libcore/lib.rs

@@ -85,29 +85,28 @@
 #![feature(prelude_import)]
 #![feature(repr_simd, platform_intrinsics)]
 #![feature(rustc_attrs)]
-#![cfg_attr(not(stage0), feature(rustc_const_unstable))]
+#![feature(rustc_const_unstable)]
 #![feature(specialization)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 #![feature(untagged_unions)]
 #![feature(unwind_attributes)]
-
+#![feature(const_min_value)]
-#![cfg_attr(not(stage0), feature(const_min_value))]
+#![feature(const_max_value)]
-#![cfg_attr(not(stage0), feature(const_max_value))]
+#![feature(const_atomic_bool_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_bool_new))]
+#![feature(const_atomic_isize_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_isize_new))]
+#![feature(const_atomic_usize_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_usize_new))]
+#![feature(const_atomic_i8_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_i8_new))]
+#![feature(const_atomic_u8_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_u8_new))]
+#![feature(const_atomic_i16_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_i16_new))]
+#![feature(const_atomic_u16_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_u16_new))]
+#![feature(const_atomic_i32_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_i32_new))]
+#![feature(const_atomic_u32_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_u32_new))]
+#![feature(const_atomic_i64_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_i64_new))]
+#![feature(const_atomic_u64_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_u64_new))]
+#![feature(const_unsafe_cell_new)]
-#![cfg_attr(not(stage0), feature(const_unsafe_cell_new))]
+#![feature(const_cell_new)]
-#![cfg_attr(not(stage0), feature(const_cell_new))]
+#![feature(const_nonzero_new)]
-#![cfg_attr(not(stage0), feature(const_nonzero_new))]
 
 #[prelude_import]
 #[allow(unused)]

src/libcore/mem.rs

@@ -311,7 +311,7 @@ pub fn forget<T>(t: T) {
 /// [alignment]: ./fn.align_of.html
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_size_of"))]
+#[rustc_const_unstable(feature = "const_size_of")]
 pub const fn size_of<T>() -> usize {
     unsafe { intrinsics::size_of::<T>() }
 }
@@ -403,7 +403,7 @@ pub fn min_align_of_val<T: ?Sized>(val: &T) -> usize {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_align_of"))]
+#[rustc_const_unstable(feature = "const_align_of")]
 pub const fn align_of<T>() -> usize {
     unsafe { intrinsics::min_align_of::<T>() }
 }

src/libcore/nonzero.rs

@@ -71,7 +71,7 @@ impl<T: Zeroable> NonZero<T> {
     #[unstable(feature = "nonzero",
                reason = "needs an RFC to flesh out the design",
                issue = "27730")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_nonzero_new"))]
+    #[rustc_const_unstable(feature = "const_nonzero_new")]
     #[inline]
     pub const unsafe fn new_unchecked(inner: T) -> Self {
         NonZero(inner)

src/libcore/num/mod.rs

@@ -109,7 +109,7 @@ macro_rules! int_impl {
         /// assert_eq!(i8::min_value(), -128);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_min_value"))]
+        #[rustc_const_unstable(feature = "const_min_value")]
         #[inline]
         pub const fn min_value() -> Self {
             !0 ^ ((!0 as $UnsignedT) >> 1) as Self
@@ -123,7 +123,7 @@ macro_rules! int_impl {
         /// assert_eq!(i8::max_value(), 127);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_max_value"))]
+        #[rustc_const_unstable(feature = "const_max_value")]
         #[inline]
         pub const fn max_value() -> Self {
             !Self::min_value()
@@ -1282,7 +1282,7 @@ macro_rules! uint_impl {
         /// assert_eq!(u8::min_value(), 0);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_min_value"))]
+        #[rustc_const_unstable(feature = "const_min_value")]
         #[inline]
         pub const fn min_value() -> Self { 0 }
 
@@ -1294,7 +1294,7 @@ macro_rules! uint_impl {
         /// assert_eq!(u8::max_value(), 255);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_max_value"))]
+        #[rustc_const_unstable(feature = "const_max_value")]
         #[inline]
         pub const fn max_value() -> Self { !0 }
 

src/libcore/ops/generator.rs

@@ -14,7 +14,7 @@
 /// possible return values of a generator. Currently this corresponds to either
 /// a suspension point (`Yielded`) or a termination point (`Complete`).
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
-#[cfg_attr(not(stage0), lang = "generator_state")]
+#[lang = "generator_state"]
 #[unstable(feature = "generator_trait", issue = "43122")]
 pub enum GeneratorState<Y, R> {
     /// The generator suspended with a value.
@@ -70,7 +70,7 @@ pub enum GeneratorState<Y, R> {
 /// More documentation of generators can be found in the unstable book.
 ///
 /// [RFC 2033]: https://github.com/rust-lang/rfcs/pull/2033
-#[cfg_attr(not(stage0), lang = "generator")]
+#[lang = "generator"]
 #[unstable(feature = "generator_trait", issue = "43122")]
 #[fundamental]
 pub trait Generator {

src/libcore/ops/try.rs

@@ -15,24 +15,19 @@
 /// extracting those success or failure values from an existing instance and
 /// creating a new instance from a success or failure value.
 #[unstable(feature = "try_trait", issue = "42327")]
-#[cfg_attr(stage0,
+#[rustc_on_unimplemented(
-           rustc_on_unimplemented = "the `?` operator can only be used in a \
+   on(all(
-                                     function that returns `Result` \
+       any(from_method="from_error", from_method="from_ok"),
-                                     (or another type that implements `{Try}`)")]
+       from_desugaring="?"),
-#[cfg_attr(not(stage0),
+      message="the `?` operator can only be used in a \
-           rustc_on_unimplemented(
+               function that returns `Result` \
-               on(all(
+               (or another type that implements `{Try}`)",
-                   any(from_method="from_error", from_method="from_ok"),
+      label="cannot use the `?` operator in a function that returns `{Self}`"),
-                   from_desugaring="?"),
+   on(all(from_method="into_result", from_desugaring="?"),
-                  message="the `?` operator can only be used in a \
+      message="the `?` operator can only be applied to values \
-                           function that returns `Result` \
+               that implement `{Try}`",
-                           (or another type that implements `{Try}`)",
+      label="the `?` operator cannot be applied to type `{Self}`")
-                  label="cannot use the `?` operator in a function that returns `{Self}`"),
+)]
-               on(all(from_method="into_result", from_desugaring="?"),
-                  message="the `?` operator can only be applied to values \
-                           that implement `{Try}`",
-                  label="the `?` operator cannot be applied to type `{Self}`")
-))]
 pub trait Try {
     /// The type of this value when viewed as successful.
     #[unstable(feature = "try_trait", issue = "42327")]

src/libcore/ptr.rs

@@ -74,7 +74,7 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_ptr_null"))]
+#[rustc_const_unstable(feature = "const_ptr_null")]
 pub const fn null<T>() -> *const T { 0 as *const T }
 
 /// Creates a null mutable raw pointer.
@@ -89,7 +89,7 @@ pub const fn null<T>() -> *const T { 0 as *const T }
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_ptr_null_mut"))]
+#[rustc_const_unstable(feature = "const_ptr_null_mut")]
 pub const fn null_mut<T>() -> *mut T { 0 as *mut T }
 
 /// Swaps the values at two mutable locations of the same type, without
@@ -2333,7 +2333,7 @@ impl<T: ?Sized> Unique<T> {
     ///
     /// `ptr` must be non-null.
     #[unstable(feature = "unique", issue = "27730")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_unique_new"))]
+    #[rustc_const_unstable(feature = "const_unique_new")]
     pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
         Unique { pointer: NonZero::new_unchecked(ptr), _marker: PhantomData }
     }
@@ -2468,7 +2468,7 @@ impl<T: ?Sized> Shared<T> {
     ///
     /// `ptr` must be non-null.
     #[unstable(feature = "shared", issue = "27730")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_shared_new"))]
+    #[rustc_const_unstable(feature = "const_shared_new")]
     pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
         Shared { pointer: NonZero::new_unchecked(ptr), _marker: PhantomData }
     }

src/libcore/sync/atomic.rs

@@ -243,7 +243,7 @@ impl AtomicBool {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_atomic_bool_new"))]
+    #[rustc_const_unstable(feature = "const_atomic_bool_new")]
     pub const fn new(v: bool) -> AtomicBool {
         AtomicBool { v: UnsafeCell::new(v as u8) }
     }
@@ -657,7 +657,7 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_atomic_ptr_new"))]
+    #[rustc_const_unstable(feature = "const_atomic_ptr_new")]
     pub const fn new(p: *mut T) -> AtomicPtr<T> {
         AtomicPtr { p: UnsafeCell::new(p) }
     }
@@ -992,7 +992,7 @@ macro_rules! atomic_int {
             /// ```
             #[inline]
             #[$stable]
-            #[cfg_attr(not(stage0), $const_unstable)]
+            #[$const_unstable]
             pub const fn new(v: $int_type) -> Self {
                 $atomic_type {v: UnsafeCell::new(v)}
             }

src/librustc/lib.rs

@@ -56,9 +56,7 @@
 #![feature(unboxed_closures)]
 #![feature(trace_macros)]
 #![feature(test)]
-
+#![feature(const_atomic_bool_new)]
-#![cfg_attr(stage0, feature(const_fn))]
-#![cfg_attr(not(stage0), feature(const_atomic_bool_new))]
 
 #![recursion_limit="512"]
 

src/librustc_apfloat/lib.rs

@@ -45,14 +45,12 @@
 #![deny(warnings)]
 #![forbid(unsafe_code)]
 
+#![feature(const_max_value)]
+#![feature(const_min_value)]
 #![feature(i128_type)]
 #![feature(slice_patterns)]
 #![feature(try_from)]
 
-#![cfg_attr(stage0, feature(const_fn))]
-#![cfg_attr(not(stage0), feature(const_min_value))]
-#![cfg_attr(not(stage0), feature(const_max_value))]
-
 // See librustc_cratesio_shim/Cargo.toml for a comment explaining this.
 #[allow(unused_extern_crates)]
 extern crate rustc_cratesio_shim;

src/librustc_const_eval/lib.rs

@@ -25,8 +25,7 @@
 #![feature(box_syntax)]
 #![feature(i128_type)]
 
-#![cfg_attr(stage0, feature(const_fn))]
+#![feature(const_min_value)]
-#![cfg_attr(not(stage0), feature(const_min_value))]
 
 extern crate arena;
 #[macro_use] extern crate syntax;

src/librustc_const_math/lib.rs

@@ -22,9 +22,8 @@
 #![feature(i128)]
 #![feature(i128_type)]
 
-#![cfg_attr(stage0, feature(const_fn))]
+#![feature(const_min_value)]
-#![cfg_attr(not(stage0), feature(const_min_value))]
+#![feature(const_max_value)]
-#![cfg_attr(not(stage0), feature(const_max_value))]
 
 extern crate rustc_apfloat;
 

src/librustc_trans/lib.rs

@@ -30,9 +30,8 @@
 #![feature(slice_patterns)]
 #![feature(conservative_impl_trait)]
 
-#![cfg_attr(stage0, feature(const_fn))]
+#![feature(const_atomic_bool_new)]
-#![cfg_attr(not(stage0), feature(const_atomic_bool_new))]
+#![feature(const_once_new)]
-#![cfg_attr(not(stage0), feature(const_once_new))]
 
 use rustc::dep_graph::WorkProduct;
 use syntax_pos::symbol::Symbol;

src/librustc_trans_utils/lib.rs

@@ -27,8 +27,6 @@
 #![feature(slice_patterns)]
 #![feature(conservative_impl_trait)]
 
-#![cfg_attr(stage0, feature(const_fn))]
-
 extern crate ar;
 extern crate flate2;
 extern crate owning_ref;

src/libstd/lib.rs

@@ -254,6 +254,15 @@
 #![feature(collections_range)]
 #![feature(compiler_builtins_lib)]
 #![feature(const_fn)]
+#![feature(const_max_value)]
+#![feature(const_atomic_bool_new)]
+#![feature(const_atomic_isize_new)]
+#![feature(const_atomic_usize_new)]
+#![feature(const_unsafe_cell_new)]
+#![feature(const_cell_new)]
+#![feature(const_once_new)]
+#![feature(const_ptr_null)]
+#![feature(const_ptr_null_mut)]
 #![feature(core_float)]
 #![feature(core_intrinsics)]
 #![feature(dropck_eyepatch)]
@@ -294,7 +303,7 @@
 #![feature(repr_align)]
 #![feature(repr_simd)]
 #![feature(rustc_attrs)]
-#![cfg_attr(not(stage0), feature(rustc_const_unstable))]
+#![feature(rustc_const_unstable)]
 #![feature(shared)]
 #![feature(sip_hash_13)]
 #![feature(slice_bytes)]
@@ -318,17 +327,7 @@
 #![feature(doc_cfg)]
 #![feature(doc_masked)]
 #![cfg_attr(test, feature(update_panic_count))]
-
+#![cfg_attr(windows, feature(const_atomic_ptr_new))]
-#![cfg_attr(not(stage0), feature(const_max_value))]
-#![cfg_attr(not(stage0), feature(const_atomic_bool_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_isize_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_usize_new))]
-#![cfg_attr(all(not(stage0), windows), feature(const_atomic_ptr_new))]
-#![cfg_attr(not(stage0), feature(const_unsafe_cell_new))]
-#![cfg_attr(not(stage0), feature(const_cell_new))]
-#![cfg_attr(not(stage0), feature(const_once_new))]
-#![cfg_attr(not(stage0), feature(const_ptr_null))]
-#![cfg_attr(not(stage0), feature(const_ptr_null_mut))]
 
 #![default_lib_allocator]
 

src/libstd/sync/once.rs

@@ -156,7 +156,7 @@ struct Finish {
 impl Once {
     /// Creates a new `Once` value.
     #[stable(feature = "once_new", since = "1.2.0")]
-    #[cfg_attr(not(stage0), rustc_const_unstable(feature = "const_once_new"))]
+    #[rustc_const_unstable(feature = "const_once_new")]
     pub const fn new() -> Once {
         Once {
             state: AtomicUsize::new(INCOMPLETE),

src/libstd/thread/local.rs

@@ -190,11 +190,6 @@ macro_rules! __thread_local_inner {
         }
     };
     ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $init:expr) => {
-        #[cfg(stage0)]
-        $(#[$attr])* $vis static $name: $crate::thread::LocalKey<$t> =
-            __thread_local_inner!(@key $(#[$attr])* $vis $name, $t, $init);
-
-        #[cfg(not(stage0))]
         $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
             __thread_local_inner!(@key $(#[$attr])* $vis $name, $t, $init);
     }

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: 2017-08-29
+date: 2017-10-20
 rustc: beta
 cargo: beta
 

src/tools/cargo

@@ -1 +1 @@
-Subproject commit e447ac7e94b7f56ab13e361f9e324dafe3eb0a34
+Subproject commit e5562ddb061b8eb5a0e754d702f164a1d42d0a21