Auto merge of #43831 - alexcrichton:beta-next, r=alexcrichton

Backporting accepted PRs to beta

Backport of:

* #43735
* #43546
* #43513
* #43373
* #43315

Author: bors

src/Cargo.lock

@@ -28,7 +28,7 @@ pub const CFG_RELEASE_NUM: &str = "1.20.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
 // versions (section 9)
-pub const CFG_PRERELEASE_VERSION: &str = ".1";
+pub const CFG_PRERELEASE_VERSION: &str = ".2";
 
 pub struct GitInfo {
     inner: Option<Info>,

src/bootstrap/channel.rs

@@ -207,6 +207,7 @@ impl Layout {
     /// of each element in the array.
     ///
     /// On arithmetic overflow, returns `None`.
+    #[inline]
     pub fn repeat(&self, n: usize) -> Option<(Self, usize)> {
         let padded_size = match self.size.checked_add(self.padding_needed_for(self.align)) {
             None => return None,

src/doc/unstable-book/src/language-features/compile-error.md

@@ -79,11 +79,9 @@
 
 #![cfg_attr(test, allow(deprecated))] // rand
 #![cfg_attr(test, feature(placement_in))]
-#![cfg_attr(not(test), feature(char_escape_debug))]
 #![cfg_attr(not(test), feature(core_float))]
 #![cfg_attr(not(test), feature(exact_size_is_empty))]
 #![cfg_attr(not(test), feature(slice_rotate))]
-#![cfg_attr(not(test), feature(str_checked_slicing))]
 #![cfg_attr(test, feature(rand, test))]
 #![cfg_attr(stage0, feature(allocator))]
 #![feature(allow_internal_unstable)]
@@ -103,7 +101,6 @@
 #![feature(i128_type)]
 #![feature(inclusive_range)]
 #![feature(lang_items)]
-#![feature(manually_drop)]
 #![feature(needs_allocator)]
 #![feature(nonzero)]
 #![feature(offset_to)]
@@ -118,7 +115,6 @@
 #![feature(specialization)]
 #![feature(staged_api)]
 #![feature(str_internals)]
-#![feature(str_mut_extras)]
 #![feature(trusted_len)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]

src/liballoc/allocator.rs

@@ -290,7 +290,7 @@ impl str {
     }
 
     /// Converts a mutable string slice to a mutable byte slice.
-    #[unstable(feature = "str_mut_extras", issue = "41119")]
+    #[stable(feature = "str_mut_extras", since = "1.20.0")]
     #[inline(always)]
     pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8] {
         core_str::StrExt::as_bytes_mut(self)
@@ -328,14 +328,13 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_checked_slicing)]
     /// let v = "🗻∈🌏";
     /// assert_eq!(Some("🗻"), v.get(0..4));
     /// assert!(v.get(1..).is_none());
     /// assert!(v.get(..8).is_none());
     /// assert!(v.get(..42).is_none());
     /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
+    #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     #[inline]
     pub fn get<I: SliceIndex<str>>(&self, i: I) -> Option<&I::Output> {
         core_str::StrExt::get(self, i)
@@ -351,14 +350,13 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_checked_slicing)]
     /// let mut v = String::from("🗻∈🌏");
     /// assert_eq!(Some("🗻"), v.get_mut(0..4).map(|v| &*v));
     /// assert!(v.get_mut(1..).is_none());
     /// assert!(v.get_mut(..8).is_none());
     /// assert!(v.get_mut(..42).is_none());
     /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
+    #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     #[inline]
     pub fn get_mut<I: SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output> {
         core_str::StrExt::get_mut(self, i)
@@ -383,15 +381,14 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_checked_slicing)]
     /// let v = "🗻∈🌏";
     /// unsafe {
     ///     assert_eq!("🗻", v.get_unchecked(0..4));
     ///     assert_eq!("∈", v.get_unchecked(4..7));
     ///     assert_eq!("🌏", v.get_unchecked(7..11));
     /// }
     /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
