---

yaml
---
r: 235351
b: refs/heads/stable
c: 69521af
h: refs/heads/master
i:
  235349: 4732276
  235347: 46f6d26
  235343: b94de65
v: v3

Author: reem

[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: 78547d2b951c4499142fa586dfb852ba35d61655
+refs/heads/stable: 69521affbb6c177192522606d4f7f09f5c07537c
 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

@@ -61,6 +61,7 @@ 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;
@@ -69,6 +70,7 @@ 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};
@@ -82,10 +84,6 @@ 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;
 
@@ -134,10 +132,6 @@ impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
     }
 }
 
-/*
-Section: Iterators
-*/
-
 // Helper functions used for Unicode normalization
 fn canonical_sort(comb: &mut [(char, u8)]) {
     let len = comb.len();
@@ -382,10 +376,6 @@ 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
@@ -414,15 +404,6 @@ impl ToOwned for str {
     }
 }
 
-/*
-Section: CowString
-*/
-
-/*
-Section: Trait implementations
-*/
-
-
 /// Any string that can be represented as a slice.
 #[lang = "str"]
 #[cfg(not(test))]
@@ -1924,4 +1905,14 @@ 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,6 +29,7 @@ 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)]
@@ -741,6 +742,16 @@ 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

@@ -44,6 +44,7 @@
 #![feature(str_escape)]
 #![feature(str_match_indices)]
 #![feature(str_utf16)]
+#![feature(box_str)]
 #![feature(subslice_offset)]
 #![feature(test)]
 #![feature(unboxed_closures)]

branches/stable/src/libcollectionstest/lib.rs

@@ -1746,6 +1746,14 @@ fn to_uppercase() {
     assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ");
 }
 
