---

yaml
---
r: 235390
b: refs/heads/stable
c: 218eb12
h: refs/heads/master
v: v3

Author: wthrowe

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: c044791d80ea0dc5c4b57b6030a67b69f8510239
+refs/heads/stable: 218eb1277d95090c7db5ba0242194b497784d04e
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/mk/cfg/i686-unknown-freebsd.mk

@@ -15,7 +15,7 @@
 #![feature(libc)]
 #![feature(path_ext)]
 #![feature(rustc_private)]
-#![feature(slice_splits)]
+#![feature(slice_extras)]
 #![feature(str_char)]
 #![feature(test)]
 #![feature(vec_push_all)]
@@ -90,7 +90,9 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           optopt("", "lldb-python-dir", "directory containing LLDB's python module", "PATH"),
           optflag("h", "help", "show this message"));
 
-    let (argv0, args_) = args.split_first().unwrap();
+    assert!(!args.is_empty());
+    let argv0 = args[0].clone();
+    let args_ = args.tail();
     if args[1] == "-h" || args[1] == "--help" {
         let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0);
         println!("{}", getopts::usage(&message, &groups));

branches/stable/src/compiletest/compiletest.rs

@@ -344,7 +344,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
         check_lines,
         breakpoint_lines
     } = parse_debugger_commands(testfile, "gdb");
-    let mut cmds = commands.join("\n");
+    let mut cmds = commands.connect("\n");
 
     // compile test file (it should have 'compile-flags:-g' in the header)
     let compiler_run_result = compile_test(config, props, testfile);
@@ -799,7 +799,7 @@ fn cleanup_debug_info_options(options: &Option<String>) -> Option<String> {
         split_maybe_args(options).into_iter()
                                  .filter(|x| !options_to_remove.contains(x))
                                  .collect::<Vec<String>>()
-                                 .join(" ");
+                                 .connect(" ");
     Some(new_options)
 }
 
@@ -1412,15 +1412,15 @@ fn make_cmdline(libpath: &str, prog: &str, args: &[String]) -> String {
 
     // Linux and mac don't require adjusting the library search path
     if cfg!(unix) {
-        format!("{} {}", prog, args.join(" "))
+        format!("{} {}", prog, args.connect(" "))
     } else {
         // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
         // for diagnostic purposes
         fn lib_path_cmd_prefix(path: &str) -> String {
             format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
         }
 
-        format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.join(" "))
+        format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
     }
 }
 

branches/stable/src/compiletest/runtest.rs

@@ -282,65 +282,34 @@ impl<T> [T] {
 
     /// Returns all but the first element of a slice.
     #[unstable(feature = "slice_extras", reason = "likely to be renamed")]
-    #[deprecated(since = "1.3.0", reason = "superseded by split_first")]
     #[inline]
     pub fn tail(&self) -> &[T] {
         core_slice::SliceExt::tail(self)
     }
 
-    /// Returns the first and all the rest of the elements of a slice.
-    #[unstable(feature = "slice_splits", reason = "new API")]
-    #[inline]
-    pub fn split_first(&self) -> Option<(&T, &[T])> {
-        core_slice::SliceExt::split_first(self)
-    }
-
     /// Returns all but the first element of a mutable slice
-    #[unstable(feature = "slice_extras", reason = "likely to be renamed or removed")]
-    #[deprecated(since = "1.3.0", reason = "superseded by split_first_mut")]
+    #[unstable(feature = "slice_extras",
+               reason = "likely to be renamed or removed")]
     #[inline]
     pub fn tail_mut(&mut self) -> &mut [T] {
         core_slice::SliceExt::tail_mut(self)
     }
 
-    /// Returns the first and all the rest of the elements of a slice.
-    #[unstable(feature = "slice_splits", reason = "new API")]
-    #[inline]
-    pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])> {
-        core_slice::SliceExt::split_first_mut(self)
-    }
-
     /// Returns all but the last element of a slice.
     #[unstable(feature = "slice_extras", reason = "likely to be renamed")]
