fix compile/docs errors

Author: liigo

src/liballoc/btree/map.rs

@@ -782,13 +782,13 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// map.insert(3, "a");
     /// map.insert(5, "b");
     /// map.insert(8, "c");
-    /// for (&key, &value) in map.range((Included(&4), Included(&8))) {
+    /// for (&key, &value) in map.range((Included(4), Included(8))) {
     ///     println!("{}: {}", key, value);
     /// }
     /// assert_eq!(Some((&5, &"b")), map.range(4..).next());
     /// ```
     #[stable(feature = "btree_range", since = "1.17.0")]
-    pub fn range<T: ?Sized, R>(&self, range: R) -> Range<K, V>
+    pub fn range<T, R>(&self, range: R) -> Range<K, V>
         where T: Ord, K: Borrow<T>, R: Into<RangeBounds<T>>
     {
         let root1 = self.root.as_ref();
@@ -828,7 +828,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// }
     /// ```
     #[stable(feature = "btree_range", since = "1.17.0")]
-    pub fn range_mut<T: ?Sized, R>(&mut self, range: R) -> RangeMut<K, V>
+    pub fn range_mut<T, R>(&mut self, range: R) -> RangeMut<K, V>
         where T: Ord, K: Borrow<T>, R: Into<RangeBounds<T>>
     {
         let root1 = self.root.as_mut();
@@ -1779,21 +1779,21 @@ fn last_leaf_edge<BorrowType, K, V>
     }
 }
 
