---

yaml
---
r: 233718
b: refs/heads/beta
c: ef3255b
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 35eb3e8b79c60ec18e724c7a68625d7cdf9300c0
+refs/heads/beta: ef3255b063a28ef1ed8346192325cfac66398739
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/configure

@@ -602,6 +602,7 @@ valopt python "" "set path to python"
 valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located"
 valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple"
 valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path (deprecated)"
+valopt i686-linux-android-ndk "" "i686-linux-android NDK standalone path"
 valopt arm-linux-androideabi-ndk "" "arm-linux-androideabi NDK standalone path"
 valopt aarch64-linux-android-ndk "" "aarch64-linux-android NDK standalone path"
 valopt release-channel "dev" "the name of the release channel to build"
@@ -1693,6 +1694,7 @@ putvar CFG_LIBDIR_RELATIVE
 putvar CFG_DISABLE_MANAGE_SUBMODULES
 putvar CFG_AARCH64_LINUX_ANDROID_NDK
 putvar CFG_ARM_LINUX_ANDROIDEABI_NDK
+putvar CFG_I686_LINUX_ANDROID_NDK
 putvar CFG_MANDIR
 
 # Avoid spurious warnings from clang by feeding it original source on

branches/beta/mk/cfg/i686-linux-android.mk

@@ -0,0 +1,25 @@
+# i686-linux-android configuration
+CC_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-gcc
+CXX_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-g++
+CPP_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-gcc -E
+AR_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-ar
+CFG_LIB_NAME_i686-linux-android=lib$(1).so
+CFG_STATIC_LIB_NAME_i686-linux-android=lib$(1).a
+CFG_LIB_GLOB_i686-linux-android=lib$(1)-*.so
+CFG_LIB_DSYM_GLOB_i686-linux-android=lib$(1)-*.dylib.dSYM
+CFG_JEMALLOC_CFLAGS_i686-linux-android := -D__i686__ -DANDROID -D__ANDROID__ $(CFLAGS)
+CFG_GCCISH_CFLAGS_i686-linux-android := -Wall -g -fPIC -D__i686__ -DANDROID -D__ANDROID__ $(CFLAGS)
+CFG_GCCISH_CXXFLAGS_i686-linux-android := -fno-rtti $(CXXFLAGS)
+CFG_GCCISH_LINK_FLAGS_i686-linux-android := -shared -fPIC -ldl -g -lm -lsupc++
+CFG_GCCISH_DEF_FLAG_i686-linux-android := -Wl,--export-dynamic,--dynamic-list=
+CFG_LLC_FLAGS_i686-linux-android :=
+CFG_INSTALL_NAME_i686-linux-android =
+CFG_EXE_SUFFIX_i686-linux-android :=
+CFG_WINDOWSY_i686-linux-android :=
+CFG_UNIXY_i686-linux-android := 1
+CFG_LDPATH_i686-linux-android :=
+CFG_RUN_i686-linux-android=
+CFG_RUN_TARG_i686-linux-android=
+RUSTC_FLAGS_i686-linux-android :=
+RUSTC_CROSS_FLAGS_i686-linux-android :=
+CFG_GNU_TRIPLE_i686-linux-android := i686-linux-android

branches/beta/src/compiletest/compiletest.rs

@@ -19,6 +19,7 @@
 #![feature(str_char)]
 #![feature(test)]
 #![feature(vec_push_all)]
+#![feature(path_components_peek)]
 
 #![deny(warnings)]
 

branches/beta/src/compiletest/runtest.rs

@@ -25,7 +25,7 @@ use std::fs::{self, File};
 use std::io::BufReader;
 use std::io::prelude::*;
 use std::net::TcpStream;
-use std::path::{Path, PathBuf};
+use std::path::{Path, PathBuf, Component};
 use std::process::{Command, Output, ExitStatus};
 
 pub fn run(config: Config, testfile: &Path) {
@@ -952,6 +952,9 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError>,
     //    filename:line1:col1: line2:col2: *warning:* msg
     // where line1:col1: is the starting point, line2:col2:
     // is the ending point, and * represents ANSI color codes.
+    //
+    // This pattern is ambiguous on windows, because filename may contain
+    // a colon, so any path prefix must be detected and removed first.
     for line in proc_res.stderr.lines() {
         let mut was_expected = false;
         let mut prev = 0;
@@ -1006,7 +1009,16 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError>,
     }
 }
 
