diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 5a1162b5c084a..35591a5e9effb 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -60,7 +60,13 @@ use core::char::CharExt;
 use core::clone::Clone;
 use core::iter::AdditiveIterator;
 use core::iter::{Iterator, IteratorExt};
-use core::ops::{FullRange, Index};
+use core::ops::Index;
+#[cfg(stage0)]
+use core::ops::FullRange as RangeFull;
+#[cfg(stage0)]
+use core::ops::FullRange;
+#[cfg(not(stage0))]
+use core::ops::RangeFull;
 use core::option::Option::{self, Some, None};
 use core::slice::AsSlice;
 use core::str as core_str;
@@ -408,7 +414,7 @@ Section: Trait implementations
 
 /// Any string that can be represented as a slice.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub trait StrExt: Index<FullRange, Output = str> {
+pub trait StrExt: Index<RangeFull, Output = str> {
     /// Escapes each char in `s` with `char::escape_default`.
     #[unstable(feature = "collections",
                reason = "return type may change to be an iterator")]
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index f13e03c5c3622..035529c7365c8 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -877,6 +877,7 @@ impl ops::Index<ops::RangeFrom<uint>> for String {
         &self[][*index]
     }
 }
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl ops::Index<ops::FullRange> for String {
     type Output = str;
@@ -885,6 +886,15 @@ impl ops::Index<ops::FullRange> for String {
         unsafe { mem::transmute(self.vec.as_slice()) }
     }
 }
+#[cfg(not(stage0))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl ops::Index<ops::RangeFull> for String {
+    type Output = str;
+    #[inline]
+    fn index(&self, _index: &ops::RangeFull) -> &str {
+        unsafe { mem::transmute(self.vec.as_slice()) }
+    }
+}
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl ops::Deref for String {
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index ab64bc88550ff..5dd88dbb02524 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1317,6 +1317,7 @@ impl<T> ops::Index<ops::RangeFrom<uint>> for Vec<T> {
         self.as_slice().index(index)
     }
 }
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::Index<ops::FullRange> for Vec<T> {
     type Output = [T];
@@ -1325,6 +1326,15 @@ impl<T> ops::Index<ops::FullRange> for Vec<T> {
         self.as_slice()
     }
 }
+#[cfg(not(stage0))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> ops::Index<ops::RangeFull> for Vec<T> {
+    type Output = [T];
+    #[inline]
+    fn index(&self, _index: &ops::RangeFull) -> &[T] {
+        self.as_slice()
+    }
+}
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::IndexMut<ops::Range<uint>> for Vec<T> {
@@ -1350,6 +1360,7 @@ impl<T> ops::IndexMut<ops::RangeFrom<uint>> for Vec<T> {
         self.as_mut_slice().index_mut(index)
     }
 }
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::IndexMut<ops::FullRange> for Vec<T> {
     type Output = [T];
@@ -1358,6 +1369,15 @@ impl<T> ops::IndexMut<ops::FullRange> for Vec<T> {
         self.as_mut_slice()
     }
 }
+#[cfg(not(stage0))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
+    type Output = [T];
+    #[inline]
+    fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {
+        self.as_mut_slice()
+    }
+}
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::Deref for Vec<T> {
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 55ff3eb4d062d..9e020eeb8a9c1 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -947,11 +947,20 @@ pub trait IndexMut<Index: ?Sized> {
 }
 
 /// An unbounded range.
+#[cfg(stage0)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="full_range"]
 #[unstable(feature = "core", reason  = "may be renamed to RangeFull")]
 pub struct FullRange;
 
+/// An unbounded range.
+#[cfg(not(stage0))]
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[lang="range_full"]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub struct RangeFull;
+
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Debug for FullRange {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
@@ -959,6 +968,14 @@ impl fmt::Debug for FullRange {
     }
 }
 
+#[cfg(not(stage0))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl fmt::Debug for RangeFull {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt("..", fmt)
+    }
+}
+
 /// A (half-open) range which is bounded at both ends.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range"]
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index b1e9084d210f5..40e66db3ae5b0 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -44,6 +44,10 @@ use iter::*;
 use marker::Copy;
 use num::Int;
 use ops::{FnMut, self, Index};
