Auto merge of #61300 - indygreg:upgrade-cross-make, r=sanxiyn

[rust.git] / src / bootstrap / install.rs

diff --git a/src/bootstrap/install.rs b/src/bootstrap/install.rs
index 2d040d60e5fd7d2aa7e3af14e70b3f57c05cb4ff..0047be4d5951b95a4fbc77bcdac5e6f902f1827b 100644 (file)
--- a/src/bootstrap/install.rs
+++ b/src/bootstrap/install.rs
@@ -5,10 +5,13 @@
 
 use std::env;
 use std::fs;
-use std::path::{Path, PathBuf, Component};
+use std::path::{Component, Path, PathBuf};
 use std::process::Command;
 
+use build_helper::t;
+
 use crate::dist::{self, pkgname, sanitize_sh, tmpdir};
+use crate::Compiler;
 
 use crate::builder::{Builder, RunConfig, ShouldRun, Step};
 use crate::cache::Interned;
@@ -56,7 +59,7 @@ fn install_sh(
     package: &str,
     name: &str,
     stage: u32,
-    host: Option<Interned<String>>
+    host: Option<Interned<String>>,
 ) {
     builder.info(&format!("Install {} stage{} ({:?})", package, stage, host));
 
@@ -142,9 +145,8 @@ macro_rules! install {
         $(
             #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
         pub struct $name {
-            pub stage: u32,
+            pub compiler: Compiler,
             pub target: Interned<String>,
-            pub host: Interned<String>,
         }
 
         impl $name {
@@ -173,9 +175,8 @@ fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
 
             fn make_run(run: RunConfig<'_>) {
                 run.builder.ensure($name {
-                    stage: run.builder.top_stage,
+                    compiler: run.builder.compiler(run.builder.top_stage, run.builder.config.build),
                     target: run.target,
-                    host: run.builder.config.build,
                 });
             }
 
@@ -188,67 +189,78 @@ fn run($sel, $builder: &Builder<'_>) {
 
 install!((self, builder, _config),
     Docs, "src/doc", _config.docs, only_hosts: false, {
-        builder.ensure(dist::Docs { stage: self.stage, host: self.target });
-        install_docs(builder, self.stage, self.target);
+        builder.ensure(dist::Docs { host: self.target });
+        install_docs(builder, self.compiler.stage, self.target);
     };
     Std, "src/libstd", true, only_hosts: true, {
         for target in &builder.targets {
             builder.ensure(dist::Std {
-                compiler: builder.compiler(self.stage, self.host),
+                compiler: self.compiler,
                 target: *target
             });
-            install_std(builder, self.stage, *target);
+            install_std(builder, self.compiler.stage, *target);
         }
     };
     Cargo, "cargo", Self::should_build(_config), only_hosts: true, {
-        builder.ensure(dist::Cargo { stage: self.stage, target: self.target });
-        install_cargo(builder, self.stage, self.target);
+        builder.ensure(dist::Cargo { compiler: self.compiler, target: self.target });
+        install_cargo(builder, self.compiler.stage, self.target);
     };
     Rls, "rls", Self::should_build(_config), only_hosts: true, {
-        if builder.ensure(dist::Rls { stage: self.stage, target: self.target }).is_some() ||
+        if builder.ensure(dist::Rls { compiler: self.compiler, target: self.target }).is_some() ||
             Self::should_install(builder) {
-            install_rls(builder, self.stage, self.target);
+            install_rls(builder, self.compiler.stage, self.target);
         } else {
-            builder.info(&format!("skipping Install RLS stage{} ({})", self.stage, self.target));
+            builder.info(
+                &format!("skipping Install RLS stage{} ({})", self.compiler.stage, self.target),
+            );
         }
     };
     Clippy, "clippy", Self::should_build(_config), only_hosts: true, {
-        if builder.ensure(dist::Clippy { stage: self.stage, target: self.target }).is_some() ||
-            Self::should_install(builder) {
-            install_clippy(builder, self.stage, self.target);
+        if builder.ensure(dist::Clippy {
+            compiler: self.compiler,
+            target: self.target,
+        }).is_some() || Self::should_install(builder) {
+            install_clippy(builder, self.compiler.stage, self.target);
         } else {
-            builder.info(&format!("skipping Install clippy stage{} ({})", self.stage, self.target));
+            builder.info(
+                &format!("skipping Install clippy stage{} ({})", self.compiler.stage, self.target),
+            );
         }
     };
     Miri, "miri", Self::should_build(_config), only_hosts: true, {
-        if builder.ensure(dist::Miri { stage: self.stage, target: self.target }).is_some() ||
+        if builder.ensure(dist::Miri { compiler: self.compiler, target: self.target }).is_some() ||
             Self::should_install(builder) {
-            install_miri(builder, self.stage, self.target);
+            install_miri(builder, self.compiler.stage, self.target);
         } else {
-            builder.info(&format!("skipping Install miri stage{} ({})", self.stage, self.target));
+            builder.info(
+                &format!("skipping Install miri stage{} ({})", self.compiler.stage, self.target),
+            );
         }
     };
     Rustfmt, "rustfmt", Self::should_build(_config), only_hosts: true, {
-        if builder.ensure(dist::Rustfmt { stage: self.stage, target: self.target }).is_some() ||
-            Self::should_install(builder) {
-            install_rustfmt(builder, self.stage, self.target);
+        if builder.ensure(dist::Rustfmt {
+            compiler: self.compiler,
+            target: self.target
+        }).is_some() || Self::should_install(builder) {
+            install_rustfmt(builder, self.compiler.stage, self.target);
         } else {
             builder.info(
-                &format!("skipping Install Rustfmt stage{} ({})", self.stage, self.target));
+                &format!("skipping Install Rustfmt stage{} ({})", self.compiler.stage, self.target),
+            );
         }
     };
     Analysis, "analysis", Self::should_build(_config), only_hosts: false, {
         builder.ensure(dist::Analysis {
-            compiler: builder.compiler(self.stage, self.host),
+            compiler: self.compiler,
             target: self.target
         });
-        install_analysis(builder, self.stage, self.target);
+        install_analysis(builder, self.compiler.stage, self.target);
     };
     Rustc, "src/librustc", true, only_hosts: true, {
         builder.ensure(dist::Rustc {
-            compiler: builder.compiler(self.stage, self.target),
+            compiler: self.compiler,
         });
-        install_rustc(builder, self.stage, self.target);
+        install_rustc(builder, self.compiler.stage, self.target);
     };
 );
 
@@ -264,15 +276,12 @@ impl Step for Src {
 
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
         let config = &run.builder.config;
-        let cond = config.extended &&
-            config.tools.as_ref().map_or(true, |t| t.contains("src"));
+        let cond = config.extended && config.tools.as_ref().map_or(true, |t| t.contains("src"));
         run.path("src").default_condition(cond)
     }
 
     fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(Src {
-            stage: run.builder.top_stage,
-        });
+        run.builder.ensure(Src { stage: run.builder.top_stage });
     }
 
     fn run(self, builder: &Builder<'_>) {