+    #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     #[inline]
     pub unsafe fn get_unchecked<I: SliceIndex<str>>(&self, i: I) -> &I::Output {
         core_str::StrExt::get_unchecked(self, i)
@@ -416,15 +413,14 @@ impl str {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(str_checked_slicing)]
     /// let mut v = String::from("🗻∈🌏");
     /// unsafe {
     ///     assert_eq!("🗻", v.get_unchecked_mut(0..4));
     ///     assert_eq!("∈", v.get_unchecked_mut(4..7));
     ///     assert_eq!("🌏", v.get_unchecked_mut(7..11));
     /// }
     /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
+    #[stable(feature = "str_checked_slicing", since = "1.20.0")]
     #[inline]
     pub unsafe fn get_unchecked_mut<I: SliceIndex<str>>(&mut self, i: I) -> &mut I::Output {
         core_str::StrExt::get_unchecked_mut(self, i)
@@ -1729,7 +1725,7 @@ impl str {
     }
 
     /// Converts a `Box<str>` into a `Box<[u8]>` without copying or allocating.
-    #[unstable(feature = "str_box_extras", issue = "41119")]
+    #[stable(feature = "str_box_extras", since = "1.20.0")]
     pub fn into_boxed_bytes(self: Box<str>) -> Box<[u8]> {
         self.into()
     }
@@ -1996,7 +1992,7 @@ impl str {
 
 /// Converts a boxed slice of bytes to a boxed string slice without checking
 /// that the string contains valid UTF-8.
-#[unstable(feature = "str_box_extras", issue = "41119")]
+#[stable(feature = "str_box_extras", since = "1.20.0")]
 pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str> {
     mem::transmute(v)
 }

src/liballoc/lib.rs

@@ -24,12 +24,10 @@
 #![feature(repr_align)]
 #![feature(slice_rotate)]
 #![feature(splice)]
-#![feature(str_checked_slicing)]
 #![feature(str_escape)]
 #![feature(test)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]
-#![feature(utf8_error_error_len)]
 
 extern crate alloc;
 extern crate test;

src/liballoc/str.rs

@@ -379,7 +379,7 @@ pub trait CharExt {
     fn escape_unicode(self) -> EscapeUnicode;
     #[stable(feature = "core", since = "1.6.0")]
     fn escape_default(self) -> EscapeDefault;
-    #[unstable(feature = "char_escape_debug", issue = "35068")]
+    #[stable(feature = "char_escape_debug", since = "1.20.0")]
     fn escape_debug(self) -> EscapeDebug;
     #[stable(feature = "core", since = "1.6.0")]
     fn len_utf8(self) -> usize;
@@ -776,24 +776,24 @@ impl fmt::Display for EscapeDefault {
 ///
 /// [`escape_debug`]: ../../std/primitive.char.html#method.escape_debug
 /// [`char`]: ../../std/primitive.char.html
-#[unstable(feature = "char_escape_debug", issue = "35068")]
+#[stable(feature = "char_escape_debug", since = "1.20.0")]
 #[derive(Clone, Debug)]
 pub struct EscapeDebug(EscapeDefault);
 
-#[unstable(feature = "char_escape_debug", issue = "35068")]
+#[stable(feature = "char_escape_debug", since = "1.20.0")]
 impl Iterator for EscapeDebug {
     type Item = char;
     fn next(&mut self) -> Option<char> { self.0.next() }
     fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
 }
 
-#[unstable(feature = "char_escape_debug", issue = "35068")]
+#[stable(feature = "char_escape_debug", since = "1.20.0")]
 impl ExactSizeIterator for EscapeDebug { }
 
 #[unstable(feature = "fused", issue = "35602")]
 impl FusedIterator for EscapeDebug {}
 
-#[unstable(feature = "char_escape_debug", issue = "35068")]
+#[stable(feature = "char_escape_debug", since = "1.20.0")]
 impl fmt::Display for EscapeDebug {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&self.0, f)

src/liballoc/tests/lib.rs

@@ -8,6 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[macro_export]
+// This stability attribute is totally useless.
+#[stable(feature = "rust1", since = "1.0.0")]
+#[cfg(stage0)]
+macro_rules! __rust_unstable_column {
+    () => {
+        column!()
+    }
+}
+
 /// Entry point of thread panic, for details, see std::macros
 #[macro_export]
 #[allow_internal_unstable]
@@ -18,7 +28,7 @@ macro_rules! panic {
     );
     ($msg:expr) => ({
         static _MSG_FILE_LINE_COL: (&'static str, &'static str, u32, u32) =
-            ($msg, file!(), line!(), column!());
+            ($msg, file!(), line!(), __rust_unstable_column!());
         $crate::panicking::panic(&_MSG_FILE_LINE_COL)
     });
     ($fmt:expr, $($arg:tt)*) => ({
@@ -27,7 +37,7 @@ macro_rules! panic {
         // insufficient, since the user may have
         // `#[forbid(dead_code)]` and which cannot be overridden.
         static _MSG_FILE_LINE_COL: (&'static str, u32, u32) =
-            (file!(), line!(), column!());
+            (file!(), line!(), __rust_unstable_column!());
         $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*), &_MSG_FILE_LINE_COL)
     });
 }
@@ -574,7 +584,7 @@ mod builtin {
     /// For more information, see the [RFC].
     ///
     /// [RFC]: https://github.com/rust-lang/rfcs/blob/master/text/1695-add-error-macro.md
-    #[unstable(feature = "compile_error_macro", issue = "40872")]
+    #[stable(feature = "compile_error_macro", since = "1.20.0")]
     #[macro_export]
     #[cfg(dox)]
     macro_rules! compile_error { ($msg:expr) => ({ /* compiler built-in */ }) }

src/libcore/char.rs

@@ -795,7 +795,6 @@ pub fn discriminant<T>(v: &T) -> Discriminant<T> {
 /// the type:
 ///
 /// ```rust
-/// # #![feature(manually_drop)]
 /// use std::mem::ManuallyDrop;
 /// struct Peach;
 /// struct Banana;
@@ -821,7 +820,7 @@ pub fn discriminant<T>(v: &T) -> Discriminant<T> {
 ///     }
 /// }
 /// ```
-#[unstable(feature = "manually_drop", issue = "40673")]
+#[stable(feature = "manually_drop", since = "1.20.0")]
 #[allow(unions_with_drop_fields)]
 pub union ManuallyDrop<T>{ value: T }
 
@@ -831,11 +830,10 @@ impl<T> ManuallyDrop<T> {
     /// # Examples
     ///
     /// ```rust
-    /// # #![feature(manually_drop)]
     /// use std::mem::ManuallyDrop;
     /// ManuallyDrop::new(Box::new(()));
     /// ```
-    #[unstable(feature = "manually_drop", issue = "40673")]
+    #[stable(feature = "manually_drop", since = "1.20.0")]
     #[inline]
     pub fn new(value: T) -> ManuallyDrop<T> {
         ManuallyDrop { value: value }
@@ -846,12 +844,11 @@ impl<T> ManuallyDrop<T> {
     /// # Examples
     ///
     /// ```rust
-    /// # #![feature(manually_drop)]
     /// use std::mem::ManuallyDrop;
     /// let x = ManuallyDrop::new(Box::new(()));
     /// let _: Box<()> = ManuallyDrop::into_inner(x);
     /// ```
-    #[unstable(feature = "manually_drop", issue = "40673")]
+    #[stable(feature = "manually_drop", since = "1.20.0")]
     #[inline]
     pub fn into_inner(slot: ManuallyDrop<T>) -> T {
         unsafe {
@@ -866,14 +863,14 @@ impl<T> ManuallyDrop<T> {
     /// This function runs the destructor of the contained value and thus the wrapped value
     /// now represents uninitialized data. It is up to the user of this method to ensure the
     /// uninitialized data is not actually used.
-    #[unstable(feature = "manually_drop", issue = "40673")]
+    #[stable(feature = "manually_drop", since = "1.20.0")]
     #[inline]
     pub unsafe fn drop(slot: &mut ManuallyDrop<T>) {
         ptr::drop_in_place(&mut slot.value)
     }
 }
 
-#[unstable(feature = "manually_drop", issue = "40673")]
+#[stable(feature = "manually_drop", since = "1.20.0")]
 impl<T> ::ops::Deref for ManuallyDrop<T> {
     type Target = T;
     #[inline]
@@ -884,7 +881,7 @@ impl<T> ::ops::Deref for ManuallyDrop<T> {
     }
 }
 
-#[unstable(feature = "manually_drop", issue = "40673")]
+#[stable(feature = "manually_drop", since = "1.20.0")]
 impl<T> ::ops::DerefMut for ManuallyDrop<T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
@@ -894,7 +891,7 @@ impl<T> ::ops::DerefMut for ManuallyDrop<T> {
     }
 }
 
-#[unstable(feature = "manually_drop", issue = "40673")]
+#[stable(feature = "manually_drop", since = "1.20.0")]
 impl<T: ::fmt::Debug> ::fmt::Debug for ManuallyDrop<T> {
     fn fmt(&self, fmt: &mut ::fmt::Formatter) -> ::fmt::Result {
         unsafe {