Use marker/specialization traits instead of associated consts to signal the need for pre/post loop calls

The loop setup and cleanup functions are only required for some specific iterators.
To avoid emitting IR when they're not needed even in debug mode we need to use the type system
instead of const-DCE because the constants would only be known after monomorphization.

Author: the8472

library/alloc/src/collections/vec_deque/iter.rs

@@ -206,8 +206,6 @@ unsafe impl<T> TrustedLen for Iter<'_, T> {}
 #[doc(hidden)]
 #[unstable(feature = "trusted_random_access", issue = "none")]
 unsafe impl<T> TrustedRandomAccess for Iter<'_, T> {
-    const NEEDS_CLEANUP: bool = false;
-
     fn cleanup(&mut self, num: usize, forward: bool) {
         if forward {
             let _ = self.advance_by(num);

library/alloc/src/collections/vec_deque/iter_mut.rs

@@ -155,8 +155,6 @@ unsafe impl<T> TrustedLen for IterMut<'_, T> {}
 #[doc(hidden)]
 #[unstable(feature = "trusted_random_access", issue = "none")]
 unsafe impl<T> TrustedRandomAccess for IterMut<'_, T> {
-    const NEEDS_CLEANUP: bool = false;
-
     fn cleanup(&mut self, num: usize, forward: bool) {
         if forward {
             let _ = self.advance_by(num);

library/alloc/src/vec/into_iter.rs

@@ -4,7 +4,10 @@ use crate::alloc::{Allocator, Global};
 use crate::raw_vec::RawVec;
 use core::fmt;
 use core::intrinsics::arith_offset;
-use core::iter::{FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess};
+use core::iter::{
+    FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess,
+    TrustedRandomAccessNeedsCleanup,
+};
 use core::marker::PhantomData;
 use core::mem::{self, ManuallyDrop};
 use core::ops::Deref;
@@ -286,8 +289,6 @@ unsafe impl<T, A: Allocator> TrustedRandomAccess for IntoIter<T, A>
 where
     T: NonDrop,
 {
-    const NEEDS_CLEANUP: bool = true;
-
     fn cleanup(&mut self, num: usize, forward: bool) {
         if forward {
             if mem::size_of::<T>() == 0 {
@@ -313,6 +314,10 @@ where
     }
 }
 
+#[doc(hidden)]
+#[unstable(issue = "none", feature = "std_internals")]
+unsafe impl<T, A: Allocator> TrustedRandomAccessNeedsCleanup for IntoIter<T, A> where T: NonDrop {}
+
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "vec_into_iter_clone", since = "1.8.0")]
 impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A> {

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

@@ -1,5 +1,8 @@
 use crate::iter::traits::trusted_random_access::try_get_unchecked;
-use crate::iter::traits::TrustedRandomAccess;
+use crate::iter::traits::{
+    TrustedRandomAccess, TrustedRandomAccessNeedsCleanup, TrustedRandomAccessNeedsForwardSetup,
+    TrustedRandomAccessNeedsReverseSetup,
+};
 use crate::iter::{FusedIterator, TrustedLen};
 use crate::ops::Try;
 
@@ -126,14 +129,31 @@ unsafe impl<I> TrustedRandomAccess for Cloned<I>
 where
     I: TrustedRandomAccess,
 {
-    const NEEDS_CLEANUP: bool = I::NEEDS_CLEANUP;
-
     #[inline]
     fn cleanup(&mut self, num: usize, forward: bool) {
         self.it.cleanup(num, forward);
     }
 }
 
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsCleanup for Cloned<I> where I: TrustedRandomAccessNeedsCleanup
+{}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsForwardSetup for Cloned<I> where
+    I: TrustedRandomAccessNeedsForwardSetup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsReverseSetup for Cloned<I> where
+    I: TrustedRandomAccessNeedsReverseSetup
+{
+}
+
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<'a, I, T: 'a> TrustedLen for Cloned<I>
 where

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

@@ -1,5 +1,8 @@
 use crate::iter::traits::trusted_random_access::try_get_unchecked;
-use crate::iter::traits::TrustedRandomAccess;
+use crate::iter::traits::{
+    TrustedRandomAccess, TrustedRandomAccessNeedsCleanup, TrustedRandomAccessNeedsForwardSetup,
+    TrustedRandomAccessNeedsReverseSetup,
+};
 use crate::iter::{FusedIterator, TrustedLen};
 use crate::ops::Try;
 
@@ -152,14 +155,31 @@ unsafe impl<I> TrustedRandomAccess for Copied<I>
 where
     I: TrustedRandomAccess,
 {
-    const NEEDS_CLEANUP: bool = I::NEEDS_CLEANUP;
-
     #[inline]
     fn cleanup(&mut self, num: usize, forward: bool) {
         self.it.cleanup(num, forward);
     }
 }
 
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsCleanup for Copied<I> where I: TrustedRandomAccessNeedsCleanup
+{}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsForwardSetup for Copied<I> where
+    I: TrustedRandomAccessNeedsForwardSetup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsReverseSetup for Copied<I> where
+    I: TrustedRandomAccessNeedsReverseSetup
+{
+}
+
 #[stable(feature = "iter_copied", since = "1.36.0")]
 unsafe impl<'a, I, T: 'a> TrustedLen for Copied<I>
 where

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

@@ -1,6 +1,9 @@
 use crate::iter::adapters::SourceIter;
 use crate::iter::traits::trusted_random_access::try_get_unchecked;
-use crate::iter::traits::TrustedRandomAccess;
+use crate::iter::traits::{
+    TrustedRandomAccess, TrustedRandomAccessNeedsCleanup, TrustedRandomAccessNeedsForwardSetup,
+    TrustedRandomAccessNeedsReverseSetup,
+};
 use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen};
 use crate::ops::Try;
 
@@ -236,14 +239,33 @@ unsafe impl<I> TrustedRandomAccess for Enumerate<I>
 where
     I: TrustedRandomAccess,
 {
-    const NEEDS_CLEANUP: bool = I::NEEDS_CLEANUP;
-
     #[inline]
     fn cleanup(&mut self, num: usize, forward: bool) {
         self.iter.cleanup(num, forward);
     }
 }
 
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsCleanup for Enumerate<I> where
+    I: TrustedRandomAccessNeedsCleanup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsForwardSetup for Enumerate<I> where
+    I: TrustedRandomAccessNeedsForwardSetup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsReverseSetup for Enumerate<I> where
+    I: TrustedRandomAccessNeedsReverseSetup
+{
+}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<I> FusedIterator for Enumerate<I> where I: FusedIterator {}
 

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

@@ -2,6 +2,8 @@ use crate::intrinsics;
 use crate::iter::traits::trusted_random_access::try_get_unchecked;
 use crate::iter::{
     DoubleEndedIterator, ExactSizeIterator, FusedIterator, TrustedLen, TrustedRandomAccess,
+    TrustedRandomAccessNeedsCleanup, TrustedRandomAccessNeedsForwardSetup,
+    TrustedRandomAccessNeedsReverseSetup,
 };
 use crate::ops::Try;
 
@@ -225,8 +227,6 @@ unsafe impl<I> TrustedRandomAccess for Fuse<I>
 where
     I: TrustedRandomAccess,
 {
-    const NEEDS_CLEANUP: bool = I::NEEDS_CLEANUP;
-
     #[inline]
     fn cleanup(&mut self, num: usize, forward: bool) {
         if let Some(iter) = self.iter.as_mut() {
@@ -235,6 +235,24 @@ where
     }
 }
 
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsCleanup for Fuse<I> where I: TrustedRandomAccessNeedsCleanup {}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsForwardSetup for Fuse<I> where
+    I: TrustedRandomAccessNeedsForwardSetup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I> TrustedRandomAccessNeedsReverseSetup for Fuse<I> where
+    I: TrustedRandomAccessNeedsReverseSetup
+{
+}
+
 /// Fuse specialization trait
 ///
 /// We only need to worry about `&mut self` methods, which

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

@@ -1,7 +1,10 @@
 use crate::fmt;
 use crate::iter::adapters::SourceIter;
 use crate::iter::traits::trusted_random_access::try_get_unchecked;
-use crate::iter::traits::TrustedRandomAccess;
+use crate::iter::traits::{
+    TrustedRandomAccess, TrustedRandomAccessNeedsCleanup, TrustedRandomAccessNeedsForwardSetup,
+    TrustedRandomAccessNeedsReverseSetup,
+};
 use crate::iter::{FusedIterator, InPlaceIterable, TrustedLen};
 use crate::ops::Try;
 
@@ -194,14 +197,33 @@ unsafe impl<I, F> TrustedRandomAccess for Map<I, F>
 where
     I: TrustedRandomAccess,
 {
-    const NEEDS_CLEANUP: bool = I::NEEDS_CLEANUP;
-
     #[inline]
     fn cleanup(&mut self, num: usize, forward: bool) {
         self.iter.cleanup(num, forward);
     }
 }
 
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I, F> TrustedRandomAccessNeedsCleanup for Map<I, F> where
+    I: TrustedRandomAccessNeedsCleanup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I, F> TrustedRandomAccessNeedsForwardSetup for Map<I, F> where
+    I: TrustedRandomAccessNeedsForwardSetup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<I, F> TrustedRandomAccessNeedsReverseSetup for Map<I, F> where
+    I: TrustedRandomAccessNeedsReverseSetup
+{
+}
+
 #[unstable(issue = "none", feature = "inplace_iteration")]
 unsafe impl<I, F> SourceIter for Map<I, F>
 where

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

@@ -2,7 +2,10 @@ 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, TrustedRandomAccess};
+use crate::iter::{
+    InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess, TrustedRandomAccessNeedsCleanup,
+    TrustedRandomAccessNeedsForwardSetup, TrustedRandomAccessNeedsReverseSetup,
+};
 use crate::ops::Try;
 
 /// An iterator that iterates two other iterators simultaneously.
@@ -259,14 +262,63 @@ where
     A: TrustedRandomAccess,
     B: TrustedRandomAccess,
 {
-    const NEEDS_CLEANUP: bool = A::NEEDS_CLEANUP || B::NEEDS_CLEANUP;
-
     fn cleanup(&mut self, num: usize, forward: bool) {
         self.a.cleanup(num, forward);
         self.b.cleanup(num, forward);
     }
 }
 
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<A, B> TrustedRandomAccessNeedsCleanup for Zip<A, B> where
+    A: TrustedRandomAccessNeedsCleanup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<A, B> TrustedRandomAccessNeedsCleanup for Zip<A, B> where
+    B: TrustedRandomAccessNeedsCleanup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<A, B> TrustedRandomAccessNeedsCleanup for Zip<A, B>
+where
+    A: TrustedRandomAccessNeedsCleanup,
+    B: TrustedRandomAccessNeedsCleanup,
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<A, B> TrustedRandomAccessNeedsForwardSetup for Zip<A, B> where
+    A: TrustedRandomAccessNeedsForwardSetup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<A, B> TrustedRandomAccessNeedsForwardSetup for Zip<A, B> where
+    B: TrustedRandomAccessNeedsForwardSetup
+{
+}
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<A, B> TrustedRandomAccessNeedsForwardSetup for Zip<A, B>
+where
+    A: TrustedRandomAccessNeedsForwardSetup,
+    B: TrustedRandomAccessNeedsForwardSetup,
+{
+}
+
+
+#[doc(hidden)]
+#[unstable(feature = "trusted_random_access", issue = "none")]
+unsafe impl<A, B> TrustedRandomAccessNeedsReverseSetup for Zip<A, B> where Self: TrustedRandomAccess {}
+
 #[stable(feature = "fused", since = "1.26.0")]
 impl<A, B> FusedIterator for Zip<A, B>
 where