Rollup merge of rust-lang#155114 - pitaj:rangeinclusiveiter-optimize, r=Mark-Simulacrum

Add `Step::forward/backward_overflowing` to enable RangeInclusive loop optimizations

ACP: rust-lang/libs-team#767

This adds new required methods to the Step trait:
```rust
trait Step: ... {
    // ... existing functions

    // New required functions
    fn forward_overflowing(start: Self, count: usize) -> (Self, bool);
    fn backward_overflowing(start: Self, count: usize) -> (Self, bool);
}
```

It was found that using these to implement RangeInclusive's Iterator impl enabled optimizations previously only applicable to the exclusive-ended `Range`.

This required changing how "exhaustion" works for `RangeInclusive`. I've nominated this for libs-api discussion because of one insta-stable change:

The new implementations now only set `exhausted` when overflow occurs, and `start` is now advanced past `end` otherwise. I doubt anyone depends on the prior behavior, but it's probably worth a crater run.

The exhaustion changes also affect `Debug` but my understanding is that debug formatting is never guaranteed stable.

I have now changed the `nth` impls to use the new functions as well.

r? libs

Author: jhpratt

compiler/rustc_abi/src/lib.rs

@@ -990,6 +990,13 @@ impl Step for Size {
         u64::forward_checked(start.bytes(), count).map(Self::from_bytes)
     }
 
+    #[inline]
+    #[cfg(not(bootstrap))]
+    fn forward_overflowing(start: Self, count: usize) -> (Self, bool) {
+        let (s, o) = u64::forward_overflowing(start.bytes(), count);
+        (Self::from_bytes(s), o)
+    }
+
     #[inline]
     fn forward(start: Self, count: usize) -> Self {
         Self::from_bytes(u64::forward(start.bytes(), count))
@@ -1005,6 +1012,13 @@ impl Step for Size {
         u64::backward_checked(start.bytes(), count).map(Self::from_bytes)
     }
 
+    #[inline]
+    #[cfg(not(bootstrap))]
+    fn backward_overflowing(start: Self, count: usize) -> (Self, bool) {
+        let (s, o) = u64::backward_overflowing(start.bytes(), count);
+        (Self::from_bytes(s), o)
+    }
+
     #[inline]
     fn backward(start: Self, count: usize) -> Self {
         Self::from_bytes(u64::backward(start.bytes(), count))

compiler/rustc_index_macros/src/newtype.rs

@@ -136,6 +136,20 @@ impl Parse for Newtype {
                     fn backward_checked(start: Self, u: usize) -> Option<Self> {
                         Self::index(start).checked_sub(u).map(Self::from_usize)
                     }
+
+                    #[inline]
+                    #[cfg(not(bootstrap))]
+                    fn forward_overflowing(start: Self, u: usize) -> (Self, bool) {
+                        let (s, o) = Self::index(start).overflowing_add(u);
+                        (Self::from_usize(s), o)
+                    }
+
+                    #[inline]
+                    #[cfg(not(bootstrap))]
+                    fn backward_overflowing(start: Self, u: usize) -> (Self, bool) {
+                        let (s, o) = Self::index(start).overflowing_sub(u);
+                        (Self::from_usize(s), o)
+                    }
                 }
                 impl ::std::cmp::Ord for #name {
                     fn cmp(&self, other: &Self) -> std::cmp::Ordering {