---

yaml
---
r: 127919
b: refs/heads/master
c: 8d27232
h: refs/heads/master
i:
  127917: 297ca9a
  127915: 1f6c682
  127911: 18f74ba
  127903: 770c161
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 56b86aaf35d96ec8cf8555205426eaed62427963
+refs/heads/master: 8d272321417df3a954802e42a66adda87ade5a49
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: aa98b25c4f0c10729dff37c699904ad57b8fbda8
 refs/heads/try: f1778314378f8951328206626b5ddf725898e0e6

trunk/src/compiletest/header.rs

@@ -233,7 +233,7 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> {
     parse_name_value_directive(line, "exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR
         let mut strs: Vec<String> = nv.as_slice()
-                                      .splitn(1, '=')
+                                      .splitn('=', 1)
                                       .map(|s| s.to_string())
                                       .collect();
 

trunk/src/doc/guide-ffi.md

@@ -350,9 +350,9 @@ linking to, and in the second case `bar` is the type of native library that the
 compiler is linking to. There are currently three known types of native
 libraries:
 
-* Dynamic - `#[link(name = "readline")]`
-* Static - `#[link(name = "my_build_dependency", kind = "static")]`
-* Frameworks - `#[link(name = "CoreFoundation", kind = "framework")]`
+* Dynamic - `#[link(name = "readline")]
+* Static - `#[link(name = "my_build_dependency", kind = "static")]
+* Frameworks - `#[link(name = "CoreFoundation", kind = "framework")]
 
 Note that frameworks are only available on OSX targets.
 

trunk/src/doc/rust.md

@@ -293,12 +293,13 @@ def emit_bsearch_range_table(f):
     f.write("""
 fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
     use core::cmp::{Equal, Less, Greater};
-    use core::slice::ImmutableSlice;
-    r.binary_search(|&(lo,hi)| {
+    use core::slice::ImmutableVector;
+    use core::option::None;
+    r.bsearch(|&(lo,hi)| {
         if lo <= c && c <= hi { Equal }
         else if hi < c { Less }
         else { Greater }
-    }).found().is_some()
+    }) != None
 }\n
 """)
 
@@ -351,10 +352,9 @@ def emit_conversions_module(f, lowerupper, upperlower):
     f.write("pub mod conversions {")
     f.write("""
     use core::cmp::{Equal, Less, Greater};
-    use core::slice::ImmutableSlice;
+    use core::slice::ImmutableVector;
     use core::tuple::Tuple2;
     use core::option::{Option, Some, None};
-    use core::slice;
 
     pub fn to_lower(c: char) -> char {
         match bsearch_case_table(c, LuLl_table) {
@@ -371,14 +371,11 @@ def emit_conversions_module(f, lowerupper, upperlower):
     }
 
     fn bsearch_case_table(c: char, table: &'static [(char, char)]) -> Option<uint> {
-        match table.binary_search(|&(key, _)| {
+        table.bsearch(|&(key, _)| {
             if c == key { Equal }
             else if key < c { Less }
             else { Greater }
-        }) {
-            slice::Found(i) => Some(i),
-            slice::NotFound(_) => None,
-        }
+        })
     }
 
 """)
@@ -390,8 +387,8 @@ def emit_conversions_module(f, lowerupper, upperlower):
 
 def emit_grapheme_module(f, grapheme_table, grapheme_cats):
     f.write("""pub mod grapheme {
-    use core::slice::ImmutableSlice;
-    use core::slice;
+    use core::option::{Some, None};
+    use core::slice::ImmutableVector;
 
     #[allow(non_camel_case_types)]
     #[deriving(Clone)]
@@ -403,16 +400,16 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
 
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
         use core::cmp::{Equal, Less, Greater};
-        match r.binary_search(|&(lo, hi, _)| {
+        match r.bsearch(|&(lo, hi, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::Found(idx) => {
+            Some(idx) => {
                 let (_, _, cat) = r[idx];
                 cat
             }
-            slice::NotFound(_) => GC_Any
+            None => GC_Any
         }
     }
 
@@ -430,21 +427,20 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
 def emit_charwidth_module(f, width_table):
     f.write("pub mod charwidth {\n")
     f.write("    use core::option::{Option, Some, None};\n")
-    f.write("    use core::slice::ImmutableSlice;\n")
-    f.write("    use core::slice;\n")
+    f.write("    use core::slice::ImmutableVector;\n")
     f.write("""
     fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
         use core::cmp::{Equal, Less, Greater};
-        match r.binary_search(|&(lo, hi, _, _)| {
+        match r.bsearch(|&(lo, hi, _, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::Found(idx) => {
+            Some(idx) => {
                 let (_, _, r_ncjk, r_cjk) = r[idx];
                 if is_cjk { r_cjk } else { r_ncjk }
             }
-            slice::NotFound(_) => 1
+            None => 1
         }
     }
 """)
@@ -529,19 +525,19 @@ def comp_pfun(char):
 
     f.write("""
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
+        use core::option::{Some, None};
         use core::cmp::{Equal, Less, Greater};
-        use core::slice::ImmutableSlice;
-        use core::slice;
-        match r.binary_search(|&(lo, hi, _)| {
+        use core::slice::ImmutableVector;
+        match r.bsearch(|&(lo, hi, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::Found(idx) => {
+            Some(idx) => {
                 let (_, _, result) = r[idx];
                 result
             }
-            slice::NotFound(_) => 0
+            None => 0
         }
     }\n
 """)

trunk/src/etc/unicode.py

@@ -296,7 +296,7 @@ mod tests {
     use std::prelude::*;
     use std::mem;
 
-    use slice::ImmutableSlice;
+    use slice::ImmutableVector;
     use super::{Hash, Hasher, Writer};
 
     struct MyWriterHasher;

trunk/src/libcollections/hash/mod.rs

@@ -275,7 +275,7 @@ mod tests {
 
     use str::Str;
     use string::String;
-    use slice::{Slice, ImmutableSlice};
+    use slice::{Vector, ImmutableVector};
     use vec::Vec;
 
     use super::super::{Hash, Writer};

trunk/src/libcollections/hash/sip.rs

@@ -362,7 +362,6 @@ pub struct MutItems<'a, T> {
 
 impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> {
     #[inline]
-    #[allow(deprecated)] // mut_shift_ref
     fn next(&mut self) -> Option<&'a mut T> {
         if self.nelts == 0 {
             return None;
@@ -385,7 +384,6 @@ impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> {
 
 impl<'a, T> DoubleEndedIterator<&'a mut T> for MutItems<'a, T> {
     #[inline]
-    #[allow(deprecated)] // mut_shift_ref
     fn next_back(&mut self) -> Option<&'a mut T> {
         if self.nelts == 0 {
             return None;

trunk/src/libcollections/ringbuf.rs

@@ -45,8 +45,8 @@ represents iteration over a slice.
 ## Traits
 
 A number of traits add methods that allow you to accomplish tasks with slices.
-These traits include `ImmutableSlice`, which is defined for `&[T]` types,
-and `MutableSlice`, defined for `&mut [T]` types.
+These traits include `ImmutableVector`, which is defined for `&[T]` types,
+and `MutableVector`, defined for `&mut [T]` types.
 
 An example is the method `.slice(a, b)` that returns an immutable "view" into
 a `Vec` or another slice from the index interval `[a, b)`:
@@ -98,11 +98,10 @@ use {Collection, MutableSeq};
 use vec::Vec;
 
 pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
-pub use core::slice::{Chunks, Slice, ImmutableSlice, ImmutablePartialEqSlice};
-pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
+pub use core::slice::{Chunks, Vector, ImmutableVector, ImmutableEqVector};
+pub use core::slice::{ImmutableOrdVector, MutableVector, Items, MutItems};
 pub use core::slice::{MutSplits, MutChunks};
-pub use core::slice::{bytes, MutableCloneableSlice};
-pub use core::slice::{BinarySearchResult, Found, NotFound};
+pub use core::slice::{bytes, MutableCloneableVector};
 
 // Functional utilities
 
@@ -117,7 +116,7 @@ pub trait VectorVector<T> {
     fn connect_vec(&self, sep: &T) -> Vec<T>;
 }
 
-impl<'a, T: Clone, V: Slice<T>> VectorVector<T> for &'a [V] {
+impl<'a, T: Clone, V: Vector<T>> VectorVector<T> for &'a [V] {
     fn concat_vec(&self) -> Vec<T> {
         let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
         let mut result = Vec::with_capacity(size);
@@ -559,7 +558,7 @@ fn merge_sort<T>(v: &mut [T], compare: |&T, &T| -> Ordering) {
 
 /// Extension methods for vectors such that their elements are
 /// mutable.
-pub trait MutableSliceAllocating<'a, T> {
+pub trait MutableVectorAllocating<'a, T> {
     /// Sort the vector, in place, using `compare` to compare
     /// elements.
     ///
@@ -605,7 +604,7 @@ pub trait MutableSliceAllocating<'a, T> {
     fn move_from(self, src: Vec<T>, start: uint, end: uint) -> uint;
 }
 
-impl<'a,T> MutableSliceAllocating<'a, T> for &'a mut [T] {
+impl<'a,T> MutableVectorAllocating<'a, T> for &'a mut [T] {
     #[inline]
     fn sort_by(self, compare: |&T, &T| -> Ordering) {
         merge_sort(self, compare)
@@ -622,7 +621,7 @@ impl<'a,T> MutableSliceAllocating<'a, T> for &'a mut [T] {
 
 /// Methods for mutable vectors with orderable elements, such as
 /// in-place sorting.
-pub trait MutableOrdSlice<T> {
+pub trait MutableOrdVector<T> {
     /// Sort the vector, in place.
     ///
     /// This is equivalent to `self.sort_by(|a, b| a.cmp(b))`.
@@ -668,7 +667,7 @@ pub trait MutableOrdSlice<T> {
     fn prev_permutation(self) -> bool;
 }
 
-impl<'a, T: Ord> MutableOrdSlice<T> for &'a mut [T] {
+impl<'a, T: Ord> MutableOrdVector<T> for &'a mut [T] {
     #[inline]
     fn sort(self) {
         self.sort_by(|a,b| a.cmp(b))

trunk/src/libcollections/slice.rs

@@ -894,7 +894,7 @@ mod tests {
     use {Collection, MutableSeq};
 
     use super::*;
-    use std::slice::{Slice, ImmutableSlice};
+    use std::slice::{Vector, ImmutableVector};
     use string::String;
     use vec::Vec;
 
@@ -1812,38 +1812,38 @@ mod tests {
     fn test_splitn_char_iterator() {
         let data = "\nMäry häd ä little lämb\nLittle lämb\n";
 
-        let split: Vec<&str> = data.splitn(3, ' ').collect();
+        let split: Vec<&str> = data.splitn(' ', 3).collect();
         assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
 
-        let split: Vec<&str> = data.splitn(3, |c: char| c == ' ').collect();
+        let split: Vec<&str> = data.splitn(|c: char| c == ' ', 3).collect();
         assert_eq!(split, vec!["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
 
         // Unicode
-        let split: Vec<&str> = data.splitn(3, 'ä').collect();
+        let split: Vec<&str> = data.splitn('ä', 3).collect();
         assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
 
-        let split: Vec<&str> = data.splitn(3, |c: char| c == 'ä').collect();
+        let split: Vec<&str> = data.splitn(|c: char| c == 'ä', 3).collect();
         assert_eq!(split, vec!["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
     }
 
     #[test]
     fn test_rsplitn_char_iterator() {
         let data = "\nMäry häd ä little lämb\nLittle lämb\n";
 
-        let mut split: Vec<&str> = data.rsplitn(3, ' ').collect();
+        let mut split: Vec<&str> = data.rsplitn(' ', 3).collect();
         split.reverse();
         assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
 
-        let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == ' ').collect();
+        let mut split: Vec<&str> = data.rsplitn(|c: char| c == ' ', 3).collect();
         split.reverse();
         assert_eq!(split, vec!["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
 
         // Unicode
-        let mut split: Vec<&str> = data.rsplitn(3, 'ä').collect();
+        let mut split: Vec<&str> = data.rsplitn('ä', 3).collect();
         split.reverse();
         assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
 
-        let mut split: Vec<&str> = data.rsplitn(3, |c: char| c == 'ä').collect();
+        let mut split: Vec<&str> = data.rsplitn(|c: char| c == 'ä', 3).collect();
         split.reverse();
         assert_eq!(split, vec!["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
     }

trunk/src/libcollections/str.rs

@@ -18,15 +18,12 @@ use core::default::Default;
 use core::fmt;
 use core::mem;
 use core::ptr;
-// FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
-use RawSlice = core::raw::Slice;
-use core::slice::Slice;
+use core::raw::Slice;
 
 use {Collection, Mutable, MutableSeq};
 use hash;
 use str;
-use str::{CharRange, StrAllocating, MaybeOwned, Owned};
-use MaybeOwnedSlice = str::Slice; // So many `Slice`s...
+use str::{CharRange, StrAllocating, MaybeOwned, Owned, Slice};
 use vec::Vec;
 
 /// A growable string stored as a UTF-8 encoded buffer.
@@ -133,15 +130,15 @@ impl String {
     /// ```
     pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> MaybeOwned<'a> {
         if str::is_utf8(v) {
-            return MaybeOwnedSlice(unsafe { mem::transmute(v) })
+            return Slice(unsafe { mem::transmute(v) })
         }
 
         static TAG_CONT_U8: u8 = 128u8;
         static REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8
         let mut i = 0;
         let total = v.len();
         fn unsafe_get(xs: &[u8], i: uint) -> u8 {
-            unsafe { *xs.unsafe_get(i) }
+            unsafe { *xs.unsafe_ref(i) }
         }
         fn safe_get(xs: &[u8], i: uint, total: uint) -> u8 {
             if i >= total {
@@ -499,7 +496,7 @@ impl String {
         unsafe {
             // Attempt to not use an intermediate buffer by just pushing bytes
             // directly onto this string.
-            let slice = RawSlice {
+            let slice = Slice {
                 data: self.vec.as_ptr().offset(cur_len as int),
                 len: 4,
             };

trunk/src/libcollections/string.rs

@@ -926,7 +926,7 @@ macro_rules! iterator_impl {
                 // such thing as invalid pointers and memory unsafety. The
                 // reason is performance, without doing this we can get the
                 // bench_iter_large microbenchmark down to about 30000 ns/iter
-                // (using .unsafe_get to index self.stack directly, 38000
+                // (using .unsafe_ref to index self.stack directly, 38000
                 // ns/iter with [] checked indexing), but this smashes that down
                 // to 13500 ns/iter.
                 //