diff --git a/src/liballoc/btree/map.rs b/src/liballoc/btree/map.rs
index a51c70159db4d..7c51273a43119 100644
--- a/src/liballoc/btree/map.rs
+++ b/src/liballoc/btree/map.rs
@@ -13,12 +13,11 @@ use core::fmt::Debug;
 use core::hash::{Hash, Hasher};
 use core::iter::{FromIterator, Peekable, FusedIterator};
 use core::marker::PhantomData;
-use core::ops::Index;
+use core::ops::{Index, RangeBounds};
+use core::ops::Bound::{Excluded, Included, Unbounded};
 use core::{fmt, intrinsics, mem, ptr};
 
 use borrow::Borrow;
-use Bound::{Excluded, Included, Unbounded};
-use range::RangeArgument;
 
 use super::node::{self, Handle, NodeRef, marker};
 use super::search;
@@ -790,11 +789,11 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// ```
     #[stable(feature = "btree_range", since = "1.17.0")]
     pub fn range<T: ?Sized, R>(&self, range: R) -> Range<K, V>
-        where T: Ord, K: Borrow<T>, R: RangeArgument<T>
+        where T: Ord, K: Borrow<T>, R: Into<RangeBounds<T>>
     {
         let root1 = self.root.as_ref();
         let root2 = self.root.as_ref();
-        let (f, b) = range_search(root1, root2, range);
+        let (f, b) = range_search(root1, root2, range.into());
 
         Range { front: f, back: b}
     }
@@ -830,11 +829,11 @@ 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>
-        where T: Ord, K: Borrow<T>, R: RangeArgument<T>
+        where T: Ord, K: Borrow<T>, R: Into<RangeBounds<T>>
     {
         let root1 = self.root.as_mut();
         let root2 = unsafe { ptr::read(&root1) };
-        let (f, b) = range_search(root1, root2, range);
+        let (f, b) = range_search(root1, root2, range.into());
 
         RangeMut {
             front: f,
@@ -1780,15 +1779,15 @@ fn last_leaf_edge<BorrowType, K, V>
     }
 }
 
