Rename FullRange to RangeFull

nrc · nrc · commit bf2b4738163b · 2015-01-30T12:01:08.000+13:00
diff --git 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
@@ -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
@@ -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
@@ -947,18 +947,35 @@ 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 {
         fmt::Debug::fmt("..", fmt)
     }
 }
 
+#[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
@@ -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,30 +835,30 @@ 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")]
 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")]
 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,30 +868,30 @@ 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")]
 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")]
 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
diff --git a/src/test/run-pass/issue-21384.rs b/src/test/run-pass/issue-21384.rs
diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs

Original file line number	Diff line number	Diff line change
`@@ -877,6 +877,7 @@ impl ops::Index<ops::RangeFrom<uint>> for String {`
`877`	`877`	`&self[][*index]`
`878`	`878`	`}`
`879`	`879`	`}`
	`880`	`+#[cfg(stage0)]`
`880`	`881`	`#[stable(feature = "rust1", since = "1.0.0")]`
`881`	`882`	`impl ops::Index<ops::FullRange> for String {`
`882`	`883`	`type Output = str;`
`@@ -885,6 +886,15 @@ impl ops::Index<ops::FullRange> for String {`
`885`	`886`	`unsafe { mem::transmute(self.vec.as_slice()) }`
`886`	`887`	`}`
`887`	`888`	`}`
	`889`	`+#[cfg(not(stage0))]`
	`890`	`+#[stable(feature = "rust1", since = "1.0.0")]`
	`891`	`+impl ops::Index<ops::RangeFull> for String {`
	`892`	`+ type Output = str;`
	`893`	`+ #[inline]`
	`894`	`+ fn index(&self, _index: &ops::RangeFull) -> &str {`
	`895`	`+ unsafe { mem::transmute(self.vec.as_slice()) }`
	`896`	`+ }`
	`897`	`+}`
`888`	`898`
`889`	`899`	`#[stable(feature = "rust1", since = "1.0.0")]`
`890`	`900`	`impl ops::Deref for String {`
Original file line number	Diff line number	Diff line change
`@@ -1317,6 +1317,7 @@ impl<T> ops::Index<ops::RangeFrom<uint>> for Vec<T> {`
`1317`	`1317`	`self.as_slice().index(index)`
`1318`	`1318`	`}`
`1319`	`1319`	`}`
	`1320`	`+#[cfg(stage0)]`
`1320`	`1321`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1321`	`1322`	`impl<T> ops::Index<ops::FullRange> for Vec<T> {`
`1322`	`1323`	`type Output = [T];`
`@@ -1325,6 +1326,15 @@ impl<T> ops::Index<ops::FullRange> for Vec<T> {`
`1325`	`1326`	`self.as_slice()`
`1326`	`1327`	`}`
`1327`	`1328`	`}`
	`1329`	`+#[cfg(not(stage0))]`
	`1330`	`+#[stable(feature = "rust1", since = "1.0.0")]`
	`1331`	`+impl<T> ops::Index<ops::RangeFull> for Vec<T> {`
	`1332`	`+ type Output = [T];`
	`1333`	`+ #[inline]`
	`1334`	`+ fn index(&self, _index: &ops::RangeFull) -> &[T] {`
	`1335`	`+ self.as_slice()`
	`1336`	`+ }`
	`1337`	`+}`
`1328`	`1338`
`1329`	`1339`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1330`	`1340`	`impl<T> ops::IndexMut<ops::Range<uint>> for Vec<T> {`
`@@ -1350,6 +1360,7 @@ impl<T> ops::IndexMut<ops::RangeFrom<uint>> for Vec<T> {`
`1350`	`1360`	`self.as_mut_slice().index_mut(index)`
`1351`	`1361`	`}`
`1352`	`1362`	`}`
	`1363`	`+#[cfg(stage0)]`
