Stabilize inclusive_range_syntax language feature.

Stabilize the syntax `a..=b` and `..=b`.

Author: kennytm

src/doc/unstable-book/src/language-features/inclusive-range-syntax.md

@@ -14,7 +14,7 @@
 #![feature(alloc_system)]
 #![feature(attr_literals)]
 #![feature(box_syntax)]
-#![feature(inclusive_range_syntax)]
+#![cfg_attr(stage0, feature(inclusive_range_syntax))]
 #![feature(collection_placement)]
 #![feature(const_fn)]
 #![feature(drain_filter)]

src/liballoc/tests/lib.rs

@@ -79,7 +79,7 @@
 #![feature(fn_must_use)]
 #![feature(fundamental)]
 #![feature(i128_type)]
-#![feature(inclusive_range_syntax)]
+#![cfg_attr(stage0, feature(inclusive_range_syntax))]
 #![feature(intrinsics)]
 #![feature(iterator_flatten)]
 #![feature(iterator_repeat_with)]

src/libcore/lib.rs

@@ -128,7 +128,7 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
     /// The range is empty if either side is incomparable:
     ///
     /// ```
-    /// #![feature(range_is_empty,inclusive_range_syntax)]
+    /// #![feature(range_is_empty)]
     ///
     /// use std::f32::NAN;
     /// assert!(!(3.0..5.0).is_empty());
@@ -283,8 +283,6 @@ impl<Idx: PartialOrd<Idx>> RangeTo<Idx> {
 /// # Examples
 ///
 /// ```
-/// #![feature(inclusive_range_syntax)]
-///
 /// assert_eq!((3..=5), std::ops::RangeInclusive { start: 3, end: 5 });
 /// assert_eq!(3 + 4 + 5, (3..=5).sum());
 ///
@@ -316,7 +314,7 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(range_contains,inclusive_range_syntax)]
+    /// #![feature(range_contains)]
     ///
     /// assert!(!(3..=5).contains(2));
     /// assert!( (3..=5).contains(3));
@@ -337,7 +335,7 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(range_is_empty,inclusive_range_syntax)]
+    /// #![feature(range_is_empty)]
     ///
     /// assert!(!(3..=5).is_empty());
     /// assert!(!(3..=3).is_empty());
@@ -347,7 +345,7 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// The range is empty if either side is incomparable:
     ///
     /// ```
-    /// #![feature(range_is_empty,inclusive_range_syntax)]
+    /// #![feature(range_is_empty)]
     ///
     /// use std::f32::NAN;
     /// assert!(!(3.0..=5.0).is_empty());
@@ -358,7 +356,7 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
     /// This method returns `true` after iteration has finished:
     ///
     /// ```
-    /// #![feature(range_is_empty,inclusive_range_syntax)]
+    /// #![feature(range_is_empty)]
     ///
     /// let mut r = 3..=5;
     /// for _ in r.by_ref() {}
@@ -381,16 +379,13 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
 /// The `..=end` syntax is a `RangeToInclusive`:
 ///
 /// ```
-/// #![feature(inclusive_range_syntax)]
 /// assert_eq!((..=5), std::ops::RangeToInclusive{ end: 5 });
 /// ```
 ///
 /// It does not have an [`IntoIterator`] implementation, so you can't use it in a
 /// `for` loop directly. This won't compile:
 ///
 /// ```compile_fail,E0277
-/// #![feature(inclusive_range_syntax)]
-///
 /// // error[E0277]: the trait bound `std::ops::RangeToInclusive<{integer}>:
 /// // std::iter::Iterator` is not satisfied
 /// for i in ..=5 {
@@ -402,8 +397,6 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
 /// array elements up to and including the index indicated by `end`.
 ///
 /// ```
-/// #![feature(inclusive_range_syntax)]
-///
 /// let arr = [0, 1, 2, 3];
 /// assert_eq!(arr[ ..=2], [0,1,2  ]);  // RangeToInclusive
 /// assert_eq!(arr[1..=2], [  1,2  ]);
@@ -434,7 +427,7 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(range_contains,inclusive_range_syntax)]
+    /// #![feature(range_contains)]
     ///
     /// assert!( (..=5).contains(-1_000_000_000));
     /// assert!( (..=5).contains(5));

src/libcore/ops/range.rs

@@ -23,7 +23,7 @@
 #![feature(fmt_internals)]
 #![feature(iterator_step_by)]
 #![feature(i128_type)]
-#![feature(inclusive_range_syntax)]
+#![cfg_attr(stage0, feature(inclusive_range_syntax))]
 #![feature(iterator_try_fold)]
 #![feature(iterator_flatten)]
 #![feature(conservative_impl_trait)]

src/libcore/tests/lib.rs

@@ -54,7 +54,7 @@
 #![feature(fs_read_write)]
 #![feature(i128)]
 #![feature(i128_type)]
-#![feature(inclusive_range_syntax)]
+#![cfg_attr(stage0, feature(inclusive_range_syntax))]
 #![cfg_attr(windows, feature(libc))]
 #![feature(match_default_bindings)]
 #![feature(macro_lifetime_matcher)]

src/librustc/lib.rs

@@ -18,7 +18,7 @@
 #![feature(conservative_impl_trait)]
 #![feature(fs_read_write)]
 #![feature(i128_type)]
-#![feature(inclusive_range_syntax)]
+#![cfg_attr(stage0, feature(inclusive_range_syntax))]
 #![feature(specialization)]
 
 extern crate graphviz;

src/librustc_incremental/lib.rs

@@ -28,7 +28,7 @@ Rust MIR: a lowered representation of Rust. Also: an experiment!
 #![feature(dyn_trait)]
 #![feature(fs_read_write)]
 #![feature(i128_type)]
-#![feature(inclusive_range_syntax)]
+#![cfg_attr(stage0, feature(inclusive_range_syntax))]
 #![feature(macro_vis_matcher)]
 #![feature(match_default_bindings)]
 #![feature(exhaustive_patterns)]

src/librustc_mir/lib.rs

@@ -26,7 +26,7 @@
 #![allow(unused_attributes)]
 #![feature(i128_type)]
 #![feature(i128)]
-#![feature(inclusive_range_syntax)]
+#![cfg_attr(stage0, feature(inclusive_range_syntax))]
 #![feature(libc)]
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]

src/librustc_trans/lib.rs

@@ -218,8 +218,6 @@ An inclusive range was used with no end.
 Erroneous code example:
 
 ```compile_fail,E0586
-#![feature(inclusive_range_syntax)]
-
 fn main() {
     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
     let x = &tmp[1..=]; // error: inclusive range was used with no end
@@ -239,8 +237,6 @@ fn main() {
 Or put an end to your inclusive range:
 
 ```
-#![feature(inclusive_range_syntax)]
-
 fn main() {
     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
     let x = &tmp[1..=3]; // ok!