---

yaml
---
r: 273183
b: refs/heads/beta
c: 4982f91
h: refs/heads/master
i:
  273181: f88e0eb
  273179: 6b2bbf1
  273175: ab22ad1
  273167: 894ecde
  273151: 2e9fba5

Author: durka

[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: f9121e87a662568d42cc481f87d81ed4df38cc0d
+refs/heads/beta: 4982f913461a2a6dfbac8bace53961233322646a
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/mk/crates.mk

@@ -53,7 +53,7 @@ TARGET_CRATES := libc std term \
                  getopts collections test rand \
                  core alloc \
                  rustc_unicode rustc_bitflags \
-		 alloc_system alloc_jemalloc rustc_const_eval
+		 alloc_system alloc_jemalloc
 RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
                 rustc_data_structures rustc_front rustc_platform_intrinsics \
@@ -91,11 +91,8 @@ DEPS_test := std getopts term native:rust_test_helpers
 DEPS_syntax := std term serialize log arena libc rustc_bitflags rustc_unicode
 DEPS_syntax_ext := syntax fmt_macros
 
-DEPS_rustc_const_eval := std syntax
-
 DEPS_rustc := syntax fmt_macros flate arena serialize getopts rbml rustc_front\
-              log graphviz rustc_llvm rustc_back rustc_data_structures\
-		  	  rustc_const_eval
+              log graphviz rustc_llvm rustc_back rustc_data_structures
 DEPS_rustc_back := std syntax rustc_llvm rustc_front flate log libc
 DEPS_rustc_borrowck := rustc rustc_front log graphviz syntax
 DEPS_rustc_data_structures := std log serialize
@@ -106,17 +103,16 @@ DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_bo
 DEPS_rustc_front := std syntax log serialize
 DEPS_rustc_lint := rustc log syntax
 DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
-DEPS_rustc_metadata := rustc rustc_front syntax rbml rustc_const_eval
+DEPS_rustc_metadata := rustc rustc_front syntax rbml
 DEPS_rustc_passes := syntax rustc core rustc_front
-DEPS_rustc_mir := rustc rustc_front syntax rustc_const_eval
+DEPS_rustc_mir := rustc rustc_front syntax
 DEPS_rustc_resolve := arena rustc rustc_front log syntax
 DEPS_rustc_platform_intrinsics := rustc rustc_llvm
 DEPS_rustc_plugin := rustc rustc_metadata syntax rustc_mir
 DEPS_rustc_privacy := rustc rustc_front log syntax
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back rustc_mir \
-                    log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics \
-					rustc_const_eval
-DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics rustc_const_eval
+                    log syntax serialize rustc_llvm rustc_front rustc_platform_intrinsics
+DEPS_rustc_typeck := rustc syntax rustc_front rustc_platform_intrinsics
 
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test rustc_lint rustc_front

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

@@ -8,11 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::process::Command;
+
 use build::{Build, Compiler};
 
 pub fn linkcheck(build: &Build, stage: u32, host: &str) {
     println!("Linkcheck stage{} ({})", stage, host);
     let compiler = Compiler::new(stage, host);
-    build.run(build.tool_cmd(&compiler, "linkchecker")
-                   .arg(build.out.join(host).join("doc")));
+    let linkchecker = build.tool(&compiler, "linkchecker");
+    build.run(Command::new(&linkchecker)
+                     .arg(build.out.join(host).join("doc")));
 }

branches/beta/src/bootstrap/build/compile.rs

@@ -23,23 +23,26 @@ use build::{Build, Compiler, Mode};
 /// This will build the standard library for a particular stage of the build
 /// using the `compiler` targeting the `target` architecture. The artifacts
 /// created will also be linked into the sysroot directory.
-pub fn std<'a>(build: &'a Build, target: &str, compiler: &Compiler<'a>) {
-    println!("Building stage{} std artifacts ({} -> {})", compiler.stage,
-             compiler.host, target);
+pub fn std<'a>(build: &'a Build, stage: u32, target: &str,
+               compiler: &Compiler<'a>) {
+    let host = compiler.host;
+    println!("Building stage{} std artifacts ({} -> {})", stage,
+             host, target);
 
     // Move compiler-rt into place as it'll be required by the compiler when
     // building the standard library to link the dylib of libstd
-    let libdir = build.sysroot_libdir(compiler, target);
+    let libdir = build.sysroot_libdir(stage, &host, target);
     let _ = fs::remove_dir_all(&libdir);
     t!(fs::create_dir_all(&libdir));
     t!(fs::hard_link(&build.compiler_rt_built.borrow()[target],
                      libdir.join(staticlib("compiler-rt", target))));
 
     build_startup_objects(build, target, &libdir);
 
-    let out_dir = build.cargo_out(compiler, Mode::Libstd, target);
+    let out_dir = build.cargo_out(stage, &host, Mode::Libstd, target);
     build.clear_if_dirty(&out_dir, &build.compiler_path(compiler));
-    let mut cargo = build.cargo(compiler, Mode::Libstd, target, "build");
+    let mut cargo = build.cargo(stage, compiler, Mode::Libstd, Some(target),
+                                "build");
     cargo.arg("--features").arg(build.std_features())
          .arg("--manifest-path")
          .arg(build.src.join("src/rustc/std_shim/Cargo.toml"));
@@ -56,20 +59,20 @@ pub fn std<'a>(build: &'a Build, target: &str, compiler: &Compiler<'a>) {
     }
 
     build.run(&mut cargo);