`1353`	`1364`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1354`	`1365`	`impl<T> ops::IndexMut<ops::FullRange> for Vec<T> {`
`1355`	`1366`	`type Output = [T];`
`@@ -1358,6 +1369,15 @@ impl<T> ops::IndexMut<ops::FullRange> for Vec<T> {`
`1358`	`1369`	`self.as_mut_slice()`
`1359`	`1370`	`}`
`1360`	`1371`	`}`
	`1372`	`+#[cfg(not(stage0))]`
	`1373`	`+#[stable(feature = "rust1", since = "1.0.0")]`
	`1374`	`+impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {`
	`1375`	`+ type Output = [T];`
	`1376`	`+ #[inline]`
	`1377`	`+ fn index_mut(&mut self, _index: &ops::RangeFull) -> &mut [T] {`
	`1378`	`+ self.as_mut_slice()`
	`1379`	`+ }`
	`1380`	`+}`
`1361`	`1381`
`1362`	`1382`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1363`	`1383`	`impl<T> ops::Deref for Vec<T> {`
Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,10 @@ use iter::*;`
`44`	`44`	`use marker::Copy;`
`45`	`45`	`use num::Int;`
`46`	`46`	`use ops::{FnMut, self, Index};`
	`47`	`+#[cfg(stage0)]`
	`48`	`+use ops::FullRange as RangeFull;`
	`49`	`+#[cfg(not(stage0))]`
	`50`	`+use ops::RangeFull;`
`47`	`51`	`use option::Option;`
`48`	`52`	`use option::Option::{None, Some};`
`49`	`53`	`use result::Result;`
`@@ -543,10 +547,10 @@ impl<T> ops::Index<ops::RangeFrom<uint>> for [T] {`
`543`	`547`	`}`
`544`	`548`	`}`
`545`	`549`	`#[stable(feature = "rust1", since = "1.0.0")]`
`546`		`-impl<T> ops::Index<ops::FullRange> for [T] {`
	`550`	`+impl<T> ops::Index<RangeFull> for [T] {`
`547`	`551`	`type Output = [T];`
`548`	`552`	`#[inline]`
`549`		`- fn index(&self, _index: &ops::FullRange) -> &[T] {`
	`553`	`+ fn index(&self, _index: &RangeFull) -> &[T] {`
`550`	`554`	`self`
`551`	`555`	`}`
`552`	`556`	`}`
`@@ -584,10 +588,10 @@ impl<T> ops::IndexMut<ops::RangeFrom<uint>> for [T] {`
`584`	`588`	`}`
`585`	`589`	`}`
`586`	`590`	`#[stable(feature = "rust1", since = "1.0.0")]`
`587`		`-impl<T> ops::IndexMut<ops::FullRange> for [T] {`
	`591`	`+impl<T> ops::IndexMut<RangeFull> for [T] {`
`588`	`592`	`type Output = [T];`
`589`	`593`	`#[inline]`
`590`		`- fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {`
	`594`	`+ fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {`
`591`	`595`	`self`
`592`	`596`	`}`
`593`	`597`	`}`
`@@ -750,6 +754,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {`
`750`	`754`	`}`
`751`	`755`	`}`
`752`	`756`
	`757`	`+#[cfg(stage0)]`
`753`	`758`	`#[unstable(feature = "core")]`
`754`	`759`	`impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {`
`755`	`760`	`type Output = [T];`
`@@ -758,6 +763,15 @@ impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {`
`758`	`763`	`self.as_slice()`
`759`	`764`	`}`
`760`	`765`	`}`
	`766`	`+#[cfg(not(stage0))]`
	`767`	`+#[unstable(feature = "core")]`
	`768`	`+impl<'a, T> ops::Index<RangeFull> for Iter<'a, T> {`
	`769`	`+ type Output = [T];`
	`770`	`+ #[inline]`
	`771`	`+ fn index(&self, _index: &RangeFull) -> &[T] {`
	`772`	`+ self.as_slice()`
	`773`	`+ }`
	`774`	`+}`
`761`	`775`
`762`	`776`	`impl<'a, T> Iter<'a, T> {`
`763`	`777`	`/// View the underlying data as a subslice of the original data.`
`@@ -821,30 +835,30 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {`
`821`	`835`	`type Output = [T];`
`822`	`836`	`#[inline]`
`823`	`837`	`fn index(&self, index: &ops::Range<uint>) -> &[T] {`
`824`		`- self.index(&ops::FullRange).index(index)`
	`838`	`+ self.index(&RangeFull).index(index)`
`825`	`839`	`}`
`826`	`840`	`}`
`827`	`841`	`#[unstable(feature = "core")]`
`828`	`842`	`impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {`
`829`	`843`	`type Output = [T];`
`830`	`844`	`#[inline]`
`831`	`845`	`fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {`
`832`		`- self.index(&ops::FullRange).index(index)`
	`846`	`+ self.index(&RangeFull).index(index)`
`833`	`847`	`}`
`834`	`848`	`}`
`835`	`849`	`#[unstable(feature = "core")]`
`836`	`850`	`impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {`
`837`	`851`	`type Output = [T];`
`838`	`852`	`#[inline]`
`839`	`853`	`fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {`
`840`		`- self.index(&ops::FullRange).index(index)`
	`854`	`+ self.index(&RangeFull).index(index)`
`841`	`855`	`}`
`842`	`856`	`}`
`843`	`857`	`#[unstable(feature = "core")]`
`844`		`-impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {`
	`858`	`+impl<'a, T> ops::Index<RangeFull> for IterMut<'a, T> {`
`845`	`859`	`type Output = [T];`
`846`	`860`	`#[inline]`
`847`		`- fn index(&self, _index: &ops::FullRange) -> &[T] {`
	`861`	`+ fn index(&self, _index: &RangeFull) -> &[T] {`
`848`	`862`	`make_slice!(T => &[T]: self.ptr, self.end)`
`849`	`863`	`}`
`850`	`864`	`}`
`@@ -854,30 +868,30 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {`
`854`	`868`	`type Output = [T];`
`855`	`869`	`#[inline]`
`856`	`870`	`fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {`
`857`		`- self.index_mut(&ops::FullRange).index_mut(index)`
	`871`	`+ self.index_mut(&RangeFull).index_mut(index)`
`858`	`872`	`}`
`859`	`873`	`}`
`860`	`874`	`#[unstable(feature = "core")]`
`861`	`875`	`impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {`
`862`	`876`	`type Output = [T];`
`863`	`877`	`#[inline]`
`864`	`878`	`fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {`
`865`		`- self.index_mut(&ops::FullRange).index_mut(index)`
	`879`	`+ self.index_mut(&RangeFull).index_mut(index)`
`866`	`880`	`}`
`867`	`881`	`}`
`868`	`882`	`#[unstable(feature = "core")]`
`869`	`883`	`impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {`
`870`	`884`	`type Output = [T];`
`871`	`885`	`#[inline]`
`872`	`886`	`fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {`
`873`		`- self.index_mut(&ops::FullRange).index_mut(index)`
	`887`	`+ self.index_mut(&RangeFull).index_mut(index)`
`874`	`888`	`}`
`875`	`889`	`}`
`876`	`890`	`#[unstable(feature = "core")]`
`877`		`-impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {`
	`891`	`+impl<'a, T> ops::IndexMut<RangeFull> for IterMut<'a, T> {`
`878`	`892`	`type Output = [T];`
`879`	`893`	`#[inline]`
`880`		`- fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {`
	`894`	`+ fn index_mut(&mut self, _index: &RangeFull) -> &mut [T] {`
`881`	`895`	`make_slice!(T => &mut [T]: self.ptr, self.end)`
`882`	`896`	`}`
`883`	`897`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1249,6 +1249,7 @@ mod traits {`
`1249`	`1249`	`}`
`1250`	`1250`	`}`
`1251`	`1251`
	`1252`	`+ #[cfg(stage0)]`