+#[test]
+fn test_into_string() {
+    // The only way to acquire a Box<str> in the first place is through a String, so just
+    // test that we can round-trip between Box<str> and String.
+    let string = String::from("Some text goes here");
+    assert_eq!(string.clone().into_boxed_slice().into_string(), string);
+}
+
 mod pattern {
     use std::str::pattern::Pattern;
     use std::str::pattern::{Searcher, ReverseSearcher};

branches/stable/src/libcollectionstest/str.rs

@@ -374,6 +374,13 @@ fn test_extend_ref() {
     assert_eq!(&a, "foobar");
 }
 
+#[test]
+fn test_into_boxed_slice() {
+    let xs = String::from("hello my name is bob");
+    let ys = xs.into_boxed_slice();
+    assert_eq!(&*ys, "hello my name is bob");
+}
+
 #[bench]
 fn bench_with_capacity(b: &mut Bencher) {
     b.iter(|| {

branches/stable/src/libcollectionstest/string.rs

@@ -175,12 +175,6 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
     fn is_pretty(&self) -> bool {
         self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
     }
-
-    /// Returns the wrapped `Formatter`.
-    #[unstable(feature = "debug_builder_formatter", reason = "recently added")]
-    pub fn formatter(&mut self) -> &mut fmt::Formatter<'b> {
-        &mut self.fmt
-    }
 }
 
 struct DebugInner<'a, 'b: 'a> {

branches/stable/src/libcore/fmt/builders.rs

@@ -1488,19 +1488,20 @@ macro_rules! tuple {
         impl<$($name:Debug),*> Debug for ($($name,)*) {
             #[allow(non_snake_case, unused_assignments)]
             fn fmt(&self, f: &mut Formatter) -> Result {
-                let mut builder = f.debug_tuple("");
+                try!(write!(f, "("));
                 let ($(ref $name,)*) = *self;
                 let mut n = 0;
                 $(
-                    builder.field($name);
+                    if n > 0 {
+                        try!(write!(f, ", "));
+                    }
+                    try!(write!(f, "{:?}", *$name));
                     n += 1;
                 )*
-
                 if n == 1 {
-                    try!(write!(builder.formatter(), ","));
+                    try!(write!(f, ","));
                 }
-
-                builder.finish()
+                write!(f, ")")
             }
         }
         peel! { $($name,)* }

branches/stable/src/libcore/fmt/mod.rs

@@ -960,100 +960,6 @@ pub mod types {
             }
         }
 
-        #[cfg(target_arch = "x86")]
-        pub mod arch {
-            pub mod c95 {
-                pub type c_char = i8;
-                pub type c_schar = i8;
-                pub type c_uchar = u8;
-                pub type c_short = i16;
-                pub type c_ushort = u16;
-                pub type c_int = i32;
-                pub type c_uint = u32;
-                pub type c_long = i32;
-                pub type c_ulong = u32;
-                pub type c_float = f32;
-                pub type c_double = f64;
-                pub type size_t = u32;
-                pub type ptrdiff_t = i32;
-                pub type clock_t = i32;
-                pub type time_t = i32;
-                pub type suseconds_t = i32;
-                pub type wchar_t = i32;
-            }
-            pub mod c99 {
-                pub type c_longlong = i64;
-                pub type c_ulonglong = u64;
-                pub type intptr_t = i32;
-                pub type uintptr_t = u32;
-                pub type intmax_t = i64;
-                pub type uintmax_t = u64;
-            }
-            pub mod posix88 {
-                pub type off_t = i64;
-                pub type dev_t = u32;
-                pub type ino_t = u32;
-                pub type pid_t = i32;
-                pub type uid_t = u32;
-                pub type gid_t = u32;
-                pub type useconds_t = u32;
-                pub type mode_t = u16;
-                pub type ssize_t = i32;
-            }
-            pub mod posix01 {
-                use types::common::c95::{c_void};
-                use types::common::c99::{uint8_t, uint32_t, int32_t};
-                use types::os::arch::c95::{c_long, time_t};
-                use types::os::arch::posix88::{dev_t, gid_t, ino_t};
-                use types::os::arch::posix88::{mode_t, off_t};
-                use types::os::arch::posix88::{uid_t};
-
-                pub type nlink_t = u16;
-                pub type blksize_t = i32;
-                pub type blkcnt_t = i64;
-                pub type fflags_t = u32;
-                #[repr(C)]
-                #[derive(Copy, Clone)] pub struct stat {
-                    pub st_dev: dev_t,
-                    pub st_ino: ino_t,
-                    pub st_mode: mode_t,
-                    pub st_nlink: nlink_t,
-                    pub st_uid: uid_t,
-                    pub st_gid: gid_t,
-                    pub st_rdev: dev_t,
-                    pub st_atime: time_t,
-                    pub st_atime_nsec: c_long,
-                    pub st_mtime: time_t,
-                    pub st_mtime_nsec: c_long,
-                    pub st_ctime: time_t,
-                    pub st_ctime_nsec: c_long,
-                    pub st_size: off_t,
-                    pub st_blocks: blkcnt_t,
-                    pub st_blksize: blksize_t,
-                    pub st_flags: fflags_t,
-                    pub st_gen: uint32_t,
-                    pub st_lspare: int32_t,
-                    pub st_birthtime: time_t,
-                    pub st_birthtime_nsec: c_long,
-                    pub __unused: [uint8_t; 2],
-                }
-
-                #[repr(C)]
-                #[derive(Copy, Clone)] pub struct utimbuf {
-                    pub actime: time_t,
-                    pub modtime: time_t,
-                }
-
-                pub type pthread_attr_t = *mut c_void;
-            }
-            pub mod posix08 {
-            }
-            pub mod bsd44 {
-            }
-            pub mod extra {
-            }
-        }
-
         #[cfg(target_arch = "x86_64")]
         pub mod arch {
             pub mod c95 {

branches/stable/src/liblibc/lib.rs

@@ -368,7 +368,6 @@ impl Target {
             arm_linux_androideabi,
             aarch64_linux_android,
 
-            i686_unknown_freebsd,
             x86_64_unknown_freebsd,
 
             i686_unknown_dragonfly,

branches/stable/src/librustc_back/target/i686_unknown_freebsd.rs

@@ -269,18 +269,14 @@ impl File {
     /// will be extended to `size` and have all of the intermediate data filled
     /// in with 0s.
     ///
-    /// # Errors
-    ///
-    /// This function will return an error if the file is not opened for writing.
-    ///
     /// # Examples
     ///
     /// ```no_run
     /// use std::fs::File;
     ///
     /// # fn foo() -> std::io::Result<()> {
-    /// let mut f = try!(File::create("foo.txt"));
-    /// try!(f.set_len(10));
+    /// let mut f = try!(File::open("foo.txt"));
+    /// try!(f.set_len(0));
     /// # Ok(())
     /// # }
     /// ```