move TrustedRandomAccess into its own module

Author: the8472

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

@@ -1,4 +1,5 @@
-use crate::iter::adapters::{zip::try_get_unchecked, TrustedRandomAccess};
+use crate::iter::traits::trusted_random_access::try_get_unchecked;
+use crate::iter::traits::TrustedRandomAccess;
 use crate::iter::{FusedIterator, TrustedLen};
 use crate::ops::Try;
 

library/core/src/iter/adapters/copied.rs

@@ -1,4 +1,5 @@
-use crate::iter::adapters::{zip::try_get_unchecked, TrustedRandomAccess};
+use crate::iter::traits::trusted_random_access::try_get_unchecked;
+use crate::iter::traits::TrustedRandomAccess;
 use crate::iter::{FusedIterator, TrustedLen};
 use crate::ops::Try;
 

library/core/src/iter/adapters/enumerate.rs

@@ -1,4 +1,6 @@
-use crate::iter::adapters::{zip::try_get_unchecked, SourceIter, TrustedRandomAccess};
+use crate::iter::adapters::SourceIter;
+use crate::iter::traits::trusted_random_access::try_get_unchecked;
+use crate::iter::traits::TrustedRandomAccess;
 use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen};
 use crate::ops::Try;
 

library/core/src/iter/adapters/fuse.rs

@@ -1,5 +1,5 @@
 use crate::intrinsics;
-use crate::iter::adapters::zip::try_get_unchecked;
+use crate::iter::traits::trusted_random_access::try_get_unchecked;
 use crate::iter::{
     DoubleEndedIterator, ExactSizeIterator, FusedIterator, TrustedLen, TrustedRandomAccess,
 };

library/core/src/iter/adapters/map.rs

@@ -1,5 +1,7 @@
 use crate::fmt;
-use crate::iter::adapters::{zip::try_get_unchecked, SourceIter, TrustedRandomAccess};
+use crate::iter::adapters::SourceIter;
+use crate::iter::traits::trusted_random_access::try_get_unchecked;
+use crate::iter::traits::TrustedRandomAccess;
 use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen};
 use crate::ops::Try;
 

library/core/src/iter/adapters/mod.rs

@@ -52,9 +52,6 @@ pub use self::intersperse::{Intersperse, IntersperseWith};
 #[stable(feature = "iter_map_while", since = "1.57.0")]
 pub use self::map_while::MapWhile;
 
-#[unstable(feature = "trusted_random_access", issue = "none")]
-pub use self::zip::TrustedRandomAccess;
-
 #[stable(feature = "iter_zip", since = "1.59.0")]
 pub use self::zip::zip;
 

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

@@ -1,7 +1,8 @@
 use crate::cmp;
 use crate::fmt::{self, Debug};
+use crate::iter::traits::trusted_random_access::try_get_unchecked;
 use crate::iter::{DoubleEndedIterator, ExactSizeIterator, FusedIterator, Iterator};
-use crate::iter::{InPlaceIterable, SourceIter, TrustedLen};
+use crate::iter::{InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess};
 use crate::ops::Try;
 
 /// An iterator that iterates two other iterators simultaneously.
@@ -326,103 +327,3 @@ impl<A: Debug + TrustedRandomAccess, B: Debug + TrustedRandomAccess> ZipFmt<A, B
         f.debug_struct("Zip").finish()
     }
 }
