Always download stage1 when download_stage1 is set

Before, bootstrap would try to second-guess the user when compiler/ was
modified or had untracked files. Now it only warns when compiler/ is
modified, which means bootstrap.py doesn't have to pass stage through to
rustbuild.

Author: jyn514

src/bootstrap/bootstrap.py

@@ -631,29 +631,14 @@ def maybe_download_stage1(self):
         merge_base = ["git", "merge-base", "HEAD", "{}/master".format(rust_lang_remote)]
         commit = subprocess.check_output(merge_base, universal_newlines=True).strip()
 
-        # Next, check if there were changes to the compiler since the ancestor commit.
-        # If so, rebuild instead of using an outdated version of the code.
+        # Warn if there were changes to the compiler since the ancestor commit.
         rev_parse = ["git", "rev-parse", "--show-toplevel"]
         top_level = subprocess.check_output(rev_parse, universal_newlines=True).strip()
         compiler = "{}/compiler/".format(top_level)
-        # This is slightly more coarse than it needs to be; it rebuild on *any* changes, not just
-        # changes to code.
         status = subprocess.call(["git", "diff-index", "--quiet", commit, "--", compiler])
         if status != 0:
-            if self.verbose:
-                print("changes to compiler/ detected, not downloading stage1")
-            return None
-        # Check for untracked files. Adding `build.rs` can change the build
-        # inputs even if no modified files were changed.
-        # Annoyingly, I can't find a way to check for untracked and modified files at the same
-        # time. Even more annoyingly, there doesn't seem to be a way to show *whether* there are
-        # untracked files without listing them.
-        ls_files = ["git", "ls-files", "-o", "--exclude-standard", "compiler/"]
-        untracked_files = subprocess.check_output(ls_files, universal_newlines=True)
-        if untracked_files != '':
-            if self.verbose:
-                print("untracked files in compiler/ detected, not downloading stage1")
-            return None
+            print("warning: `download_stage1` is enabled, but there are changes to compiler/")
+
         return commit
 
     def rustc_stamp(self):
@@ -1154,8 +1139,6 @@ def bootstrap(help_triggered):
     env["RUSTC_BOOTSTRAP"] = '1'
     if toml_path:
         env["BOOTSTRAP_CONFIG"] = toml_path
-    if build.stage1_commit is not None:
-        env["BOOTSTRAP_CACHE_STAGE1"] = "1"
     run(args, env=env, verbose=build.verbose)
 
 

src/bootstrap/builder.rs

@@ -629,7 +629,7 @@ impl<'a> Builder<'a> {
                     .join("rustlib")
                     .join(self.target.triple)
                     .join("lib");
-                if !crate::use_cached_rustc(&self.compiler) {
+                if !builder.use_cached_rustc(&self.compiler) {
                     let _ = fs::remove_dir_all(&sysroot);
                     t!(fs::create_dir_all(&sysroot));
                 }
@@ -702,6 +702,10 @@ impl<'a> Builder<'a> {
         add_dylib_path(vec![self.rustc_libdir(compiler)], cmd);
     }
 
+    pub fn use_cached_rustc(&self, compiler: &Compiler) -> bool {
+        self.config.download_stage1 && compiler.stage == 0
+    }
+
     /// Gets a path to the compiler specified.
     pub fn rustc(&self, compiler: Compiler) -> PathBuf {
         if compiler.is_snapshot(self) {

src/bootstrap/compile.rs

@@ -27,7 +27,6 @@ use crate::config::TargetSelection;
 use crate::dist;
 use crate::native;
 use crate::tool::SourceType;
-use crate::use_cached_rustc;
 use crate::util::{exe, is_dylib, symlink_dir};
 use crate::{Compiler, DependencyType, GitRepo, Mode};
 
@@ -70,7 +69,7 @@ impl Step for Std {
         }
 
         // If this is stage 0 or 1 and we're using a cached rustc, copy the stage 0 standard library instead of rebuilding.
-        if std::env::var("BOOTSTRAP_CACHE_STAGE1").is_ok() && compiler.stage < 2 {
+        if builder.config.download_stage1 && compiler.stage < 2 {
             return;
         }
 
@@ -507,7 +506,7 @@ impl Step for Rustc {
         // No need to build from source if we've already downloaded rustc for this platform.
         // This just copies the files from stage0 to stage1.
         let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
-        if use_cached_rustc(&compiler) {
+        if builder.use_cached_rustc(&compiler) {
             return;
         } else if compiler_to_use != compiler {
             builder.ensure(Rustc { compiler: compiler_to_use, target });
@@ -907,14 +906,14 @@ impl Step for Sysroot {
 
         // stage0-sysroot stores master libstd for the beta compiler.
         // When not using the beta compiler, there's no need to override the sysroot.
-        let sysroot = if compiler.stage == 0 && !use_cached_rustc(&compiler) {
+        let sysroot = if compiler.stage == 0 && !builder.use_cached_rustc(&compiler) {
             builder.out.join(&compiler.host.triple).join("stage0-sysroot")
         } else {
             builder.out.join(&compiler.host.triple).join(format!("stage{}", compiler.stage))
         };
 
         // The sysroot is copied to stage1/ in Assemble, not here.
-        if use_cached_rustc(&compiler) {
+        if builder.use_cached_rustc(&compiler) {
             return INTERNER.intern_path(sysroot);
         }
 
@@ -1086,7 +1085,7 @@ impl Step for Assemble {
         t!(fs::create_dir_all(&bindir));
         let compiler = builder.rustc(target_compiler);
 
-        if use_cached_rustc(&build_compiler) {
+        if builder.use_cached_rustc(&build_compiler) {
             let stage0 = builder.out.join(&*build_compiler.host.triple).join("stage0");
             builder.cp_r(&stage0, &builder.sysroot(target_compiler));
         } else {

src/bootstrap/config.rs

@@ -80,6 +80,7 @@ pub struct Config {
     pub cmd: Subcommand,
     pub incremental: bool,
     pub dry_run: bool,
+    pub download_stage1: bool,
 
     pub deny_warnings: bool,
     pub backtrace_on_ice: bool,
@@ -883,6 +884,8 @@ impl Config {
             config.rust_codegen_units_std = rust.codegen_units_std.map(threads_from_config);
             config.rust_profile_use = flags.rust_profile_use.or(rust.profile_use);
             config.rust_profile_generate = flags.rust_profile_generate.or(rust.profile_generate);
+
+            config.download_stage1 = rust.download_stage1.unwrap_or(false);
         } else {
             config.rust_profile_use = flags.rust_profile_use;
             config.rust_profile_generate = flags.rust_profile_generate;

src/bootstrap/lib.rs

@@ -169,10 +169,6 @@ use crate::cache::{Interned, INTERNER};
 pub use crate::config::Config;
 pub use crate::flags::Subcommand;
 
-fn use_cached_rustc(compiler: &Compiler) -> bool {
-    std::env::var("BOOTSTRAP_CACHE_STAGE1").is_ok() && compiler.stage == 0
-}
-
 const LLVM_TOOLS: &[&str] = &[
     "llvm-cov",      // used to generate coverage report
     "llvm-nm",       // used to inspect binaries; it shows symbol names, their sizes and visibility