`1252`	`1253`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1253`	`1254`	`impl ops::Index<ops::FullRange> for str {`
`1254`	`1255`	`type Output = str;`
`@@ -1257,6 +1258,15 @@ mod traits {`
`1257`	`1258`	`self`
`1258`	`1259`	`}`
`1259`	`1260`	`}`
	`1261`	`+ #[cfg(not(stage0))]`
	`1262`	`+ #[stable(feature = "rust1", since = "1.0.0")]`
	`1263`	`+ impl ops::Index<ops::RangeFull> for str {`
	`1264`	`+ type Output = str;`
	`1265`	`+ #[inline]`
	`1266`	`+ fn index(&self, _index: &ops::RangeFull) -> &str {`
	`1267`	`+ self`
	`1268`	`+ }`
	`1269`	`+ }`
`1260`	`1270`	`}`
`1261`	`1271`
`1262`	`1272`	`/// Any string that can be represented as a slice`
Original file line number	Diff line number	Diff line change
`@@ -1050,8 +1050,8 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,`
`1050`	`1050`	`(tcx.lang_items.range_to_struct(), fields, vec![node_id_type(bcx, end.id)])`
`1051`	`1051`	`}`
`1052`	`1052`	`_ => {`
`1053`		`- // Desugar to FullRange`
`1054`		`- (tcx.lang_items.full_range_struct(), vec![], vec![])`
	`1053`	`+ // Desugar to RangeFull`
	`1054`	`+ (tcx.lang_items.range_full_struct(), vec![], vec![])`
