Auto merge of #133662 - paolobarbolini:vec-extend-with-via-repeatn, r=<try>

Use `iter::repeat_n` to implement `Vec::extend_with`

Author: rust-bors[bot]

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
@@ -3498,34 +3504,11 @@ impl<T, A: Allocator, const N: usize> Vec<[T; N], A> {
 }
 
 impl<T: Clone, A: Allocator> Vec<T, A> {
-    #[cfg(not(no_global_oom_handling))]
     /// Extend the vector by `n` clones of value.
+    #[cfg(not(no_global_oom_handling))]
+    #[inline]
     fn extend_with(&mut self, n: usize, value: T) {
-        self.reserve(n);
-
-        unsafe {
-            let mut ptr = self.as_mut_ptr().add(self.len());
-            // Use SetLenOnDrop to work around bug where compiler
-            // might not realize the store through `ptr` through self.set_len()
-            // don't alias.
-            let mut local_len = SetLenOnDrop::new(&mut self.len);
-
-            // Write all elements except the last one
-            for _ in 1..n {
-                ptr::write(ptr, value.clone());
-                ptr = ptr.add(1);
-                // Increment the length in every step in case clone() panics
-                local_len.increment_len(1);
-            }
-
-            if n > 0 {
-                // We can write the last element directly without cloning needlessly
-                ptr::write(ptr, value);
-                local_len.increment_len(1);
-            }
-
-            // len set by scope guard
-        }
+        <Self as SpecExtendWith<T>>::spec_extend_with(self, n, value);
     }
 }
 

library/alloc/src/vec/spec_extend_with.rs

@@ -0,0 +1,35 @@
+use core::clone::TrivialClone;
+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> {
+    #[inline]
+    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().as_mut_ptr().cast_init();
+
+        for i in 0..n {
+            // SAFETY: `unfilled` is at least as long as `n` thanks
+            // to the `reserve` call. Because `T` is `TrivialClone`,
+            // this is equivalent to calling `T::clone` for every element.
+            unsafe { ptr::write(unfilled.add(i), ptr::read(&value)) };
+        }
+
+        // SAFETY: the elements have been initialized above.
+        unsafe { self.set_len(len + n) }
+    }
+}