Rename FullRange to RangeFull

diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 5a1162b5c084a9c2890fa869995ca7830d44513d..35591a5e9effb049a22b73ebff18e6a65072dc90 100644 (file)
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -60,7 +60,13 @@
 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 @@ fn to_owned(&self) -> String {
 
 /// 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 f13e03c5c36229c273fedb41552349c090c1a329..035529c7365c8c500a0de0536e4fd6e58bebf036 100644 (file)
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -877,6 +877,7 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
         &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 @@ fn index(&self, _index: &ops::FullRange) -> &str {
         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 ab64bc88550ff30d20e72bbd4ee2c470f31d058f..5dd88dbb02524134f9445d58e2a35999fe078053 100644 (file)
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1317,6 +1317,7 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &[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 @@ fn index(&self, _index: &ops::FullRange) -> &[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 @@ fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [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 @@ fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [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 55ff3eb4d062d8bc7be2967c379931343591c5ff..9e020eeb8a9c18492a69ae7cf6f8711086a3aae6 100644 (file)
--- 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 @@ fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
     }
 }
 
+#[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 b1e9084d210f5c77d5f6258c012ecae0e5b64ce1..40e66db3ae5b0eddc95b3fae19280026296851a3 100644 (file)
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -44,6 +44,10 @@
 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 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &[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 @@ fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [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 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
     }
 }
 
+#[cfg(stage0)]
 #[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
     type Output = [T];
@@ -758,6 +763,15 @@ fn index(&self, _index: &ops::FullRange) -> &[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 228519656446c5917ffa6c65c26b3905bac338d0..8495a03747e7b97977dda929ef85332fee5e296e 100644 (file)
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -1249,6 +1249,7 @@ fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
         }
     }
 
+    #[cfg(stage0)]
     #[stable(feature = "rust1", since = "1.0.0")]
     impl ops::Index<ops::FullRange> for str {
         type Output = str;
@@ -1257,6 +1258,15 @@ fn index(&self, _index: &ops::FullRange) -> &str {
             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 c1ce5945946c294a594e367ed92da4f70726bb4b..16d2c68ad60a92a8b9737b3fcff9cbc5b7abaeb6 100644 (file)
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -269,7 +269,7 @@ pub fn collect_language_items(krate: &ast::Crate,
     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 a6c9a988b4d46e486639a50248219c439296a281..1d86fa85d1e9a125a82e5ae8026daf7d606692d8 100644 (file)
--- a/src/librustc_trans/trans/expr.rs
+++ b/src/librustc_trans/trans/expr.rs
@@ -1050,8 +1050,8 @@ fn make_field(field_name: &str, expr: P<ast::Expr>) -> ast::Field {
                     (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 6dabec31e2c6ff855b06bc2cb81f42b4c7db3fe9..31ad1f31417eb197bc6bd9eefccbfe3bc7d1f758 100644 (file)
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -4095,8 +4095,8 @@ fn check_struct_fields_on_error(fcx: &FnCtxt,
                 }
             }
             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 8fdc5547e46b106994600555fab427c74b8f8eaa..18e2aa8c098a712de0c4cc00dd849224a22b0be3 100644 (file)
--- a/src/libstd/ffi/os_str.rs
+++ b/src/libstd/ffi/os_str.rs
@@ -82,6 +82,7 @@ pub fn push_os_str(&mut self, s: &OsStr) {
     }
 }
 
+#[cfg(stage0)]
 impl ops::Index<ops::FullRange> for OsString {
     type Output = OsStr;
 
@@ -91,6 +92,16 @@ fn index(&self, _index: &ops::FullRange) -> &OsStr {
     }
 }
 
+#[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 b42353e964c511993cd2d89612ca502632ca6a61..b5409da9c9ca4c8c6f68ebd8bc26b499aee45c8b 100644 (file)
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -68,6 +68,7 @@
 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 2e6b9d50553fa7c064081d8fc8b1d67fc9a029ef..88db27013ac83c43003d7ca101cd8e1acc99c77d 100644 (file)
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -25,6 +25,7 @@
 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 51c9f9de83cc88e7fc210550665c7629186c7342..b3c4ffa5120e88eed17620067b13658f2c789471 100644 (file)
--- 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 bc0721550634c21b5d9ecddc1b826eebcc460f45..fdcb0c19f30afbb1a59e0ecf3e481975cd943213 100644 (file)
--- a/src/libstd/sys/common/wtf8.rs
+++ b/src/libstd/sys/common/wtf8.rs
@@ -680,6 +680,7 @@ fn index(&self, range: &ops::RangeTo<usize>) -> &Wtf8 {
     }
 }
 
+#[cfg(stage0)]
 impl ops::Index<ops::FullRange> for Wtf8 {
     type Output = Wtf8;
 
@@ -689,6 +690,16 @@ fn index(&self, _range: &ops::FullRange) -> &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 3d65dd82643bf5fb26d19a2187e42e0195f0fd60..b9b1dd9afeefc63c7b3a6560cd41e48bbb72d69d 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2527,14 +2527,14 @@ pub fn parse_dot_or_call_expr_with(&mut self, e0: P<Expr>) -> P<Expr> {
                 }
 
                 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 0ec33d218f9a9117e40c523d51cb5401a7f8627c..4c8ba0dd51fe62529001ab53e71760bb054d1ad4 100644 (file)
--- 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 9cb7cfd7fe98bc80a41efc7544424e49076f26ce..81db525db28a2a3d40c7053d4fe69785f0a3c31a 100644 (file)
--- 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 @@ fn index(&self, index: &RangeFrom<Foo>) -> &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 @@ fn index_mut(&mut self, index: &RangeFrom<Foo>) -> &mut 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
     }