-fn range_search<BorrowType, K, V, Q: ?Sized>(
+fn range_search<BorrowType, K, V, Q>(
     root1: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,
     root2: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,
-    range: RangeBounds<&Q>
+    range: RangeBounds<Q>
 )-> (Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>,
      Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>)
         where Q: Ord, K: Borrow<Q>
 {
-    match (range.start, range.end) {
-        (Excluded(s), Excluded(e)) if s==e =>
+    match (&range.start, &range.end) {
+        (&Excluded(ref s), &Excluded(ref e)) if *s == *e =>
             panic!("range start and end are equal and excluded in BTreeMap"),
-        (Included(s), Included(e)) |
-        (Included(s), Excluded(e)) |
-        (Excluded(s), Included(e)) |
-        (Excluded(s), Excluded(e)) if s>e =>
+        (&Included(ref s), &Included(ref e)) |
+        (&Included(ref s), &Excluded(ref e)) |
+        (&Excluded(ref s), &Included(ref e)) |
+        (&Excluded(ref s), &Excluded(ref e)) if *s > *e =>
             panic!("range start is greater than range end in BTreeMap"),
         _ => {},
     };
@@ -1805,32 +1805,32 @@ fn range_search<BorrowType, K, V, Q: ?Sized>(
     let mut diverged = false;
 
     loop {
-        let min_edge = match (min_found, range.start()) {
-            (false, Included(key)) => match search::search_linear(&min_node, key) {
+        let min_edge = match (min_found, &range.start) {
+            (false, &Included(ref key)) => match search::search_linear(&min_node, key) {
                 (i, true) => { min_found = true; i },
                 (i, false) => i,
             },
-            (false, Excluded(key)) => match search::search_linear(&min_node, key) {
+            (false, &Excluded(ref key)) => match search::search_linear(&min_node, &key) {
                 (i, true) => { min_found = true; i+1 },
                 (i, false) => i,
             },
-            (_, Unbounded) => 0,
-            (true, Included(_)) => min_node.keys().len(),
-            (true, Excluded(_)) => 0,
+            (_, &Unbounded) => 0,
+            (true, &Included(_)) => min_node.keys().len(),
+            (true, &Excluded(_)) => 0,
         };
 
-        let max_edge = match (max_found, range.end()) {
-            (false, Included(key)) => match search::search_linear(&max_node, key) {
+        let max_edge = match (max_found, &range.end) {
+            (false, &Included(ref key)) => match search::search_linear(&max_node, key) {
                 (i, true) => { max_found = true; i+1 },
                 (i, false) => i,
             },
-            (false, Excluded(key)) => match search::search_linear(&max_node, key) {
+            (false, &Excluded(ref key)) => match search::search_linear(&max_node, key) {
                 (i, true) => { max_found = true; i },
                 (i, false) => i,
             },
-            (_, Unbounded) => max_node.keys().len(),
-            (true, Included(_)) => 0,
-            (true, Excluded(_)) => max_node.keys().len(),
+            (_, &Unbounded) => max_node.keys().len(),
+            (true, &Included(_)) => 0,
+            (true, &Excluded(_)) => max_node.keys().len(),
         };
 
         if !diverged {

src/liballoc/btree/set.rs

@@ -281,13 +281,13 @@ impl<T: Ord> BTreeSet<T> {
     /// set.insert(3);
     /// set.insert(5);
     /// set.insert(8);
-    /// for &elem in set.range((Included(&4), Included(&8))) {
+    /// for &elem in set.range((Included(4), Included(8))) {
     ///     println!("{}", elem);
     /// }
     /// assert_eq!(Some(&5), set.range(4..).next());
     /// ```
     #[stable(feature = "btree_range", since = "1.17.0")]
-    pub fn range<K: ?Sized, R>(&self, range: R) -> Range<T>
+    pub fn range<K, R>(&self, range: R) -> Range<T>
         where K: Ord, T: Borrow<K>, R: Into<RangeBounds<K>>
     {
         Range { iter: self.map.range(range.into()) }

src/liballoc/lib.rs

@@ -106,6 +106,7 @@
 #![feature(pattern)]
 #![feature(placement_in_syntax)]
 #![feature(placement_new_protocol)]
+#![feature(range_argument)]
 #![feature(rustc_attrs)]
 #![feature(shared)]
 #![feature(slice_get_slice)]
@@ -204,10 +205,9 @@ trait SpecExtend<I: IntoIterator> {
 }
 
 #[rustc_deprecated(reason = "moved to core::ops", since = "1.22.0")]
+#[unstable(feature = "range_argument", issue = "30877")]
 pub use core::ops::Bound;
 
-pub use oom::oom;
-
 #[doc(no_inline)]
 pub use binary_heap::BinaryHeap;
 #[doc(no_inline)]

src/liballoc/string.rs

@@ -1375,6 +1375,7 @@ impl String {
         // Because the range removal happens in Drop, if the Drain iterator is leaked,
         // the removal will not happen.
         let len = self.len();
+        let range = range.into();
         let start = match range.start {
             Included(n) => n,
             Excluded(n) => n + 1,
@@ -1429,25 +1430,24 @@ impl String {
     /// assert_eq!(s, "Α is capital alpha; β is beta");
     /// ```
     #[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-    pub fn splice<'a, 'b, R>(&'a mut self, range: R, replace_with: &'b str) -> Splice<'a, 'b>
+    pub fn splice<'a, 'b, R>(&'a mut self, range: R, replace_with: &'b str)
         where R: Into<RangeBounds<usize>>
     {
         // Memory safety
         //
         // The String version of Splice does not have the memory safety issues
         // of the vector version. The data is just plain bytes.
-        // Because the range removal happens in Drop, if the Splice iterator is leaked,
-        // the removal will not happen.
-        let len = self.len();
-        let start = match range.start {
-             Included(n) => n,
-             Excluded(n) => n + 1,
-             Unbounded => 0,
+
+        let range = range.into();
+        match range.start {
+             Included(n) => assert!(self.is_char_boundary(n)),
+             Excluded(n) => assert!(self.is_char_boundary(n + 1)),
+             Unbounded => {},
         };
-        let end = match range.end {
-             Included(n) => n + 1,
-             Excluded(n) => n,
-             Unbounded => len,
+        match range.end {
+             Included(n) => assert!(self.is_char_boundary(n + 1)),
+             Excluded(n) => assert!(self.is_char_boundary(n)),
+             Unbounded => {},
         };
 
         unsafe {

src/liballoc/tests/btree/map.rs

@@ -9,8 +9,8 @@
 // except according to those terms.
 
 use std::collections::BTreeMap;
-use std::collections::Bound::{self, Excluded, Included, Unbounded};
 use std::collections::btree_map::Entry::{Occupied, Vacant};
+use std::ops::Bound::{self, Excluded, Included, Unbounded};
 use std::rc::Rc;
 
 use std::iter::FromIterator;
@@ -262,7 +262,7 @@ fn test_range_1000() {
     let size = 1000;
     let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
-    fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
+    fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<u32>, max: Bound<u32>) {
         let mut kvs = map.range((min, max)).map(|(&k, &v)| (k, v));
         let mut pairs = (0..size).map(|i| (i, i));
 
@@ -272,11 +272,11 @@ fn test_range_1000() {
         assert_eq!(kvs.next(), None);
         assert_eq!(pairs.next(), None);
     }
-    test(&map, size, Included(&0), Excluded(&size));
-    test(&map, size, Unbounded, Excluded(&size));
-    test(&map, size, Included(&0), Included(&(size - 1)));
-    test(&map, size, Unbounded, Included(&(size - 1)));
-    test(&map, size, Included(&0), Unbounded);
+    test(&map, size, Included(0), Excluded(size));
+    test(&map, size, Unbounded, Excluded(size));
+    test(&map, size, Included(0), Included(size - 1));
+    test(&map, size, Unbounded, Included(size - 1));
+    test(&map, size, Included(0), Unbounded);
     test(&map, size, Unbounded, Unbounded);
 }
 
@@ -288,7 +288,7 @@ fn test_range_borrowed_key() {
     map.insert("coyote".to_string(), 3);
     map.insert("dingo".to_string(), 4);
     // NOTE: would like to use simply "b".."d" here...
-    let mut iter = map.range::<str, _>((Included("b"),Excluded("d")));
+    let mut iter = map.range::<String, _>((Included("b".to_string()),Excluded("d".to_string())));
     assert_eq!(iter.next(), Some((&"baboon".to_string(), &2)));
     assert_eq!(iter.next(), Some((&"coyote".to_string(), &3)));
     assert_eq!(iter.next(), None);
@@ -301,7 +301,7 @@ fn test_range() {
 
     for i in 0..size {
         for j in i..size {
-            let mut kvs = map.range((Included(&i), Included(&j))).map(|(&k, &v)| (k, v));
+            let mut kvs = map.range((Included(i), Included(j))).map(|(&k, &v)| (k, v));
             let mut pairs = (i..j + 1).map(|i| (i, i));
 
             for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
@@ -320,7 +320,7 @@ fn test_range_mut() {
 
     for i in 0..size {
         for j in i..size {
-            let mut kvs = map.range_mut((Included(&i), Included(&j))).map(|(&k, &mut v)| (k, v));
+            let mut kvs = map.range_mut((Included(i), Included(j))).map(|(&k, &mut v)| (k, v));
             let mut pairs = (i..j + 1).map(|i| (i, i));
 
             for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {

src/liballoc/vec.rs

@@ -1101,6 +1101,7 @@ impl<T> Vec<T> {
         // the hole, and the vector length is restored to the new length.
         //
         let len = self.len();
+        let range = range.into();
         let start = match range.start {
             Included(n) => n,
             Excluded(n) => n + 1,

src/liballoc/vec_deque.rs

@@ -856,6 +856,7 @@ impl<T> VecDeque<T> {
         // and the head/tail values will be restored correctly.
         //
         let len = self.len();
+        let range = range.into();
         let start = match range.start {
             Included(n) => n,
             Excluded(n) => n + 1,

src/libcollections/lib.rs

@@ -24,7 +24,6 @@
 #![deny(warnings)]
 
 #![feature(alloc)]
-#![feature(collections_range)]
 #![feature(macro_reexport)]
 #![feature(staged_api)]
 
@@ -33,13 +32,12 @@
 //! See [`std::collections`](../std/collections/index.html) for a detailed
 //! discussion of collections in Rust.
 
-extern crate core;
-
 #[macro_reexport(vec, format)]
 extern crate alloc;
 
 #[rustc_deprecated(reason = "moved to core::ops", since = "1.22.0")]
-pub use core::ops::range;
+#[unstable(feature = "range_argument", issue = "30877")]
+pub mod range { }
 
 pub use alloc::Bound;
 

src/libcore/ops/range.rs

@@ -389,22 +389,21 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
 /// `Bound`s are range endpoints:
 ///
 /// ```
-/// #![feature(collections_range)]
+/// # #![feature(range_argument)]
+/// use std::ops::RangeBounds;
+/// use std::ops::Bound::*;
 ///
-/// use std::collections::range::RangeArgument;
-/// use std::collections::Bound::*;
-///
-/// assert_eq!((..100).start(), Unbounded);
-/// assert_eq!((1..12).start(), Included(&1));
-/// assert_eq!((1..12).end(), Excluded(&12));
+/// assert_eq!(Into::<RangeBounds<i32>>::into((..100)).start, Unbounded);
+/// assert_eq!(Into::<RangeBounds<i32>>::into((1..12)).start, Included(1));
+/// assert_eq!(Into::<RangeBounds<i32>>::into((1..12)).end, Excluded(12));
 /// ```
 ///
 /// Using a tuple of `Bound`s as an argument to [`BTreeMap::range`].
 /// Note that in most cases, it's better to use range syntax (`1..5`) instead.
 ///
 /// ```
 /// use std::collections::BTreeMap;
-/// use std::collections::Bound::{Excluded, Included, Unbounded};
+/// use std::ops::Bound::{Excluded, Included, Unbounded};
 ///
 /// let mut map = BTreeMap::new();
 /// map.insert(3, "a");
@@ -418,7 +417,7 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
 /// assert_eq!(Some((&3, &"a")), map.range((Unbounded, Included(5))).next());
 /// ```
 ///
-/// [`BTreeMap::range`]: btree_map/struct.BTreeMap.html#method.range
+/// [`BTreeMap::range`]: ../std/collections/struct.BTreeMap.html#method.range
 #[stable(feature = "collections_bound", since = "1.17.0")]
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum Bound<T> {

src/librustc_data_structures/array_vec.rs

@@ -118,6 +118,7 @@ impl<A: Array> ArrayVec<A> {
         // the hole, and the vector length is restored to the new length.
         //
         let len = self.len();
+        let range = range.into();
         let start = match range.start {
             Included(n) => n,
             Excluded(n) => n + 1,

src/librustc_data_structures/indexed_vec.rs

@@ -152,7 +152,7 @@ impl<I: Idx, T> IndexVec<I, T> {
     }
 
     #[inline]
-    pub fn drain_enumerated<'a, R: RangeArgument<usize>>(
+    pub fn drain_enumerated<'a, R: Into<RangeBounds<usize>>> (
         &'a mut self, range: R) -> impl Iterator<Item=(I, T)> + 'a {
         self.raw.drain(range).enumerate().map(IntoIdx { _marker: PhantomData })
     }

src/librustc_data_structures/lib.rs

@@ -22,14 +22,14 @@
 #![deny(warnings)]
 
 #![feature(shared)]
-#![feature(collections_range)]
 #![feature(nonzero)]
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
 #![feature(unsize)]
 #![feature(i128_type)]
 #![feature(conservative_impl_trait)]
 #![feature(specialization)]
+#![feature(range_argument)]
 
 #![cfg_attr(unix, feature(libc))]
 #![cfg_attr(test, feature(test))]

src/libstd/collections/mod.rs

@@ -436,7 +436,9 @@ pub use self::hash_map::HashMap;
 pub use self::hash_set::HashSet;
 
 #[rustc_deprecated(reason = "moved to std::ops", since = "1.22.0")]
-pub use std::ops::range;
+#[unstable(feature = "range_argument", issue = "30877")]
+/// `RangeArgument` is deprecated and moved to std::ops
+pub mod range { }
 
 mod hash;
 

src/test/run-pass/sync-send-iterators-in-libcollections.rs

@@ -50,11 +50,11 @@ fn main() {
     all_sync_send!(BinaryHeap::<usize>::new(), iter, drain, into_iter);
 
     all_sync_send!(BTreeMap::<usize, usize>::new(), iter, iter_mut, into_iter, keys, values);
-    is_sync_send!(BTreeMap::<usize, usize>::new(), range((Included(&0), Included(&9))));
-    is_sync_send!(BTreeMap::<usize, usize>::new(), range_mut((Included(&0), Included(&9))));
+    is_sync_send!(BTreeMap::<usize, usize>::new(), range((Included(0), Included(9))));
+    is_sync_send!(BTreeMap::<usize, usize>::new(), range_mut((Included(0), Included(9))));
 
     all_sync_send!(BTreeSet::<usize>::new(), iter, into_iter);
-    is_sync_send!(BTreeSet::<usize>::new(), range((Included(&0), Included(&9))));
+    is_sync_send!(BTreeSet::<usize>::new(), range((Included(0), Included(9))));
     is_sync_send!(BTreeSet::<usize>::new(), difference(&BTreeSet::<usize>::new()));
     is_sync_send!(BTreeSet::<usize>::new(), symmetric_difference(&BTreeSet::<usize>::new()));
     is_sync_send!(BTreeSet::<usize>::new(), intersection(&BTreeSet::<usize>::new()));