Revert "Auto merge of #83770 - the8472:tra-extend, r=Mark-Simulacrum"

Due to a performance regression that didn't show up in the original perf run
this reverts commit 9111b8ae9793f18179a1336417618fc07a9cac85, reversing
changes made to 9a700d2947f2d7f97a2c0dfca3117a8dcc255bdd.

diff --git a/library/alloc/src/vec/spec_extend.rs b/library/alloc/src/vec/spec_extend.rs
index 5303fdb0c956152d0a78706b02548792a82f47b9..c6f4f22a01f6e2170cb382a9ebfb633951c8ad39 100644 (file)
--- a/library/alloc/src/vec/spec_extend.rs
+++ b/library/alloc/src/vec/spec_extend.rs
@@ -1,5 +1,5 @@
 use crate::alloc::Allocator;
-use core::iter::{TrustedLen, TrustedRandomAccess};
+use core::iter::TrustedLen;
 use core::ptr::{self};
 use core::slice::{self};
 
@@ -11,49 +11,6 @@ pub(super) trait SpecExtend<T, I> {
 }
 
 impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
-where
-    I: Iterator<Item = T>,
-{
-    default fn spec_extend(&mut self, iter: I) {
-        SpecExtendInner::spec_extend(self, iter);
-    }
-}
-
-impl<T, A: Allocator> SpecExtend<T, IntoIter<T>> for Vec<T, A> {
-    fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
-        unsafe {
-            self.append_elements(iterator.as_slice() as _);
-        }
-        iterator.ptr = iterator.end;
-    }
-}
-
-impl<'a, T: 'a, I, A: Allocator + 'a> SpecExtend<&'a T, I> for Vec<T, A>
-where
-    I: Iterator<Item = &'a T>,
-    T: Clone,
-{
-    default fn spec_extend(&mut self, iterator: I) {
-        SpecExtend::spec_extend(self, iterator.cloned())
-    }
-}
-
-impl<'a, T: 'a, A: Allocator + 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T, A>
-where
-    T: Copy,
-{
-    fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
-        let slice = iterator.as_slice();
-        unsafe { self.append_elements(slice) };
-    }
-}
-
-// Helper trait to disambiguate overlapping specializations
-trait SpecExtendInner<T, I> {
-    fn spec_extend(&mut self, iter: I);
-}
-
-impl<T, I, A: Allocator> SpecExtendInner<T, I> for Vec<T, A>
 where
     I: Iterator<Item = T>,
 {
@@ -62,7 +19,7 @@ impl<T, I, A: Allocator> SpecExtendInner<T, I> for Vec<T, A>
     }
 }
 
-impl<T, I, A: Allocator> SpecExtendInner<T, I> for Vec<T, A>
+impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
 where
     I: TrustedLen<Item = T>,
 {
@@ -98,22 +55,31 @@ impl<T, I, A: Allocator> SpecExtendInner<T, I> for Vec<T, A>
     }
 }
 
-impl<T, I, A: Allocator> SpecExtendInner<T, I> for Vec<T, A>
+impl<T, A: Allocator> SpecExtend<T, IntoIter<T>> for Vec<T, A> {
+    fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
+        unsafe {
+            self.append_elements(iterator.as_slice() as _);
+        }
+        iterator.ptr = iterator.end;
+    }
+}
+
+impl<'a, T: 'a, I, A: Allocator + 'a> SpecExtend<&'a T, I> for Vec<T, A>
 where
-    I: TrustedLen<Item = T> + TrustedRandomAccess,
+    I: Iterator<Item = &'a T>,
+    T: Clone,
 {
-    default fn spec_extend(&mut self, mut iterator: I) {
-        let size = iterator.size();
-        self.reserve(size);
+    default fn spec_extend(&mut self, iterator: I) {
+        self.spec_extend(iterator.cloned())
+    }
+}
 
-        // SAFETY: reserve ensured that there is sufficient capacity for the additional items.
-        // The loop upholds the TRA requirements by accessing each element only once.
-        unsafe {
-            let sink = self.as_mut_ptr().add(self.len());
-            for i in 0..size {
-                ptr::write(sink.add(i), iterator.__iterator_get_unchecked(i));
-                self.set_len(self.len() + 1);
-            }
-        }
+impl<'a, T: 'a, A: Allocator + 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T, A>
+where
+    T: Copy,
+{
+    fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
+        let slice = iterator.as_slice();
+        unsafe { self.append_elements(slice) };
     }
 }

diff --git a/library/core/src/iter/adapters/zip.rs b/library/core/src/iter/adapters/zip.rs
index 4f6ef24be1ba48a6c543f3fee45b3e8827c922d8..2f8f504d8fcaa1c3b630efad35eac7e43266ee5b 100644 (file)
--- a/library/core/src/iter/adapters/zip.rs
+++ b/library/core/src/iter/adapters/zip.rs
@@ -416,10 +416,6 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 
 /// An iterator whose items are random-accessible efficiently
 ///
-/// Iterators that implement this trait should also implement TrustedLen which
-/// allows specialization to disambiguate overlaps with a `TrustedLen + TrustedRandomAccess`
-/// bound.
-///
 /// # Safety
 ///
 /// The iterator's `size_hint` must be exact and cheap to call.