-fn range_search<BorrowType, K, V, Q: ?Sized, R: RangeArgument<Q>>(
+fn range_search<BorrowType, K, V, Q: ?Sized>(
     root1: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,
     root2: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,
-    range: R
+    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()) {
+    match (range.start, range.end) {
         (Excluded(s), Excluded(e)) if s==e =>
             panic!("range start and end are equal and excluded in BTreeMap"),
         (Included(s), Included(e)) |
diff --git a/src/liballoc/btree/set.rs b/src/liballoc/btree/set.rs
index d32460da93923..cdfaa53e8cc32 100644
--- a/src/liballoc/btree/set.rs
+++ b/src/liballoc/btree/set.rs
@@ -16,12 +16,11 @@ use core::cmp::{min, max};
 use core::fmt::Debug;
 use core::fmt;
 use core::iter::{Peekable, FromIterator, FusedIterator};
-use core::ops::{BitOr, BitAnd, BitXor, Sub};
+use core::ops::{BitOr, BitAnd, BitXor, Sub, RangeBounds};
 
 use borrow::Borrow;
 use btree_map::{BTreeMap, Keys};
 use super::Recover;
-use range::RangeArgument;
 
 // FIXME(conventions): implement bounded iterators
 
@@ -289,9 +288,9 @@ impl<T: Ord> BTreeSet<T> {
     /// ```
     #[stable(feature = "btree_range", since = "1.17.0")]
     pub fn range<K: ?Sized, R>(&self, range: R) -> Range<T>
-        where K: Ord, T: Borrow<K>, R: RangeArgument<K>
+        where K: Ord, T: Borrow<K>, R: Into<RangeBounds<K>>
     {
-        Range { iter: self.map.range(range) }
+        Range { iter: self.map.range(range.into()) }
     }
 }
 
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index 23da29131362e..9f4b55ae8d071 100644
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -202,57 +202,6 @@ mod std {
     pub use core::ops;      // RangeFull
 }
 
-/// An endpoint of a range of keys.
-///
-/// # Examples
-///
-/// `Bound`s are range endpoints:
-///
-/// ```
-/// #![feature(collections_range)]
-///
-/// 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));
-/// ```
-///
-/// 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};
-///
-/// let mut map = BTreeMap::new();
-/// map.insert(3, "a");
-/// map.insert(5, "b");
-/// map.insert(8, "c");
-///
-/// for (key, value) in map.range((Excluded(3), Included(8))) {
-///     println!("{}: {}", key, value);
-/// }
-///
-/// assert_eq!(Some((&3, &"a")), map.range((Unbounded, Included(5))).next());
-/// ```
-///
-/// [`BTreeMap::range`]: btree_map/struct.BTreeMap.html#method.range
-#[stable(feature = "collections_bound", since = "1.17.0")]
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
-pub enum Bound<T> {
-    /// An inclusive bound.
-    #[stable(feature = "collections_bound", since = "1.17.0")]
-    Included(T),
-    /// An exclusive bound.
-    #[stable(feature = "collections_bound", since = "1.17.0")]
-    Excluded(T),
-    /// An infinite endpoint. Indicates that there is no bound in this direction.
-    #[stable(feature = "collections_bound", since = "1.17.0")]
-    Unbounded,
-}
-
 /// An intermediate trait for specialization of `Extend`.
 #[doc(hidden)]
 trait SpecExtend<I: IntoIterator> {
@@ -260,6 +209,10 @@ trait SpecExtend<I: IntoIterator> {
     fn spec_extend(&mut self, iter: I);
 }
 
+#[rustc_deprecated(reason = "moved to core::ops", since = "1.19.0")]
+#[allow(deprecated)]
+pub use core::ops::Bound;
+
 pub use oom::oom;
 
 #[doc(no_inline)]
diff --git a/src/liballoc/range.rs b/src/liballoc/range.rs
index f862da0d61e01..12d1cb76392d9 100644
--- a/src/liballoc/range.rs
+++ b/src/liballoc/range.rs
@@ -11,142 +11,7 @@
 #![unstable(feature = "collections_range",
             reason = "waiting for dust to settle on inclusive ranges",
             issue = "30877")]
+#![rustc_deprecated(reason = "moved to core::ops", since = "1.19.0")]
 
 //! Range syntax.
-
-use core::ops::{RangeFull, Range, RangeTo, RangeFrom, RangeInclusive, RangeToInclusive};
-use Bound::{self, Excluded, Included, Unbounded};
-
-/// `RangeArgument` is implemented by Rust's built-in range types, produced
-/// by range syntax like `..`, `a..`, `..b` or `c..d`.
-pub trait RangeArgument<T: ?Sized> {
-    /// Start index bound.
-    ///
-    /// Returns the start value as a `Bound`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(alloc)]
-    /// #![feature(collections_range)]
-    ///
-    /// extern crate alloc;
-    ///
-    /// # fn main() {
-    /// use alloc::range::RangeArgument;
-    /// use alloc::Bound::*;
-    ///
-    /// assert_eq!((..10).start(), Unbounded);
-    /// assert_eq!((3..10).start(), Included(&3));
-    /// # }
-    /// ```
-    fn start(&self) -> Bound<&T>;
-
-    /// End index bound.
-    ///
-    /// Returns the end value as a `Bound`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(alloc)]
-    /// #![feature(collections_range)]
-    ///
-    /// extern crate alloc;
-    ///
-    /// # fn main() {
-    /// use alloc::range::RangeArgument;
-    /// use alloc::Bound::*;
-    ///
-    /// assert_eq!((3..).end(), Unbounded);
-    /// assert_eq!((3..10).end(), Excluded(&10));
-    /// # }
-    /// ```
-    fn end(&self) -> Bound<&T>;
-}
-
-// FIXME add inclusive ranges to RangeArgument
-
-impl<T: ?Sized> RangeArgument<T> for RangeFull {
-    fn start(&self) -> Bound<&T> {
-        Unbounded
-    }
-    fn end(&self) -> Bound<&T> {
-        Unbounded
-    }
-}
-
-impl<T> RangeArgument<T> for RangeFrom<T> {
-    fn start(&self) -> Bound<&T> {
-        Included(&self.start)
-    }
-    fn end(&self) -> Bound<&T> {
-        Unbounded
-    }
-}
-
-impl<T> RangeArgument<T> for RangeTo<T> {
-    fn start(&self) -> Bound<&T> {
-        Unbounded
-    }
-    fn end(&self) -> Bound<&T> {
-        Excluded(&self.end)
-    }
-}
-
-impl<T> RangeArgument<T> for Range<T> {
-    fn start(&self) -> Bound<&T> {
-        Included(&self.start)
-    }
-    fn end(&self) -> Bound<&T> {
-        Excluded(&self.end)
-    }
-}
-
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> RangeArgument<T> for RangeInclusive<T> {
-    fn start(&self) -> Bound<&T> {
-        Included(&self.start)
-    }
-    fn end(&self) -> Bound<&T> {
-        Included(&self.end)
-    }
-}
-
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> RangeArgument<T> for RangeToInclusive<T> {
-    fn start(&self) -> Bound<&T> {
-        Unbounded
-    }
-    fn end(&self) -> Bound<&T> {
-        Included(&self.end)
-    }
-}
-
-impl<T> RangeArgument<T> for (Bound<T>, Bound<T>) {
-    fn start(&self) -> Bound<&T> {
-        match *self {
-            (Included(ref start), _) => Included(start),
-            (Excluded(ref start), _) => Excluded(start),
-            (Unbounded, _)           => Unbounded,
-        }
-    }
-
-    fn end(&self) -> Bound<&T> {
-        match *self {
-            (_, Included(ref end)) => Included(end),
-            (_, Excluded(ref end)) => Excluded(end),
-            (_, Unbounded)         => Unbounded,
-        }
-    }
-}
-
-impl<'a, T: ?Sized + 'a> RangeArgument<T> for (Bound<&'a T>, Bound<&'a T>) {
-    fn start(&self) -> Bound<&T> {
-        self.0
-    }
-
-    fn end(&self) -> Bound<&T> {
-        self.1
-    }
-}
+use core::ops::RangeBounds;
diff --git a/src/liballoc/string.rs b/src/liballoc/string.rs
index 79d1ccf637d37..bdd28d2050dcc 100644
--- a/src/liballoc/string.rs
+++ b/src/liballoc/string.rs
@@ -59,15 +59,14 @@
 use core::fmt;
 use core::hash;
 use core::iter::{FromIterator, FusedIterator};
-use core::ops::{self, Add, AddAssign, Index, IndexMut};
+use core::ops::{self, Add, AddAssign, Index, IndexMut, RangeBounds};
+use core::ops::Bound::{Excluded, Included, Unbounded};
 use core::ptr;
 use core::str::pattern::Pattern;
 use std_unicode::lossy;
 use std_unicode::char::{decode_utf16, REPLACEMENT_CHARACTER};
 
 use borrow::{Cow, ToOwned};
-use range::RangeArgument;
-use Bound::{Excluded, Included, Unbounded};
 use str::{self, from_boxed_utf8_unchecked, FromStr, Utf8Error, Chars};
 use vec::Vec;
 use boxed::Box;
@@ -1270,7 +1269,7 @@ impl String {
     /// ```
     #[stable(feature = "drain", since = "1.6.0")]
     pub fn drain<R>(&mut self, range: R) -> Drain
-        where R: RangeArgument<usize>
+        where R: Into<RangeBounds<usize>>
     {
         // Memory safety
         //
@@ -1279,14 +1278,14 @@ 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 start = match range.start() {
-            Included(&n) => n,
-            Excluded(&n) => n + 1,
+        let start = match range.start {
+            Included(n) => n,
+            Excluded(n) => n + 1,
             Unbounded => 0,
         };
-        let end = match range.end() {
-            Included(&n) => n + 1,
-            Excluded(&n) => n,
+        let end = match range.end {
+            Included(n) => n + 1,
+            Excluded(n) => n,
             Unbounded => len,
         };
 
@@ -1334,7 +1333,7 @@ impl String {
     /// ```
     #[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>
-        where R: RangeArgument<usize>
+        where R: Into<RangeBounds<usize>>
     {
         // Memory safety
         //
@@ -1343,14 +1342,14 @@ impl String {
         // 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,
+        let start = match range.start {
+             Included(n) => n,
+             Excluded(n) => n + 1,
              Unbounded => 0,
         };
-        let end = match range.end() {
-             Included(&n) => n + 1,
-             Excluded(&n) => n,
+        let end = match range.end {
+             Included(n) => n + 1,
+             Excluded(n) => n,
              Unbounded => len,
         };
 
diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs
index 5d1999a42629a..8c1fbdba57de1 100644
--- a/src/liballoc/vec.rs
+++ b/src/liballoc/vec.rs
@@ -74,7 +74,8 @@ use core::iter::{FromIterator, FusedIterator, TrustedLen};
 use core::mem;
 #[cfg(not(test))]
 use core::num::Float;
-use core::ops::{InPlace, Index, IndexMut, Place, Placer};
+use core::ops::{InPlace, Index, IndexMut, Place, Placer, RangeBounds};
+use core::ops::Bound::{Excluded, Included, Unbounded};
 use core::ops;
 use core::ptr;
 use core::ptr::Shared;
@@ -84,8 +85,6 @@ use borrow::ToOwned;
 use borrow::Cow;
 use boxed::Box;
 use raw_vec::RawVec;
-use super::range::RangeArgument;
-use Bound::{Excluded, Included, Unbounded};
 
 /// A contiguous growable array type, written `Vec<T>` but pronounced 'vector'.
 ///
@@ -1086,7 +1085,7 @@ impl<T> Vec<T> {
     /// ```
     #[stable(feature = "drain", since = "1.6.0")]
     pub fn drain<R>(&mut self, range: R) -> Drain<T>
-        where R: RangeArgument<usize>
+        where R: Into<RangeBounds<usize>>
     {
         // Memory safety
         //
@@ -1099,14 +1098,14 @@ impl<T> Vec<T> {
         // the hole, and the vector length is restored to the new length.
         //
         let len = self.len();
-        let start = match range.start() {
-            Included(&n) => n,
-            Excluded(&n) => n + 1,
+        let start = match range.start {
+            Included(n) => n,
+            Excluded(n) => n + 1,
             Unbounded    => 0,
         };
-        let end = match range.end() {
-            Included(&n) => n + 1,
-            Excluded(&n) => n,
+        let end = match range.end {
+            Included(n) => n + 1,
+            Excluded(n) => n,
             Unbounded    => len,
         };
         assert!(start <= end);
@@ -1949,7 +1948,7 @@ impl<T> Vec<T> {
     #[inline]
     #[unstable(feature = "splice", reason = "recently added", issue = "32310")]
     pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<I::IntoIter>
-        where R: RangeArgument<usize>, I: IntoIterator<Item=T>
+        where R: Into<RangeBounds<usize>>, I: IntoIterator<Item=T>
     {
         Splice {
             drain: self.drain(range),
diff --git a/src/liballoc/vec_deque.rs b/src/liballoc/vec_deque.rs
index 18175a5d01bd2..f47a5535f0393 100644
--- a/src/liballoc/vec_deque.rs
+++ b/src/liballoc/vec_deque.rs
@@ -21,7 +21,8 @@ use core::cmp::Ordering;
 use core::fmt;
 use core::iter::{repeat, FromIterator, FusedIterator};
 use core::mem;
-use core::ops::{Index, IndexMut, Place, Placer, InPlace};
+use core::ops::{Index, IndexMut, Place, Placer, InPlace, RangeBounds};
+use core::ops::Bound::{Excluded, Included, Unbounded};
 use core::ptr;
 use core::ptr::Shared;
 use core::slice;
@@ -31,8 +32,6 @@ use core::cmp;
 
 use raw_vec::RawVec;
 
-use super::range::RangeArgument;
-use Bound::{Excluded, Included, Unbounded};
 use super::vec::Vec;
 
 const INITIAL_CAPACITY: usize = 7; // 2^3 - 1
@@ -842,7 +841,7 @@ impl<T> VecDeque<T> {
     #[inline]
     #[stable(feature = "drain", since = "1.6.0")]
     pub fn drain<R>(&mut self, range: R) -> Drain<T>
-        where R: RangeArgument<usize>
+        where R: Into<RangeBounds<usize>>
     {
         // Memory safety
         //
@@ -855,14 +854,14 @@ impl<T> VecDeque<T> {
         // and the head/tail values will be restored correctly.
         //
         let len = self.len();
-        let start = match range.start() {
-            Included(&n) => n,
-            Excluded(&n) => n + 1,
+        let start = match range.start {
+            Included(n) => n,
+            Excluded(n) => n + 1,
             Unbounded    => 0,
         };
-        let end = match range.end() {
-            Included(&n) => n + 1,
-            Excluded(&n) => n,
+        let end = match range.end {
+            Included(n) => n + 1,
+            Excluded(n) => n,
             Unbounded    => len,
         };
         assert!(start <= end, "drain lower bound was too large");
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index de5d6df328cbd..0a939831622f5 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -46,6 +46,7 @@ pub use alloc::binary_heap;
 pub use alloc::borrow;
 pub use alloc::fmt;
 pub use alloc::linked_list;
+#[allow(deprecated)]
 pub use alloc::range;
 pub use alloc::slice;
 pub use alloc::str;
diff --git a/src/libcore/ops/mod.rs b/src/libcore/ops/mod.rs
index a78f4fe28a6b4..bedcc9e15e227 100644
--- a/src/libcore/ops/mod.rs
+++ b/src/libcore/ops/mod.rs
@@ -186,6 +186,12 @@ pub use self::range::{Range, RangeFrom, RangeFull, RangeTo};
 #[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
 pub use self::range::{RangeInclusive, RangeToInclusive};
 
+#[stable(feature = "collections_bound", since = "1.17.0")]
+pub use self::range::Bound;
+
+#[unstable(feature = "range_argument", issue = "30877")]
+pub use self::range::RangeBounds;
+
 #[unstable(feature = "try_trait", issue = "42327")]
 pub use self::try::Try;
 
diff --git a/src/libcore/ops/range.rs b/src/libcore/ops/range.rs
index 33258b7a875c5..8d2ee44579edd 100644
--- a/src/libcore/ops/range.rs
+++ b/src/libcore/ops/range.rs
@@ -365,3 +365,129 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
 
 // RangeToInclusive<Idx> cannot impl From<RangeTo<Idx>>
 // because underflow would be possible with (..0).into()
+
+/// An endpoint of a range of keys.
+///
+/// # Examples
+///
+/// `Bound`s are range endpoints:
+///
+/// ```
+/// #![feature(collections_range)]
+///
+/// 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));
+/// ```
+///
+/// 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};
+///
+/// let mut map = BTreeMap::new();
+/// map.insert(3, "a");
+/// map.insert(5, "b");
+/// map.insert(8, "c");
+///
+/// for (key, value) in map.range((Excluded(3), Included(8))) {
+///     println!("{}: {}", key, value);
+/// }
+///
+/// assert_eq!(Some((&3, &"a")), map.range((Unbounded, Included(5))).next());
+/// ```
+///
+/// [`BTreeMap::range`]: btree_map/struct.BTreeMap.html#method.range
+#[stable(feature = "collections_bound", since = "1.17.0")]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+pub enum Bound<T> {
+    /// An inclusive bound.
+    #[stable(feature = "collections_bound", since = "1.17.0")]
+    Included(
+        #[stable(feature = "collections_bound", since = "1.17.0")]
+        T
+    ),
+    /// An exclusive bound.
+    #[stable(feature = "collections_bound", since = "1.17.0")]
+    Excluded(
+        #[stable(feature = "collections_bound", since = "1.17.0")]
+        T
+    ),
+    /// An infinite endpoint. Indicates that there is no bound in this direction.
+    #[stable(feature = "collections_bound", since = "1.17.0")]
+    Unbounded,
+}
+use self::Bound::{Included, Excluded, Unbounded};
+
+
+/// Rust's built-in range types can be converted to `RangeBounds`.
+#[unstable(feature = "range_argument", issue = "30877")]
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+pub struct RangeBounds<T> {
+    /// The lower bound of the range.
+    pub start: Bound<T>,
+
+    /// The upper bound of the range.
+    pub end: Bound<T>,
+}
+impl<T> RangeBounds<T> {
+    /// Constructs a pair of range bounds.
+    #[unstable(feature = "range_argument", issue = "30877")]
+    pub fn new(start: Bound<T>, end: Bound<T>) -> RangeBounds<T> {
+        RangeBounds { start, end }
+    }
+}
+
+#[unstable(feature = "range_argument", issue = "30877")]
+impl<T> From<RangeFull> for RangeBounds<T> {
+    fn from(_: RangeFull) -> RangeBounds<T> {
+        RangeBounds::new(Unbounded, Unbounded)
+    }
+}
+
+#[unstable(feature = "range_argument", issue = "30877")]
+impl<T> From<RangeFrom<T>> for RangeBounds<T> {
+    fn from(range: RangeFrom<T>) -> RangeBounds<T> {
+        RangeBounds::new(Included(range.start), Unbounded)
+    }
+}
+
+#[unstable(feature = "range_argument", issue = "30877")]
+impl<T> From<RangeTo<T>> for RangeBounds<T> {
+    fn from(range: RangeTo<T>) -> RangeBounds<T> {
+        RangeBounds::new(Unbounded, Excluded(range.end))
+    }
+}
+
+#[unstable(feature = "range_argument", issue = "30877")]
+impl<T> From<Range<T>> for RangeBounds<T> {
+    fn from(range: Range<T>) -> RangeBounds<T> {
+        RangeBounds::new(Included(range.start), Excluded(range.end))
+    }
+}
+
+#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
+impl<T> From<RangeInclusive<T>> for RangeBounds<T> {
+    fn from(range: RangeInclusive<T>) -> RangeBounds<T> {
+        RangeBounds::new(Included(range.start), Included(range.end))
+    }
+}
+
+#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
+impl<T> From<RangeToInclusive<T>> for RangeBounds<T> {
+    fn from(range: RangeToInclusive<T>) -> RangeBounds<T> {
+        RangeBounds::new(Unbounded, Included(range.end))
+    }
+}
+
+#[unstable(feature = "range_argument", issue = "30877")]
+impl<T> From<(Bound<T>, Bound<T>)> for RangeBounds<T> {
+    fn from((start, end): (Bound<T>, Bound<T>)) -> RangeBounds<T> {
+        RangeBounds::new(start, end)
+    }
+}
diff --git a/src/librustc_data_structures/accumulate_vec.rs b/src/librustc_data_structures/accumulate_vec.rs
index c03c2890ba34c..d9a97cba82ece 100644
--- a/src/librustc_data_structures/accumulate_vec.rs
+++ b/src/librustc_data_structures/accumulate_vec.rs
@@ -15,11 +15,10 @@
 //!
 //! The N above is determined by Array's implementor, by way of an associatated constant.
 
-use std::ops::{Deref, DerefMut};
+use std::ops::{Deref, DerefMut, RangeBounds};
 use std::iter::{self, IntoIterator, FromIterator};
 use std::slice;
 use std::vec;
-use std::collections::range::RangeArgument;
 
 use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
 
@@ -74,7 +73,7 @@ impl<A: Array> AccumulateVec<A> {
     }
 
     pub fn drain<R>(&mut self, range: R) -> Drain<A>
-        where R: RangeArgument<usize>
+        where R: Into<RangeBounds<usize>>
     {
         match *self {
             AccumulateVec::Array(ref mut v) => {
diff --git a/src/librustc_data_structures/array_vec.rs b/src/librustc_data_structures/array_vec.rs
index 078bb801751d0..5f43bf71273e5 100644
--- a/src/librustc_data_structures/array_vec.rs
+++ b/src/librustc_data_structures/array_vec.rs
@@ -13,13 +13,12 @@
 use std::marker::Unsize;
 use std::iter::Extend;
 use std::ptr::{self, drop_in_place, Shared};
-use std::ops::{Deref, DerefMut, Range};
+use std::ops::{Deref, DerefMut, Range, RangeBounds};
+use std::ops::Bound::{Excluded, Included, Unbounded};
 use std::hash::{Hash, Hasher};
 use std::slice;
 use std::fmt;
 use std::mem;
-use std::collections::range::RangeArgument;
-use std::collections::Bound::{Excluded, Included, Unbounded};
 use std::mem::ManuallyDrop;
 
 pub unsafe trait Array {
@@ -106,7 +105,7 @@ impl<A: Array> ArrayVec<A> {
     }
 
     pub fn drain<R>(&mut self, range: R) -> Drain<A>
-        where R: RangeArgument<usize>
+        where R: Into<RangeBounds<usize>>
     {
         // Memory safety
         //
@@ -119,14 +118,14 @@ impl<A: Array> ArrayVec<A> {
         // the hole, and the vector length is restored to the new length.
         //
         let len = self.len();
-        let start = match range.start() {
-            Included(&n) => n,
-            Excluded(&n) => n + 1,
+        let start = match range.start {
+            Included(n) => n,
+            Excluded(n) => n + 1,
             Unbounded    => 0,
         };
-        let end = match range.end() {
-            Included(&n) => n + 1,
-            Excluded(&n) => n,
+        let end = match range.end {
+            Included(n) => n + 1,
+            Excluded(n) => n,
             Unbounded    => len,
         };
         assert!(start <= end);
diff --git a/src/librustc_data_structures/indexed_vec.rs b/src/librustc_data_structures/indexed_vec.rs
index 29ac650aa7053..d4cd2abb29dbc 100644
--- a/src/librustc_data_structures/indexed_vec.rs
+++ b/src/librustc_data_structures/indexed_vec.rs
@@ -8,12 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::range::RangeArgument;
 use std::fmt::Debug;
 use std::iter::{self, FromIterator};
 use std::slice;
 use std::marker::PhantomData;
-use std::ops::{Index, IndexMut, Range};
+use std::ops::{Index, IndexMut, Range, RangeBounds};
 use std::fmt;
 use std::vec;
 use std::u32;
@@ -147,7 +146,7 @@ impl<I: Idx, T> IndexVec<I, T> {
     }
 
     #[inline]
-    pub fn drain<'a, R: RangeArgument<usize>>(
+    pub fn drain<'a, R: Into<RangeBounds<usize>>> (
         &'a mut self, range: R) -> impl Iterator<Item=T> + 'a {
         self.raw.drain(range)
     }
diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index b8a6a66eaa65d..914b5e30b6fac 100644
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -435,7 +435,8 @@ pub use self::hash_map::HashMap;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::hash_set::HashSet;
 
-#[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_deprecated(reason = "moved to std::ops", since = "1.19.0")]
+#[allow(deprecated)]
 pub use alloc::range;
 
 mod hash;