-
-/// An iterator whose items are random-accessible efficiently
-///
-/// # Safety
-///
-/// The iterator's `size_hint` must be exact and cheap to call.
-///
-/// `TrustedRandomAccess::size` may not be overridden.
-///
-/// All subtypes and all supertypes of `Self` must also implement `TrustedRandomAccess`.
-/// In particular, this means that types with non-invariant parameters usually can not have
-/// an impl for `TrustedRandomAccess` that depends on any trait bounds on such parameters, except
-/// for bounds that come from the respective struct/enum definition itself, or bounds involving
-/// traits that themselves come with a guarantee similar to this one.
-///
-/// If `Self: ExactSizeIterator` then `self.len()` must always produce results consistent
-/// with `self.size()`.
-///
-/// If `Self: Iterator`, then `<Self as Iterator>::__iterator_get_unchecked(&mut self, idx)`
-/// must be safe to call provided the following conditions are met.
-///
-/// 1. `0 <= idx` and `idx < self.size()`.
-/// 2. If `Self: !Clone`, then `self.__iterator_get_unchecked(idx)` is never called with the same
-///    index on `self` more than once.
-/// 3. After `self.__iterator_get_unchecked(idx)` has been called, then `self.next_back()` will
-///    only be called at most `self.size() - idx - 1` times. If `Self: Clone` and `self` is cloned,
-///    then this number is calculated for `self` and its clone individually,
-///    but `self.next_back()` calls that happened before the cloning count for both `self` and the clone.
-/// 4. After `self.__iterator_get_unchecked(idx)` has been called, then only the following methods
-///    will be called on `self` or on any new clones of `self`:
-///     * `std::clone::Clone::clone`
-///     * `std::iter::Iterator::size_hint`
-///     * `std::iter::DoubleEndedIterator::next_back`
-///     * `std::iter::ExactSizeIterator::len`
-///     * `std::iter::Iterator::__iterator_get_unchecked`
-///     * `std::iter::TrustedRandomAccess::size`
-///
-/// Further, given that these conditions are met, it must guarantee that:
-///
-/// * It does not change the value returned from `size_hint`
-/// * It must be safe to call the methods listed above on `self` after calling
-///   `self.__iterator_get_unchecked(idx)`, assuming that the required traits are implemented.
-/// * It must also be safe to drop `self` after calling `self.__iterator_get_unchecked(idx)`.
-//
-// FIXME: Clarify interaction with SourceIter/InPlaceIterable. Calling `SourceIter::as_inner`
-// after `__iterator_get_unchecked` is supposed to be allowed.
-#[doc(hidden)]
-#[unstable(feature = "trusted_random_access", issue = "none")]
-#[rustc_specialization_trait]
-pub unsafe trait TrustedRandomAccess: Sized {
-    // Convenience method.
-    fn size(&self) -> usize
-    where
-        Self: Iterator,
-    {
-        self.size_hint().0
-    }
-
-    const NEEDS_CLEANUP: bool;
-
-    fn cleanup(&mut self, num: usize, forward: bool);
-}
-
-/// Like `Iterator::__iterator_get_unchecked`, but doesn't require the compiler to
-/// know that `U: TrustedRandomAccess`.
-///
-/// ## Safety
-///
-/// Same requirements calling `get_unchecked` directly.
-#[doc(hidden)]
-#[inline]
-pub(in crate::iter::adapters) unsafe fn try_get_unchecked<I>(it: &mut I, idx: usize) -> I::Item
-where
-    I: Iterator,
-{
-    // SAFETY: the caller must uphold the contract for
-    // `Iterator::__iterator_get_unchecked`.
-    unsafe { it.try_get_unchecked(idx) }
-}
-
-unsafe trait SpecTrustedRandomAccess: Iterator {
-    /// If `Self: TrustedRandomAccess`, it must be safe to call
-    /// `Iterator::__iterator_get_unchecked(self, index)`.
-    unsafe fn try_get_unchecked(&mut self, index: usize) -> Self::Item;
-}
-
-unsafe impl<I: Iterator> SpecTrustedRandomAccess for I {
-    default unsafe fn try_get_unchecked(&mut self, _: usize) -> Self::Item {
-        panic!("Should only be called on TrustedRandomAccess iterators");
-    }
-}
-
-unsafe impl<I: Iterator + TrustedRandomAccess> SpecTrustedRandomAccess for I {
-    #[inline]
-    unsafe fn try_get_unchecked(&mut self, index: usize) -> Self::Item {
-        // SAFETY: the caller must uphold the contract for
-        // `Iterator::__iterator_get_unchecked`.
-        unsafe { self.__iterator_get_unchecked(index) }
-    }
-}

library/core/src/iter/mod.rs

@@ -383,6 +383,8 @@ pub use self::traits::FusedIterator;
 pub use self::traits::InPlaceIterable;
 #[unstable(feature = "trusted_len", issue = "37572")]
 pub use self::traits::TrustedLen;
+#[unstable(feature = "trusted_random_access", issue = "none")]
+pub use self::traits::TrustedRandomAccess;
 #[unstable(feature = "trusted_step", issue = "85731")]
 pub use self::traits::TrustedStep;
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -404,8 +406,6 @@ pub use self::adapters::MapWhile;
 pub use self::adapters::SourceIter;
 #[stable(feature = "iterator_step_by", since = "1.28.0")]
 pub use self::adapters::StepBy;
