From f174547124ab84c699e519033b047ef01435c284 Mon Sep 17 00:00:00 2001
From: The 8472 <git@infinite-source.de>
Date: Sun, 25 Jun 2023 18:09:47 +0200
Subject: [PATCH] Mark the StepBy specialization as unsafe

---
 library/core/src/iter/adapters/step_by.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/library/core/src/iter/adapters/step_by.rs b/library/core/src/iter/adapters/step_by.rs
index 2458a13d987..7f58f7d1775 100644
--- a/library/core/src/iter/adapters/step_by.rs
+++ b/library/core/src/iter/adapters/step_by.rs
@@ -141,7 +141,7 @@ impl<T> SpecRangeSetup<T> for T {
 
 /// Specialization trait to optimize `StepBy<Range<{integer}>>` iteration.
 ///
-/// # Correctness
+/// # Safety
 ///
 /// Technically this is safe to implement (look ma, no unsafe!), but in reality
 /// a lot of unsafe code relies on ranges over integers being correct.
@@ -149,7 +149,7 @@ impl<T> SpecRangeSetup<T> for T {
 /// For correctness *all* public StepBy methods must be specialized
 /// because `setup` drastically alters the meaning of the struct fields so that mixing
 /// different implementations would lead to incorrect results.
-trait StepByImpl<I> {
+unsafe trait StepByImpl<I> {
     type Item;
 
     fn spec_next(&mut self) -> Option<Self::Item>;
@@ -172,13 +172,13 @@ fn spec_fold<Acc, F>(self, acc: Acc, f: F) -> Acc
 ///
 /// See also: `StepByImpl`
 ///
-/// # Correctness
+/// # Safety
 ///
 /// The specializations must be implemented together with `StepByImpl`
 /// where applicable. I.e. if `StepBy` does support backwards iteration
 /// for a given iterator and that is specialized for forward iteration then
 /// it must also be specialized for backwards iteration.
-trait StepByBackImpl<I> {
+unsafe trait StepByBackImpl<I> {
     type Item;
 
     fn spec_next_back(&mut self) -> Option<Self::Item>
@@ -201,7 +201,7 @@ fn spec_rfold<Acc, F>(self, init: Acc, f: F) -> Acc
         F: FnMut(Acc, Self::Item) -> Acc;
 }
 
-impl<I: Iterator> StepByImpl<I> for StepBy<I> {
+unsafe impl<I: Iterator> StepByImpl<I> for StepBy<I> {
     type Item = I::Item;
 
     #[inline]
@@ -319,7 +319,7 @@ fn nth<I: Iterator>(iter: &mut I, step: usize) -> impl FnMut() -> Option<I::Item
     }
 }
 
-impl<I: DoubleEndedIterator + ExactSizeIterator> StepByBackImpl<I> for StepBy<I> {
+unsafe impl<I: DoubleEndedIterator + ExactSizeIterator> StepByBackImpl<I> for StepBy<I> {
     type Item = I::Item;
 
     #[inline]
@@ -416,7 +416,7 @@ fn setup(mut r: Range<$t>, step: usize) -> Range<$t> {
             }
         }
 
-        impl StepByImpl<Range<$t>> for StepBy<Range<$t>> {
+        unsafe impl StepByImpl<Range<$t>> for StepBy<Range<$t>> {
             #[inline]
             fn spec_next(&mut self) -> Option<$t> {
                 // if a step size larger than the type has been specified fall back to
@@ -497,7 +497,7 @@ macro_rules! spec_int_ranges_r {
     ($($t:ty)*) => ($(
         const _: () = assert!(usize::BITS >= <$t>::BITS);
 
-        impl StepByBackImpl<Range<$t>> for StepBy<Range<$t>> {
+        unsafe impl StepByBackImpl<Range<$t>> for StepBy<Range<$t>> {
 
             #[inline]
             fn spec_next_back(&mut self) -> Option<Self::Item>