-fn is_compiler_error_or_warning(line: &str) -> bool {
+fn is_compiler_error_or_warning(mut line: &str) -> bool {
+    // Remove initial prefix which may contain a colon
+    let mut components = Path::new(line).components();
+    if let Some(Component::Prefix(_)) = components.peek() {
+        components.next();
+    }
+
+    // Safe as path was originally constructed from a &str ^
+    line = components.as_path().to_str().unwrap();
+
     let mut i = 0;
     return
         scan_until_char(line, ':', &mut i) &&

branches/beta/src/doc/reference.md

@@ -1452,7 +1452,7 @@ fn draw_twice<T: Shape>(surface: Surface, sh: T) {
 }
 ```
 
-Traits also define an [trait object](#trait-objects) with the same
+Traits also define a [trait object](#trait-objects) with the same
 name as the trait. Values of this type are created by coercing from a
 pointer of some specific type to a pointer of trait type. For example,
 `&T` could be coerced to `&Shape` if `T: Shape` holds (and similarly
@@ -1881,11 +1881,15 @@ type int8_t = i8;
 - `no_start` - disable linking to the `native` crate, which specifies the
   "start" language item.
 - `no_std` - disable linking to the `std` crate.
-- `plugin` — load a list of named crates as compiler plugins, e.g.
+- `plugin` - load a list of named crates as compiler plugins, e.g.
              `#![plugin(foo, bar)]`. Optional arguments for each plugin,
              i.e. `#![plugin(foo(... args ...))]`, are provided to the plugin's
              registrar function.  The `plugin` feature gate is required to use
              this attribute.
+- `recursion_limit` - Sets the maximum depth for potentially
+                      infinitely-recursive compile-time operations like
+                      auto-dereference or macro expansion. The default is
+                      `#![recursion_limit="64"]`.
 
 ### Module-only attributes
 

branches/beta/src/doc/trpl/error-handling.md

@@ -208,8 +208,8 @@ Because these kinds of situations are relatively rare, use panics sparingly.
 
 In certain circumstances, even though a function may fail, we may want to treat
 it as a panic instead. For example, `io::stdin().read_line(&mut buffer)` returns
-a `Result<usize>`, when there is an error reading the line. This allows us to
-handle and possibly recover from error.
+a `Result<usize>`, which can indicate an error if one occurs when reading the line.
+This allows us to handle and possibly recover from errors.
 
 If we don't want to handle this error, and would rather just abort the program,
 we can use the `unwrap()` method:

branches/beta/src/doc/trpl/testing.md

@@ -219,6 +219,66 @@ fn it_works() {
 This is a very common use of `assert_eq!`: call some function with
 some known arguments and compare it to the expected output.
 
+# The `ignore` attribute
+
+Sometimes a few specific tests can be very time-consuming to execute. These
+can be disabled by default by using the `ignore` attribute:
+
+```rust
+#[test]
+fn it_works() {
+    assert_eq!(4, add_two(2));
+}
+
+#[test]
+#[ignore]
+fn expensive_test() {
+    // code that takes an hour to run
+}
+```
+
+Now we run our tests and see that `it_works` is run, but `expensive_test` is
+not:
+
+```bash
+$ cargo test
+   Compiling adder v0.0.1 (file:///home/you/projects/adder)
+     Running target/adder-91b3e234d4ed382a
+
+running 2 tests
+test expensive_test ... ignored
+test it_works ... ok
+
+test result: ok. 1 passed; 0 failed; 1 ignored; 0 measured
+
+   Doc-tests adder
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
+```
+
+The expensive tests can be run explicitly using `cargo test -- --ignored`:
+
+```bash
+$ cargo test -- --ignored
+     Running target/adder-91b3e234d4ed382a
+
+running 1 test
+test expensive_test ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
+
+   Doc-tests adder
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
+```
+
+The `--ignored` argument is an argument to the test binary, and not to cargo,
+which is why the command is `cargo test -- --ignored`.
+
 # The `tests` module
 
 There is one way in which our existing example is not idiomatic: it's

branches/beta/src/libcollections/string.rs

@@ -813,11 +813,7 @@ impl<'a> Extend<&'a char> for String {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Extend<&'a str> for String {
     fn extend<I: IntoIterator<Item=&'a str>>(&mut self, iterable: I) {
-        let iterator = iterable.into_iter();
-        // A guess that at least one byte per iterator element will be needed.
-        let (lower_bound, _) = iterator.size_hint();
-        self.reserve(lower_bound);
-        for s in iterator {
+        for s in iterable {
             self.push_str(s)
         }
     }

branches/beta/src/liblibc/lib.rs

@@ -102,6 +102,7 @@ pub use types::os::arch::extra::*;
 pub use consts::os::c95::*;
 pub use consts::os::posix88::*;
 pub use consts::os::posix01::*;
+pub use consts::os::posix08::*;
 pub use consts::os::bsd44::*;
 pub use consts::os::extra::*;
 
@@ -466,18 +467,19 @@ pub mod types {
                 pub type off_t = i32;
                 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;
             }
-            #[cfg(any(target_arch = "x86",
+            #[cfg(any(all(any(target_arch = "arm", target_arch = "x86"),
+                          not(target_os = "android")),
                       target_arch = "le32",
-                      target_arch = "powerpc",
-                      all(any(target_arch = "arm", target_arch = "x86"),
-                          not(target_os = "android"))))]
+                      target_arch = "powerpc"))]
             pub mod posix01 {
                 use types::os::arch::c95::{c_short, c_long, time_t};
                 use types::os::arch::posix88::{dev_t, gid_t, ino_t};
@@ -523,12 +525,13 @@ pub mod types {
                     pub __size: [u32; 9]
                 }
             }
