Replace various iterator! parameters with self calls

Rather than encoding things as method calls or token expansions.

This isn't directly useful for Iter/IterMut, but sets this up for the next commit that adds another invocation of the macro.

Author: scottmcm

library/core/src/slice/iter.rs

@@ -78,7 +78,7 @@ pub struct Iter<'a, T: 'a> {
 #[stable(feature = "core_impl_debug", since = "1.9.0")]
 impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("Iter").field(&self.as_slice()).finish()
+        f.debug_tuple("Iter").field(&self.make_shortlived_slice()).finish()
     }
 }
 
@@ -129,11 +129,22 @@ impl<'a, T> Iter<'a, T> {
     #[stable(feature = "iter_to_slice", since = "1.4.0")]
     #[inline]
     pub fn as_slice(&self) -> &'a [T] {
-        self.make_slice()
+        // SAFETY: the type invariant guarantees the pointer represents a valid slice
+        unsafe { self.make_nonnull_slice().as_ref() }
+    }
+
+    #[inline]
+    unsafe fn non_null_to_item(p: NonNull<T>) -> <Self as Iterator>::Item {
+        // SAFETY: the type invariant guarantees the pointer represents a valid reference
+        unsafe { p.as_ref() }
+    }
+
+    fn empty() -> Self {
+        (&[]).into_iter()
     }
 }
 
-iterator! {struct Iter -> *const T, &'a T, const, {/* no mut */}, as_ref, {
+iterator! {struct Iter -> *const T, &'a T, {
     fn is_sorted_by<F>(self, mut compare: F) -> bool
     where
         Self: Sized,
@@ -201,7 +212,7 @@ pub struct IterMut<'a, T: 'a> {
 #[stable(feature = "core_impl_debug", since = "1.9.0")]
 impl<T: fmt::Debug> fmt::Debug for IterMut<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple("IterMut").field(&self.make_slice()).finish()
+        f.debug_tuple("IterMut").field(&self.make_shortlived_slice()).finish()
     }
 }
 
@@ -307,7 +318,8 @@ impl<'a, T> IterMut<'a, T> {
     #[stable(feature = "slice_iter_mut_as_slice", since = "1.53.0")]
     #[inline]
     pub fn as_slice(&self) -> &[T] {
-        self.make_slice()
+        // SAFETY: the type invariant guarantees the pointer represents a valid slice
+        unsafe { self.make_nonnull_slice().as_ref() }
     }
 
     /// Views the underlying data as a mutable subslice of the original data.
@@ -350,6 +362,16 @@ impl<'a, T> IterMut<'a, T> {
         // for `from_raw_parts_mut` are fulfilled.
         unsafe { from_raw_parts_mut(self.ptr.as_ptr(), len!(self)) }
     }
+
+    #[inline]
+    unsafe fn non_null_to_item(mut p: NonNull<T>) -> <Self as Iterator>::Item {
+        // SAFETY: the type invariant guarantees the pointer represents a valid item
+        unsafe { p.as_mut() }
+    }
+
+    fn empty() -> Self {
+        (&mut []).into_iter()
+    }
 }
 
 #[stable(feature = "slice_iter_mut_as_slice", since = "1.53.0")]
@@ -367,7 +389,7 @@ impl<T> AsRef<[T]> for IterMut<'_, T> {
 //     }
 // }
 
-iterator! {struct IterMut -> *mut T, &'a mut T, mut, {mut}, as_mut, {}}
+iterator! {struct IterMut -> *mut T, &'a mut T, {}}
 
 /// An internal abstraction over the splitting iterators, so that
 /// splitn, splitn_mut etc can be implemented once.

library/core/src/slice/iter/macros.rs

@@ -65,9 +65,6 @@ macro_rules! iterator {
     (
         struct $name:ident -> $ptr:ty,
         $elem:ty,
-        $raw_mut:tt,
-        {$( $mut_:tt )?},
-        $into_ref:ident,
         {$($extra:tt)*}
     ) => {
         impl<'a, T> $name<'a, T> {
@@ -80,16 +77,22 @@ macro_rules! iterator {
             unsafe fn next_back_unchecked(&mut self) -> $elem {
                 // SAFETY: the caller promised it's not empty, so
                 // the offsetting is in-bounds and there's an element to return.
-                unsafe { self.pre_dec_end(1).$into_ref() }
+                unsafe { Self::non_null_to_item(self.pre_dec_end(1)) }
             }
 
             // Helper function for creating a slice from the iterator.
-            #[inline(always)]
-            fn make_slice(&self) -> &'a [T] {
-                // SAFETY: the iterator was created from a slice with pointer
-                // `self.ptr` and length `len!(self)`. This guarantees that all
-                // the prerequisites for `from_raw_parts` are fulfilled.
-                unsafe { from_raw_parts(self.ptr.as_ptr(), len!(self)) }
+            #[inline]
+            pub(crate) fn make_nonnull_slice(&self) -> NonNull<[T]> {
+                NonNull::slice_from_raw_parts(self.ptr, len!(self))
+            }
+
+            #[inline]
+            pub(crate) fn make_shortlived_slice<'b>(&'b self) -> &'b [T] {
+                // SAFETY: Everything expanded with this macro is readable while
+                // the iterator exists and is unchanged, so by tying this to the
+                // shorter-than-`'a` self borrow we can make this safe to call.
+                // (Elision would be fine here, but using `'b` for emphasis.)
+                unsafe { self.make_nonnull_slice().as_ref() }
             }
 
             // Helper function for moving the start of the iterator forwards by `offset` elements,
@@ -229,7 +232,7 @@ macro_rules! iterator {
                 loop {
                     // SAFETY: the loop iterates `i in 0..len`, which always is in bounds of
                     // the slice allocation
-                    acc = f(acc, unsafe { & $( $mut_ )? *self.ptr.add(i).as_ptr() });
+                    acc = f(acc, unsafe { Self::non_null_to_item(self.ptr.add(i)) });
                     // SAFETY: `i` can't overflow since it'll only reach usize::MAX if the
                     // slice had that length, in which case we'll break out of the loop
                     // after the increment
@@ -380,7 +383,7 @@ macro_rules! iterator {
                 // that will access this subslice are called, so it is valid
                 // for the returned reference to be mutable in the case of
                 // `IterMut`
-                unsafe { & $( $mut_ )? * self.ptr.as_ptr().add(idx) }
+                unsafe { Self::non_null_to_item(self.ptr.add(idx)) }
             }
 
             $($extra)*
@@ -440,7 +443,7 @@ macro_rules! iterator {
             unsafe fn next_unchecked(&mut self) -> $elem {
                 // SAFETY: The caller promised there's at least one more item.
                 unsafe {
-                    self.post_inc_start(1).$into_ref()
+                    Self::non_null_to_item(self.post_inc_start(1))
                 }
             }
         }
@@ -455,7 +458,7 @@ macro_rules! iterator {
             /// assert_eq!(iter.len(), 0);
             /// ```
             fn default() -> Self {
-                (& $( $mut_ )? []).into_iter()
+                Self::empty()
             }
         }
     }