-    std_link(build, target, compiler, compiler.host);
+    std_link(build, stage, target, compiler, host);
 }
 
 /// Link all libstd rlibs/dylibs into the sysroot location.
 ///
 /// Links those artifacts generated in the given `stage` for `target` produced
 /// by `compiler` into `host`'s sysroot.
 pub fn std_link(build: &Build,
+                stage: u32,
                 target: &str,
                 compiler: &Compiler,
                 host: &str) {
-    let target_compiler = Compiler::new(compiler.stage, host);
-    let libdir = build.sysroot_libdir(&target_compiler, target);
-    let out_dir = build.cargo_out(compiler, Mode::Libstd, target);
+    let libdir = build.sysroot_libdir(stage, host, target);
+    let out_dir = build.cargo_out(stage, compiler.host, Mode::Libstd, target);
 
     // If we're linking one compiler host's output into another, then we weren't
     // called from the `std` method above. In that case we clean out what's
@@ -82,8 +85,7 @@ pub fn std_link(build: &Build,
     }
     add_to_sysroot(&out_dir, &libdir);
 
-    if target.contains("musl") &&
-       (target.contains("x86_64") || target.contains("i686")) {
+    if target.contains("musl") && (target.contains("x86_64") || target.contains("i686")) {
         copy_third_party_objects(build, target, &libdir);
     }
 }
@@ -128,14 +130,17 @@ fn build_startup_objects(build: &Build, target: &str, into: &Path) {
 /// This will build the compiler for a particular stage of the build using
 /// the `compiler` targeting the `target` architecture. The artifacts
 /// created will also be linked into the sysroot directory.
-pub fn rustc<'a>(build: &'a Build, target: &str, compiler: &Compiler<'a>) {
-    println!("Building stage{} compiler artifacts ({} -> {})",
-             compiler.stage, compiler.host, target);
+pub fn rustc<'a>(build: &'a Build, stage: u32, target: &str,
+                 compiler: &Compiler<'a>) {
+    let host = compiler.host;
+    println!("Building stage{} compiler artifacts ({} -> {})", stage,
+             host, target);
 
-    let out_dir = build.cargo_out(compiler, Mode::Librustc, target);
-    build.clear_if_dirty(&out_dir, &libstd_shim(build, compiler, target));
+    let out_dir = build.cargo_out(stage, &host, Mode::Librustc, target);
+    build.clear_if_dirty(&out_dir, &libstd_shim(build, stage, &host, target));
 
-    let mut cargo = build.cargo(compiler, Mode::Librustc, target, "build");
+    let mut cargo = build.cargo(stage, compiler, Mode::Librustc, Some(target),
+                                "build");
     cargo.arg("--features").arg(build.rustc_features())
          .arg("--manifest-path")
          .arg(build.src.join("src/rustc/Cargo.toml"));
@@ -179,27 +184,27 @@ pub fn rustc<'a>(build: &'a Build, target: &str, compiler: &Compiler<'a>) {
     }
     build.run(&mut cargo);
 
-    rustc_link(build, target, compiler, compiler.host);
+    rustc_link(build, stage, target, compiler, compiler.host);
 }
 
 /// Link all librustc rlibs/dylibs into the sysroot location.
 ///
 /// Links those artifacts generated in the given `stage` for `target` produced
 /// by `compiler` into `host`'s sysroot.
 pub fn rustc_link(build: &Build,
+                  stage: u32,
                   target: &str,
                   compiler: &Compiler,
                   host: &str) {
-    let target_compiler = Compiler::new(compiler.stage, host);
-    let libdir = build.sysroot_libdir(&target_compiler, target);
-    let out_dir = build.cargo_out(compiler, Mode::Librustc, target);
+    let libdir = build.sysroot_libdir(stage, host, target);
+    let out_dir = build.cargo_out(stage, compiler.host, Mode::Librustc, target);
     add_to_sysroot(&out_dir, &libdir);
 }
 
 /// Cargo's output path for the standard library in a given stage, compiled
 /// by a particular compiler for the specified target.