-    #[deprecated(since = "1.3.0", reason = "superseded by split_last")]
     #[inline]
     pub fn init(&self) -> &[T] {
         core_slice::SliceExt::init(self)
     }
 
-    /// Returns the last and all the rest of the elements of a slice.
-    #[unstable(feature = "slice_splits", reason = "new API")]
-    #[inline]
-    pub fn split_last(&self) -> Option<(&T, &[T])> {
-        core_slice::SliceExt::split_last(self)
-
-    }
-
     /// Returns all but the last element of a mutable slice
-    #[unstable(feature = "slice_extras", reason = "likely to be renamed or removed")]
-    #[deprecated(since = "1.3.0", reason = "superseded by split_last_mut")]
+    #[unstable(feature = "slice_extras",
+               reason = "likely to be renamed or removed")]
     #[inline]
     pub fn init_mut(&mut self) -> &mut [T] {
         core_slice::SliceExt::init_mut(self)
     }
 
-    /// Returns the last and all the rest of the elements of a slice.
-    #[unstable(feature = "slice_splits", since = "1.3.0")]
-    #[inline]
-    pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])> {
-        core_slice::SliceExt::split_last_mut(self)
-    }
-
     /// Returns the last element of a slice, or `None` if it is empty.
     ///
     /// # Examples
@@ -1056,17 +1025,6 @@ pub trait SliceConcatExt<T: ?Sized> {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn concat(&self) -> Self::Output;
 
-    /// Flattens a slice of `T` into a single value `Self::Output`, placing a
-    /// given separator between each.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// assert_eq!(["hello", "world"].join(" "), "hello world");
-    /// ```
-    #[stable(feature = "rename_connect_to_join", since = "1.3.0")]
-    fn join(&self, sep: &T) -> Self::Output;
-
     /// Flattens a slice of `T` into a single value `Self::Output`, placing a
     /// given separator between each.
     ///
@@ -1076,7 +1034,6 @@ pub trait SliceConcatExt<T: ?Sized> {
     /// assert_eq!(["hello", "world"].connect(" "), "hello world");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    #[deprecated(since = "1.3.0", reason = "renamed to join")]
     fn connect(&self, sep: &T) -> Self::Output;
 }
 
@@ -1092,7 +1049,7 @@ impl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {
         result
     }
 
-    fn join(&self, sep: &T) -> Vec<T> {
+    fn connect(&self, sep: &T) -> Vec<T> {
         let size = self.iter().fold(0, |acc, v| acc + v.borrow().len());
         let mut result = Vec::with_capacity(size + self.len());
         let mut first = true;
@@ -1102,10 +1059,6 @@ impl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {
         }
         result
     }
-
-    fn connect(&self, sep: &T) -> Vec<T> {
-        self.join(sep)
-    }
 }
 
 /// An iterator that yields the element swaps needed to produce

branches/stable/src/libcollections/slice.rs

@@ -61,7 +61,6 @@ use core::result::Result;
 use core::str as core_str;
 use core::str::pattern::Pattern;
 use core::str::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};
-use core::mem;
 use rustc_unicode::str::{UnicodeStr, Utf16Encoder};
 
 use vec_deque::VecDeque;
@@ -70,7 +69,6 @@ use string::String;
 use rustc_unicode;
 use vec::Vec;
 use slice::SliceConcatExt;
-use boxed::Box;
 
 pub use core::str::{FromStr, Utf8Error};
 pub use core::str::{Lines, LinesAny, CharRange};
@@ -84,6 +82,10 @@ pub use core::str::{from_utf8_unchecked, ParseBoolError};
 pub use rustc_unicode::str::{SplitWhitespace, Words, Graphemes, GraphemeIndices};
 pub use core::str::pattern;
 
+/*
+Section: Creating a string
+*/
+
 impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
     type Output = String;
 
@@ -103,7 +105,7 @@ impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
         result
     }
 
-    fn join(&self, sep: &str) -> String {
+    fn connect(&self, sep: &str) -> String {
         if self.is_empty() {
             return String::new();
         }
@@ -130,12 +132,12 @@ impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
         }
         result
     }
