---

yaml
---
r: 128471
b: refs/heads/auto
c: cd6eb12
h: refs/heads/master
i:
  128469: 36431f6
  128467: e8020ad
  128463: c0c3900
v: v3

Author: tbu-

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: dee8313364185046670044f2f9faa0561166f882
+refs/heads/auto: cd6eb122707f5f6dddffd871e9e54c4561e4e5f0
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/CONTRIBUTING.md

@@ -16,8 +16,7 @@ please do two things:
 
 2. Run the full Rust test suite with the `make check` command.  You're
    not off the hook even if you just stick to documentation; code
-   examples in the docs are tested as well! Although for simple
-   wording or grammar fixes, this is probably unnecessary.
+   examples in the docs are tested as well!
 
 Pull requests will be treated as "review requests", and we will give
 feedback we expect to see corrected on

branches/auto/README.md

@@ -32,7 +32,7 @@ documentation.
 
     To build from the [tarball] do:
 
-        $ curl -O https://static.rust-lang.org/dist/rust-nightly.tar.gz
+        $ curl -O http://static.rust-lang.org/dist/rust-nightly.tar.gz
         $ tar -xzf rust-nightly.tar.gz
         $ cd rust-nightly
 
@@ -75,7 +75,7 @@ To easily build on windows we can use [MSYS2](http://sourceforge.net/projects/ms
         $ make && make install
 
 [repo]: https://github.com/rust-lang/rust
-[tarball]: https://static.rust-lang.org/dist/rust-nightly.tar.gz
+[tarball]: http://static.rust-lang.org/dist/rust-nightly.tar.gz
 [tutorial]: http://doc.rust-lang.org/tutorial.html
 
 ## Notes

branches/auto/mk/main.mk

@@ -139,10 +139,6 @@ endif
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
 
-# Landing pads require a lot of codegen. We can get through bootstrapping faster
-# by not emitting them.
-RUSTFLAGS_STAGE0 += -Z no-landing-pads
-
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 

branches/auto/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();
 

branches/auto/src/compiletest/runtest.rs

@@ -16,8 +16,7 @@ use header::TestProps;
 use header;
 use procsrv;
 use util::logv;
-#[cfg(target_os = "windows")]
-#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+#[cfg(target_os = "win32")]
 use util;
 
 use std::io::File;
@@ -31,7 +30,6 @@ use std::os;
 use std::str;
 use std::string::String;
 use std::task;
-use std::time::Duration;
 use test::MetricMap;
 
 pub fn run(config: Config, testfile: String) {
@@ -402,7 +400,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 .expect(format!("failed to exec `{}`", config.adb_path).as_slice());
             loop {
                 //waiting 1 second for gdbserver start
-                timer::sleep(Duration::milliseconds(1000));
+                timer::sleep(1000);
                 let result = task::try(proc() {
                     tcp::TcpStream::connect("127.0.0.1", 5039).unwrap();
                 });
@@ -818,8 +816,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         format!("{}:{}:", testfile.display(), ee.line)
     }).collect::<Vec<String> >();
 
-    #[cfg(target_os = "windows")]
-    #[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+    #[cfg(target_os = "win32")]
     fn to_lower( s : &str ) -> String {
         let i = s.chars();
         let c : Vec<char> = i.map( |c| {
@@ -832,8 +829,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         String::from_chars(c.as_slice())
     }
 
-    #[cfg(target_os = "windows")]
-    #[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+    #[cfg(target_os = "win32")]
     fn prefix_matches( line : &str, prefix : &str ) -> bool {
         to_lower(line).as_slice().starts_with(to_lower(prefix).as_slice())
     }
@@ -1250,16 +1246,14 @@ fn make_cmdline(_libpath: &str, prog: &str, args: &[String]) -> String {
     format!("{} {}", prog, args.connect(" "))
 }
 
-#[cfg(target_os = "windows")]
-#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+#[cfg(target_os = "win32")]
 fn make_cmdline(libpath: &str, prog: &str, args: &[String]) -> String {
     format!("{} {} {}", lib_path_cmd_prefix(libpath), prog, args.connect(" "))
 }
 
 // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
 // for diagnostic purposes
-#[cfg(target_os = "windows")]
-#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+#[cfg(target_os = "win32")]
 fn lib_path_cmd_prefix(path: &str) -> String {
     format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
 }

branches/auto/src/compiletest/util.rs

@@ -10,15 +10,13 @@
 
 use common::Config;
 
-#[cfg(target_os = "windows")]
-#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+#[cfg(target_os = "win32")]
 use std::os::getenv;
 
 /// Conversion table from triple OS name to Rust SYSNAME
 static OS_TABLE: &'static [(&'static str, &'static str)] = &[
-    ("mingw32", "windows"),
-    ("win32", "windows"),
-    ("windows", "windows"),
+    ("mingw32", "win32"),
+    ("win32", "win32"),
     ("darwin", "macos"),
     ("android", "android"),
     ("linux", "linux"),
@@ -35,8 +33,7 @@ pub fn get_os(triple: &str) -> &'static str {
     fail!("Cannot determine OS from triple");
 }
 
-#[cfg(target_os = "windows")]
-#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+#[cfg(target_os = "win32")]
 pub fn make_new_path(path: &str) -> String {
 
     // Windows just uses PATH as the library search path, so we have to
@@ -49,12 +46,10 @@ pub fn make_new_path(path: &str) -> String {
     }
 }
 
-#[cfg(target_os = "windows")]
-#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+#[cfg(target_os = "win32")]
 pub fn lib_path_env_var() -> &'static str { "PATH" }
 
-#[cfg(target_os = "windows")]
-#[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
+#[cfg(target_os = "win32")]
 pub fn path_div() -> &'static str { ";" }
 
 pub fn logv(config: &Config, s: String) {

branches/auto/src/doc/README.md

@@ -19,7 +19,7 @@ for the 'std' and 'extra' libraries.
 To generate HTML documentation from one source file/crate, do something like:
 
 ~~~~
-rustdoc --output html-doc/ --output-format html ../src/libstd/path.rs
+rustdoc --output-dir html-doc/ --output-format html ../src/libstd/path.rs
 ~~~~
 
 (This, of course, requires a working build of the `rustdoc` tool.)

branches/auto/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.
 

branches/auto/src/doc/guide-pointers.md

@@ -655,7 +655,7 @@ This part is coming soon.
 # Returning Pointers
 
 In many languages with pointers, you'd return a pointer from a function
-so as to avoid copying a large data structure. For example:
+so as to avoid a copying a large data structure. For example:
 
 ```{rust}
 struct BigStruct {

branches/auto/src/doc/guide-runtime.md

@@ -128,7 +128,7 @@ itself, yet again implying that they are not defined in the standard library.
 The full complement of runtime features is defined by the [`Runtime`
 trait](std/rt/trait.Runtime.html) and the [`Task`
 struct](std/rt/task/struct.Task.html). A `Task` is constant among all runtime
-implementations, but each runtime has its own implementation of the
+implementations, but each runtime implements has its own implementation of the
 `Runtime` trait.
 
 The local `Task` stores the runtime value inside of itself, and then ownership

branches/auto/src/doc/guide-testing.md

@@ -198,7 +198,7 @@ per-iteration speed of.
 
 For benchmarks relating to processing/generating data, one can set the
 `bytes` field to the number of bytes consumed/produced in each
-iteration; this will be used to show the throughput of the benchmark.
+iteration; this will used to show the throughput of the benchmark.
 This must be the amount used in each iteration, *not* the total
 amount.
 

branches/auto/src/doc/guide-unsafe.md

@@ -137,7 +137,7 @@ explicitly with, respectively, `value as *const T` and `value as *mut T`).
 
 Going the opposite direction, from `*const` to a reference `&`, is not
 safe. A `&T` is always valid, and so, at a minimum, the raw pointer
-`*const T` has to point to a valid instance of type `T`. Furthermore,
+`*const T` has to be a valid to a valid instance of type `T`. Furthermore,
 the resulting pointer must satisfy the aliasing and mutability laws of
 references. The compiler assumes these properties are true for any
 references, no matter how they are created, and so any conversion from
@@ -537,12 +537,11 @@ extern crate core;
 use core::prelude::*;
 
 use core::mem;
+use core::raw::Slice;
 
 #[no_mangle]
 pub extern fn dot_product(a: *const u32, a_len: u32,
                           b: *const u32, b_len: u32) -> u32 {
-    use core::raw::Slice;
-
     // Convert the provided arrays into Rust slices.
     // The core::raw module guarantees that the Slice
     // structure has the same memory layout as a &[T]