-fn libstd_shim(build: &Build, compiler: &Compiler, target: &str) -> PathBuf {
-    build.cargo_out(compiler, Mode::Libstd, target).join("libstd_shim.rlib")
+fn libstd_shim(build: &Build, stage: u32, host: &str, target: &str) -> PathBuf {
+    build.cargo_out(stage, host, Mode::Libstd, target).join("libstd_shim.rlib")
 }
 
 fn compiler_file(compiler: &Path, file: &str) -> String {
@@ -214,29 +219,25 @@ fn compiler_file(compiler: &Path, file: &str) -> String {
 /// compiler.
 pub fn assemble_rustc(build: &Build, stage: u32, host: &str) {
     assert!(stage > 0, "the stage0 compiler isn't assembled, it's downloaded");
-    // The compiler that we're assembling
-    let target_compiler = Compiler::new(stage, host);
-
-    // The compiler that compiled the compiler we're assembling
-    let build_compiler = Compiler::new(stage - 1, &build.config.build);
 
     // Clear out old files
-    let sysroot = build.sysroot(&target_compiler);
+    let sysroot = build.sysroot(stage, host);
     let _ = fs::remove_dir_all(&sysroot);
     t!(fs::create_dir_all(&sysroot));
 
     // Link in all dylibs to the libdir
     let sysroot_libdir = sysroot.join(libdir(host));
     t!(fs::create_dir_all(&sysroot_libdir));
-    let src_libdir = build.sysroot_libdir(&build_compiler, host);
+    let src_libdir = build.sysroot_libdir(stage - 1, &build.config.build, host);
     for f in t!(fs::read_dir(&src_libdir)).map(|f| t!(f)) {
         let filename = f.file_name().into_string().unwrap();
         if is_dylib(&filename) {
             t!(fs::hard_link(&f.path(), sysroot_libdir.join(&filename)));
         }
     }
 
-    let out_dir = build.cargo_out(&build_compiler, Mode::Librustc, host);
+    let out_dir = build.cargo_out(stage - 1, &build.config.build,
+                                  Mode::Librustc, host);
 
     // Link the compiler binary itself into place
     let rustc = out_dir.join(exe("rustc", host));
@@ -314,7 +315,7 @@ pub fn tool(build: &Build, stage: u32, host: &str, tool: &str) {
     // let out_dir = build.cargo_out(stage, &host, Mode::Librustc, target);
     // build.clear_if_dirty(&out_dir, &libstd_shim(build, stage, &host, target));
 
-    let mut cargo = build.cargo(&compiler, Mode::Tool, host, "build");
+    let mut cargo = build.cargo(stage, &compiler, Mode::Tool, None, "build");
     cargo.arg("--manifest-path")
          .arg(build.src.join(format!("src/tools/{}/Cargo.toml", tool)));
     build.run(&mut cargo);

branches/beta/src/bootstrap/build/doc.rs

@@ -81,7 +81,6 @@ pub fn standalone(build: &Build, stage: u32, host: &str, out: &Path) {
         }
 
         let mut cmd = Command::new(&rustdoc);
-        build.add_rustc_lib_path(&compiler, &mut cmd);
         cmd.arg("--html-after-content").arg(&footer)
            .arg("--html-before-content").arg(&version_info)
            .arg("--html-in-header").arg(&favicon)
@@ -108,13 +107,14 @@ pub fn standalone(build: &Build, stage: u32, host: &str, out: &Path) {
 pub fn std(build: &Build, stage: u32, host: &str, out: &Path) {
     println!("Documenting stage{} std ({})", stage, host);
     let compiler = Compiler::new(stage, host);
-    let out_dir = build.stage_out(&compiler, Mode::Libstd)
+    let out_dir = build.stage_out(stage, host, Mode::Libstd)
                        .join(host).join("doc");
     let rustdoc = build.rustdoc(&compiler);
 
     build.clear_if_dirty(&out_dir, &rustdoc);
 
-    let mut cargo = build.cargo(&compiler, Mode::Libstd, host, "doc");
+    let mut cargo = build.cargo(stage, &compiler, Mode::Libstd, Some(host),
+                                "doc");
     cargo.arg("--manifest-path")
          .arg(build.src.join("src/rustc/std_shim/Cargo.toml"))
          .arg("--features").arg(build.std_features());
@@ -125,13 +125,14 @@ pub fn std(build: &Build, stage: u32, host: &str, out: &Path) {
 pub fn rustc(build: &Build, stage: u32, host: &str, out: &Path) {
     println!("Documenting stage{} compiler ({})", stage, host);
     let compiler = Compiler::new(stage, host);
-    let out_dir = build.stage_out(&compiler, Mode::Librustc)
+    let out_dir = build.stage_out(stage, host, Mode::Librustc)
                        .join(host).join("doc");
     let rustdoc = build.rustdoc(&compiler);
     if !up_to_date(&rustdoc, &out_dir.join("rustc/index.html")) {
         t!(fs::remove_dir_all(&out_dir));
     }
-    let mut cargo = build.cargo(&compiler, Mode::Librustc, host, "doc");
+    let mut cargo = build.cargo(stage, &compiler, Mode::Librustc, Some(host),
+                                "doc");
     cargo.arg("--manifest-path")
          .arg(build.src.join("src/rustc/Cargo.toml"))
          .arg("--features").arg(build.rustc_features());
@@ -142,7 +143,7 @@ pub fn rustc(build: &Build, stage: u32, host: &str, out: &Path) {
 pub fn error_index(build: &Build, stage: u32, host: &str, out: &Path) {
     println!("Documenting stage{} error index ({})", stage, host);
     let compiler = Compiler::new(stage, host);
-    let mut index = build.tool_cmd(&compiler, "error_index_generator");
+    let mut index = Command::new(build.tool(&compiler, "error_index_generator"));
     index.arg("html");
     index.arg(out.join("error-index.html"));