`1055`	`1055`	`}`
`1056`	`1056`	`};`
`1057`	`1057`
Original file line number	Diff line number	Diff line change
`@@ -4095,8 +4095,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,`
`4095`	`4095`	`}`
`4096`	`4096`	`}`
`4097`	`4097`	`None => {`
`4098`		`- // Neither start nor end => FullRange`
`4099`		`- if let Some(did) = tcx.lang_items.full_range_struct() {`
	`4098`	`+ // Neither start nor end => RangeFull`
	`4099`	`+ if let Some(did) = tcx.lang_items.range_full_struct() {`
`4100`	`4100`	`let substs = Substs::new_type(vec![], vec![]);`
`4101`	`4101`	`ty::mk_struct(tcx, did, tcx.mk_substs(substs))`
`4102`	`4102`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,7 @@ impl OsString {`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
	`85`	`+#[cfg(stage0)]`
`85`	`86`	`impl ops::Index<ops::FullRange> for OsString {`
`86`	`87`	`type Output = OsStr;`
`87`	`88`
`@@ -91,6 +92,16 @@ impl ops::Index<ops::FullRange> for OsString {`
`91`	`92`	`}`
`92`	`93`	`}`
`93`	`94`
	`95`	`+#[cfg(not(stage0))]`
	`96`	`+impl ops::Index<ops::RangeFull> for OsString {`
	`97`	`+ type Output = OsStr;`
	`98`	`+`
	`99`	`+ #[inline]`
	`100`	`+ fn index(&self, _index: &ops::RangeFull) -> &OsStr {`
	`101`	`+ unsafe { mem::transmute(self.inner.as_slice()) }`
	`102`	`+ }`
	`103`	`+}`
	`104`	`+`
`94`	`105`	`impl ops::Deref for OsString {`
`95`	`106`	`type Target = OsStr;`
`96`	`107`
Original file line number	Diff line number	Diff line change
`@@ -680,6 +680,7 @@ impl ops::Index<ops::RangeTo<usize>> for Wtf8 {`
`680`	`680`	`}`
`681`	`681`	`}`
`682`	`682`
	`683`	`+#[cfg(stage0)]`
`683`	`684`	`impl ops::Index<ops::FullRange> for Wtf8 {`
`684`	`685`	`type Output = Wtf8;`
`685`	`686`
`@@ -689,6 +690,16 @@ impl ops::Index<ops::FullRange> for Wtf8 {`
`689`	`690`	`}`
`690`	`691`	`}`
`691`	`692`
	`693`	`+#[cfg(not(stage0))]`
	`694`	`+impl ops::Index<ops::RangeFull> for Wtf8 {`
	`695`	`+ type Output = Wtf8;`
	`696`	`+`
	`697`	`+ #[inline]`
	`698`	`+ fn index(&self, _range: &ops::RangeFull) -> &Wtf8 {`
	`699`	`+ self`
	`700`	`+ }`
	`701`	`+}`
	`702`	`+`
`692`	`703`	`#[inline]`
`693`	`704`	`fn decode_surrogate(second_byte: u8, third_byte: u8) -> u16 {`
`694`	`705`	`// The first byte is assumed to be 0xED`