+#[cfg(stage0)]
+use ops::FullRange as RangeFull;
+#[cfg(not(stage0))]
+use ops::RangeFull;
 use option::Option;
 use option::Option::{None, Some};
 use result::Result;
@@ -543,10 +547,10 @@ impl<T> ops::Index<ops::RangeFrom<uint>> for [T] {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::FullRange> for [T] {
+impl<T> ops::Index<RangeFull> for [T] {
     type Output = [T];
     #[inline]
-    fn index(&self, _index: &ops::FullRange) -> &[T] {
+    fn index(&self, _index: &RangeFull) -> &[T] {
         self
     }
 }
@@ -584,10 +588,10 @@ impl<T> ops::IndexMut<ops::RangeFrom<uint>> for [T] {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::FullRange> for [T] {
+impl<T> ops::IndexMut<RangeFull> for [T] {
     type Output = [T];
     #[inline]
-    fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {
+    fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
         self
     }
 }
@@ -750,6 +754,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
     }
 }
 
+#[cfg(stage0)]
 #[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
     type Output = [T];
@@ -758,6 +763,15 @@ impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
         self.as_slice()
     }
 }
+#[cfg(not(stage0))]
+#[unstable(feature = "core")]
+impl<'a, T> ops::Index<RangeFull> for Iter<'a, T> {
+    type Output = [T];
+    #[inline]
+    fn index(&self, _index: &RangeFull) -> &[T] {
+        self.as_slice()
+    }
+}
 
 impl<'a, T> Iter<'a, T> {
     /// View the underlying data as a subslice of the original data.
@@ -821,7 +835,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index(&self, index: &ops::Range<uint>) -> &[T] {
-        self.index(&ops::FullRange).index(index)
+        self.index(&RangeFull).index(index)
     }
 }
 #[unstable(feature = "core")]
@@ -829,7 +843,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
-        self.index(&ops::FullRange).index(index)
+        self.index(&RangeFull).index(index)
     }
 }
 #[unstable(feature = "core")]
@@ -837,14 +851,14 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
-        self.index(&ops::FullRange).index(index)
+        self.index(&RangeFull).index(index)
     }
 }
 #[unstable(feature = "core")]
-impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
+impl<'a, T> ops::Index<RangeFull> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
-    fn index(&self, _index: &ops::FullRange) -> &[T] {
+    fn index(&self, _index: &RangeFull) -> &[T] {
         make_slice!(T => &[T]: self.ptr, self.end)
     }
 }
@@ -854,7 +868,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
-        self.index_mut(&ops::FullRange).index_mut(index)
+        self.index_mut(&RangeFull).index_mut(index)
     }
 }
 #[unstable(feature = "core")]
@@ -862,7 +876,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
-        self.index_mut(&ops::FullRange).index_mut(index)
+        self.index_mut(&RangeFull).index_mut(index)
     }
 }
 #[unstable(feature = "core")]
@@ -870,14 +884,14 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
-        self.index_mut(&ops::FullRange).index_mut(index)
+        self.index_mut(&RangeFull).index_mut(index)
     }
 }
 #[unstable(feature = "core")]
-impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {
+impl<'a, T> ops::IndexMut<RangeFull> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
-    fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {
+    fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {
         make_slice!(T => &mut [T]: self.ptr, self.end)
     }
 }
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 228519656446c..8495a03747e7b 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1249,6 +1249,7 @@ mod traits {
         }
     }
 
+    #[cfg(stage0)]
     #[stable(feature = "rust1", since = "1.0.0")]
     impl ops::Index<ops::FullRange> for str {
         type Output = str;
@@ -1257,6 +1258,15 @@ mod traits {
             self
         }
     }
