introduce Step::forward/backward_overflowing

and optimize the RangeInclusive iterator implementation with them

This changes the `exhausted` field to represent an overflow flag
for the bounds, essentially acting as an extra bit for `Idx`.
This was found to enable optimizations previously only applicable
to the exclusive-ended Range type.

- change end_bound to return Excluded(start) when exhausted
- add contains to tests
- make into_bounds panic when exhausted
  matches From<legacy::RangeInclusive<T>> for RangeInclusive<T>

Author: pitaj

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 {