Auto merge of #46362 - kennytm:rollup, r=kennytm

Rollup of 10 pull requests

- Successful merges: #45969, #46077, #46219, #46287, #46293, #46322, #46323, #46330, #46354, #46356
- Failed merges:

52 files changed, 378 insertions, 508 deletions

diff --git a/src/liballoc/slice.rs b/src/liballoc/slice.rs
index 7e3d2af79ce..0eee7fb722e 100644
--- a/src/liballoc/slice.rs
+++ b/src/liballoc/slice.rs
@@ -1428,15 +1428,45 @@ impl<T> [T] {
     ///
     /// # Examples
     ///
+    /// Cloning two elements from a slice into another:
+    ///
+    /// ```
+    /// let src = [1, 2, 3, 4];
+    /// let mut dst = [0, 0];
+    ///
+    /// dst.clone_from_slice(&src[2..]);
+    ///
+    /// assert_eq!(src, [1, 2, 3, 4]);
+    /// assert_eq!(dst, [3, 4]);
+    /// ```
+    ///
+    /// Rust enforces that there can only be one mutable reference with no
+    /// immutable references to a particular piece of data in a particular
+    /// scope. Because of this, attempting to use `clone_from_slice` on a
+    /// single slice will result in a compile failure:
+    ///
+    /// ```compile_fail
+    /// let mut slice = [1, 2, 3, 4, 5];
+    ///
+    /// slice[..2].clone_from_slice(&slice[3..]); // compile fail!
+    /// ```
+    ///
+    /// To work around this, we can use [`split_at_mut`] to create two distinct
+    /// sub-slices from a slice:
+    ///
     /// ```
-    /// let mut dst = [0, 0, 0];
-    /// let src = [1, 2, 3];
+    /// let mut slice = [1, 2, 3, 4, 5];
     ///
-    /// dst.clone_from_slice(&src);
-    /// assert!(dst == [1, 2, 3]);
+    /// {
+    ///     let (left, right) = slice.split_at_mut(2);
+    ///     left.clone_from_slice(&right[1..]);
+    /// }
+    ///
+    /// assert_eq!(slice, [4, 5, 3, 4, 5]);
     /// ```
     ///
     /// [`copy_from_slice`]: #method.copy_from_slice
+    /// [`split_at_mut`]: #method.split_at_mut
     #[stable(feature = "clone_from_slice", since = "1.7.0")]
     pub fn clone_from_slice(&mut self, src: &[T]) where T: Clone {
         core_slice::SliceExt::clone_from_slice(self, src)
@@ -1454,15 +1484,45 @@ impl<T> [T] {
     ///
     /// # Examples
     ///
+    /// Copying two elements from a slice into another:
+    ///
+    /// ```
+    /// let src = [1, 2, 3, 4];
+    /// let mut dst = [0, 0];
+    ///
+    /// dst.copy_from_slice(&src[2..]);
+    ///
+    /// assert_eq!(src, [1, 2, 3, 4]);
+    /// assert_eq!(dst, [3, 4]);
+    /// ```
+    ///
+    /// Rust enforces that there can only be one mutable reference with no
+    /// immutable references to a particular piece of data in a particular
+    /// scope. Because of this, attempting to use `copy_from_slice` on a
+    /// single slice will result in a compile failure:
+    ///
+    /// ```compile_fail
+    /// let mut slice = [1, 2, 3, 4, 5];
+    ///
+    /// slice[..2].copy_from_slice(&slice[3..]); // compile fail!
+    /// ```
+    ///
+    /// To work around this, we can use [`split_at_mut`] to create two distinct
+    /// sub-slices from a slice:
+    ///
     /// ```
-    /// let mut dst = [0, 0, 0];
-    /// let src = [1, 2, 3];
+    /// let mut slice = [1, 2, 3, 4, 5];
     ///
-    /// dst.copy_from_slice(&src);
-    /// assert_eq!(src, dst);
+    /// {
+    ///     let (left, right) = slice.split_at_mut(2);
+    ///     left.copy_from_slice(&right[1..]);
+    /// }
+    ///
+    /// assert_eq!(slice, [4, 5, 3, 4, 5]);
     /// ```
     ///
     /// [`clone_from_slice`]: #method.clone_from_slice
+    /// [`split_at_mut`]: #method.split_at_mut
     #[stable(feature = "copy_from_slice", since = "1.9.0")]
     pub fn copy_from_slice(&mut self, src: &[T]) where T: Copy {
         core_slice::SliceExt::copy_from_slice(self, src)
@@ -1478,16 +1538,49 @@ impl<T> [T] {
     ///
     /// # Example
     ///
+    /// Swapping two elements across slices:
+    ///
+    /// ```
+    /// #![feature(swap_with_slice)]
+    ///
+    /// let mut slice1 = [0, 0];
+    /// let mut slice2 = [1, 2, 3, 4];
+    ///
+    /// slice1.swap_with_slice(&mut slice2[2..]);
+    ///
+    /// assert_eq!(slice1, [3, 4]);
+    /// assert_eq!(slice2, [1, 2, 0, 0]);
+    /// ```
+    ///
+    /// Rust enforces that there can only be one mutable reference to a
+    /// particular piece of data in a particular scope. Because of this,
+    /// attempting to use `swap_with_slice` on a single slice will result in
+    /// a compile failure:
+    ///
+    /// ```compile_fail
+    /// #![feature(swap_with_slice)]
+    ///
+    /// let mut slice = [1, 2, 3, 4, 5];
+    /// slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!
+    /// ```
+    ///
+    /// To work around this, we can use [`split_at_mut`] to create two distinct
+    /// mutable sub-slices from a slice:
+    ///
     /// ```
     /// #![feature(swap_with_slice)]
     ///
-    /// let mut slice1 = [1, 2, 3];
-    /// let mut slice2 = [7, 8, 9];
+    /// let mut slice = [1, 2, 3, 4, 5];
+    ///
+    /// {
+    ///     let (left, right) = slice.split_at_mut(2);
+    ///     left.swap_with_slice(&mut right[1..]);
+    /// }
     ///
-    /// slice1.swap_with_slice(&mut slice2);
-    /// assert_eq!(slice1, [7, 8, 9]);
-    /// assert_eq!(slice2, [1, 2, 3]);
+    /// assert_eq!(slice, [4, 5, 3, 1, 2]);
     /// ```
+    ///
+    /// [`split_at_mut`]: #method.split_at_mut
     #[unstable(feature = "swap_with_slice", issue = "44030")]
     pub fn swap_with_slice(&mut self, other: &mut [T]) {
         core_slice::SliceExt::swap_with_slice(self, other)
@@ -1626,120 +1719,6 @@ impl [u8] {
             byte.make_ascii_lowercase();
         }
     }
-
-    /// Checks if all bytes of this slice are ASCII alphabetic characters:
-    ///
-    /// - U+0041 'A' ... U+005A 'Z', or
-    /// - U+0061 'a' ... U+007A 'z'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_alphabetic(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_alphabetic())
-    }
-
-    /// Checks if all bytes of this slice are ASCII uppercase characters:
-    /// U+0041 'A' ... U+005A 'Z'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_uppercase(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_uppercase())
-    }
-
-    /// Checks if all bytes of this slice are ASCII lowercase characters:
-    /// U+0061 'a' ... U+007A 'z'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_lowercase(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_lowercase())
-    }
-
-    /// Checks if all bytes of this slice are ASCII alphanumeric characters:
-    ///
-    /// - U+0041 'A' ... U+005A 'Z', or
-    /// - U+0061 'a' ... U+007A 'z', or
-    /// - U+0030 '0' ... U+0039 '9'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_alphanumeric(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_alphanumeric())
-    }
-
-    /// Checks if all bytes of this slice are ASCII decimal digit:
-    /// U+0030 '0' ... U+0039 '9'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_digit(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_digit())
-    }
-
-    /// Checks if all bytes of this slice are ASCII hexadecimal digits:
-    ///
-    /// - U+0030 '0' ... U+0039 '9', or
-    /// - U+0041 'A' ... U+0046 'F', or
-    /// - U+0061 'a' ... U+0066 'f'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_hexdigit(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_hexdigit())
-    }
-
-    /// Checks if all bytes of this slice are ASCII punctuation characters:
-    ///
-    /// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
-    /// - U+003A ... U+0040 `: ; < = > ? @`, or
-    /// - U+005B ... U+0060 `[ \\ ] ^ _ \``, or
-    /// - U+007B ... U+007E `{ | } ~`
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_punctuation(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_punctuation())
-    }
-
-    /// Checks if all bytes of this slice are ASCII graphic characters:
-    /// U+0021 '@' ... U+007E '~'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_graphic(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_graphic())
-    }
-
-    /// Checks if all bytes of this slice are ASCII whitespace characters:
-    /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
-    /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
-    ///
-    /// Rust uses the WhatWG Infra Standard's [definition of ASCII
-    /// whitespace][infra-aw]. There are several other definitions in
-    /// wide use. For instance, [the POSIX locale][pct] includes
-    /// U+000B VERTICAL TAB as well as all the above characters,
-    /// but—from the very same specification—[the default rule for
-    /// "field splitting" in the Bourne shell][bfs] considers *only*
-    /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
-    ///
-    /// If you are writing a program that will process an existing
-    /// file format, check what that format's definition of whitespace is
-    /// before using this function.
-    ///
-    /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
-    /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
-    /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_whitespace(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_whitespace())
-    }
-
-    /// Checks if all bytes of this slice are ASCII control characters:
-    ///
-    /// - U+0000 NUL ... U+001F UNIT SEPARATOR, or
-    /// - U+007F DELETE.
-    ///
-    /// Note that most ASCII whitespace characters are control
-    /// characters, but SPACE is not.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_control(&self) -> bool {
-        self.iter().all(|b| b.is_ascii_control())
-    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/liballoc/str.rs b/src/liballoc/str.rs
index 6e8515f0b36..9755c5d54f2 100644
--- a/src/liballoc/str.rs
+++ b/src/liballoc/str.rs
@@ -2199,153 +2199,6 @@ impl str {
         let me = unsafe { self.as_bytes_mut() };
         me.make_ascii_lowercase()
     }