-
-    fn connect(&self, sep: &str) -> String {
-        self.join(sep)
-    }
 }
 
+/*
+Section: Iterators
+*/
+
 // Helper functions used for Unicode normalization
 fn canonical_sort(comb: &mut [(char, u8)]) {
     let len = comb.len();
@@ -380,6 +382,10 @@ impl<'a> Iterator for Utf16Units<'a> {
     fn size_hint(&self) -> (usize, Option<usize>) { self.encoder.size_hint() }
 }
 
+/*
+Section: Misc
+*/
+
 // Return the initial codepoint accumulator for the first byte.
 // The first byte is special, only want bottom 5 bits for width 2, 4 bits
 // for width 3, and 3 bits for width 4
@@ -408,6 +414,15 @@ impl ToOwned for str {
     }
 }
 
+/*
+Section: CowString
+*/
+
+/*
+Section: Trait implementations
+*/
+
+
 /// Any string that can be represented as a slice.
 #[lang = "str"]
 #[cfg(not(test))]
@@ -1909,14 +1924,4 @@ impl str {
     pub fn escape_unicode(&self) -> String {
         self.chars().flat_map(|c| c.escape_unicode()).collect()
     }
-
-    /// Converts the `Box<str>` into a `String` without copying or allocating.
-    #[unstable(feature = "box_str",
-               reason = "recently added, matches RFC")]
-    pub fn into_string(self: Box<str>) -> String {
-        unsafe {
-            let slice = mem::transmute::<Box<str>, Box<[u8]>>(self);
-            String::from_utf8_unchecked(slice.into_vec())
-        }
-    }
 }

branches/stable/src/libcollections/str.rs

@@ -29,7 +29,6 @@ use borrow::{Cow, IntoCow};
 use range::RangeArgument;
 use str::{self, FromStr, Utf8Error, Chars};
 use vec::{DerefVec, Vec, as_vec};
-use boxed::Box;
 
 /// A growable string stored as a UTF-8 encoded buffer.
 #[derive(Clone, PartialOrd, Eq, Ord)]
@@ -742,16 +741,6 @@ impl String {
             string: self_ptr,
         }
     }
-
-    /// Converts the string into `Box<str>`.
-    ///
-    /// Note that this will drop any excess capacity.
-    #[unstable(feature = "box_str",
-               reason = "recently added, matches RFC")]
-    pub fn into_boxed_slice(self) -> Box<str> {
-        let slice = self.vec.into_boxed_slice();
-        unsafe { mem::transmute::<Box<[u8]>, Box<str>>(slice) }
-    }
 }
 
 impl FromUtf8Error {

branches/stable/src/libcollections/string.rs

@@ -108,7 +108,7 @@ impl<T> VecDeque<T> {
         ptr::write(self.ptr.offset(off as isize), t);
     }
 
-    /// Returns true if and only if the buffer is at capacity
+    /// Returns true iff the buffer is at capacity
     #[inline]
     fn is_full(&self) -> bool { self.cap - self.len() == 1 }
 

branches/stable/src/libcollections/vec_deque.rs

@@ -36,26 +36,24 @@
 #![feature(rustc_private)]
 #![feature(slice_bytes)]
 #![feature(slice_chars)]
-#![feature(slice_splits)]
+#![feature(slice_extras)]
 #![feature(slice_position_elem)]
 #![feature(split_off)]
 #![feature(step_by)]
 #![feature(str_char)]
 #![feature(str_escape)]
 #![feature(str_match_indices)]
 #![feature(str_utf16)]
-#![feature(box_str)]
 #![feature(subslice_offset)]
 #![feature(test)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]
 #![feature(vec_deque_retain)]
 #![feature(vec_from_raw_buf)]
 #![feature(vec_push_all)]
+#![feature(vec_split_off)]
 #![feature(vecmap)]
 
-#![allow(deprecated)]
-
 #[macro_use] extern crate log;
 
 extern crate collections;