Auto merge of #51033 - coryshrmn:master, r=dtolnay

stabilize RangeBounds collections_range #30877

The FCP for #30877 closed last month, with the decision to:
1. move from `collections::range::RangeArgument` to `ops::RangeBounds`, and
2. rename `start()` and `end()` to `start_bounds()` and `end_bounds()`.

Simon Sapin already moved it to `ops::RangeBounds` in #49163.

I renamed the functions, and removed the old `collections::range::RangeArgument` alias.

This is my first Rust PR, please let me know if I can improve anything. This passes all tests for me, except the `clippy` tool (which uses `RangeArgument::start()`).

I considered deprecating `start()` and `end()` instead of removing them, but the contribution guidelines indicate we can break `clippy` temporarily. I thought it was best to remove the functions, since we're worried about name collisions with `Range::start` and `end`.

Closes #30877.

1 files changed, 53 insertions, 85 deletions

diff --git a/src/libcore/ops/range.rs b/src/libcore/ops/range.rs
index 7c6e2447bdb..01e279589da 100644
--- a/src/libcore/ops/range.rs
+++ b/src/libcore/ops/range.rs
@@ -588,14 +588,12 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
 /// `Bound`s are range endpoints:
 ///
 /// ```
-/// #![feature(collections_range)]
-///
 /// use std::ops::Bound::*;
 /// use std::ops::RangeBounds;
 ///
-/// assert_eq!((..100).start(), Unbounded);
-/// assert_eq!((1..12).start(), Included(&1));
-/// assert_eq!((1..12).end(), Excluded(&12));
+/// assert_eq!((..100).start_bound(), Unbounded);
+/// assert_eq!((1..12).start_bound(), Included(&1));
+/// assert_eq!((1..12).end_bound(), Excluded(&12));
 /// ```
 ///
 /// Using a tuple of `Bound`s as an argument to [`BTreeMap::range`].
@@ -632,9 +630,7 @@ pub enum Bound<T> {
     Unbounded,
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 /// `RangeBounds` is implemented by Rust's built-in range types, produced
 /// by range syntax like `..`, `a..`, `..b` or `c..d`.
 pub trait RangeBounds<T: ?Sized> {
@@ -645,17 +641,16 @@ pub trait RangeBounds<T: ?Sized> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(collections_range)]
-    ///
     /// # fn main() {
     /// use std::ops::Bound::*;
     /// use std::ops::RangeBounds;
     ///
-    /// assert_eq!((..10).start(), Unbounded);
-    /// assert_eq!((3..10).start(), Included(&3));
+    /// assert_eq!((..10).start_bound(), Unbounded);
+    /// assert_eq!((3..10).start_bound(), Included(&3));
     /// # }
     /// ```
-    fn start(&self) -> Bound<&T>;
+    #[stable(feature = "collections_range", since = "1.28.0")]
+    fn start_bound(&self) -> Bound<&T>;
 
     /// End index bound.
     ///
@@ -664,17 +659,16 @@ pub trait RangeBounds<T: ?Sized> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(collections_range)]
-    ///
     /// # fn main() {
     /// use std::ops::Bound::*;
     /// use std::ops::RangeBounds;
     ///
-    /// assert_eq!((3..).end(), Unbounded);
-    /// assert_eq!((3..10).end(), Excluded(&10));
+    /// assert_eq!((3..).end_bound(), Unbounded);
+    /// assert_eq!((3..10).end_bound(), Excluded(&10));
     /// # }
     /// ```
-    fn end(&self) -> Bound<&T>;
+    #[stable(feature = "collections_range", since = "1.28.0")]
+    fn end_bound(&self) -> Bound<&T>;
 
 
     /// Returns `true` if `item` is contained in the range.
@@ -699,13 +693,13 @@ pub trait RangeBounds<T: ?Sized> {
         T: PartialOrd<U>,
         U: ?Sized + PartialOrd<T>,
     {
-        (match self.start() {
+        (match self.start_bound() {
             Included(ref start) => *start <= item,
             Excluded(ref start) => *start < item,
             Unbounded => true,
         })
         &&
-        (match self.end() {
+        (match self.end_bound() {
             Included(ref end) => item <= *end,
             Excluded(ref end) => item < *end,
             Unbounded => true,
@@ -715,83 +709,69 @@ pub trait RangeBounds<T: ?Sized> {
 
 use self::Bound::{Excluded, Included, Unbounded};
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<T: ?Sized> RangeBounds<T> for RangeFull {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Unbounded
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<T> RangeBounds<T> for RangeFrom<T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Unbounded
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<T> RangeBounds<T> for RangeTo<T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Excluded(&self.end)
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<T> RangeBounds<T> for Range<T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Excluded(&self.end)
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<T> RangeBounds<T> for RangeInclusive<T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Included(&self.start)
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Included(&self.end)
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<T> RangeBounds<T> for RangeToInclusive<T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Included(&self.end)
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<T> RangeBounds<T> for (Bound<T>, Bound<T>) {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         match *self {
             (Included(ref start), _) => Included(start),
             (Excluded(ref start), _) => Excluded(start),
@@ -799,7 +779,7 @@ impl<T> RangeBounds<T> for (Bound<T>, Bound<T>) {
         }
     }
 
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         match *self {
             (_, Included(ref end)) => Included(end),
             (_, Excluded(ref end)) => Excluded(end),
@@ -808,75 +788,63 @@ impl<T> RangeBounds<T> for (Bound<T>, Bound<T>) {
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<'a, T: ?Sized + 'a> RangeBounds<T> for (Bound<&'a T>, Bound<&'a T>) {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         self.0
     }
 
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         self.1
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<'a, T> RangeBounds<T> for RangeFrom<&'a T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Unbounded
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<'a, T> RangeBounds<T> for RangeTo<&'a T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Excluded(self.end)
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<'a, T> RangeBounds<T> for Range<&'a T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Excluded(self.end)
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<'a, T> RangeBounds<T> for RangeInclusive<&'a T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Included(self.start)
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Included(self.end)
     }
 }
 
-#[unstable(feature = "collections_range",
-           reason = "might be replaced with `Into<_>` and a type containing two `Bound` values",
-           issue = "30877")]
+#[stable(feature = "collections_range", since = "1.28.0")]
 impl<'a, T> RangeBounds<T> for RangeToInclusive<&'a T> {
-    fn start(&self) -> Bound<&T> {
+    fn start_bound(&self) -> Bound<&T> {
         Unbounded
     }
-    fn end(&self) -> Bound<&T> {
+    fn end_bound(&self) -> Bound<&T> {
         Included(self.end)
     }
 }