Use TrustedRandomAccess for for _ in loops

Author: the8472

library/core/src/iter/loop_desugar.rs

@@ -0,0 +1,76 @@
+use crate::iter::IntoIterator as RealIntoIterator;
+use crate::iter::TrustedRandomAccessNoCoerce;
+
+#[unstable(feature = "trusted_random_access", issue = "none")]
+#[doc(hidden)]
+
+pub trait IntoIterator {
+    type IntoIter: Iterator;
+
+    #[unstable(feature = "trusted_random_access", issue = "none")]
+    // #[cfg_attr(not(bootstrap), lang = "loop_desugar")]
+    #[cfg_attr(not(bootstrap), lang = "into_iter")]
+    fn into_iter(self) -> Self::IntoIter;
+}
+
+impl<C: RealIntoIterator> IntoIterator for C {
+    type IntoIter = ForLoopDesugar<C::IntoIter>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        ForLoopDesugar { iter: <Self as RealIntoIterator>::into_iter(self), idx: 0 }
+    }
+}
+
+#[derive(Debug)]
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+pub struct ForLoopDesugar<I> {
+    iter: I,
+    idx: usize,
+}
+
+#[unstable(feature = "trusted_random_access", issue = "none")]
+impl<I: Iterator> Iterator for ForLoopDesugar<I> {
+    type Item = I::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<I::Item> {
+        // self.iter.next_spec(&mut self.idx)
+        self.next_spec()
+    }
+}
+
+trait DesugarSpec<T> {
+    fn next_spec(&mut self) -> Option<T>;
+}
+
+impl<I, T> DesugarSpec<T> for ForLoopDesugar<I>
+where
+    I: Iterator<Item = T>,
+{
+    #[inline]
+    default fn next_spec(&mut self) -> Option<I::Item> {
+        self.iter.next()
+    }
+}
+
+impl<I, T> DesugarSpec<T> for ForLoopDesugar<I>
+where
+    I: TrustedRandomAccessNoCoerce + Iterator<Item = T>,
+{
+    #[inline]
+    fn next_spec(&mut self) -> Option<I::Item> {
+        let idx = self.idx;
+        if idx < self.iter.size() {
+            // SAFETY: idx can't overflow since size is a usize. idx is always
+            // less than size, so the index is always valid.
+            unsafe {
+                self.idx = idx.unchecked_add(1);
+                Some(self.iter.__iterator_get_unchecked(idx))
+            }
+        } else {
+            None
+        }
+    }
+}

library/core/src/iter/mod.rs

@@ -419,6 +419,7 @@ pub use self::adapters::{Intersperse, IntersperseWith};
 pub(crate) use self::adapters::{try_process, ByRefSized};
 
 mod adapters;
+mod loop_desugar;
 mod range;
 mod sources;
 mod traits;

library/core/src/iter/traits/collect.rs

@@ -262,7 +262,7 @@ pub trait IntoIterator {
     /// assert_eq!(Some(3), iter.next());
     /// assert_eq!(None, iter.next());
     /// ```
-    #[lang = "into_iter"]
+    #[cfg_attr(bootstrap, lang = "into_iter")]
     #[stable(feature = "rust1", since = "1.0.0")]
     fn into_iter(self) -> Self::IntoIter;
 }

library/core/tests/iter/adapters/cloned.rs

@@ -31,7 +31,7 @@ fn test_cloned_side_effects() {
             .zip(&[1]);
         for _ in iter {}
     }
-    assert_eq!(count, 2);
+    assert_eq!(count, 1);
 }
 
 #[test]

library/core/tests/iter/adapters/zip.rs

@@ -119,7 +119,7 @@ fn test_zip_cloned_sideffectful() {
 
     for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
 
-    assert_eq!(&xs, &[1, 1, 1, 0][..]);
+    assert_eq!(&xs, &[1, 1, 0, 0][..]);
     assert_eq!(&ys, &[1, 1][..]);
 
     let xs = [CountClone::new(), CountClone::new()];
@@ -138,7 +138,7 @@ fn test_zip_map_sideffectful() {
 
     for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
 
-    assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
+    assert_eq!(&xs, &[1, 1, 1, 1, 0, 0]);
     assert_eq!(&ys, &[1, 1, 1, 1]);
 
     let mut xs = [0; 4];