---

yaml
---
r: 189913
b: refs/heads/tmp
c: f58a653
h: refs/heads/master
i:
  189911: b20eed8
v: v3

Author: apasel422

[refs]

@@ -34,6 +34,6 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: f899513a30165946a75ff7f515ab37a226e72172
+refs/heads/tmp: f58a65374b6a372b641852283cc4ce94bdb07035
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 7ce5a21b274ff53e77b561467177bc34c668f95e

branches/tmp/src/compiletest/compiletest.rs

@@ -19,6 +19,7 @@
 #![feature(unboxed_closures)]
 #![feature(std_misc)]
 #![feature(test)]
+#![feature(unicode)]
 #![feature(core)]
 #![feature(path)]
 #![feature(io)]

branches/tmp/src/compiletest/errors.rs

@@ -71,7 +71,7 @@ fn parse_expected(last_nonfollow_error: Option<uint>,
     let letters = line[kind_start..].chars();
     let kind = letters.skip_while(|c| c.is_whitespace())
                       .take_while(|c| !c.is_whitespace())
-                      .flat_map(|c| c.to_lowercase())
+                      .map(|c| c.to_lowercase())
                       .collect::<String>();
     let letters = line[kind_start..].chars();
     let msg = letters.skip_while(|c| c.is_whitespace())

branches/tmp/src/libcollections/lib.rs

@@ -175,6 +175,7 @@ mod prelude {
 }
 
 /// An endpoint of a range of keys.
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub enum Bound<T> {
     /// An inclusive bound.
     Included(T),

branches/tmp/src/libcollections/str.rs

@@ -12,14 +12,13 @@
 
 //! Unicode string manipulation (the [`str`](../primitive.str.html) type).
 //!
-//! Rust's [`str`](../primitive.str.html) type is one of the core primitive
-//! types of the language. `&str` is the borrowed string type. This type of
-//! string can only be created from other strings, unless it is a `&'static str`
-//! (see below). It is not possible to move out of borrowed strings because they
-//! are owned elsewhere.
+//! Rust's [`str`](../primitive.str.html) type is one of the core primitive types of the
+//! language. `&str` is the borrowed string type. This type of string can only be created
+//! from other strings, unless it is a `&'static str` (see below). It is not possible to
+//! move out of borrowed strings because they are owned elsewhere.
 //!
-//! Basic operations are implemented directly by the compiler, but more advanced
-//! operations are defined on the [`StrExt`](trait.StrExt.html) trait.
+//! Basic operations are implemented directly by the compiler, but more advanced operations are
+//! defined on the [`StrExt`](trait.StrExt.html) trait.
 //!
 //! # Examples
 //!
@@ -29,9 +28,8 @@
 //! let s = "Hello, world.";
 //! ```
 //!
-//! This `&str` is a `&'static str`, which is the type of string literals.
-//! They're `'static` because literals are available for the entire lifetime of
-//! the program.
+//! This `&str` is a `&'static str`, which is the type of string literals. They're `'static`
+//! because literals are available for the entire lifetime of the program.
 //!
 //! You can get a non-`'static` `&str` by taking a slice of a `String`:
 //!
@@ -42,30 +40,29 @@
 //!
 //! # Representation
 //!
-//! Rust's string type, `str`, is a sequence of Unicode scalar values encoded as
-//! a stream of UTF-8 bytes. All [strings](../../reference.html#literals) are
-//! guaranteed to be validly encoded UTF-8 sequences. Additionally, strings are
-//! not null-terminated and can thus contain null bytes.
+//! Rust's string type, `str`, is a sequence of Unicode scalar values encoded as a stream of UTF-8
+//! bytes. All [strings](../../reference.html#literals) are guaranteed to be validly encoded UTF-8
+//! sequences. Additionally, strings are not null-terminated and can thus contain null bytes.
 //!
-//! The actual representation of `str`s have direct mappings to slices: `&str`
-//! is the same as `&[u8]`.
+//! The actual representation of `str`s have direct mappings to slices: `&str` is the same as
+//! `&[u8]`.
 
 #![doc(primitive = "str")]
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use self::RecompositionState::*;
 use self::DecompositionType::*;
 
+use core::char::CharExt;
 use core::clone::Clone;
 use core::iter::AdditiveIterator;
-use core::iter::{Iterator, IteratorExt, Extend};
+use core::iter::{Iterator, IteratorExt};
 use core::ops::Index;
 use core::ops::RangeFull;
 use core::option::Option::{self, Some, None};
 use core::result::Result;
 use core::slice::AsSlice;
 use core::str as core_str;
-use unicode::char::CharExt;
 use unicode::str::{UnicodeStr, Utf16Encoder};
 
 use vec_deque::VecDeque;
@@ -839,19 +836,17 @@ pub trait StrExt: Index<RangeFull, Output = str> {
 
     /// Returns a slice of the string from the character range [`begin`..`end`).
     ///
-    /// That is, start at the `begin`-th code point of the string and continue
-    /// to the `end`-th code point. This does not detect or handle edge cases
-    /// such as leaving a combining character as the first code point of the
-    /// string.
+    /// That is, start at the `begin`-th code point of the string and continue to the `end`-th code
+    /// point. This does not detect or handle edge cases such as leaving a combining character as
+    /// the first code point of the string.
     ///
-    /// Due to the design of UTF-8, this operation is `O(end)`. See `slice`,
-    /// `slice_to` and `slice_from` for `O(1)` variants that use byte indices
-    /// rather than code point indices.
+    /// Due to the design of UTF-8, this operation is `O(end)`. See `slice`, `slice_to` and
+    /// `slice_from` for `O(1)` variants that use byte indices rather than code point indices.
     ///
     /// # Panics
     ///
-    /// Panics if `begin` > `end` or the either `begin` or `end` are beyond the
-    /// last character of the string.
+    /// Panics if `begin` > `end` or the either `begin` or `end` are beyond the last character of
+    /// the string.
     ///
     /// # Examples
     ///
@@ -873,8 +868,8 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     ///
     /// # Unsafety
     ///
-    /// Caller must check both UTF-8 character boundaries and the boundaries of
-    /// the entire slice as well.
+    /// Caller must check both UTF-8 character boundaries and the boundaries of the entire slice as
+    /// well.
     ///
     /// # Examples
     ///
@@ -1511,32 +1506,6 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     fn trim_right(&self) -> &str {
         UnicodeStr::trim_right(&self[..])
     }
-
-    /// Returns the lowercase equivalent of this string.
-    ///
-    /// # Examples
-    ///
-    /// let s = "HELLO";
-    /// assert_eq!(s.to_lowercase(), "hello");
-    #[unstable(feature = "collections")]
-    fn to_lowercase(&self) -> String {
-        let mut s = String::with_capacity(self.len());
-        s.extend(self[..].chars().flat_map(|c| c.to_lowercase()));
-        return s;
-    }
-
-    /// Returns the uppercase equivalent of this string.
-    ///
-    /// # Examples
-    ///
-    /// let s = "hello";
-    /// assert_eq!(s.to_uppercase(), "HELLO");
-    #[unstable(feature = "collections")]
-    fn to_uppercase(&self) -> String {
-        let mut s = String::with_capacity(self.len());
-        s.extend(self[..].chars().flat_map(|c| c.to_uppercase()));
-        return s;
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]