-#[unstable(feature = "trusted_random_access", issue = "none")]
-pub use self::adapters::TrustedRandomAccess;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::adapters::{
     Chain, Cycle, Enumerate, Filter, FilterMap, FlatMap, Fuse, Inspect, Map, Peekable, Rev, Scan,

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

@@ -4,6 +4,7 @@ mod double_ended;
 mod exact_size;
 mod iterator;
 mod marker;
+pub(crate) mod trusted_random_access;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::{
@@ -19,3 +20,5 @@ pub use self::{
 pub use self::marker::InPlaceIterable;
 #[unstable(feature = "trusted_step", issue = "85731")]
 pub use self::marker::TrustedStep;
+#[unstable(feature = "trusted_random_access", issue = "none")]
+pub use self::trusted_random_access::TrustedRandomAccess;

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

@@ -0,0 +1,99 @@
+/// An iterator whose items are random-accessible efficiently
+///
+/// # Safety
+///
+/// The iterator's `size_hint` must be exact and cheap to call.
+///
+/// `TrustedRandomAccess::size` may not be overridden.
+///
+/// All subtypes and all supertypes of `Self` must also implement `TrustedRandomAccess`.
+/// In particular, this means that types with non-invariant parameters usually can not have
+/// an impl for `TrustedRandomAccess` that depends on any trait bounds on such parameters, except
+/// for bounds that come from the respective struct/enum definition itself, or bounds involving
+/// traits that themselves come with a guarantee similar to this one.
+///
+/// If `Self: ExactSizeIterator` then `self.len()` must always produce results consistent
+/// with `self.size()`.
+///
+/// If `Self: Iterator`, then `<Self as Iterator>::__iterator_get_unchecked(&mut self, idx)`
+/// must be safe to call provided the following conditions are met.
+///
+/// 1. `0 <= idx` and `idx < self.size()`.
+/// 2. If `Self: !Clone`, then `self.__iterator_get_unchecked(idx)` is never called with the same
+///    index on `self` more than once.
+/// 3. After `self.__iterator_get_unchecked(idx)` has been called, then `self.next_back()` will
+///    only be called at most `self.size() - idx - 1` times. If `Self: Clone` and `self` is cloned,
+///    then this number is calculated for `self` and its clone individually,
+///    but `self.next_back()` calls that happened before the cloning count for both `self` and the clone.
+/// 4. After `self.__iterator_get_unchecked(idx)` has been called, then only the following methods
+///    will be called on `self` or on any new clones of `self`:
+///     * `std::clone::Clone::clone`
+///     * `std::iter::Iterator::size_hint`
+///     * `std::iter::DoubleEndedIterator::next_back`
+///     * `std::iter::ExactSizeIterator::len`
+///     * `std::iter::Iterator::__iterator_get_unchecked`
+///     * `std::iter::TrustedRandomAccess::size`
+///
+/// Further, given that these conditions are met, it must guarantee that:
+///
+/// * It does not change the value returned from `size_hint`
+/// * It must be safe to call the methods listed above on `self` after calling
+///   `self.__iterator_get_unchecked(idx)`, assuming that the required traits are implemented.
+/// * It must also be safe to drop `self` after calling `self.__iterator_get_unchecked(idx)`.
+//
+// FIXME: Clarify interaction with SourceIter/InPlaceIterable. Calling `SourceIter::as_inner`
+// after `__iterator_get_unchecked` is supposed to be allowed.
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+#[rustc_specialization_trait]
+pub unsafe trait TrustedRandomAccess: Sized {
+    // Convenience method.
+    fn size(&self) -> usize
+    where
+        Self: Iterator,
+    {
+        self.size_hint().0
+    }
+
+    const NEEDS_CLEANUP: bool;
+
+    fn cleanup(&mut self, num: usize, forward: bool);
+}
+
+/// Like `Iterator::__iterator_get_unchecked`, but doesn't require the compiler to
+/// know that `U: TrustedRandomAccess`.
+///
+/// ## Safety
+///
+/// Same requirements calling `get_unchecked` directly.
+#[doc(hidden)]
+#[inline]
+pub(in crate::iter) unsafe fn try_get_unchecked<I>(it: &mut I, idx: usize) -> I::Item
+where
+    I: Iterator,
+{
+    // SAFETY: the caller must uphold the contract for
+    // `Iterator::__iterator_get_unchecked`.
+    unsafe { it.try_get_unchecked(idx) }
+}
+
+unsafe trait SpecTrustedRandomAccess: Iterator {
+    /// If `Self: TrustedRandomAccess`, it must be safe to call
+    /// `Iterator::__iterator_get_unchecked(self, index)`.
+    unsafe fn try_get_unchecked(&mut self, index: usize) -> Self::Item;
+}
+
+unsafe impl<I: Iterator> SpecTrustedRandomAccess for I {
+    default unsafe fn try_get_unchecked(&mut self, _: usize) -> Self::Item {
+        panic!("Should only be called on TrustedRandomAccess iterators");
+    }
+}
+
+unsafe impl<I: Iterator + TrustedRandomAccess> SpecTrustedRandomAccess for I {
+    #[inline]
+    unsafe fn try_get_unchecked(&mut self, index: usize) -> Self::Item {
+        // SAFETY: the caller must uphold the contract for
+        // `Iterator::__iterator_get_unchecked`.
+        unsafe { self.__iterator_get_unchecked(index) }
+    }
+}