-
-    /// Checks if all characters of this string are ASCII alphabetic
-    /// characters:
-    ///
-    /// - U+0041 'A' ... U+005A 'Z', or
-    /// - U+0061 'a' ... U+007A 'z'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_alphabetic(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_alphabetic())
-    }
-
-    /// Checks if all characters of this string are ASCII uppercase characters:
-    /// U+0041 'A' ... U+005A 'Z'.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// #![feature(ascii_ctype)]
-    ///
-    /// // Only ascii uppercase characters
-    /// assert!("HELLO".is_ascii_uppercase());
-    ///
-    /// // While all characters are ascii, 'y' and 'e' are not uppercase
-    /// assert!(!"Bye".is_ascii_uppercase());
-    ///
-    /// // While all characters are uppercase, 'Ü' is not ascii
-    /// assert!(!"TSCHÜSS".is_ascii_uppercase());
-    /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_uppercase(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_uppercase())
-    }
-
-    /// Checks if all characters of this string are ASCII lowercase characters:
-    /// U+0061 'a' ... U+007A 'z'.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// #![feature(ascii_ctype)]
-    ///
-    /// // Only ascii uppercase characters
-    /// assert!("hello".is_ascii_lowercase());
-    ///
-    /// // While all characters are ascii, 'B' is not lowercase
-    /// assert!(!"Bye".is_ascii_lowercase());
-    ///
-    /// // While all characters are lowercase, 'Ü' is not ascii
-    /// assert!(!"tschüss".is_ascii_lowercase());
-    /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_lowercase(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_lowercase())
-    }
-
-    /// Checks if all characters of this string are ASCII alphanumeric
-    /// characters:
-    ///
-    /// - U+0041 'A' ... U+005A 'Z', or
-    /// - U+0061 'a' ... U+007A 'z', or
-    /// - U+0030 '0' ... U+0039 '9'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_alphanumeric(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_alphanumeric())
-    }
-
-    /// Checks if all characters of this string are ASCII decimal digit:
-    /// U+0030 '0' ... U+0039 '9'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_digit(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_digit())
-    }
-
-    /// Checks if all characters of this string are ASCII hexadecimal digits:
-    ///
-    /// - U+0030 '0' ... U+0039 '9', or
-    /// - U+0041 'A' ... U+0046 'F', or
-    /// - U+0061 'a' ... U+0066 'f'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_hexdigit(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_hexdigit())
-    }
-
-    /// Checks if all characters of this string are ASCII punctuation
-    /// characters:
-    ///
-    /// - U+0021 ... U+002F `! " # $ % & ' ( ) * + , - . /`, or
-    /// - U+003A ... U+0040 `: ; < = > ? @`, or
-    /// - U+005B ... U+0060 ``[ \ ] ^ _ ` ``, or
-    /// - U+007B ... U+007E `{ | } ~`
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_punctuation(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_punctuation())
-    }
-
-    /// Checks if all characters of this string are ASCII graphic characters:
-    /// U+0021 '@' ... U+007E '~'.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_graphic(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_graphic())
-    }
-
-    /// Checks if all characters of this string are ASCII whitespace characters:
-    /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,
-    /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.
-    ///
-    /// Rust uses the WhatWG Infra Standard's [definition of ASCII
-    /// whitespace][infra-aw]. There are several other definitions in
-    /// wide use. For instance, [the POSIX locale][pct] includes
-    /// U+000B VERTICAL TAB as well as all the above characters,
-    /// but—from the very same specification—[the default rule for
-    /// "field splitting" in the Bourne shell][bfs] considers *only*
-    /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.
-    ///
-    /// If you are writing a program that will process an existing
-    /// file format, check what that format's definition of whitespace is
-    /// before using this function.
-    ///
-    /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace
-    /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01
-    /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_whitespace(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_whitespace())
-    }
-
-    /// Checks if all characters of this string are ASCII control characters:
-    ///
-    /// - U+0000 NUL ... U+001F UNIT SEPARATOR, or
-    /// - U+007F DELETE.
-    ///
-    /// Note that most ASCII whitespace characters are control
-    /// characters, but SPACE is not.
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
-    #[inline]
-    pub fn is_ascii_control(&self) -> bool {
-        self.bytes().all(|b| b.is_ascii_control())
-    }
 }
 
 /// Converts a boxed slice of bytes to a boxed string slice without checking
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index d02576ae546..d4cd3f6264e 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -329,7 +329,6 @@ impl<T> Cell<T> {
     /// let c = Cell::new(5);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_cell_new")]
     #[inline]
     pub const fn new(value: T) -> Cell<T> {
         Cell {
@@ -544,7 +543,6 @@ impl<T> RefCell<T> {
     /// let c = RefCell::new(5);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_refcell_new")]
     #[inline]
     pub const fn new(value: T) -> RefCell<T> {
         RefCell {
@@ -1215,7 +1213,6 @@ impl<T> UnsafeCell<T> {
     /// let uc = UnsafeCell::new(5);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_unsafe_cell_new")]
     #[inline]
     pub const fn new(value: T) -> UnsafeCell<T> {
         UnsafeCell { value: value }
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index c8218172583..ee989854a37 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -134,7 +134,7 @@ macro_rules! radix {
     }
 }
 
-radix! { Binary,    2, "0b", x @  0 ...  2 => b'0' + x }
+radix! { Binary,    2, "0b", x @  0 ...  1 => b'0' + x }
 radix! { Octal,     8, "0o", x @  0 ...  7 => b'0' + x }
 radix! { Decimal,  10, "",   x @  0 ...  9 => b'0' + x }
 radix! { LowerHex, 16, "0x", x @  0 ...  9 => b'0' + x,
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 631b9f98589..07b45ad6a50 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -85,47 +85,13 @@
 #![feature(prelude_import)]
 #![feature(repr_simd, platform_intrinsics)]
 #![feature(rustc_attrs)]
-#![feature(rustc_const_unstable)]
 #![feature(specialization)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 #![feature(untagged_unions)]
 #![feature(unwind_attributes)]
-#![feature(const_min_value)]
-#![feature(const_max_value)]
-#![feature(const_atomic_bool_new)]
-#![feature(const_atomic_isize_new)]
-#![feature(const_atomic_usize_new)]
-#![feature(const_atomic_i8_new)]
-#![feature(const_atomic_u8_new)]
-#![feature(const_atomic_i16_new)]
-#![feature(const_atomic_u16_new)]
-#![feature(const_atomic_i32_new)]
-#![feature(const_atomic_u32_new)]
-#![feature(const_atomic_i64_new)]
-#![feature(const_atomic_u64_new)]
-#![feature(const_unsafe_cell_new)]
-#![feature(const_cell_new)]
-#![feature(const_nonzero_new)]
 #![cfg_attr(not(stage0), feature(doc_spotlight))]
 
-#![cfg_attr(not(stage0), feature(const_min_value))]
-#![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(not(stage0), feature(const_atomic_i8_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_u8_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_i16_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_u16_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_i32_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_u32_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_i64_new))]
-#![cfg_attr(not(stage0), feature(const_atomic_u64_new))]
-#![cfg_attr(not(stage0), feature(const_unsafe_cell_new))]
-#![cfg_attr(not(stage0), feature(const_cell_new))]
-#![cfg_attr(not(stage0), feature(const_nonzero_new))]
-
 #[prelude_import]
 #[allow(unused)]
 use prelude::v1::*;
diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs
index d57fbdf55f8..5b1a9399c39 100644
--- a/src/libcore/mem.rs
+++ b/src/libcore/mem.rs
@@ -311,7 +311,6 @@ pub fn forget<T>(t: T) {
 /// [alignment]: ./fn.align_of.html
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_size_of")]
 pub const fn size_of<T>() -> usize {
     unsafe { intrinsics::size_of::<T>() }
 }
@@ -403,7 +402,6 @@ pub fn min_align_of_val<T: ?Sized>(val: &T) -> usize {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_align_of")]
 pub const fn align_of<T>() -> usize {
     unsafe { intrinsics::min_align_of::<T>() }
 }
diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs
index ec277b4ae99..2c966eb3b57 100644
--- a/src/libcore/nonzero.rs
+++ b/src/libcore/nonzero.rs
@@ -70,7 +70,6 @@ impl<T: Zeroable> NonZero<T> {
     #[unstable(feature = "nonzero",
                reason = "needs an RFC to flesh out the design",
                issue = "27730")]
-    #[rustc_const_unstable(feature = "const_nonzero_new")]
     #[inline]
     pub const unsafe fn new_unchecked(inner: T) -> Self {
         NonZero(inner)
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 19e91a65964..5b9dd4b1c69 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -110,7 +110,6 @@ macro_rules! int_impl {
         /// assert_eq!(i8::min_value(), -128);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_min_value")]
         #[inline]
         pub const fn min_value() -> Self {
             !0 ^ ((!0 as $UnsignedT) >> 1) as Self
@@ -124,7 +123,6 @@ macro_rules! int_impl {
         /// assert_eq!(i8::max_value(), 127);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_max_value")]
         #[inline]
         pub const fn max_value() -> Self {
             !Self::min_value()
@@ -1290,7 +1288,6 @@ macro_rules! uint_impl {
         /// assert_eq!(u8::min_value(), 0);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_min_value")]
         #[inline]
         pub const fn min_value() -> Self { 0 }
 
@@ -1302,7 +1299,6 @@ macro_rules! uint_impl {
         /// assert_eq!(u8::max_value(), 255);
         /// ```
         #[stable(feature = "rust1", since = "1.0.0")]
-        #[rustc_const_unstable(feature = "const_max_value")]
         #[inline]
         pub const fn max_value() -> Self { !0 }
 
@@ -2438,7 +2434,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_alphabetic());
     /// assert!(!esc.is_ascii_alphabetic());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_alphabetic(&self) -> bool {
         if *self >= 0x80 { return false; }
@@ -2476,7 +2472,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_uppercase());
     /// assert!(!esc.is_ascii_uppercase());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_uppercase(&self) -> bool {
         if *self >= 0x80 { return false }
@@ -2514,7 +2510,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_lowercase());
     /// assert!(!esc.is_ascii_lowercase());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_lowercase(&self) -> bool {
         if *self >= 0x80 { return false }
@@ -2555,7 +2551,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_alphanumeric());
     /// assert!(!esc.is_ascii_alphanumeric());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_alphanumeric(&self) -> bool {
         if *self >= 0x80 { return false }
@@ -2593,7 +2589,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_digit());
     /// assert!(!esc.is_ascii_digit());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_digit(&self) -> bool {
         if *self >= 0x80 { return false }
@@ -2634,7 +2630,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_hexdigit());
     /// assert!(!esc.is_ascii_hexdigit());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_hexdigit(&self) -> bool {
         if *self >= 0x80 { return false }
@@ -2676,7 +2672,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_punctuation());
     /// assert!(!esc.is_ascii_punctuation());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_punctuation(&self) -> bool {
         if *self >= 0x80 { return false }
@@ -2714,7 +2710,7 @@ impl u8 {
     /// assert!(!lf.is_ascii_graphic());
     /// assert!(!esc.is_ascii_graphic());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_graphic(&self) -> bool {
         if *self >= 0x80 { return false; }
@@ -2769,7 +2765,7 @@ impl u8 {
     /// assert!(lf.is_ascii_whitespace());
     /// assert!(!esc.is_ascii_whitespace());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_whitespace(&self) -> bool {
         if *self >= 0x80 { return false; }
@@ -2809,7 +2805,7 @@ impl u8 {
     /// assert!(lf.is_ascii_control());
     /// assert!(esc.is_ascii_control());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_control(&self) -> bool {
         if *self >= 0x80 { return false; }
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 19553d0c37b..5e70c8283f4 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -74,7 +74,6 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[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 +88,6 @@ pub const fn null<T>() -> *const T { 0 as *const T }
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[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
@@ -2347,7 +2345,6 @@ impl<T: ?Sized> Unique<T> {
     ///
     /// `ptr` must be non-null.
     #[unstable(feature = "unique", issue = "27730")]
-    #[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 }
     }
@@ -2482,7 +2479,6 @@ impl<T: ?Sized> Shared<T> {
     ///
     /// `ptr` must be non-null.
     #[unstable(feature = "shared", issue = "27730")]
-    #[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 }
     }
diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs
index 8a261b8f077..4c6ff4d1bb4 100644
--- a/src/libcore/sync/atomic.rs
+++ b/src/libcore/sync/atomic.rs
@@ -242,7 +242,6 @@ impl AtomicBool {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_atomic_bool_new")]
     pub const fn new(v: bool) -> AtomicBool {
         AtomicBool { v: UnsafeCell::new(v as u8) }
     }
@@ -656,7 +655,6 @@ impl<T> AtomicPtr<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_unstable(feature = "const_atomic_ptr_new")]
     pub const fn new(p: *mut T) -> AtomicPtr<T> {
         AtomicPtr { p: UnsafeCell::new(p) }
     }
@@ -926,6 +924,13 @@ impl<T> AtomicPtr<T> {
     }
 }
 
+#[cfg(target_has_atomic = "8")]
+#[stable(feature = "atomic_bool_from", since = "1.24.0")]
+impl From<bool> for AtomicBool {
+    #[inline]
+    fn from(b: bool) -> Self { Self::new(b) }
+}
+
 #[cfg(target_has_atomic = "ptr")]
 #[stable(feature = "atomic_from", since = "1.23.0")]
 impl<T> From<*mut T> for AtomicPtr<T> {
@@ -935,7 +940,7 @@ impl<T> From<*mut T> for AtomicPtr<T> {
 
 #[cfg(target_has_atomic = "ptr")]
 macro_rules! atomic_int {
-    ($stable:meta, $const_unstable:meta,
+    ($stable:meta,
      $stable_cxchg:meta,
      $stable_debug:meta,
      $stable_access:meta,
@@ -1004,7 +1009,6 @@ macro_rules! atomic_int {
             /// ```
             #[inline]
             #[$stable]
-            #[$const_unstable]
             pub const fn new(v: $int_type) -> Self {
                 $atomic_type {v: UnsafeCell::new(v)}
             }
@@ -1368,7 +1372,6 @@ macro_rules! atomic_int {
 #[cfg(target_has_atomic = "8")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_i8_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1378,7 +1381,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "8")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_u8_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1388,7 +1390,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "16")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_i16_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1398,7 +1399,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "16")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_u16_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1408,7 +1408,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "32")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_i32_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1418,7 +1417,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "32")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_u32_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1428,7 +1426,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "64")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_i64_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1438,7 +1435,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "64")]
 atomic_int! {
     unstable(feature = "integer_atomics", issue = "32976"),
-    rustc_const_unstable(feature = "const_atomic_u64_new"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
     unstable(feature = "integer_atomics", issue = "32976"),
@@ -1448,7 +1444,6 @@ atomic_int! {
 #[cfg(target_has_atomic = "ptr")]
 atomic_int!{
     stable(feature = "rust1", since = "1.0.0"),
-    rustc_const_unstable(feature = "const_atomic_isize_new"),
     stable(feature = "extended_compare_and_swap", since = "1.10.0"),
     stable(feature = "atomic_debug", since = "1.3.0"),
     stable(feature = "atomic_access", since = "1.15.0"),
@@ -1458,7 +1453,6 @@ atomic_int!{
 #[cfg(target_has_atomic = "ptr")]
 atomic_int!{
     stable(feature = "rust1", since = "1.0.0"),
-    rustc_const_unstable(feature = "const_atomic_usize_new"),
     stable(feature = "extended_compare_and_swap", since = "1.10.0"),
     stable(feature = "atomic_debug", since = "1.3.0"),
     stable(feature = "atomic_access", since = "1.15.0"),
diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs
index e2283a71a0a..0e445cdac35 100644
--- a/src/libcore/tests/lib.rs
+++ b/src/libcore/tests/lib.rs
@@ -42,10 +42,6 @@
 #![feature(try_trait)]
 #![feature(unique)]
 
-#![feature(const_atomic_bool_new)]
-#![feature(const_atomic_usize_new)]
-#![feature(const_atomic_isize_new)]
-
 extern crate core;
 extern crate test;
 
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index b59f7480476..a8c80aaa030 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -64,7 +64,6 @@
 #![feature(underscore_lifetimes)]
 #![feature(trace_macros)]
 #![feature(test)]
-#![feature(const_atomic_bool_new)]
 
 #![recursion_limit="512"]
 
diff --git a/src/librustc_apfloat/lib.rs b/src/librustc_apfloat/lib.rs
index 09c9cecdcee..7dea3dae0bc 100644
--- a/src/librustc_apfloat/lib.rs
+++ b/src/librustc_apfloat/lib.rs
@@ -45,8 +45,6 @@
 #![deny(warnings)]
 #![forbid(unsafe_code)]
 
-#![feature(const_max_value)]
-#![feature(const_min_value)]
 #![feature(i128_type)]
 #![feature(slice_patterns)]
 #![feature(try_from)]
diff --git a/src/librustc_const_eval/lib.rs b/src/librustc_const_eval/lib.rs
index 714cead4bef..5e569e21de7 100644
--- a/src/librustc_const_eval/lib.rs
+++ b/src/librustc_const_eval/lib.rs
@@ -25,8 +25,6 @@
 #![feature(box_syntax)]
 #![feature(i128_type)]
 
-#![feature(const_min_value)]
-
 extern crate arena;
 #[macro_use] extern crate syntax;
 #[macro_use] extern crate log;
diff --git a/src/librustc_const_math/lib.rs b/src/librustc_const_math/lib.rs
index c6893acb31f..095b8bb50dc 100644
--- a/src/librustc_const_math/lib.rs
+++ b/src/librustc_const_math/lib.rs
@@ -22,9 +22,6 @@
 #![feature(i128)]
 #![feature(i128_type)]
 
-#![feature(const_min_value)]
-#![feature(const_max_value)]
-
 extern crate rustc_apfloat;
 
 extern crate syntax;
diff --git a/src/librustc_mir/diagnostics.rs b/src/librustc_mir/diagnostics.rs
index 0f67f7bf6de..619c0dc847e 100644
--- a/src/librustc_mir/diagnostics.rs
+++ b/src/librustc_mir/diagnostics.rs
@@ -770,8 +770,6 @@ static B: &'static AtomicUsize = &A; // ok!
 You can also have this error while using a cell type:
 
 ```compile_fail,E0492
-#![feature(const_cell_new)]
-
 use std::cell::Cell;
 
 const A: Cell<usize> = Cell::new(1);
@@ -798,8 +796,6 @@ However, if you still wish to use these types, you can achieve this by an unsafe
 wrapper:
 
 ```
-#![feature(const_cell_new)]
-
 use std::cell::Cell;
 use std::marker::Sync;
 
diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs
index 923d93587e9..3d1bd81fe21 100644
--- a/src/librustc_trans/lib.rs
+++ b/src/librustc_trans/lib.rs
@@ -33,9 +33,6 @@
 #![feature(slice_patterns)]
 #![feature(conservative_impl_trait)]
 
-#![feature(const_atomic_bool_new)]
-#![feature(const_once_new)]
-
 use rustc::dep_graph::WorkProduct;
 use syntax_pos::symbol::Symbol;
 
diff --git a/src/librustc_trans/llvm_util.rs b/src/librustc_trans/llvm_util.rs
index 68e05d43044..a9ea96134fa 100644
--- a/src/librustc_trans/llvm_util.rs
+++ b/src/librustc_trans/llvm_util.rs
@@ -85,7 +85,7 @@ const X86_WHITELIST: &'static [&'static str] = &["avx\0", "avx2\0", "bmi\0", "bm
                                                  "avx512dq\0", "avx512er\0",
                                                  "avx512f\0", "avx512ifma\0",
                                                  "avx512pf\0", "avx512vbmi\0",
-                                                 "avx512vl\0", "avx512vpopcntdq\0"];
+                                                 "avx512vl\0", "avx512vpopcntdq\0", "mmx\0"];
 
 const HEXAGON_WHITELIST: &'static [&'static str] = &["hvx\0", "hvx-double\0"];
 
@@ -94,6 +94,8 @@ const POWERPC_WHITELIST: &'static [&'static str] = &["altivec\0",
                                                      "power8-vector\0", "power9-vector\0",
                                                      "vsx\0"];
 
+const MIPS_WHITELIST: &'static [&'static str] = &["msa\0"];
+
 pub fn target_features(sess: &Session) -> Vec<Symbol> {
     let target_machine = create_target_machine(sess);
 
@@ -102,6 +104,7 @@ pub fn target_features(sess: &Session) -> Vec<Symbol> {
         "aarch64" => AARCH64_WHITELIST,
         "x86" | "x86_64" => X86_WHITELIST,
         "hexagon" => HEXAGON_WHITELIST,
+        "mips" | "mips64" => MIPS_WHITELIST,
         "powerpc" | "powerpc64" => POWERPC_WHITELIST,
         _ => &[],
     };
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 96d719c528c..312da203574 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -490,77 +490,199 @@ impl AsciiExt for [u8] {
     }
 }
 
-macro_rules! impl_by_delegating {
-    ($ty:ty, $owned:ty) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
-        impl AsciiExt for $ty {
-            type Owned = $owned;
+macro_rules! delegating_ascii_methods {
+    () => {
+        #[inline]
+        fn is_ascii(&self) -> bool { self.is_ascii() }
 
-            #[inline]
-            fn is_ascii(&self) -> bool { self.is_ascii() }
+        #[inline]
+        fn to_ascii_uppercase(&self) -> Self::Owned { self.to_ascii_uppercase() }
 
-            #[inline]
-            fn to_ascii_uppercase(&self) -> Self::Owned { self.to_ascii_uppercase() }
+        #[inline]
+        fn to_ascii_lowercase(&self) -> Self::Owned { self.to_ascii_lowercase() }
 
-            #[inline]
-            fn to_ascii_lowercase(&self) -> Self::Owned { self.to_ascii_lowercase() }
+        #[inline]
+        fn eq_ignore_ascii_case(&self, o: &Self) -> bool { self.eq_ignore_ascii_case(o) }
 
-            #[inline]
-            fn eq_ignore_ascii_case(&self, o: &Self) -> bool { self.eq_ignore_ascii_case(o) }
+        #[inline]
+        fn make_ascii_uppercase(&mut self) { self.make_ascii_uppercase(); }
 
-            #[inline]
-            fn make_ascii_uppercase(&mut self) { self.make_ascii_uppercase(); }
-
-            #[inline]
-            fn make_ascii_lowercase(&mut self) { self.make_ascii_lowercase(); }
+        #[inline]
+        fn make_ascii_lowercase(&mut self) { self.make_ascii_lowercase(); }
+    }
+}
 
-            #[inline]
-            fn is_ascii_alphabetic(&self) -> bool { self.is_ascii_alphabetic() }
+macro_rules! delegating_ascii_ctype_methods {
+    () => {
+        #[inline]
+        fn is_ascii_alphabetic(&self) -> bool { self.is_ascii_alphabetic() }
 
-            #[inline]
-            fn is_ascii_uppercase(&self) -> bool { self.is_ascii_uppercase() }
+        #[inline]
+        fn is_ascii_uppercase(&self) -> bool { self.is_ascii_uppercase() }
 
-            #[inline]
-            fn is_ascii_lowercase(&self) -> bool { self.is_ascii_lowercase() }
+        #[inline]
+        fn is_ascii_lowercase(&self) -> bool { self.is_ascii_lowercase() }
 
-            #[inline]
-            fn is_ascii_alphanumeric(&self) -> bool { self.is_ascii_alphanumeric() }
+        #[inline]
+        fn is_ascii_alphanumeric(&self) -> bool { self.is_ascii_alphanumeric() }
 
-            #[inline]
-            fn is_ascii_digit(&self) -> bool { self.is_ascii_digit() }
+        #[inline]
+        fn is_ascii_digit(&self) -> bool { self.is_ascii_digit() }
 
-            #[inline]
-            fn is_ascii_hexdigit(&self) -> bool { self.is_ascii_hexdigit() }
+        #[inline]
+        fn is_ascii_hexdigit(&self) -> bool { self.is_ascii_hexdigit() }
 
-            #[inline]
-            fn is_ascii_punctuation(&self) -> bool { self.is_ascii_punctuation() }
+        #[inline]
+        fn is_ascii_punctuation(&self) -> bool { self.is_ascii_punctuation() }
 
-            #[inline]
-            fn is_ascii_graphic(&self) -> bool { self.is_ascii_graphic() }
+        #[inline]
+        fn is_ascii_graphic(&self) -> bool { self.is_ascii_graphic() }
 
-            #[inline]
-            fn is_ascii_whitespace(&self) -> bool { self.is_ascii_whitespace() }
+        #[inline]
+        fn is_ascii_whitespace(&self) -> bool { self.is_ascii_whitespace() }
 
-            #[inline]
-            fn is_ascii_control(&self) -> bool { self.is_ascii_control() }
-        }
+        #[inline]
+        fn is_ascii_control(&self) -> bool { self.is_ascii_control() }
     }
 }
 
-impl_by_delegating!(u8, u8);
-impl_by_delegating!(char, char);
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsciiExt for u8 {
+    type Owned = u8;
+
+    delegating_ascii_methods!();
+    delegating_ascii_ctype_methods!();
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsciiExt for char {
+    type Owned = char;
+
+    delegating_ascii_methods!();
+    delegating_ascii_ctype_methods!();
+}
 
 // FIXME(LukasKalbertodt): the macro invocation should replace the impl block
 // for `[u8]` above. But this is not possible until the stage0 compiler is new
 // enough to contain the inherent ascii methods for `[u8]`.
 #[cfg(not(stage0))]
-impl_by_delegating!([u8], Vec<u8>);
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsciiExt for [u8] {
+    type Owned = Vec<u8>;
+
+    delegating_ascii_methods!();
+
+    #[inline]
+    fn is_ascii_alphabetic(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_alphabetic())
+    }
+
+    #[inline]
+    fn is_ascii_uppercase(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_uppercase())
+    }
+
+    #[inline]
+    fn is_ascii_lowercase(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_lowercase())
+    }
+
+    #[inline]
+    fn is_ascii_alphanumeric(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_alphanumeric())
+    }
+
+    #[inline]
+    fn is_ascii_digit(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_digit())
+    }
+
+    #[inline]
+    fn is_ascii_hexdigit(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_hexdigit())
+    }
+
+    #[inline]
+    fn is_ascii_punctuation(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_punctuation())
+    }
+
+    #[inline]
+    fn is_ascii_graphic(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_graphic())
+    }
+
+    #[inline]
+    fn is_ascii_whitespace(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_whitespace())
+    }
+
+    #[inline]
+    fn is_ascii_control(&self) -> bool {
+        self.iter().all(|b| b.is_ascii_control())
+    }
+}
 
 // FIXME(LukasKalbertodt): the macro invocation should replace the impl block
 // for `str` above. But this is not possible until the stage0 compiler is new
 // enough to contain the inherent ascii methods for `str`.
 #[cfg(not(stage0))]
-impl_by_delegating!(str, String);
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsciiExt for str {
+    type Owned = String;
+
+    delegating_ascii_methods!();
+
+    #[inline]
+    fn is_ascii_alphabetic(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_alphabetic())
+    }
+
+    #[inline]
+    fn is_ascii_uppercase(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_uppercase())
+    }
+
+    #[inline]
+    fn is_ascii_lowercase(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_lowercase())
+    }
+
+    #[inline]
+    fn is_ascii_alphanumeric(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_alphanumeric())
+    }
+
+    #[inline]
+    fn is_ascii_digit(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_digit())
+    }
+
+    #[inline]
+    fn is_ascii_hexdigit(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_hexdigit())
+    }
+
+    #[inline]
+    fn is_ascii_punctuation(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_punctuation())
+    }
+
+    #[inline]
+    fn is_ascii_graphic(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_graphic())
+    }
+
+    #[inline]
+    fn is_ascii_whitespace(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_whitespace())
+    }
+
+    #[inline]
+    fn is_ascii_control(&self) -> bool {
+        self.bytes().all(|b| b.is_ascii_control())
+    }
+}
 
 /// An iterator over the escaped version of a byte.
 ///
@@ -684,6 +806,7 @@ mod tests {
     //! Note that most of these tests are not testing `AsciiExt` methods, but
     //! test inherent ascii methods of char, u8, str and [u8]. `AsciiExt` is
     //! just using those methods, though.
+    use super::AsciiExt;
     use char::from_u32;
 
     #[test]
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 9587bb424bd..bf177ac7f2c 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -256,15 +256,6 @@
 #![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)]
@@ -306,7 +297,6 @@
 #![feature(repr_align)]
 #![feature(repr_simd)]
 #![feature(rustc_attrs)]
-#![feature(rustc_const_unstable)]
 #![feature(shared)]
 #![feature(sip_hash_13)]
 #![feature(slice_bytes)]
@@ -331,7 +321,6 @@
 #![feature(doc_masked)]
 #![feature(doc_spotlight)]
 #![cfg_attr(test, feature(update_panic_count))]
-#![cfg_attr(windows, feature(const_atomic_ptr_new))]
 #![cfg_attr(windows, feature(used))]
 
 #![default_lib_allocator]
diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs
index 8d7f60f9d2c..2dd3aebe610 100644
--- a/src/libstd/sync/mpsc/mod.rs
+++ b/src/libstd/sync/mpsc/mod.rs
@@ -1297,11 +1297,72 @@ impl<T> Receiver<T> {
             Err(TryRecvError::Disconnected)
                 => Err(RecvTimeoutError::Disconnected),
             Err(TryRecvError::Empty)
-                => self.recv_max_until(Instant::now() + timeout)
+                => self.recv_deadline(Instant::now() + timeout)
         }
     }
 
-    fn recv_max_until(&self, deadline: Instant) -> Result<T, RecvTimeoutError> {
+    /// Attempts to wait for a value on this receiver, returning an error if the
+    /// corresponding channel has hung up, or if `deadline` is reached.
+    ///
+    /// This function will always block the current thread if there is no data
+    /// available and it's possible for more data to be sent. Once a message is
+    /// sent to the corresponding [`Sender`][] (or [`SyncSender`]), then this
+    /// receiver will wake up and return that message.
+    ///
+    /// If the corresponding [`Sender`] has disconnected, or it disconnects while
+    /// this call is blocking, this call will wake up and return [`Err`] to
+    /// indicate that no more messages can ever be received on this channel.
+    /// However, since channels are buffered, messages sent before the disconnect
+    /// will still be properly received.
+    ///
+    /// [`Sender`]: struct.Sender.html
+    /// [`SyncSender`]: struct.SyncSender.html
+    /// [`Err`]: ../../../std/result/enum.Result.html#variant.Err
+    ///
+    /// # Examples
+    ///
+    /// Successfully receiving value before reaching deadline:
+    ///
+    /// ```no_run
+    /// #![feature(deadline_api)]
+    /// use std::thread;
+    /// use std::time::{Duration, Instant};
+    /// use std::sync::mpsc;
+    ///
+    /// let (send, recv) = mpsc::channel();
+    ///
+    /// thread::spawn(move || {
+    ///     send.send('a').unwrap();
+    /// });
+    ///
+    /// assert_eq!(
+    ///     recv.recv_deadline(Instant::now() + Duration::from_millis(400)),
+    ///     Ok('a')
+    /// );
+    /// ```
+    ///
+    /// Receiving an error upon reaching deadline:
+    ///
+    /// ```no_run
+    /// #![feature(deadline_api)]
+    /// use std::thread;
+    /// use std::time::{Duration, Instant};
+    /// use std::sync::mpsc;
+    ///
+    /// let (send, recv) = mpsc::channel();
+    ///
+    /// thread::spawn(move || {
+    ///     thread::sleep(Duration::from_millis(800));
+    ///     send.send('a').unwrap();
+    /// });
+    ///
+    /// assert_eq!(
+    ///     recv.recv_deadline(Instant::now() + Duration::from_millis(400)),
+    ///     Err(mpsc::RecvTimeoutError::Timeout)
+    /// );
+    /// ```
+    #[unstable(feature = "deadline_api", issue = "46316")]
+    pub fn recv_deadline(&self, deadline: Instant) -> Result<T, RecvTimeoutError> {
         use self::RecvTimeoutError::*;
 
         loop {
@@ -1625,7 +1686,7 @@ impl<T: Send> error::Error for TrySendError<T> {
     }
 }
 
-#[stable(feature = "mpsc_error_conversions", since = "1.23.0")]
+#[stable(feature = "mpsc_error_conversions", since = "1.24.0")]
 impl<T> From<SendError<T>> for TrySendError<T> {
     fn from(err: SendError<T>) -> TrySendError<T> {
         match err {
@@ -1686,7 +1747,7 @@ impl error::Error for TryRecvError {
     }
 }
 
-#[stable(feature = "mpsc_error_conversions", since = "1.23.0")]
+#[stable(feature = "mpsc_error_conversions", since = "1.24.0")]
 impl From<RecvError> for TryRecvError {
     fn from(err: RecvError) -> TryRecvError {
         match err {
@@ -1727,7 +1788,7 @@ impl error::Error for RecvTimeoutError {
     }
 }
 
-#[stable(feature = "mpsc_error_conversions", since = "1.23.0")]
+#[stable(feature = "mpsc_error_conversions", since = "1.24.0")]
 impl From<RecvError> for RecvTimeoutError {
     fn from(err: RecvError) -> RecvTimeoutError {
         match err {
diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs
index 2ef99525af5..6fd8b6a5bba 100644
--- a/src/libstd/sync/once.rs
+++ b/src/libstd/sync/once.rs
@@ -156,7 +156,6 @@ struct Finish {
 impl Once {
     /// Creates a new `Once` value.
     #[stable(feature = "once_new", since = "1.2.0")]
-    #[rustc_const_unstable(feature = "const_once_new")]
     pub const fn new() -> Once {
         Once {
             state: AtomicUsize::new(INCOMPLETE),
diff --git a/src/libstd_unicode/char.rs b/src/libstd_unicode/char.rs
index 0faf5bd9121..6b573e5011b 100644
--- a/src/libstd_unicode/char.rs
+++ b/src/libstd_unicode/char.rs
@@ -1109,7 +1109,7 @@ impl char {
     /// assert!(!lf.is_ascii_alphabetic());
     /// assert!(!esc.is_ascii_alphabetic());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_alphabetic(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_alphabetic()
@@ -1143,7 +1143,7 @@ impl char {
     /// assert!(!lf.is_ascii_uppercase());
     /// assert!(!esc.is_ascii_uppercase());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_uppercase(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_uppercase()
@@ -1177,7 +1177,7 @@ impl char {
     /// assert!(!lf.is_ascii_lowercase());
     /// assert!(!esc.is_ascii_lowercase());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_lowercase(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_lowercase()
@@ -1214,7 +1214,7 @@ impl char {
     /// assert!(!lf.is_ascii_alphanumeric());
     /// assert!(!esc.is_ascii_alphanumeric());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_alphanumeric(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_alphanumeric()
@@ -1248,7 +1248,7 @@ impl char {
     /// assert!(!lf.is_ascii_digit());
     /// assert!(!esc.is_ascii_digit());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_digit(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_digit()
@@ -1285,7 +1285,7 @@ impl char {
     /// assert!(!lf.is_ascii_hexdigit());
     /// assert!(!esc.is_ascii_hexdigit());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_hexdigit(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_hexdigit()
@@ -1323,7 +1323,7 @@ impl char {
     /// assert!(!lf.is_ascii_punctuation());
     /// assert!(!esc.is_ascii_punctuation());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_punctuation(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_punctuation()
@@ -1357,7 +1357,7 @@ impl char {
     /// assert!(!lf.is_ascii_graphic());
     /// assert!(!esc.is_ascii_graphic());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_graphic(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_graphic()
@@ -1408,7 +1408,7 @@ impl char {
     /// assert!(lf.is_ascii_whitespace());
     /// assert!(!esc.is_ascii_whitespace());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_whitespace(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_whitespace()
@@ -1444,7 +1444,7 @@ impl char {
     /// assert!(lf.is_ascii_control());
     /// assert!(esc.is_ascii_control());
     /// ```
-    #[unstable(feature = "ascii_ctype", issue = "39658")]
+    #[stable(feature = "ascii_ctype_on_intrinsics", since = "1.24.0")]
     #[inline]
     pub fn is_ascii_control(&self) -> bool {
         self.is_ascii() && (*self as u8).is_ascii_control()
diff --git a/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs b/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs
index fa85432fb8e..bc88ff9244c 100644
--- a/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs
+++ b/src/test/compile-fail-fulldeps/dropck_tarena_cycle_checked.rs
@@ -17,7 +17,6 @@
 //  for the error message we see here.)
 
 #![feature(rustc_private)]
-#![feature(const_atomic_usize_new)]
 
 extern crate arena;
 
diff --git a/src/test/compile-fail/const-fn-feature-flags.rs b/src/test/compile-fail/const-fn-feature-flags.rs
deleted file mode 100644
index 823cb89b365..00000000000
--- a/src/test/compile-fail/const-fn-feature-flags.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Test use of const fns in std using individual feature gates.
-
-use std::cell::Cell;
-
-const CELL: Cell<i32> = Cell::new(42); //~ERROR not yet stable as a const fn
-    //~^HELP #![feature(const_cell_new)]
-
-fn main() {
-    let v = CELL.get();
-    CELL.set(v+1);
-
-    assert_eq!(CELL.get(), v);
-}
-
diff --git a/src/test/compile-fail/dropck_trait_cycle_checked.rs b/src/test/compile-fail/dropck_trait_cycle_checked.rs
index c0f0e3650d9..b6b7fa1a233 100644
--- a/src/test/compile-fail/dropck_trait_cycle_checked.rs
+++ b/src/test/compile-fail/dropck_trait_cycle_checked.rs
@@ -13,8 +13,6 @@
 //
 // (Compare against compile-fail/dropck_vec_cycle_checked.rs)
 
-#![feature(const_atomic_usize_new)]
-
 use std::cell::Cell;
 use id::Id;
 
diff --git a/src/test/compile-fail/issue-17718-const-borrow.rs b/src/test/compile-fail/issue-17718-const-borrow.rs
index 1464fcd9a1c..07123c69492 100644
--- a/src/test/compile-fail/issue-17718-const-borrow.rs
+++ b/src/test/compile-fail/issue-17718-const-borrow.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(const_unsafe_cell_new)]
-
 use std::cell::UnsafeCell;
 
 const A: UnsafeCell<usize> = UnsafeCell::new(1);
diff --git a/src/test/compile-fail/issue-43733-2.rs b/src/test/compile-fail/issue-43733-2.rs
index 1bf165c89d3..0fd31454596 100644
--- a/src/test/compile-fail/issue-43733-2.rs
+++ b/src/test/compile-fail/issue-43733-2.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(const_fn, const_cell_new, const_unsafe_cell_new)]
+#![feature(const_fn)]
 #![feature(cfg_target_thread_local, thread_local_internals)]
 
 // On platforms *without* `#[thread_local]`, use
diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs
index ef53be75780..3979790e3d4 100644
--- a/src/test/compile-fail/issue-7364.rs
+++ b/src/test/compile-fail/issue-7364.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(box_syntax, const_refcell_new)]
+#![feature(box_syntax)]
 
 use std::cell::RefCell;
 
diff --git a/src/test/debuginfo/constant-debug-locs.rs b/src/test/debuginfo/constant-debug-locs.rs
index 7a24510b7d4..8fc910d8a6d 100644
--- a/src/test/debuginfo/constant-debug-locs.rs
+++ b/src/test/debuginfo/constant-debug-locs.rs
@@ -15,7 +15,6 @@
 #![allow(dead_code, unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
-#![feature(const_unsafe_cell_new)]
 #![feature(static_mutex)]
 
 // This test makes sure that the compiler doesn't crash when trying to assign
diff --git a/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs b/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs
index 82305045f80..adc72aa0ea2 100644
--- a/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs
+++ b/src/test/run-pass-fulldeps/vector-sort-panic-safe.rs
@@ -12,7 +12,6 @@
 
 #![feature(rustc_private)]
 #![feature(sort_unstable)]
-#![feature(const_atomic_usize_new)]
 
 extern crate rand;
 
diff --git a/src/test/run-pass-valgrind/cast-enum-with-dtor.rs b/src/test/run-pass-valgrind/cast-enum-with-dtor.rs
index 439c1080f47..4466a95cb39 100644
--- a/src/test/run-pass-valgrind/cast-enum-with-dtor.rs
+++ b/src/test/run-pass-valgrind/cast-enum-with-dtor.rs
@@ -11,7 +11,6 @@
 // no-prefer-dynamic
 
 #![allow(dead_code)]
-#![feature(const_atomic_usize_new)]
 
 // check dtor calling order when casting enums.
 
diff --git a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs
index 7cde780cc54..5ceb1013ad8 100644
--- a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs
+++ b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where.rs
@@ -12,8 +12,6 @@
 // `Item` originates in a where-clause, not the declaration of
 // `T`. Issue #20300.
 
-#![feature(const_atomic_usize_new)]
-
 use std::marker::{PhantomData};
 use std::sync::atomic::{AtomicUsize};
 use std::sync::atomic::Ordering::SeqCst;
diff --git a/src/test/run-pass/auxiliary/issue-17718-aux.rs b/src/test/run-pass/auxiliary/issue-17718-aux.rs
index 36891a1ecad..2bc8b4b7ba0 100644
--- a/src/test/run-pass/auxiliary/issue-17718-aux.rs
+++ b/src/test/run-pass/auxiliary/issue-17718-aux.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(const_atomic_usize_new)]
-
 use std::sync::atomic;
 
 pub const C1: usize = 1;
diff --git a/src/test/run-pass/auxiliary/thread-local-extern-static.rs b/src/test/run-pass/auxiliary/thread-local-extern-static.rs
index bce87ef5a26..e9457886be8 100644
--- a/src/test/run-pass/auxiliary/thread-local-extern-static.rs
+++ b/src/test/run-pass/auxiliary/thread-local-extern-static.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 #![feature(cfg_target_thread_local, const_fn, thread_local)]
-#![feature(const_cell_new)]
 #![crate_type = "lib"]
 
 #[cfg(target_thread_local)]
diff --git a/src/test/run-pass/box-of-array-of-drop-1.rs b/src/test/run-pass/box-of-array-of-drop-1.rs
index 47b44863a74..db055e6886a 100644
--- a/src/test/run-pass/box-of-array-of-drop-1.rs
+++ b/src/test/run-pass/box-of-array-of-drop-1.rs
@@ -13,8 +13,6 @@
 
 // ignore-emscripten no threads support
 
-#![feature(const_atomic_usize_new)]
-
 use std::thread;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
diff --git a/src/test/run-pass/box-of-array-of-drop-2.rs b/src/test/run-pass/box-of-array-of-drop-2.rs
index 54be4955baf..9dde53bb31d 100644
--- a/src/test/run-pass/box-of-array-of-drop-2.rs
+++ b/src/test/run-pass/box-of-array-of-drop-2.rs
@@ -13,8 +13,6 @@
 
 // ignore-emscripten no threads support
 
-#![feature(const_atomic_usize_new)]
-
 use std::thread;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
diff --git a/src/test/run-pass/const-fn-feature-flags.rs b/src/test/run-pass/const-fn-feature-flags.rs
index 1e27a3edac8..a7736a2eb34 100644
--- a/src/test/run-pass/const-fn-feature-flags.rs
+++ b/src/test/run-pass/const-fn-feature-flags.rs
@@ -8,9 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test use of const fns in std using individual feature gates.
-
-#![feature(const_cell_new)]
+// Test use of stabilized const fns in std formerly using individual feature gates.
 
 use std::cell::Cell;
 
diff --git a/src/test/run-pass/const-size_of-align_of.rs b/src/test/run-pass/const-size_of-align_of.rs
index d5547ea5add..06fbe9bf4f6 100644
--- a/src/test/run-pass/const-size_of-align_of.rs
+++ b/src/test/run-pass/const-size_of-align_of.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(const_fn, const_size_of, const_align_of)]
+#![feature(const_fn)]
 
 use std::mem;
 
diff --git a/src/test/run-pass/issue-17718-static-unsafe-interior.rs b/src/test/run-pass/issue-17718-static-unsafe-interior.rs
index 66f70cdaeb0..5f7629fa267 100644
--- a/src/test/run-pass/issue-17718-static-unsafe-interior.rs
+++ b/src/test/run-pass/issue-17718-static-unsafe-interior.rs
@@ -10,9 +10,6 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(core)]
-#![feature(const_unsafe_cell_new)]
-
 use std::marker;
 use std::cell::UnsafeCell;
 
diff --git a/src/test/run-pass/issue-17718.rs b/src/test/run-pass/issue-17718.rs
index 1b8fbc1ad2f..502e4a81664 100644
--- a/src/test/run-pass/issue-17718.rs
+++ b/src/test/run-pass/issue-17718.rs
@@ -10,10 +10,6 @@
 
 // aux-build:issue-17718-aux.rs
 
-
-#![feature(core)]
-#![feature(const_atomic_usize_new)]
-
 extern crate issue_17718_aux as other;
 
 use std::sync::atomic::{AtomicUsize, Ordering};
diff --git a/src/test/run-pass/issue-21486.rs b/src/test/run-pass/issue-21486.rs
index 23d06c4324d..a61f294465d 100644
--- a/src/test/run-pass/issue-21486.rs
+++ b/src/test/run-pass/issue-21486.rs
@@ -12,8 +12,6 @@
 // created via FRU and control-flow breaks in the middle of
 // construction.
 
-#![feature(const_atomic_usize_new)]
-
 use std::sync::atomic::{Ordering, AtomicUsize};
 
 #[derive(Debug)]
diff --git a/src/test/run-pass/issue-26655.rs b/src/test/run-pass/issue-26655.rs
index 3e252b8629e..6d43451af6b 100644
--- a/src/test/run-pass/issue-26655.rs
+++ b/src/test/run-pass/issue-26655.rs
@@ -12,8 +12,6 @@
 
 // Check that the destructors of simple enums are run on unwinding
 
-#![feature(const_atomic_usize_new)]
-
 use std::sync::atomic::{Ordering, AtomicUsize};
 use std::thread;
 
diff --git a/src/test/run-pass/issue-27997.rs b/src/test/run-pass/issue-27997.rs
index dab42e48e16..9dba477a7e5 100644
--- a/src/test/run-pass/issue-27997.rs
+++ b/src/test/run-pass/issue-27997.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(const_atomic_usize_new)]
-
 use std::sync::atomic::{Ordering, AtomicUsize};
 
 use std::mem;
diff --git a/src/test/run-pass/nested-vec-3.rs b/src/test/run-pass/nested-vec-3.rs
index 9141b5f29ce..d1a63b44392 100644
--- a/src/test/run-pass/nested-vec-3.rs
+++ b/src/test/run-pass/nested-vec-3.rs
@@ -14,8 +14,6 @@
 // the contents implement Drop and we hit a panic in the middle of
 // construction.
 
-#![feature(const_atomic_usize_new)]
-
 use std::thread;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
diff --git a/src/test/run-pass/panic-handler-chain.rs b/src/test/run-pass/panic-handler-chain.rs
index c5dc8ccd2ee..8d692f2241b 100644
--- a/src/test/run-pass/panic-handler-chain.rs
+++ b/src/test/run-pass/panic-handler-chain.rs
@@ -11,7 +11,6 @@
 // ignore-emscripten no threads support
 
 #![feature(panic_handler, std_panic)]
-#![feature(const_atomic_usize_new)]
 
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::panic;
diff --git a/src/test/run-pass/panic-handler-set-twice.rs b/src/test/run-pass/panic-handler-set-twice.rs
index 8bf2683cd9f..81da13afaa5 100644
--- a/src/test/run-pass/panic-handler-set-twice.rs
+++ b/src/test/run-pass/panic-handler-set-twice.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 #![feature(panic_handler, std_panic)]
-#![feature(const_atomic_usize_new)]
 
 // ignore-emscripten no threads support
 
diff --git a/src/test/run-pass/struct-order-of-eval-3.rs b/src/test/run-pass/struct-order-of-eval-3.rs
index cf93133d205..3059c8e9e89 100644
--- a/src/test/run-pass/struct-order-of-eval-3.rs
+++ b/src/test/run-pass/struct-order-of-eval-3.rs
@@ -11,8 +11,6 @@
 // Checks that functional-record-update order-of-eval is as expected
 // even when no Drop-implementations are involved.
 
-#![feature(const_atomic_usize_new)]
-
 use std::sync::atomic::{Ordering, AtomicUsize};
 
 struct W { wrapped: u32 }
diff --git a/src/test/run-pass/struct-order-of-eval-4.rs b/src/test/run-pass/struct-order-of-eval-4.rs
index d442923478f..2ae9ebc34e1 100644
--- a/src/test/run-pass/struct-order-of-eval-4.rs
+++ b/src/test/run-pass/struct-order-of-eval-4.rs
@@ -11,8 +11,6 @@
 // Checks that struct-literal expression order-of-eval is as expected
 // even when no Drop-implementations are involved.
 
-#![feature(const_atomic_usize_new)]
-
 use std::sync::atomic::{Ordering, AtomicUsize};
 
 struct W { wrapped: u32 }
diff --git a/src/test/ui/span/dropck_arr_cycle_checked.rs b/src/test/ui/span/dropck_arr_cycle_checked.rs
index 995a198271c..455c9dc57f5 100644
--- a/src/test/ui/span/dropck_arr_cycle_checked.rs
+++ b/src/test/ui/span/dropck_arr_cycle_checked.rs
@@ -13,7 +13,7 @@
 //
 // (Compare against compile-fail/dropck_vec_cycle_checked.rs)
 
-#![feature(const_atomic_usize_new)]
+
 
 use std::cell::Cell;
 use id::Id;
diff --git a/src/test/ui/span/dropck_vec_cycle_checked.rs b/src/test/ui/span/dropck_vec_cycle_checked.rs
index 5bcaa71f73c..5e7cb79680c 100644
--- a/src/test/ui/span/dropck_vec_cycle_checked.rs
+++ b/src/test/ui/span/dropck_vec_cycle_checked.rs
@@ -12,7 +12,7 @@
 //
 // (Compare against compile-fail/dropck_arr_cycle_checked.rs)
 
-#![feature(const_atomic_usize_new)]
+
 
 use std::cell::Cell;
 use id::Id;
diff --git a/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs b/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs
index d99f3bb19db..c4596e7c368 100644
--- a/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs
+++ b/src/test/ui/span/vec-must-not-hide-type-from-dropck.rs
@@ -23,7 +23,7 @@
 // conditions above to be satisfied, meaning that if the dropck is
 // sound, it should reject this code.
 
-#![feature(const_atomic_usize_new)]
+
 
 use std::cell::Cell;
 use id::Id;