Specialize Vec::extend_with for T: TrivialClone

After running perf on the previous commit, it was found that the
compile-time regression was too significant to ignore.
This introduces a specialized, simplified implementation for
`T: TrivialClone` that will reduce the perf regression.

Author: paolobarbolini

library/alloc/src/vec/mod.rs

@@ -172,6 +172,12 @@ use self::spec_extend::SpecExtend;
 #[cfg(not(no_global_oom_handling))]
 mod spec_extend;
 
+#[cfg(not(no_global_oom_handling))]
+use self::spec_extend_with::SpecExtendWith;
+
+#[cfg(not(no_global_oom_handling))]
+mod spec_extend_with;
+
 /// A contiguous growable array type, written as `Vec<T>`, short for 'vector'.
 ///
 /// # Examples
@@ -3448,7 +3454,7 @@ impl<T: Clone, A: Allocator> Vec<T, A> {
     #[cfg(not(no_global_oom_handling))]
     /// Extend the vector by `n` clones of value.
     fn extend_with(&mut self, n: usize, value: T) {
-        self.extend_trusted(iter::repeat_n(value, n));
+        <Self as SpecExtendWith<T>>::spec_extend_with(self, n, value);
     }
 }
 

library/alloc/src/vec/spec_extend_with.rs

@@ -0,0 +1,37 @@
+use core::clone::TrivialClone;
+use core::mem::MaybeUninit;
+use core::{iter, ptr};
+
+use super::Vec;
+use crate::alloc::Allocator;
+
+// Specialization trait used for Vec::extend_with
+pub(super) trait SpecExtendWith<T> {
+    fn spec_extend_with(&mut self, n: usize, value: T);
+}
+
+impl<T: Clone, A: Allocator> SpecExtendWith<T> for Vec<T, A> {
+    default fn spec_extend_with(&mut self, n: usize, value: T) {
+        self.extend_trusted(iter::repeat_n(value, n));
+    }
+}
+
+impl<T: TrivialClone, A: Allocator> SpecExtendWith<T> for Vec<T, A> {
+    fn spec_extend_with(&mut self, n: usize, value: T) {
+        let len = self.len();
+        self.reserve(n);
+        let unfilled = self.spare_capacity_mut();
+
+        // SAFETY: the above `reserve` call guarantees `n` to be in bounds.
+        let unfilled = unsafe { unfilled.get_unchecked_mut(..n) };
+
+        // SAFETY: because `T` is `TrivialClone`, this is equivalent to calling
+        // `T::clone` for every element. Notably, `TrivialClone` also implies
+        // that the `clone` implementation will not panic, so we can avoid
+        // initialization guards and such.
+        unfilled.fill_with(|| MaybeUninit::new(unsafe { ptr::read(&value) }));
+
+        // SAFETY: the elements have been initialized above.
+        unsafe { self.set_len(len + n) }
+    }
+}