move optimize-tests flag handling from bootstrap to compiletest

src/bootstrap/test.rs

@@ -1363,16 +1363,10 @@ fn run(self, builder: &Builder<'_>) {
         if let Some(ref npm) = builder.config.npm {
             cmd.arg("--npm").arg(npm);
         }
-
-        let mut flags = if is_rustdoc { Vec::new() } else { vec!["-Crpath".to_string()] };
-        if !is_rustdoc && mode != "ui" {
-            if builder.config.rust_optimize_tests {
-                flags.push("-O".to_string());
-            }
-        }
         if builder.config.rust_optimize_tests {
             cmd.arg("--optimize-tests");
         }
+        let mut flags = if is_rustdoc { Vec::new() } else { vec!["-Crpath".to_string()] };
         flags.push(format!("-Cdebuginfo={}", builder.config.rust_debuginfo_level_tests));
         flags.push(builder.config.cmd.rustc_args().join(" "));
 

src/tools/compiletest/src/common.rs

@@ -269,9 +269,8 @@ pub struct Config {
     /// Flags to pass to the compiler when building for the target
     pub target_rustcflags: Option<String>,
 
-    /// Whether tests should be optimized.
-    /// Currently only provides a default for UI-tests that are run-pass.
-    /// Other tests are controlled by rustcflags or the testfiles themselves.
+    /// Whether tests should be optimized by default. Individual test-suites and test files may
+    /// override this setting.
     pub optimize_tests: bool,
 
     /// What panic strategy the target is built with.  Unwind supports Abort, but

src/tools/compiletest/src/main.rs

@@ -102,7 +102,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
         )
         .optmulti("", "host-rustcflags", "flags to pass to rustc for host", "FLAGS")
         .optmulti("", "target-rustcflags", "flags to pass to rustc for target", "FLAGS")
-        .optflag("", "optimize-tests", "build UI tests with optimization enabled")
+        .optflag("", "optimize-tests", "run tests with optimizations enabled")
         .optopt("", "target-panic", "what panic strategy the target supports", "unwind | abort")
         .optflag("", "verbose", "run tests verbosely, showing all output")
         .optflag(

src/tools/compiletest/src/runtest.rs

@@ -1862,6 +1862,31 @@ fn make_compile_args(
             }
         }
 
+        if self.config.optimize_tests && !is_rustdoc {
+            match self.config.mode {
+                Ui => {
+                    // If optimize-tests is true we still only want to optimize tests that actually get
+                    // executed and that don't specify their own optimization levels.
+                    // Note: aux libs don't have a pass-mode, so they won't get optimized
+                    // unless compile-flags are set in the aux file.
+                    if self.config.optimize_tests
+                        && self.props.pass_mode(&self.config) == Some(PassMode::Run)
+                        && !self
+                            .props
+                            .compile_flags
+                            .iter()
+                            .any(|arg| arg == "-O" || arg.contains("opt-level"))
+                    {
+                        rustc.arg("-O");
+                    }
+                }
+                DebugInfo => { /* debuginfo tests must be unoptimized */ }
+                _ => {
+                    rustc.arg("-O");
+                }
+            }
+        }
+
         match self.config.mode {
             Incremental => {
                 // If we are extracting and matching errors in the new
@@ -1875,18 +1900,6 @@ fn make_compile_args(
                 rustc.arg("-Zdeduplicate-diagnostics=no");
             }
             Ui => {
-                // If optimize-tests is true we still only want to optimize tests that actually get
-                // executed and that don't specify their own optimization levels
-                if self.config.optimize_tests
-                    && self.props.pass_mode(&self.config) == Some(PassMode::Run)
-                    && !self
-                        .props
-                        .compile_flags
-                        .iter()
-                        .any(|arg| arg == "-O" || arg.contains("opt-level"))
-                {
-                    rustc.arg("-O");
-                }
                 if !self.props.compile_flags.iter().any(|s| s.starts_with("--error-format")) {
                     rustc.args(&["--error-format", "json"]);
                     rustc.args(&["--json", "future-incompat"]);