---

yaml
---
r: 277115
b: refs/heads/try
c: 73c2d2a
h: refs/heads/master
i:
  277113: 8e83684
  277111: 5c985f7

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 5d5f4b5e3fcd377400bcc2140621cff6fd73a617
+refs/heads/try: 73c2d2a7419844f763b1ac72b89236bd3183bfaf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/RELEASES.md

@@ -418,7 +418,7 @@ Compatibility Notes
   numbers [no longer return platform-specific types][1.8r], but
   instead return widened integers. [RFC 1415].
 * [Modules sourced from the filesystem cannot appear within arbitrary
-  blocks, but only within other modules][1.8mf].
+  blocks, but only within other modules][1.8m].
 * [`--cfg` compiler flags are parsed strictly as identifiers][1.8c].
 * On Unix, [stack overflow triggers a runtime abort instead of a
   SIGSEGV][1.8so].
@@ -448,7 +448,7 @@ Compatibility Notes
 [1.8h]: https://github.com/rust-lang/rust/pull/31460
 [1.8l]: https://github.com/rust-lang/rust/pull/31668
 [1.8m]: https://github.com/rust-lang/rust/pull/31020
-[1.8mf]: https://github.com/rust-lang/rust/pull/31534
+[1.8m]: https://github.com/rust-lang/rust/pull/31534
 [1.8mp]: https://github.com/rust-lang/rust/pull/30894
 [1.8mr]: https://users.rust-lang.org/t/multirust-0-8-with-cross-std-installation/4901
 [1.8ms]: https://github.com/rust-lang/rust/pull/30448

branches/try/mk/main.mk

@@ -13,7 +13,7 @@
 ######################################################################
 
 # The version number
-CFG_RELEASE_NUM=1.10.0
+CFG_RELEASE_NUM=1.9.0
 
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release

branches/try/src/bootstrap/Cargo.lock

@@ -21,7 +21,7 @@ path = "rustdoc.rs"
 
 [dependencies]
 build_helper = { path = "../build_helper" }
-cmake = "0.1.17"
+cmake = "0.1.10"
 filetime = "0.1"
 num_cpus = "0.2"
 toml = "0.1"
@@ -31,4 +31,3 @@ winapi = "0.2"
 kernel32-sys = "0.2"
 gcc = "0.3.17"
 libc = "0.2"
-md5 = "0.1"

branches/try/src/bootstrap/Cargo.toml

@@ -8,15 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::env;
 use std::fs::{self, File};
 use std::io::prelude::*;
+use std::path::Path;
 use std::process::Command;
 
 use build_helper::output;
-use md5;
 
 use build::Build;
+use build::util::mtime;
 
 pub fn collect(build: &mut Build) {
     let mut main_mk = String::new();
@@ -80,8 +80,7 @@ pub fn collect(build: &mut Build) {
         build.short_ver_hash = Some(short_ver_hash);
     }
 
-    let key = md5::compute(build.release.as_bytes());
-    build.bootstrap_key = format!("{:02x}{:02x}{:02x}{:02x}",
-                                  key[0], key[1], key[2], key[3]);
-    env::set_var("RUSTC_BOOTSTRAP_KEY", &build.bootstrap_key);
+    build.bootstrap_key = mtime(Path::new("config.toml")).seconds()
+                                                        .to_string();
 }
+

