Auto merge of #60949 - Centril:rollup-f918e1v, r=Centril

Rollup of 8 pull requests

Successful merges:

 - #60370 (Mark core::alloc::Layout::from_size_align_unchecked const)
 - #60678 (Stabilize vecdeque_rotate)
 - #60924 (Explain that ? converts the error type using From)
 - #60931 (Use iter() for iterating arrays by slice)
 - #60934 (Declare DefIndex with the newtype_index macro)
 - #60943 (fix copy-paste typo in docs for ptr::read_volatile)
 - #60945 (Simplify BufRead::fill_buf doc example using NLL)
 - #60947 (Fix typos in docs of GlobalAlloc)

Failed merges:

r? @ghost

src/liballoc/collections/vec_deque.rs

@@ -1948,8 +1948,6 @@ impl<T> VecDeque<T> {
  /// # Examples
  ///
  /// ```
- /// #![feature(vecdeque_rotate)]
- ///
  /// use std::collections::VecDeque;
  ///
  /// let mut buf: VecDeque<_> = (0..10).collect();
@@ -1963,7 +1961,7 @@ impl<T> VecDeque<T> {
  /// }
  /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  /// ```
- #[unstable(feature = "vecdeque_rotate", issue = "56686")]
+ #[stable(feature = "vecdeque_rotate", since = "1.36.0")]
  pub fn rotate_left(&mut self, mid: usize) {
  assert!(mid <= self.len());
  let k = self.len() - mid;
@@ -1993,8 +1991,6 @@ impl<T> VecDeque<T> {
  /// # Examples
  ///
  /// ```
- /// #![feature(vecdeque_rotate)]
- ///
  /// use std::collections::VecDeque;
  ///
  /// let mut buf: VecDeque<_> = (0..10).collect();
@@ -2008,7 +2004,7 @@ impl<T> VecDeque<T> {
  /// }
  /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  /// ```
- #[unstable(feature = "vecdeque_rotate", issue = "56686")]
+ #[stable(feature = "vecdeque_rotate", since = "1.36.0")]
  pub fn rotate_right(&mut self, k: usize) {
  assert!(k <= self.len());
  let mid = self.len() - k;

src/liballoc/tests/btree/set.rs

@@ -143,8 +143,8 @@ fn test_union() {
 #[test]
 // Only tests the simple function definition with respect to intersection
 fn test_is_disjoint() {
- let one = [1].into_iter().collect::<BTreeSet<_>>();
- let two = [2].into_iter().collect::<BTreeSet<_>>();
+ let one = [1].iter().collect::<BTreeSet<_>>();
+ let two = [2].iter().collect::<BTreeSet<_>>();
  assert!(one.is_disjoint(&two));
 }
 

src/liballoc/tests/lib.rs

@@ -6,7 +6,6 @@
 #![feature(repeat_generic_slice)]
 #![feature(try_reserve)]
 #![feature(unboxed_closures)]
-#![feature(vecdeque_rotate)]
 #![deny(rust_2018_idioms)]
 
 use std::hash::{Hash, Hasher};

src/libcore/alloc.rs

@@ -99,7 +99,7 @@ impl Layout {
  /// [`Layout::from_size_align`](#method.from_size_align).
  #[stable(feature = "alloc_layout", since = "1.28.0")]
  #[inline]
- pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self {
+ pub const unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self {
  Layout { size_: size, align_: NonZeroUsize::new_unchecked(align) }
  }
 
@@ -480,7 +480,7 @@ pub unsafe trait GlobalAlloc {
  /// this allocator,
  ///
  /// * `layout` must be the same layout that was used
- /// to allocated that block of memory,
+ /// to allocate that block of memory,
  #[stable(feature = "global_alloc", since = "1.28.0")]
  unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);
 
@@ -535,7 +535,7 @@ pub unsafe trait GlobalAlloc {
  /// * `ptr` must be currently allocated via this allocator,
  ///
  /// * `layout` must be the same layout that was used
- /// to allocated that block of memory,
+ /// to allocate that block of memory,
  ///
  /// * `new_size` must be greater than zero.
  ///

src/libcore/iter/traits/iterator.rs

@@ -356,7 +356,7 @@ pub trait Iterator {
  ///
  /// ```
  /// let a = [0, 1, 2, 3, 4, 5];
- /// let mut iter = a.into_iter().step_by(2);
+ /// let mut iter = a.iter().step_by(2);
  ///
  /// assert_eq!(iter.next(), Some(&0));
  /// assert_eq!(iter.next(), Some(&2));
@@ -531,7 +531,7 @@ pub trait Iterator {
  /// ```
  /// let a = [1, 2, 3];
  ///
- /// let mut iter = a.into_iter().map(|x| 2 * x);
+ /// let mut iter = a.iter().map(|x| 2 * x);
  ///
  /// assert_eq!(iter.next(), Some(2));
  /// assert_eq!(iter.next(), Some(4));
@@ -620,7 +620,7 @@ pub trait Iterator {
  /// ```
  /// let a = [0i32, 1, 2];
  ///
- /// let mut iter = a.into_iter().filter(|x| x.is_positive());
+ /// let mut iter = a.iter().filter(|x| x.is_positive());
  ///
  /// assert_eq!(iter.next(), Some(&1));
  /// assert_eq!(iter.next(), Some(&2));
@@ -634,7 +634,7 @@ pub trait Iterator {
  /// ```
  /// let a = [0, 1, 2];
  ///
- /// let mut iter = a.into_iter().filter(|x| **x > 1); // need two *s!
+ /// let mut iter = a.iter().filter(|x| **x > 1); // need two *s!
  ///
  /// assert_eq!(iter.next(), Some(&2));
  /// assert_eq!(iter.next(), None);
@@ -646,7 +646,7 @@ pub trait Iterator {
  /// ```
  /// let a = [0, 1, 2];
  ///
- /// let mut iter = a.into_iter().filter(|&x| *x > 1); // both & and *
+ /// let mut iter = a.iter().filter(|&x| *x > 1); // both & and *
  ///
  /// assert_eq!(iter.next(), Some(&2));
  /// assert_eq!(iter.next(), None);
@@ -657,7 +657,7 @@ pub trait Iterator {
  /// ```
  /// let a = [0, 1, 2];
  ///
- /// let mut iter = a.into_iter().filter(|&&x| x > 1); // two &s
+ /// let mut iter = a.iter().filter(|&&x| x > 1); // two &s
  ///
  /// assert_eq!(iter.next(), Some(&2));
  /// assert_eq!(iter.next(), None);
@@ -837,7 +837,7 @@ pub trait Iterator {
  /// ```
  /// let a = [-1i32, 0, 1];
  ///
- /// let mut iter = a.into_iter().skip_while(|x| x.is_negative());
+ /// let mut iter = a.iter().skip_while(|x| x.is_negative());
  ///
  /// assert_eq!(iter.next(), Some(&0));
  /// assert_eq!(iter.next(), Some(&1));
@@ -851,7 +851,7 @@ pub trait Iterator {
  /// ```
  /// let a = [-1, 0, 1];
  ///
- /// let mut iter = a.into_iter().skip_while(|x| **x < 0); // need two *s!
+ /// let mut iter = a.iter().skip_while(|x| **x < 0); // need two *s!
  ///
  /// assert_eq!(iter.next(), Some(&0));
  /// assert_eq!(iter.next(), Some(&1));
@@ -863,7 +863,7 @@ pub trait Iterator {
  /// ```
  /// let a = [-1, 0, 1, -2];
  ///
- /// let mut iter = a.into_iter().skip_while(|x| **x < 0);
+ /// let mut iter = a.iter().skip_while(|x| **x < 0);
  ///
  /// assert_eq!(iter.next(), Some(&0));
  /// assert_eq!(iter.next(), Some(&1));
@@ -898,7 +898,7 @@ pub trait Iterator {
  /// ```
  /// let a = [-1i32, 0, 1];
  ///
- /// let mut iter = a.into_iter().take_while(|x| x.is_negative());
+ /// let mut iter = a.iter().take_while(|x| x.is_negative());
  ///
  /// assert_eq!(iter.next(), Some(&-1));
  /// assert_eq!(iter.next(), None);
@@ -911,7 +911,7 @@ pub trait Iterator {
  /// ```
  /// let a = [-1, 0, 1];
  ///
- /// let mut iter = a.into_iter().take_while(|x| **x < 0); // need two *s!
+ /// let mut iter = a.iter().take_while(|x| **x < 0); // need two *s!
  ///
  /// assert_eq!(iter.next(), Some(&-1));
  /// assert_eq!(iter.next(), None);
@@ -922,7 +922,7 @@ pub trait Iterator {
  /// ```
  /// let a = [-1, 0, 1, -2];
  ///
- /// let mut iter = a.into_iter().take_while(|x| **x < 0);
+ /// let mut iter = a.iter().take_while(|x| **x < 0);
  ///
  /// assert_eq!(iter.next(), Some(&-1));
  ///
@@ -937,7 +937,7 @@ pub trait Iterator {
  ///
  /// ```
  /// let a = [1, 2, 3, 4];
- /// let mut iter = a.into_iter();
+ /// let mut iter = a.iter();
  ///
  /// let result: Vec<i32> = iter.by_ref()
  /// .take_while(|n| **n != 3)
@@ -1321,7 +1321,7 @@ pub trait Iterator {
  /// ```
  /// let a = [1, 2, 3];
  ///
- /// let iter = a.into_iter();
+ /// let iter = a.iter();
  ///
  /// let sum: i32 = iter.take(5).fold(0, |acc, i| acc + i );
  ///
@@ -1334,7 +1334,7 @@ pub trait Iterator {
  /// // let's try that again
  /// let a = [1, 2, 3];
  ///
- /// let mut iter = a.into_iter();
+ /// let mut iter = a.iter();
  ///
  /// // instead, we add in a .by_ref()
  /// let sum: i32 = iter.by_ref().take(2).fold(0, |acc, i| acc + i );
@@ -1479,7 +1479,7 @@ pub trait Iterator {
  /// let a = [1, 2, 3];
  ///
  /// let (even, odd): (Vec<i32>, Vec<i32>) = a
- /// .into_iter()
+ /// .iter()
  /// .partition(|&n| n % 2 == 0);
  ///
  /// assert_eq!(even, vec![2]);

src/libcore/ptr.rs

@@ -837,7 +837,7 @@ pub unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
 ///
 /// * `src` must be properly aligned.
 ///
-/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of
+/// Like [`read`], `read_volatile` creates a bitwise copy of `T`, regardless of
 /// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
 /// value and the value at `*src` can [violate memory safety][read-ownership].
 /// However, storing non-[`Copy`] types in volatile memory is almost certainly

src/libcore/tests/alloc.rs

@@ -0,0 +1,10 @@
+use core::alloc::Layout;
+
+#[test]
+fn const_unchecked_layout() {
+ const SIZE: usize = 0x2000;
+ const ALIGN: usize = 0x1000;
+ const LAYOUT: Layout = unsafe { Layout::from_size_align_unchecked(SIZE, ALIGN) };
+ assert_eq!(LAYOUT.size(), SIZE);
+ assert_eq!(LAYOUT.align(), ALIGN);
+}

src/libcore/tests/lib.rs

@@ -31,10 +31,12 @@
 #![feature(slice_partition_dedup)]
 #![feature(copy_within)]
 #![feature(int_error_matching)]
+#![feature(const_fn)]
 #![warn(rust_2018_idioms)]
 
 extern crate test;
 
+mod alloc;
 mod any;
 mod array;
 mod ascii;

src/librustc/hir/def_id.rs

@@ -96,34 +96,20 @@ impl fmt::Display for CrateNum {
 impl serialize::UseSpecializedEncodable for CrateNum {}
 impl serialize::UseSpecializedDecodable for CrateNum {}
 
-/// A DefIndex is an index into the hir-map for a crate, identifying a
-/// particular definition. It should really be considered an interned
-/// shorthand for a particular DefPath.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
-pub struct DefIndex(u32);
-
-/// The crate root is always assigned index 0 by the AST Map code,
-/// thanks to `NodeCollector::new`.
-pub const CRATE_DEF_INDEX: DefIndex = DefIndex(0);
+newtype_index! {
+ /// A DefIndex is an index into the hir-map for a crate, identifying a
+ /// particular definition. It should really be considered an interned
+ /// shorthand for a particular DefPath.
+ pub struct DefIndex {
+ DEBUG_FORMAT = "DefIndex({})",
 
-impl fmt::Debug for DefIndex {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "DefIndex({})", self.as_array_index())
+ /// The crate root is always assigned index 0 by the AST Map code,
+  /// thanks to `NodeCollector::new`.
+ const CRATE_DEF_INDEX = 0,
  }
 }
 
 impl DefIndex {
- /// Converts this DefIndex into a zero-based array index.
- #[inline]
- pub fn as_array_index(&self) -> usize {
- self.0 as usize
- }
-
- #[inline]
- pub fn from_array_index(i: usize) -> DefIndex {
- DefIndex(i as u32)
- }
-
  // Proc macros from a proc-macro crate have a kind of virtual DefIndex. This
  // function maps the index of the macro within the crate (which is also the
  // index of the macro in the CrateMetadata::proc_macros array) to the
@@ -132,7 +118,7 @@ impl DefIndex {
  // DefIndex for proc macros start from FIRST_FREE_DEF_INDEX,
  // because the first FIRST_FREE_DEF_INDEX indexes are reserved
  // for internal use.
- let def_index = DefIndex::from_array_index(
+ let def_index = DefIndex::from(
  proc_macro_index.checked_add(FIRST_FREE_DEF_INDEX)
  .expect("integer overflow adding `proc_macro_index`"));
  assert!(def_index != CRATE_DEF_INDEX);
@@ -141,19 +127,11 @@ impl DefIndex {
 
  // This function is the reverse of from_proc_macro_index() above.
  pub fn to_proc_macro_index(self: DefIndex) -> usize {
- self.as_array_index().checked_sub(FIRST_FREE_DEF_INDEX)
+ self.index().checked_sub(FIRST_FREE_DEF_INDEX)
  .unwrap_or_else(|| {
  bug!("using local index {:?} as proc-macro index", self)
  })
  }
-
- pub fn from_raw_u32(x: u32) -> DefIndex {
- DefIndex(x)
- }
-
- pub fn as_raw_u32(&self) -> u32 {
- self.0
- }
 }
 
 impl serialize::UseSpecializedEncodable for DefIndex {}
@@ -169,7 +147,7 @@ pub struct DefId {
 
 impl fmt::Debug for DefId {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "DefId({}:{}", self.krate, self.index.as_array_index())?;
+ write!(f, "DefId({}:{}", self.krate, self.index.index())?;
 
  ty::tls::with_opt(|opt_tcx| {
  if let Some(tcx) = opt_tcx {

src/librustc/hir/map/collector.rs

@@ -226,7 +226,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
  fn insert_entry(&mut self, id: HirId, entry: Entry<'hir>) {
  debug!("hir_map: {:?} => {:?}", id, entry);
- let local_map = &mut self.map[id.owner.as_array_index()];
+ let local_map = &mut self.map[id.owner.index()];
  let i = id.local_id.as_u32() as usize;
  if local_map.is_none() {
  *local_map = Some(IndexVec::with_capacity(i + 1));