+    #[cfg(not(stage0))]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    impl ops::Index<ops::RangeFull> for str {
+        type Output = str;
+        #[inline]
+        fn index(&self, _index: &ops::RangeFull) -> &str {
+            self
+        }
+    }
 }
 
 /// Any string that can be represented as a slice
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index c1ce5945946c2..16d2c68ad60a9 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -269,7 +269,7 @@ lets_do_this! {
     RangeStructLangItem,             "range",                   range_struct;
     RangeFromStructLangItem,         "range_from",              range_from_struct;
     RangeToStructLangItem,           "range_to",                range_to_struct;
-    FullRangeStructLangItem,         "full_range",              full_range_struct;
+    RangeFullStructLangItem,         "range_full",              range_full_struct;
 
     UnsafeTypeLangItem,              "unsafe",                  unsafe_type;
 
diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs
index a6c9a988b4d46..1d86fa85d1e9a 100644
--- a/src/librustc_trans/trans/expr.rs
+++ b/src/librustc_trans/trans/expr.rs
@@ -1050,8 +1050,8 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                     (tcx.lang_items.range_to_struct(), fields, vec![node_id_type(bcx, end.id)])
                 }
                 _ => {
-                    // Desugar to FullRange
-                    (tcx.lang_items.full_range_struct(), vec![], vec![])
+                    // Desugar to RangeFull
+                    (tcx.lang_items.range_full_struct(), vec![], vec![])
                 }
             };
 
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 6dabec31e2c6f..31ad1f31417eb 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -4095,8 +4095,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                 }
             }
             None => {
-                // Neither start nor end => FullRange
-                if let Some(did) = tcx.lang_items.full_range_struct() {
+                // Neither start nor end => RangeFull
+                if let Some(did) = tcx.lang_items.range_full_struct() {
                     let substs = Substs::new_type(vec![], vec![]);
                     ty::mk_struct(tcx, did, tcx.mk_substs(substs))
                 } else {
diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs
index 8fdc5547e46b1..18e2aa8c098a7 100644
--- a/src/libstd/ffi/os_str.rs
+++ b/src/libstd/ffi/os_str.rs
@@ -82,6 +82,7 @@ impl OsString {
     }
 }
 
+#[cfg(stage0)]
 impl ops::Index<ops::FullRange> for OsString {
     type Output = OsStr;
 
@@ -91,6 +92,16 @@ impl ops::Index<ops::FullRange> for OsString {
     }
 }
 
+#[cfg(not(stage0))]
+impl ops::Index<ops::RangeFull> for OsString {
+    type Output = OsStr;
+
+    #[inline]
+    fn index(&self, _index: &ops::RangeFull) -> &OsStr {
+        unsafe { mem::transmute(self.inner.as_slice()) }
+    }
+}
+
 impl ops::Deref for OsString {
     type Target = OsStr;
 
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index b42353e964c51..b5409da9c9ca4 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -68,6 +68,7 @@ use fmt;
 use iter::IteratorExt;
 use option::Option;
 use option::Option::{None, Some};
+#[cfg(stage0)]
 use ops::FullRange;
 use str;
 use str::StrExt;
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 2e6b9d50553fa..88db27013ac83 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -25,6 +25,7 @@ use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map, repeat};
 use mem;
 use option::Option::{self, Some, None};
+#[cfg(stage0)]
 use ops::FullRange;
 use slice::{SliceExt, SliceConcatExt};
 use str::{SplitTerminator, FromStr, StrExt};
diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index 51c9f9de83cc8..b3c4ffa5120e8 100644
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -18,7 +18,7 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
 
-// TEMPORARY
+#[cfg(stage0)]
 #[unstable(feature = "std_misc")]
 #[doc(no_inline)] pub use ops::FullRange;
 
diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs
index bc0721550634c..fdcb0c19f30af 100644
--- a/src/libstd/sys/common/wtf8.rs
+++ b/src/libstd/sys/common/wtf8.rs
@@ -680,6 +680,7 @@ impl ops::Index<ops::RangeTo<usize>> for Wtf8 {
     }
 }
 
+#[cfg(stage0)]
 impl ops::Index<ops::FullRange> for Wtf8 {
     type Output = Wtf8;
 
@@ -689,6 +690,16 @@ impl ops::Index<ops::FullRange> for Wtf8 {
     }
 }
 
+#[cfg(not(stage0))]
+impl ops::Index<ops::RangeFull> for Wtf8 {
+    type Output = Wtf8;
+
+    #[inline]
+    fn index(&self, _range: &ops::RangeFull) -> &Wtf8 {
+        self
+    }
+}
+
 #[inline]
 fn decode_surrogate(second_byte: u8, third_byte: u8) -> u16 {
     // The first byte is assumed to be 0xED
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 3d65dd82643bf..b9b1dd9afeefc 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2527,14 +2527,14 @@ impl<'a> Parser<'a> {
                 }
 
                 if found_dotdot || self.eat(&token::CloseDelim(token::Bracket)) {
-                    // No expression, expand to a FullRange
+                    // No expression, expand to a RangeFull
                     // FIXME(#20516) It would be better to use a lang item or
-                    // something for FullRange.
+                    // something for RangeFull.
                     hi = self.last_span.hi;
 
                     let idents = vec![token::str_to_ident("core"),
                                       token::str_to_ident("ops"),
-                                      token::str_to_ident("FullRange")];
+                                      token::str_to_ident("RangeFull")];
                     let segments = idents.into_iter().map(|ident| {
                         ast::PathSegment {
                             identifier: ident,
diff --git a/src/test/run-pass/issue-21384.rs b/src/test/run-pass/issue-21384.rs
index 0ec33d218f9a9..4c8ba0dd51fe6 100644
--- a/src/test/run-pass/issue-21384.rs
+++ b/src/test/run-pass/issue-21384.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use ::core::ops::RangeFull;
+
 fn test<T : Clone>(arg: T) -> T {
     arg.clone()
 }
@@ -20,7 +22,7 @@ fn main() {
     assert!(test(1..5) == (1..5));
     assert!(test(..5) == (..5));
     assert!(test(1..) == (1..));
-    assert!(test(FullRange) == (FullRange));
+    assert!(test(RangeFull) == (RangeFull));
 
     // Check that ranges can still be used with non-clone limits
     assert!((Test(1)..Test(5)) == (Test(1)..Test(5)));
diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs
index 9cb7cfd7fe98b..81db525db28a2 100644
--- a/src/test/run-pass/slice.rs
+++ b/src/test/run-pass/slice.rs
@@ -13,7 +13,7 @@
 #![feature(associated_types)]
 
 extern crate core;
-use core::ops::{Index, IndexMut, Range, RangeTo, RangeFrom, FullRange};
+use core::ops::{Index, IndexMut, Range, RangeTo, RangeFrom, RangeFull};
 
 static mut COUNT: uint = 0;
 
@@ -40,9 +40,9 @@ impl Index<RangeFrom<Foo>> for Foo {
         self
     }
 }
-impl Index<FullRange> for Foo {
+impl Index<RangeFull> for Foo {
     type Output = Foo;
-    fn index(&self, _index: &FullRange) -> &Foo {
+    fn index(&self, _index: &RangeFull) -> &Foo {
         unsafe { COUNT += 1; }
         self
     }
@@ -69,9 +69,9 @@ impl IndexMut<RangeFrom<Foo>> for Foo {
         self
     }
 }
-impl IndexMut<FullRange> for Foo {
+impl IndexMut<RangeFull> for Foo {
     type Output = Foo;
-    fn index_mut(&mut self, _index: &FullRange) -> &mut Foo {
+    fn index_mut(&mut self, _index: &RangeFull) -> &mut Foo {
         unsafe { COUNT += 1; }
         self
     }