branches/try/src/bootstrap/build/channel.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::fs;
+
 use build::{Build, Compiler};
 
 pub fn linkcheck(build: &Build, stage: u32, host: &str) {
@@ -29,9 +31,16 @@ pub fn cargotest(build: &Build, stage: u32, host: &str) {
     let sep = if cfg!(windows) { ";" } else {":" };
     let ref newpath = format!("{}{}{}", path.display(), sep, old_path);
 
+    // Note that this is a short, cryptic, and not scoped directory name. This
+    // is currently to minimize the length of path on Windows where we otherwise
+    // quickly run into path name limit constraints.
+    let out_dir = build.out.join("ct");
+    t!(fs::create_dir_all(&out_dir));
+
     build.run(build.tool_cmd(compiler, "cargotest")
-              .env("PATH", newpath)
-              .arg(&build.cargo));
+                   .env("PATH", newpath)
+                   .arg(&build.cargo)
+                   .arg(&out_dir));
 }
 
 pub fn tidy(build: &Build, stage: u32, host: &str) {

branches/try/src/bootstrap/build/check.rs

@@ -31,7 +31,6 @@ use toml::{Parser, Decoder, Value};
 #[derive(Default)]
 pub struct Config {
     pub ccache: bool,
-    pub ninja: bool,
     pub verbose: bool,
     pub submodules: bool,
     pub compiler_docs: bool,
@@ -108,7 +107,6 @@ struct Build {
 #[derive(RustcDecodable, Default)]
 struct Llvm {
     ccache: Option<bool>,
-    ninja: Option<bool>,
     assertions: Option<bool>,
     optimize: Option<bool>,
     version_check: Option<bool>,
@@ -202,9 +200,9 @@ impl Config {
 
         if let Some(ref llvm) = toml.llvm {
             set(&mut config.ccache, llvm.ccache);
-            set(&mut config.ninja, llvm.ninja);
             set(&mut config.llvm_assertions, llvm.assertions);
             set(&mut config.llvm_optimize, llvm.optimize);
+            set(&mut config.llvm_optimize, llvm.optimize);
             set(&mut config.llvm_version_check, llvm.version_check);
             set(&mut config.llvm_static_stdcpp, llvm.static_libstdcpp);
         }

branches/try/src/bootstrap/build/config.rs

@@ -43,9 +43,6 @@ pub fn llvm(build: &Build, target: &str) {
 
     // http://llvm.org/docs/CMake.html
     let mut cfg = cmake::Config::new(build.src.join("src/llvm"));
-    if build.config.ninja {
-        cfg.generator("Ninja");
-    }
     cfg.target(target)
        .host(&build.config.build)
        .out_dir(&dst)

branches/try/src/bootstrap/build/native.rs

@@ -48,9 +48,6 @@ pub fn check(build: &mut Build) {
             }
         }
         need_cmd("cmake".as_ref());
-        if build.config.ninja {
-            need_cmd("ninja".as_ref())
-        }
         break
     }
 

branches/try/src/bootstrap/build/sanity.rs

@@ -318,7 +318,8 @@ impl<'a> Step<'a> {
                 vec![self.tool_linkchecker(stage), self.doc(stage)]
             }
             Source::CheckCargoTest { stage } => {
-                vec![self.tool_cargotest(stage)]
+                vec![self.tool_cargotest(stage),
+                     self.librustc(self.compiler(stage))]
             }
             Source::CheckTidy { stage } => {
                 vec![self.tool_tidy(stage)]
@@ -333,7 +334,7 @@ impl<'a> Step<'a> {
                 vec![self.librustc(self.compiler(stage))]
             }
             Source::ToolCargoTest { stage } => {
-                vec![self.librustc(self.compiler(stage))]
+                vec![self.libstd(self.compiler(stage))]
             }
 
             Source::DistDocs { stage } => vec![self.doc(stage)],

branches/try/src/bootstrap/build/step.rs

@@ -20,7 +20,6 @@ extern crate libc;
 extern crate num_cpus;
 extern crate rustc_serialize;
 extern crate toml;
-extern crate md5;
 
 use std::env;
 

branches/try/src/bootstrap/main.rs

@@ -988,7 +988,8 @@ fn main() {
 
 # Complete!
 
-This project showed you a lot: `let`, `match`, methods, associated
-functions, using external crates, and more.
-
 At this point, you have successfully built the Guessing Game! Congratulations!
+
+This first project showed you a lot: `let`, `match`, methods, associated
+functions, using external crates, and more. Our next project will show off
+even more.

branches/try/src/doc/book/guessing-game.md

@@ -27,7 +27,6 @@
        test(no_crate_inject, attr(allow(unused_variables), deny(warnings))))]
 
 #![cfg_attr(test, allow(deprecated))] // rand
-#![cfg_attr(not(test), feature(slice_binary_search_by_key))] // impl [T]
 #![cfg_attr(not(stage0), deny(warnings))]
 
 #![feature(alloc)]
@@ -132,10 +131,3 @@ pub enum Bound<T> {
     /// An infinite endpoint. Indicates that there is no bound in this direction.
     Unbounded,
 }
-
-/// An intermediate trait for specialization of `Extend`.
-#[doc(hidden)]
-trait SpecExtend<I: IntoIterator> {
-    /// Extends `self` with the contents of the given iterator.
-    fn spec_extend(&mut self, iter: I);
-}

branches/try/src/libcollections/lib.rs

@@ -30,8 +30,6 @@ use core::mem;
 use core::ops::{BoxPlace, InPlace, Place, Placer};
 use core::ptr::{self, Shared};
 
-use super::SpecExtend;
-
 /// A doubly-linked list.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct LinkedList<T> {
@@ -971,24 +969,12 @@ impl<'a, T> IntoIterator for &'a mut LinkedList<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A> Extend<A> for LinkedList<A> {
     fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T) {
-        <Self as SpecExtend<T>>::spec_extend(self, iter);
-    }
-}
-
-impl<I: IntoIterator> SpecExtend<I> for LinkedList<I::Item> {
-    default fn spec_extend(&mut self, iter: I) {
         for elt in iter {
             self.push_back(elt);
         }
     }
 }
 
-impl<T> SpecExtend<LinkedList<T>> for LinkedList<T> {
-    fn spec_extend(&mut self, ref mut other: LinkedList<T>) {
-        self.append(other);
-    }
-}
-
 #[stable(feature = "extend_ref", since = "1.2.0")]
 impl<'a, T: 'a + Copy> Extend<&'a T> for LinkedList<T> {
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {

branches/try/src/libcollections/linked_list.rs

@@ -741,44 +741,6 @@ impl<T> [T] {
         core_slice::SliceExt::binary_search_by(self, f)
     }
 
-    /// Binary search a sorted slice with a key extraction function.
-    ///
-    /// Assumes that the slice is sorted by the key, for instance with
-    /// `sort_by_key` using the same key extraction function.
-    ///
-    /// If a matching value is found then returns `Ok`, containing the
-    /// index for the matched element; if no match is found then `Err`
-    /// is returned, containing the index where a matching element could
-    /// be inserted while maintaining sorted order.
-    ///
-    /// # Examples
-    ///
-    /// Looks up a series of four elements in a slice of pairs sorted by
-    /// their second elements. The first is found, with a uniquely
-    /// determined position; the second and third are not found; the
-    /// fourth could match any position in `[1,4]`.
-    ///
-    /// ```rust
-    /// #![feature(slice_binary_search_by_key)]
-    /// let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
-    ///          (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
-    ///          (1, 21), (2, 34), (4, 55)];
-    ///
-    /// assert_eq!(s.binary_search_by_key(&13, |&(a,b)| b),  Ok(9));
-    /// assert_eq!(s.binary_search_by_key(&4, |&(a,b)| b),   Err(7));
-    /// assert_eq!(s.binary_search_by_key(&100, |&(a,b)| b), Err(13));
-    /// let r = s.binary_search_by_key(&1, |&(a,b)| b);
-    /// assert!(match r { Ok(1...4) => true, _ => false, });
-    /// ```
-    #[unstable(feature = "slice_binary_search_by_key", reason = "recently added", issue = "0")]
-    #[inline]
-    pub fn binary_search_by_key<B, F>(&self, b: &B, f: F) -> Result<usize, usize>
-        where F: FnMut(&T) -> B,
-              B: Ord
-    {
-        core_slice::SliceExt::binary_search_by_key(self, b, f)
-    }
-
     /// Sorts the slice, in place.
     ///
     /// This is equivalent to `self.sort_by(|a, b| a.cmp(b))`.

branches/try/src/libcollections/slice.rs

@@ -634,9 +634,9 @@ impl str {
     /// Basic usage:
     ///
     /// ```
-    /// let mut s = "Per Martin-Löf".to_string();
+    /// let s = "Per Martin-Löf";
     ///
-    /// let (first, last) = s.split_at_mut(3);
+    /// let (first, last) = s.split_at(3);
     ///
     /// assert_eq!("Per", first);
     /// assert_eq!(" Martin-Löf", last);

branches/try/src/libcollections/str.rs

@@ -75,7 +75,6 @@ use core::ops;
 use core::ptr;
 use core::slice;
 
-use super::SpecExtend;
 use super::range::RangeArgument;
 
 /// A contiguous growable array type, written `Vec<T>` but pronounced 'vector.'
@@ -1391,22 +1390,10 @@ impl<'a, T> IntoIterator for &'a mut Vec<T> {
 impl<T> Extend<T> for Vec<T> {
     #[inline]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        <Self as SpecExtend<I>>::spec_extend(self, iter);
-    }
-}
-
-impl<I: IntoIterator> SpecExtend<I> for Vec<I::Item> {
-    default fn spec_extend(&mut self, iter: I) {
         self.extend_desugared(iter.into_iter())
     }
 }
 
-impl<T> SpecExtend<Vec<T>> for Vec<T> {
-    fn spec_extend(&mut self, ref mut other: Vec<T>) {
-        self.append(other);
-    }
-}
-
 impl<T> Vec<T> {
     fn extend_desugared<I: Iterator<Item = T>>(&mut self, mut iterator: I) {
         // This function should be the moral equivalent of:

branches/try/src/libcollections/vec.rs

@@ -339,22 +339,6 @@ fn test_extend_ref() {
     assert_eq!(a, list_from(&[1, 2, 3, 4, 5, 6]));
 }
 
-#[test]
-fn test_extend() {
-    let mut a = LinkedList::new();
-    a.push_back(1);
-    a.extend(vec![2, 3, 4]); // uses iterator
-
-    assert_eq!(a.len(), 4);
-    assert!(a.iter().eq(&[1, 2, 3, 4]));
-
-    let b: LinkedList<_> = vec![5, 6, 7].into_iter().collect();
-    a.extend(b); // specializes to `append`
-
-    assert_eq!(a.len(), 7);
-    assert!(a.iter().eq(&[1, 2, 3, 4, 5, 6, 7]));
-}
-
 #[bench]
 fn bench_collect_into(b: &mut test::Bencher) {
     let v = &[0; 64];