Auto merge of rust-lang#126793 - saethlin:mono-rawvec, r=<try>

Apply "polymorphization at home" to RawVec

The idea here is to move all the logic in RawVec into functions with explicit size and alignment parameters. This should eliminate all the fussing about how tweaking RawVec code produces large swings in compile times.

This uncovered rust-lang/rust-clippy#12979, so I've modified the relevant test in a way that tries to preserve the spirit of the test without tripping the ICE.

Author: bors

library/alloc/src/boxed.rs

@@ -727,7 +727,7 @@ impl<T> Box<[T]> {
     #[inline]
     pub fn try_new_uninit_slice(len: usize) -> Result<Box<[mem::MaybeUninit<T>]>, AllocError> {
         let ptr = if T::IS_ZST || len == 0 {
-            NonNull::dangling()
+            NonNull::<T>::dangling()
         } else {
             let layout = match Layout::array::<mem::MaybeUninit<T>>(len) {
                 Ok(l) => l,
@@ -761,7 +761,7 @@ impl<T> Box<[T]> {
     #[inline]
     pub fn try_new_zeroed_slice(len: usize) -> Result<Box<[mem::MaybeUninit<T>]>, AllocError> {
         let ptr = if T::IS_ZST || len == 0 {
-            NonNull::dangling()
+            NonNull::<T>::dangling()
         } else {
             let layout = match Layout::array::<mem::MaybeUninit<T>>(len) {
                 Ok(l) => l,

library/alloc/src/collections/vec_deque/mod.rs

@@ -11,6 +11,7 @@ use core::cmp::{self, Ordering};
 use core::fmt;
 use core::hash::{Hash, Hasher};
 use core::iter::{repeat_n, repeat_with, ByRefSized};
+use core::marker::PhantomData;
 use core::mem::{ManuallyDrop, SizedTypeProperties};
 use core::ops::{Index, IndexMut, Range, RangeBounds};
 use core::ptr;
@@ -103,6 +104,7 @@ pub struct VecDeque<
     // if `T` is zero-Sized, then `self.len <= usize::MAX`, otherwise `self.len <= isize::MAX as usize`.
     len: usize,
     buf: RawVec<T, A>,
+    _marker: PhantomData<T>,
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -139,6 +141,7 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque<T, A> {
         }
 
         let (front, back) = self.as_mut_slices();
+
         unsafe {
             let _back_dropper = Dropper(back);
             // use drop for [T]
@@ -559,7 +562,7 @@ impl<T> VecDeque<T> {
     #[must_use]
     pub const fn new() -> VecDeque<T> {
         // FIXME: This should just be `VecDeque::new_in(Global)` once that hits stable.
-        VecDeque { head: 0, len: 0, buf: RawVec::NEW }
+        VecDeque { head: 0, len: 0, buf: RawVec::new(), _marker: PhantomData }
     }
 
     /// Creates an empty deque with space for at least `capacity` elements.
@@ -599,7 +602,12 @@ impl<T> VecDeque<T> {
     #[inline]
     #[unstable(feature = "try_with_capacity", issue = "91913")]
     pub fn try_with_capacity(capacity: usize) -> Result<VecDeque<T>, TryReserveError> {
-        Ok(VecDeque { head: 0, len: 0, buf: RawVec::try_with_capacity_in(capacity, Global)? })
+        Ok(VecDeque {
+            head: 0,
+            len: 0,
+            buf: RawVec::try_with_capacity_in(capacity, Global)?,
+            _marker: PhantomData,
+        })
     }
 }
 
@@ -616,7 +624,12 @@ impl<T, A: Allocator> VecDeque<T, A> {
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
     pub const fn new_in(alloc: A) -> VecDeque<T, A> {
-        VecDeque { head: 0, len: 0, buf: RawVec::new_in(alloc) }
+        VecDeque {
+            head: 0,
+            len: 0,
+            buf: RawVec::new_in(alloc, core::mem::align_of::<T>()),
+            _marker: PhantomData,
+        }
     }
 
     /// Creates an empty deque with space for at least `capacity` elements.
@@ -630,7 +643,12 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
     pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A> {
-        VecDeque { head: 0, len: 0, buf: RawVec::with_capacity_in(capacity, alloc) }
+        VecDeque {
+            head: 0,
+            len: 0,
+            buf: RawVec::with_capacity_in(capacity, alloc),
+            _marker: PhantomData,
+        }
     }
 
     /// Creates a `VecDeque` from a raw allocation, when the initialized
@@ -661,6 +679,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
                 head: initialized.start,
                 len: initialized.end.unchecked_sub(initialized.start),
                 buf: RawVec::from_raw_parts_in(ptr, capacity, alloc),
+                _marker: PhantomData,
             }
         }
     }
@@ -767,7 +786,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn capacity(&self) -> usize {
-        if T::IS_ZST { usize::MAX } else { self.buf.capacity() }
+        self.buf.capacity()
     }
 
     /// Reserves the minimum capacity for at least `additional` more elements to be inserted in the
@@ -2980,7 +2999,12 @@ impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A> {
     #[inline]
     fn from(other: Vec<T, A>) -> Self {
         let (ptr, len, cap, alloc) = other.into_raw_parts_with_alloc();
-        Self { head: 0, len, buf: unsafe { RawVec::from_raw_parts_in(ptr, cap, alloc) } }
+        Self {
+            head: 0,
+            len,
+            buf: unsafe { RawVec::from_raw_parts_in(ptr, cap, alloc) },
+            _marker: PhantomData,
+        }
     }
 }
 
@@ -3020,7 +3044,7 @@ impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A> {
 
         unsafe {
             let other = ManuallyDrop::new(other);
-            let buf = other.buf.ptr();
+            let buf: *mut T = other.buf.ptr();
             let len = other.len();
             let cap = other.capacity();
             let alloc = ptr::read(other.allocator());