---

yaml
---
r: 191419
b: refs/heads/try
c: c42067c
h: refs/heads/master
i:
  191417: 7732703
  191415: c798ee1
v: v3

Author: Manishearth

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 809a554fca2d0ebc2ba50077016fe282a4064752
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c64d671671aea2e44ee7fc6eb00ee75fc30ed7b9
-refs/heads/try: e245e65ef8ddb8c047cafcd3d0c30f427a33e6c4
+refs/heads/try: c42067c9e9ac605fc330c3ed11d29477ac251d8a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/compiletest/runtest.rs

@@ -1052,22 +1052,22 @@ fn scan_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
     if *idx >= haystack.len() {
         return false;
     }
-    let ch = haystack.char_at(*idx);
-    if ch != needle {
+    let range = haystack.char_range_at(*idx);
+    if range.ch != needle {
         return false;
     }
-    *idx += ch.len_utf8();
+    *idx = range.next;
     return true;
 }
 
 fn scan_integer(haystack: &str, idx: &mut uint) -> bool {
     let mut i = *idx;
     while i < haystack.len() {
-        let ch = haystack.char_at(i);
-        if ch < '0' || '9' < ch {
+        let range = haystack.char_range_at(i);
+        if range.ch < '0' || '9' < range.ch {
             break;
         }
-        i += ch.len_utf8();
+        i = range.next;
     }
     if i == *idx {
         return false;
@@ -1083,9 +1083,9 @@ fn scan_string(haystack: &str, needle: &str, idx: &mut uint) -> bool {
         if haystack_i >= haystack.len() {
             return false;
         }
-        let ch = haystack.char_at(haystack_i);
-        haystack_i += ch.len_utf8();
-        if !scan_char(needle, ch, &mut needle_i) {
+        let range = haystack.char_range_at(haystack_i);
+        haystack_i = range.next;
+        if !scan_char(needle, range.ch, &mut needle_i) {
             return false;
         }
     }

branches/try/src/libcollections/lib.rs

@@ -35,7 +35,6 @@
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag)]
 #![feature(step_by)]
-#![feature(str_char)]
 #![cfg_attr(test, feature(rand, rustc_private, test))]
 #![cfg_attr(test, allow(deprecated))] // rand
 

branches/try/src/libcollections/str.rs

@@ -29,7 +29,7 @@ use unicode::str as unicode_str;
 use unicode::str::Utf16Item;
 
 use borrow::{Cow, IntoCow};
-use str::{self, FromStr, Utf8Error};
+use str::{self, CharRange, FromStr, Utf8Error};
 use vec::{DerefVec, Vec, as_vec};
 
 /// A growable string stored as a UTF-8 encoded buffer.
@@ -561,9 +561,9 @@ impl String {
             return None
         }
 
-        let ch = self.char_at_reverse(len);
+        let CharRange {ch, next} = self.char_range_at_reverse(len);
         unsafe {
-            self.vec.set_len(len - ch.len_utf8());
+            self.vec.set_len(next);
         }
         Some(ch)
     }
@@ -595,8 +595,7 @@ impl String {
         let len = self.len();
         assert!(idx <= len);
 
-        let ch = self.char_at(idx);
-        let next = idx + ch.len_utf8();
+        let CharRange { ch, next } = self.char_range_at(idx);
         unsafe {
             ptr::copy(self.vec.as_mut_ptr().offset(idx as isize),
                       self.vec.as_ptr().offset(next as isize),

branches/try/src/libcollections/string.rs

@@ -18,7 +18,6 @@
 
 use self::OldSearcher::{TwoWay, TwoWayLong};
 
-use char::CharExt;
 use clone::Clone;
 use cmp::{self, Eq};
 use default::Default;
@@ -1113,10 +1112,8 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [
 /// the next `char` in a string.  This can be used as a data structure
 /// for iterating over the UTF-8 bytes of a string.
 #[derive(Copy)]
-#[unstable(feature = "str_char",
-           reason = "existence of this struct is uncertain as it is frequently \
-                     able to be replaced with char.len_utf8() and/or \
-                     char/char_indices iterators")]
+#[unstable(feature = "core",
+           reason = "naming is uncertain with container conventions")]
 pub struct CharRange {
     /// Current `char`
     pub ch: char,
@@ -1649,8 +1646,8 @@ impl StrExt for str {
         if self.is_empty() {
             None
         } else {
-            let ch = self.char_at(0);
-            let next_s = unsafe { self.slice_unchecked(ch.len_utf8(), self.len()) };
+            let CharRange {ch, next} = self.char_range_at(0);
+            let next_s = unsafe { self.slice_unchecked(next, self.len()) };
             Some((ch, next_s))
         }
     }

branches/try/src/libcore/str/mod.rs

@@ -92,10 +92,11 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![deny(missing_docs)]
+#![feature(collections)]
 #![feature(int_uint)]
 #![feature(staged_api)]
+#![feature(core)]
 #![feature(str_words)]
-#![feature(str_char)]
 #![cfg_attr(test, feature(rustc_private))]
 
 #[cfg(test)] #[macro_use] extern crate log;
@@ -619,8 +620,8 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                 let mut j = 1;
                 names = Vec::new();
                 while j < curlen {
-                    let ch = cur.char_at(j);
-                    let opt = Short(ch);
+                    let range = cur.char_range_at(j);
+                    let opt = Short(range.ch);
 
                     /* In a series of potential options (eg. -aheJ), if we
                        see one which takes an argument, we assume all
@@ -641,13 +642,12 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                         No => false
                     };
 
-                    let next = j + ch.len_utf8();
-                    if arg_follows && next < curlen {
-                        i_arg = Some((&cur[next..curlen]).to_string());
+                    if arg_follows && range.next < curlen {
+                        i_arg = Some((&cur[range.next..curlen]).to_string());
                         break;
                     }
 
-                    j = next;
+                    j = range.next;
                 }
             }
             let mut name_pos = 0;

branches/try/src/libgetopts/lib.rs

@@ -269,8 +269,8 @@ pub mod types {
                 #[repr(C)]
                 #[derive(Copy)] pub struct sockaddr_storage {
                     pub ss_family: sa_family_t,
-                    pub __ss_align: isize,
-                    pub __ss_pad2: [u8; 128 - 2 * (::core::isize::BYTES as usize)],
+                    pub __ss_align: i64,
+                    pub __ss_pad2: [u8; 112],
                 }
                 #[repr(C)]
                 #[derive(Copy)] pub struct sockaddr_in {

branches/try/src/liblibc/lib.rs

@@ -42,7 +42,6 @@
 #![feature(io)]
 #![feature(path_ext)]
 #![feature(str_words)]
-#![feature(str_char)]
 #![cfg_attr(test, feature(test))]
 
 extern crate arena;

branches/try/src/librustc/lib.rs

@@ -38,7 +38,6 @@
 #![feature(exit_status)]
 #![feature(io)]
 #![feature(set_stdio)]
-#![feature(unicode)]
 
 extern crate arena;
 extern crate flate;

branches/try/src/librustc_driver/lib.rs

@@ -41,7 +41,6 @@
 #![feature(unsafe_destructor)]
 #![feature(staged_api)]
 #![feature(std_misc)]
-#![feature(str_char)]
 #![cfg_attr(test, feature(test))]
 
 extern crate syntax;

branches/try/src/librustc_lint/lib.rs

@@ -5240,7 +5240,7 @@ pub fn may_break(cx: &ty::ctxt, id: ast::NodeId, b: &ast::Block) -> bool {
     // inside the loop?
     (loop_query(&*b, |e| {
         match *e {
-            ast::ExprBreak(None) => true,
+            ast::ExprBreak(_) => true,
             _ => false
         }
     })) ||

branches/try/src/librustc_typeck/check/mod.rs

@@ -37,7 +37,6 @@ Core encoding and decoding interfaces.
 #![feature(staged_api)]
 #![feature(std_misc)]
 #![feature(unicode)]
-#![feature(str_char)]
 #![cfg_attr(test, feature(test))]
 
 // test harness access

branches/try/src/libserialize/lib.rs

@@ -73,10 +73,10 @@
 //!
 //! ## Concurrency, I/O, and the runtime
 //!
-//! The [`thread`](thread/index.html) module contains Rust's threading abstractions.
-//! [`sync`](sync/index.html) contains further, primitive, shared memory types,
-//! including [`atomic`](sync/atomic/index.html), and [`mpsc`](sync/mpmc/index.html),
-//! which contains the channel types for message passing.
+//! The [`thread`](thread/index.html) module contains Rust's threading abstractions,
+//! while [`comm`](comm/index.html) contains the channel types for message
+//! passing. [`sync`](sync/index.html) contains further, primitive, shared
+//! memory types, including [`atomic`](sync/atomic/index.html).
 //!
 //! Common types of I/O, including files, TCP, UDP, pipes, Unix domain sockets,
 //! timers, and process spawning, are defined in the
@@ -127,7 +127,6 @@
 #![feature(int_uint)]
 #![feature(unique)]
 #![feature(allow_internal_unstable)]
-#![feature(str_char)]
 #![cfg_attr(test, feature(test, rustc_private))]
 
 // Don't link to std. We are std.

branches/try/src/libstd/lib.rs

@@ -202,7 +202,7 @@ impl FromInner<libc::in_addr> for Ipv4Addr {
 impl Ipv6Addr {
     /// Create a new IPv6 address from eight 16-bit segments.
     ///
-    /// The result will represent the IP address a:b:c:d:e:f:g:h
+    /// The result will represent the IP address a:b:c:d:e:f
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16,
                h: u16) -> Ipv6Addr {