Do not deny warnings for fast try builds

Author: Kobzol

src/tools/opt-dist/src/environment.rs

@@ -26,6 +26,7 @@ pub struct Environment {
     use_bolt: bool,
     shared_llvm: bool,
     run_tests: bool,
+    fast_try_build: bool,
 }
 
 impl Environment {
@@ -106,6 +107,10 @@ impl Environment {
     pub fn run_tests(&self) -> bool {
         self.run_tests
     }
+
+    pub fn is_fast_try_build(&self) -> bool {
+        self.fast_try_build
+    }
 }
 
 /// What is the extension of binary executables on this platform?

src/tools/opt-dist/src/exec.rs

@@ -23,6 +23,13 @@ impl CmdBuilder {
         self
     }
 
+    pub fn args(mut self, args: &[&str]) -> Self {
+        for arg in args {
+            self.args.push(arg.to_string());
+        }
+        self
+    }
+
     pub fn env(mut self, name: &str, value: &str) -> Self {
         self.env.insert(name.to_string(), value.to_string());
         self
@@ -100,26 +107,28 @@ pub struct Bootstrap {
 impl Bootstrap {
     pub fn build(env: &Environment) -> Self {
         let metrics_path = env.build_root().join("build").join("metrics.json");
-        let cmd = cmd(&[
-            env.python_binary(),
-            env.checkout_path().join("x.py").as_str(),
-            "build",
-            "--target",
-            &env.host_tuple(),
-            "--host",
-            &env.host_tuple(),
-            "--stage",
-            "2",
-            "library/std",
-        ])
-        .env("RUST_BACKTRACE", "full");
+        let cmd = cmd(&[env.python_binary(), env.checkout_path().join("x.py").as_str()]);
+        let cmd = add_shared_x_flags(env, cmd)
+            .args(&[
+                "build",
+                "--target",
+                &env.host_tuple(),
+                "--host",
+                &env.host_tuple(),
+                "--stage",
+                "2",
+                "library/std",
+            ])
+            .env("RUST_BACKTRACE", "full");
+
         Self { cmd, metrics_path }
     }
 
     pub fn dist(env: &Environment, dist_args: &[String]) -> Self {
         let metrics_path = env.build_root().join("build").join("metrics.json");
-        let cmd = cmd(&dist_args.iter().map(|arg| arg.as_str()).collect::<Vec<_>>())
-            .env("RUST_BACKTRACE", "full");
+        let args = dist_args.iter().map(|arg| arg.as_str()).collect::<Vec<_>>();
+        let cmd = cmd(&args).env("RUST_BACKTRACE", "full");
+        let cmd = add_shared_x_flags(env, cmd);
         Self { cmd, metrics_path }
     }
 
@@ -184,3 +193,7 @@ impl Bootstrap {
         Ok(())
     }
 }
+
+fn add_shared_x_flags(env: &Environment, cmd: CmdBuilder) -> CmdBuilder {
+    if env.is_fast_try_build() { cmd.arg("--set").arg("rust.deny-warnings=false") } else { cmd }
+}

src/tools/opt-dist/src/main.rs

@@ -111,11 +111,13 @@ enum EnvironmentCmd {
     },
 }
 
-fn is_try_build() -> bool {
+/// Are we supposed to only build the bare minimum of components to get a working toolchain?
+fn is_fast_try_build() -> bool {
     std::env::var("DIST_TRY_BUILD").unwrap_or_else(|_| "0".to_string()) != "0"
 }
 
 fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)> {
+    let is_fast_try_build = is_fast_try_build();
     let (env, args) = match args.env {
         EnvironmentCmd::Local {
             target_triple,
@@ -144,6 +146,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .skipped_tests(skipped_tests)
                 .benchmark_cargo_config(benchmark_cargo_config)
                 .run_tests(run_tests)
+                .fast_try_build(is_fast_try_build)
                 .build()?;
 
             (env, shared.build_args)
@@ -167,6 +170,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .use_bolt(!is_aarch64)
                 .skipped_tests(vec![])
                 .run_tests(true)
+                .fast_try_build(is_fast_try_build)
                 .build()?;
 
             (env, shared.build_args)
@@ -187,6 +191,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec<String>)>
                 .use_bolt(false)
                 .skipped_tests(vec![])
                 .run_tests(true)
+                .fast_try_build(is_fast_try_build)
                 .build()?;
 
             (env, shared.build_args)
@@ -352,7 +357,7 @@ fn execute_pipeline(
     // possible regressions.
     // The tests are not executed for try builds, which can be in various broken states, so we don't
     // want to gatekeep them with tests.
-    if !is_try_build() && env.run_tests() {
+    if !is_fast_try_build() && env.run_tests() {
         timer.section("Run tests", |_| run_tests(env))?;
     }
 
@@ -397,7 +402,7 @@ fn main() -> anyhow::Result<()> {
     let (env, mut build_args) = create_environment(args).context("Cannot create environment")?;
 
     // Skip components that are not needed for try builds to speed them up
-    if is_try_build() {
+    if is_fast_try_build() {
         log::info!("Skipping building of unimportant components for a try build");
         for target in [
             "rust-docs",