Auto merge of #24120 - aturon:range-perf, r=alexcrichton

A recent change to the implementation of range iterators meant that,
even when stepping by 1, the iterators *always* involved checked
arithmetic.

This commit reverts to the earlier behavior (while retaining the
refactoring into traits).

Fixes #24095
Closes #24119
cc #24014 

r? @alexcrichton

src/libcore/iter.rs

@@ -60,7 +60,7 @@
 
 use clone::Clone;
 use cmp;
-use cmp::Ord;
+use cmp::{Ord, PartialOrd, PartialEq};
 use default::Default;
 use marker;
 use mem;
@@ -2382,7 +2382,7 @@ fn size_hint(&self) -> (usize, Option<usize>) {
 /// two `Step` objects.
 #[unstable(feature = "step_trait",
            reason = "likely to be replaced by finer-grained traits")]
-pub trait Step: Ord {
+pub trait Step: PartialOrd {
     /// Steps `self` if possible.
     fn step(&self, by: &Self) -> Option<Self>;
 
@@ -2549,7 +2549,10 @@ pub fn range_inclusive<A>(start: A, stop: A) -> RangeInclusive<A>
 
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-impl<A: Step + One + Clone> Iterator for RangeInclusive<A> {
+impl<A> Iterator for RangeInclusive<A> where
+    A: PartialEq + Step + One + Clone,
+    for<'a> &'a A: Add<&'a A, Output = A>
+{
     type Item = A;
 
     #[inline]
@@ -2579,9 +2582,10 @@ fn size_hint(&self) -> (usize, Option<usize>) {
 
 #[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
-impl<A> DoubleEndedIterator for RangeInclusive<A>
-    where A: Step + One + Clone,
-          for<'a> &'a A: Sub<Output=A>
+impl<A> DoubleEndedIterator for RangeInclusive<A> where
+    A: PartialEq + Step + One + Clone,
+    for<'a> &'a A: Add<&'a A, Output = A>,
+    for<'a> &'a A: Sub<Output=A>
 {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
@@ -2709,24 +2713,17 @@ impl ExactSizeIterator for ops::Range<$t> { }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(deprecated)]
-impl<A: Step + One + Clone> Iterator for ops::Range<A> {
+impl<A: Step + One> Iterator for ops::Range<A> where
+    for<'a> &'a A: Add<&'a A, Output = A>
+{
     type Item = A;
 
     #[inline]
     fn next(&mut self) -> Option<A> {
         if self.start < self.end {
-            match self.start.step(&A::one()) {
-                Some(mut n) => {
-                    mem::swap(&mut n, &mut self.start);
-                    Some(n)
-                },
-                None => {
-                    let mut n = self.end.clone();
-                    mem::swap(&mut n, &mut self.start);
-                    Some(n)
-
-                }
-            }
+            let mut n = &self.start + &A::one();
+            mem::swap(&mut n, &mut self.start);
+            Some(n)
         } else {
             None
         }
@@ -2748,6 +2745,7 @@ fn size_hint(&self) -> (usize, Option<usize>) {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(deprecated)]
 impl<A: Step + One + Clone> DoubleEndedIterator for ops::Range<A> where
+    for<'a> &'a A: Add<&'a A, Output = A>,
     for<'a> &'a A: Sub<&'a A, Output = A>
 {
     #[inline]
@@ -2763,15 +2761,16 @@ fn next_back(&mut self) -> Option<A> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(deprecated)]
-impl<A: Step + One> Iterator for ops::RangeFrom<A> {
+impl<A: Step + One> Iterator for ops::RangeFrom<A> where
+    for<'a> &'a A: Add<&'a A, Output = A>
+{
     type Item = A;
 
     #[inline]
     fn next(&mut self) -> Option<A> {
-        self.start.step(&A::one()).map(|mut n| {
-            mem::swap(&mut n, &mut self.start);
-            n
-        })
+        let mut n = &self.start + &A::one();
+        mem::swap(&mut n, &mut self.start);
+        Some(n)
     }
 }
 

src/test/compile-fail/range-1.rs

@@ -19,6 +19,7 @@ pub fn main() {
     for i in false..true {}
     //~^ ERROR the trait
     //~^^ ERROR the trait
+    //~^^^ ERROR the trait
 
     // Unsized type.
     let arr: &[_] = &[1, 2, 3];