+
             #[cfg(all(any(target_arch = "arm", target_arch = "x86"),
-                          target_os = "android"))]
+                      target_os = "android"))]
             pub mod posix01 {
-                use types::os::arch::c95::{c_uchar, c_uint, c_ulong, time_t};
+                use types::os::arch::c95::{c_uchar, c_uint, c_ulong, c_long, time_t};
                 use types::os::arch::c99::{c_longlong, c_ulonglong};
-                use types::os::arch::posix88::{uid_t, gid_t, ino_t};
+                use types::os::arch::posix88::{uid_t, gid_t};
 
                 pub type nlink_t = u16;
                 pub type blksize_t = u32;
@@ -538,15 +541,15 @@ pub mod types {
                 #[derive(Copy, Clone)] pub struct stat {
                     pub st_dev: c_ulonglong,
                     pub __pad0: [c_uchar; 4],
-                    pub __st_ino: ino_t,
+                    pub __st_ino: c_long,
                     pub st_mode: c_uint,
                     pub st_nlink: c_uint,
                     pub st_uid: uid_t,
                     pub st_gid: gid_t,
                     pub st_rdev: c_ulonglong,
                     pub __pad3: [c_uchar; 4],
                     pub st_size: c_longlong,
-                    pub st_blksize: blksize_t,
+                    pub st_blksize: c_ulong,
                     pub st_blocks: c_ulonglong,
                     pub st_atime: time_t,
                     pub st_atime_nsec: c_ulong,
@@ -568,6 +571,7 @@ pub mod types {
                     pub __size: [u32; 9]
                 }
             }
+
             #[cfg(any(target_arch = "mips",
                       target_arch = "mipsel"))]
             pub mod posix01 {
@@ -3608,6 +3612,8 @@ pub mod consts {
             pub const RUSAGE_THREAD: c_int = 1;
         }
         pub mod posix08 {
+            use types::os::arch::c95::c_int;
+            pub const O_CLOEXEC: c_int = 0x80000;
         }
         #[cfg(any(target_arch = "arm",
                   target_arch = "aarch64",
@@ -4267,7 +4273,15 @@ pub mod consts {
             pub const RUSAGE_CHILDREN: c_int = -1;
             pub const RUSAGE_THREAD: c_int = 1;
         }
+        #[cfg(target_os = "freebsd")]
         pub mod posix08 {
+            use types::os::arch::c95::c_int;
+            pub const O_CLOEXEC: c_int = 0x100000;
+        }
+        #[cfg(target_os = "dragonfly")]
+        pub mod posix08 {
+            use types::os::arch::c95::c_int;
+            pub const O_CLOEXEC: c_int = 0x20000;
         }
         pub mod bsd44 {
             use types::os::arch::c95::c_int;
@@ -4710,7 +4724,15 @@ pub mod consts {
             pub const RUSAGE_CHILDREN: c_int = -1;
             pub const RUSAGE_THREAD: c_int = 1;
         }
+        #[cfg(any(target_os = "bitrig", target_os = "openbsd"))]
         pub mod posix08 {
+            use types::os::arch::c95::c_int;
+            pub const O_CLOEXEC: c_int = 0x10000;
+        }
+        #[cfg(target_os = "netbsd")]
+        pub mod posix08 {
+            use types::os::arch::c95::c_int;
+            pub const O_CLOEXEC: c_int = 0x400000;
         }
         pub mod bsd44 {
             use types::os::arch::c95::c_int;
@@ -5148,6 +5170,8 @@ pub mod consts {
             pub const RUSAGE_THREAD: c_int = 1;
         }
         pub mod posix08 {
+            use types::os::arch::c95::c_int;
+            pub const O_CLOEXEC: c_int = 0x1000000;
         }
         pub mod bsd44 {
             use types::os::arch::c95::c_int;

branches/beta/src/librustc/diagnostics.rs

@@ -731,9 +731,14 @@ type X = u32; // ok!
 "##,
 
 E0133: r##"
-Using unsafe functionality, such as dereferencing raw pointers and calling
-functions via FFI or marked as unsafe, is potentially dangerous and disallowed
-by safety checks. These safety checks can be relaxed for a section of the code
+Using unsafe functionality, is potentially dangerous and disallowed
+by safety checks. Examples:
+
+- Dereferencing raw pointers
+- Calling functions via FFI
+- Calling functions marked unsafe
+
+These safety checks can be relaxed for a section of the code
 by wrapping the unsafe instructions with an `unsafe` block. For instance:
 
 ```
@@ -831,9 +836,7 @@ is a size mismatch in one of the impls.
 It is also possible to manually transmute:
 
 ```
-let result: SomeType = mem::uninitialized();
-unsafe { copy_nonoverlapping(&v, &result) };
-result // `v` transmuted to type `SomeType`
+ptr::read(&v as *const _ as *const SomeType) // `v` transmuted to `SomeType`
 ```
 "##,