---

yaml
---
r: 272491
b: refs/heads/master
c: bcbc9e5
h: refs/heads/master
i:
  272489: 4da5315
  272487: f8fc3f8

Author: barosl

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 933000613b7774727dd7f1bfe766e2bee71c5747
+refs/heads/master: bcbc9e5346941011f36f71f66c808675b263a589
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
 refs/heads/try: 49312a405e14a449b98fe0056b12a40ac128be4a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/src/compiletest/compiletest.rs

@@ -13,6 +13,7 @@
 #![feature(box_syntax)]
 #![feature(libc)]
 #![feature(rustc_private)]
+#![feature(str_char)]
 #![feature(test)]
 #![feature(question_mark)]
 
@@ -411,26 +412,16 @@ fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
 
             // used to be a regex "(^|[^0-9])([0-9]\.[0-9]+)"
             for (pos, c) in full_version_line.char_indices() {
-                if !c.is_digit(10) {
-                    continue
-                }
-                if pos + 2 >= full_version_line.len() {
-                    continue
-                }
-                if full_version_line[pos + 1..].chars().next().unwrap() != '.' {
-                    continue
-                }
-                if !full_version_line[pos + 2..].chars().next().unwrap().is_digit(10) {
-                    continue
-                }
-                if pos > 0 && full_version_line[..pos].chars().next_back()
-                                                      .unwrap().is_digit(10) {
+                if !c.is_digit(10) { continue }
+                if pos + 2 >= full_version_line.len() { continue }
+                if full_version_line.char_at(pos + 1) != '.' { continue }
+                if !full_version_line.char_at(pos + 2).is_digit(10) { continue }
+                if pos > 0 && full_version_line.char_at_reverse(pos).is_digit(10) {
                     continue
                 }
                 let mut end = pos + 3;
                 while end < full_version_line.len() &&
-                      full_version_line[end..].chars().next()
-                                              .unwrap().is_digit(10) {
+                      full_version_line.char_at(end).is_digit(10) {
                     end += 1;
                 }
                 return Some(full_version_line[pos..end].to_owned());
@@ -462,13 +453,13 @@ fn extract_lldb_version(full_version_line: Option<String>) -> Option<String> {
             for (pos, l) in full_version_line.char_indices() {
                 if l != 'l' && l != 'L' { continue }
                 if pos + 5 >= full_version_line.len() { continue }
-                let l = full_version_line[pos + 1..].chars().next().unwrap();
+                let l = full_version_line.char_at(pos + 1);
                 if l != 'l' && l != 'L' { continue }
-                let d = full_version_line[pos + 2..].chars().next().unwrap();
+                let d = full_version_line.char_at(pos + 2);
                 if d != 'd' && d != 'D' { continue }
-                let b = full_version_line[pos + 3..].chars().next().unwrap();
+                let b = full_version_line.char_at(pos + 3);
                 if b != 'b' && b != 'B' { continue }
-                let dash = full_version_line[pos + 4..].chars().next().unwrap();
+                let dash = full_version_line.char_at(pos + 4);
                 if dash != '-' { continue }
 
                 let vers = full_version_line[pos + 5..].chars().take_while(|c| {

trunk/src/compiletest/errors.rs

@@ -115,7 +115,7 @@ fn parse_expected(last_nonfollow_error: Option<usize>,
                   tag: &str)
                   -> Option<(WhichLine, ExpectedError)> {
     let start = match line.find(tag) { Some(i) => i, None => return None };
-    let (follow, adjusts) = if line[start + tag.len()..].chars().next().unwrap() == '|' {
+    let (follow, adjusts) = if line.char_at(start + tag.len()) == '|' {
         (true, 0)
     } else {
         (false, line[start + tag.len()..].chars().take_while(|c| *c == '^').count())

trunk/src/compiletest/runtest.rs

@@ -1177,7 +1177,7 @@ fn scan_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
     if *idx >= haystack.len() {
         return false;
     }
-    let ch = haystack[*idx..].chars().next().unwrap();
+    let ch = haystack.char_at(*idx);
     if ch != needle {
         return false;
     }
@@ -1188,7 +1188,7 @@ fn scan_char(haystack: &str, needle: char, idx: &mut usize) -> bool {
 fn scan_integer(haystack: &str, idx: &mut usize) -> bool {
     let mut i = *idx;
     while i < haystack.len() {
-        let ch = haystack[i..].chars().next().unwrap();
+        let ch = haystack.char_at(i);
         if ch < '0' || '9' < ch {
             break;
         }
@@ -1208,7 +1208,7 @@ fn scan_string(haystack: &str, needle: &str, idx: &mut usize) -> bool {
         if haystack_i >= haystack.len() {
             return false;
         }
-        let ch = haystack[haystack_i..].chars().next().unwrap();
+        let ch = haystack.char_at(haystack_i);
         haystack_i += ch.len_utf8();
         if !scan_char(needle, ch, &mut needle_i) {
             return false;

trunk/src/libcollections/btree/set.rs

@@ -379,7 +379,7 @@ impl<T: Ord> BTreeSet<T> {
     /// The value may be any borrowed form of the set's value type,
     /// but the ordering on the borrowed form *must* match the
     /// ordering on the value type.
-    #[stable(feature = "set_recovery", since = "1.9.0")]
+    #[unstable(feature = "set_recovery", issue = "28050")]
     pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T>
         where T: Borrow<Q>,
               Q: Ord
@@ -502,7 +502,7 @@ impl<T: Ord> BTreeSet<T> {
 
     /// Adds a value to the set, replacing the existing value, if any, that is equal to the given
     /// one. Returns the replaced value.
-    #[stable(feature = "set_recovery", since = "1.9.0")]
+    #[unstable(feature = "set_recovery", issue = "28050")]
     pub fn replace(&mut self, value: T) -> Option<T> {
         Recover::replace(&mut self.map, value)
     }
@@ -538,7 +538,7 @@ impl<T: Ord> BTreeSet<T> {
     /// The value may be any borrowed form of the set's value type,
     /// but the ordering on the borrowed form *must* match the
     /// ordering on the value type.
-    #[stable(feature = "set_recovery", since = "1.9.0")]
+    #[unstable(feature = "set_recovery", issue = "28050")]
     pub fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T>
         where T: Borrow<Q>,
               Q: Ord

trunk/src/libcollections/lib.rs

@@ -27,13 +27,15 @@
        test(no_crate_inject, attr(allow(unused_variables), deny(warnings))))]
 
 #![cfg_attr(test, allow(deprecated))] // rand
+#![cfg_attr(not(test), feature(copy_from_slice))] // impl [T]
 #![cfg_attr(not(stage0), deny(warnings))]
 
 #![feature(alloc)]
 #![feature(allow_internal_unstable)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(core_intrinsics)]
+#![feature(decode_utf16)]
 #![feature(dropck_parametricity)]
 #![feature(fmt_internals)]
 #![feature(heap_api)]

trunk/src/libcollections/slice.rs

@@ -845,13 +845,14 @@ impl<T> [T] {
     /// # Example
     ///
     /// ```rust
+    /// #![feature(copy_from_slice)]
     /// let mut dst = [0, 0, 0];
     /// let src = [1, 2, 3];
     ///
     /// dst.copy_from_slice(&src);
     /// assert_eq!(src, dst);
     /// ```
-    #[stable(feature = "copy_from_slice", since = "1.9.0")]
+    #[unstable(feature = "copy_from_slice", issue = "31755")]
     pub fn copy_from_slice(&mut self, src: &[T]) where T: Copy {
         core_slice::SliceExt::copy_from_slice(self, src)
     }

trunk/src/libcollections/str.rs

@@ -228,6 +228,8 @@ impl str {
     /// # Examples
     ///
     /// ```
+    /// #![feature(str_char)]
+    ///
     /// let s = "Löwe 老虎 Léopard";
     /// assert!(s.is_char_boundary(0));
     /// // start of `老`
@@ -240,7 +242,12 @@ impl str {
     /// // third byte of `老`
     /// assert!(!s.is_char_boundary(8));
     /// ```
-    #[stable(feature = "is_char_boundary", since = "1.9.0")]
+    #[unstable(feature = "str_char",
+               reason = "it is unclear whether this method pulls its weight \
+                         with the existence of the char_indices iterator or \
+                         this method may want to be replaced with checked \
+                         slicing",
+               issue = "27754")]
     #[inline]
     pub fn is_char_boundary(&self, index: usize) -> bool {
         core_str::StrExt::is_char_boundary(self, index)
@@ -367,7 +374,6 @@ impl str {
     ///
     /// ```
     /// #![feature(str_char)]
-    /// #![allow(deprecated)]
     ///
     /// use std::str::CharRange;
     ///
@@ -402,9 +408,6 @@ impl str {
                          removed altogether",
                issue = "27754")]
     #[inline]
-    #[rustc_deprecated(reason = "use slicing plus chars() plus len_utf8",
-                       since = "1.9.0")]
-    #[allow(deprecated)]
     pub fn char_range_at(&self, start: usize) -> CharRange {
         core_str::StrExt::char_range_at(self, start)
     }
@@ -429,7 +432,6 @@ impl str {
     ///
     /// ```
     /// #![feature(str_char)]
-    /// #![allow(deprecated)]
     ///
     /// use std::str::CharRange;
     ///
@@ -464,9 +466,6 @@ impl str {
                          eventually removed altogether",
                issue = "27754")]
     #[inline]
-    #[rustc_deprecated(reason = "use slicing plus chars().rev() plus len_utf8",
-                       since = "1.9.0")]
-    #[allow(deprecated)]
     pub fn char_range_at_reverse(&self, start: usize) -> CharRange {
         core_str::StrExt::char_range_at_reverse(self, start)
     }
@@ -482,7 +481,6 @@ impl str {
     ///
     /// ```
     /// #![feature(str_char)]
-    /// #![allow(deprecated)]
     ///
     /// let s = "abπc";
     /// assert_eq!(s.char_at(1), 'b');
@@ -497,9 +495,6 @@ impl str {
                          subslice",
                issue = "27754")]
     #[inline]
-    #[allow(deprecated)]
-    #[rustc_deprecated(reason = "use slicing plus chars()",
-                       since = "1.9.0")]
     pub fn char_at(&self, i: usize) -> char {
         core_str::StrExt::char_at(self, i)
     }
@@ -516,7 +511,6 @@ impl str {
     ///
     /// ```
     /// #![feature(str_char)]
-    /// #![allow(deprecated)]
     ///
     /// let s = "abπc";
     /// assert_eq!(s.char_at_reverse(1), 'a');
@@ -529,9 +523,6 @@ impl str {
                          cases generate panics",
                issue = "27754")]
     #[inline]
-    #[rustc_deprecated(reason = "use slicing plus chars().rev()",
-                       since = "1.9.0")]
-    #[allow(deprecated)]
     pub fn char_at_reverse(&self, i: usize) -> char {
         core_str::StrExt::char_at_reverse(self, i)
     }
@@ -550,7 +541,6 @@ impl str {
     ///
     /// ```
     /// #![feature(str_char)]
-    /// #![allow(deprecated)]
     ///
     /// let s = "Łódź"; // \u{141}o\u{301}dz\u{301}
     /// let (c, s1) = s.slice_shift_char().unwrap();
@@ -569,9 +559,6 @@ impl str {
                          and/or char_indices iterators",
                issue = "27754")]
     #[inline]
-    #[rustc_deprecated(reason = "use chars() plus Chars::as_str",
-                       since = "1.9.0")]
-    #[allow(deprecated)]
     pub fn slice_shift_char(&self) -> Option<(char, &str)> {
         core_str::StrExt::slice_shift_char(self)
     }

trunk/src/libcollections/string.rs

@@ -1037,13 +1037,14 @@ impl String {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn pop(&mut self) -> Option<char> {
-        let ch = match self.chars().rev().next() {
-            Some(ch) => ch,
-            None => return None,
-        };
-        let newlen = self.len() - ch.len_utf8();
+        let len = self.len();
+        if len == 0 {
+            return None;
+        }
+
+        let ch = self.char_at_reverse(len);
         unsafe {
-            self.vec.set_len(newlen);
+            self.vec.set_len(len - ch.len_utf8());
         }
         Some(ch)
     }
@@ -1074,13 +1075,11 @@ impl String {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn remove(&mut self, idx: usize) -> char {
-        let ch = match self[idx..].chars().next() {
-            Some(ch) => ch,
-            None => panic!("cannot remove a char from the end of a string"),
-        };
+        let len = self.len();
+        assert!(idx < len);
 
+        let ch = self.char_at(idx);
         let next = idx + ch.len_utf8();
-        let len = self.len();
         unsafe {
             ptr::copy(self.vec.as_ptr().offset(next as isize),
                       self.vec.as_mut_ptr().offset(idx as isize),

trunk/src/libcollectionstest/lib.rs

@@ -10,11 +10,13 @@
 
 #![deny(warnings)]
 
+#![feature(ascii)]
 #![feature(binary_heap_extras)]
 #![feature(box_syntax)]
 #![feature(btree_range)]
 #![feature(collections)]
 #![feature(collections_bound)]
+#![feature(copy_from_slice)]
 #![feature(const_fn)]
 #![feature(fn_traits)]
 #![feature(enumset)]
@@ -23,6 +25,7 @@
 #![feature(map_values_mut)]
 #![feature(pattern)]
 #![feature(rand)]
+#![feature(set_recovery)]
 #![feature(step_by)]
 #![feature(str_char)]
 #![feature(str_escape)]

trunk/src/libcollectionstest/str.rs

@@ -464,14 +464,12 @@ fn test_is_whitespace() {
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_slice_shift_char() {
     let data = "ประเทศไทย中";
     assert_eq!(data.slice_shift_char(), Some(('ป', "ระเทศไทย中")));
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_slice_shift_char_2() {
     let empty = "";
     assert_eq!(empty.slice_shift_char(), None);
@@ -659,7 +657,6 @@ fn test_contains_char() {
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_char_at() {
     let s = "ศไทย中华Việt Nam";
     let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
@@ -671,7 +668,6 @@ fn test_char_at() {
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_char_at_reverse() {
     let s = "ศไทย中华Việt Nam";
     let v = vec!['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
@@ -749,7 +745,6 @@ fn test_total_ord() {
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_char_range_at() {
     let data = "b¢€𤭢𤭢€¢b";
     assert_eq!('b', data.char_range_at(0).ch);
@@ -763,7 +758,6 @@ fn test_char_range_at() {
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_char_range_at_reverse_underflow() {
     assert_eq!("abc".char_range_at_reverse(0).next, 0);
 }