Calculate rustc outputs concurrently with other hashing tasks

Currently, `sccache` invokes `rustc` twice for generating the hash key:
once for the inputs and env-deps (`--emit dep-info`), and another time
for the output file names (`--print file-names`).
However, the latter is invoked only after the former finishes. There is
no reason for this dependency.

Run `get_compiler_outputs` concurrently with the other `rustc` and
hashing tasks in `RustHasher::generate_hash_key`.

I initially thought that these two invocations could be merged together,
but `--print` stop compilation before the `--emit` is evaluated, so I
went with the simpler approach of just running them at the same time.

Author: DaniPopes

src/compiler/rust.rs

@@ -238,7 +238,7 @@ static ALLOWED_EMIT: Lazy<HashSet<&'static str>> =
 /// Version number for cache key.
 const CACHE_VERSION: &[u8] = b"6";
 
-/// Get absolute paths for all source files and env-deps listed in rustc's dep-info output.
+/// Run `rustc --emit=dep-info` to get the list of source files and env-deps.
 async fn get_source_files_and_env_deps<T>(
     creator: &T,
     crate_name: &str,
@@ -382,22 +382,25 @@ async fn get_compiler_outputs<T>(
 where
     T: Clone + CommandCreatorSync,
 {
+    let start = time::Instant::now();
     let mut cmd = creator.clone().new_command_sync(executable);
     cmd.args(&arguments)
         .args(&["--print", "file-names"])
         .env_clear()
         .envs(env_vars.to_vec())
         .current_dir(cwd);
-    if log_enabled!(Trace) {
-        trace!("get_compiler_outputs: {:?}", cmd);
-    }
+    trace!("get_compiler_outputs: {:?}", cmd);
     let outputs = run_input_output(cmd, None).await?;
 
     let outstr = String::from_utf8(outputs.stdout).context("Error parsing rustc output")?;
-    if log_enabled!(Trace) {
-        trace!("get_compiler_outputs: {:?}", outstr);
-    }
-    Ok(outstr.lines().map(|l| l.to_owned()).collect())
+    let outputs = outstr.lines().map(|l| l.to_owned()).collect::<Vec<_>>();
+    trace!(
+        "get_compiler_outputs: got {} outputs in {}: {:?}",
+        outputs.len(),
+        fmt_duration_as_secs(&start.elapsed()),
+        outstr,
+    );
+    Ok(outputs)
 }
 
 impl Rust {
@@ -1382,6 +1385,23 @@ where
             Ok((source_files, source_hashes, env_deps))
         };
 
+        // Turn arguments into a simple Vec<OsString> to calculate outputs.
+        let flat_os_string_arguments: Vec<OsString> = os_string_arguments
+            .iter()
+            .cloned()
+            .flat_map(|(arg, val)| iter::once(arg).chain(val))
+            .collect();
+        let outputs = async {
+            get_compiler_outputs(
+                creator,
+                &self.executable,
+                flat_os_string_arguments,
+                &cwd,
+                &env_vars,
+            )
+            .await
+        };
+
         // Hash the contents of the externs listed on the commandline.
         trace!(
             "[{}]: hashing {} externs",
@@ -1423,17 +1443,19 @@ where
 
         let target_json_hash = hash_all(&target_json_files, pool);
 
-        // Perform all hashing operations on the files.
+        // Invoke the compiler and perform all hashing operations on the files.
         let (
             (source_files, source_hashes, mut env_deps),
             extern_hashes,
             staticlib_hashes,
             target_json_hash,
+            mut outputs,
         ) = futures::try_join!(
             source_files_and_hashes_and_env_deps,
             extern_hashes,
             staticlib_hashes,
-            target_json_hash
+            target_json_hash,
+            outputs,
         )?;
 
         // If you change any of the inputs to the hash, you should change `CACHE_VERSION`.
@@ -1539,21 +1561,6 @@ where
         // 10. The version of the compiler.
         self.version.hash(&mut HashToDigest { digest: &mut m });
 
-        // Turn arguments into a simple Vec<OsString> to calculate outputs.
-        let flat_os_string_arguments: Vec<OsString> = os_string_arguments
-            .into_iter()
-            .flat_map(|(arg, val)| iter::once(arg).chain(val))
-            .collect();
-
-        let mut outputs = get_compiler_outputs(
-            creator,
-            &self.executable,
-            flat_os_string_arguments,
-            &cwd,
-            &env_vars,
-        )
-        .await?;
-
         // metadata / dep-info don't ever generate binaries, but
         // rustc still makes them appear in the --print
         // file-names output (see