Change metadata strategy to extract hash from nested compilation

Author: willcrichton

src/cargo/core/compiler/context/compilation_files.rs

@@ -540,17 +540,7 @@ fn compute_metadata(
     // `panic=abort` and `panic=unwind` artifacts, additionally with various
     // settings like debuginfo and whatnot.
     unit.profile.hash(&mut hasher);
-
-    // For RFC #3123, we need the metadata of a Check and Doc unit of the same crate
-    // to be the same. So we add a special case that ensures Doc and Check are hashed
-    // to the same value.
-    match unit.mode {
-        CompileMode::Doc { .. } | CompileMode::Check { .. } => {
-            (CompileMode::Check { test: false }).hash(&mut hasher)
-        }
-        mode => mode.hash(&mut hasher),
-    };
-
+    unit.mode.hash(&mut hasher);
     cx.lto[unit].hash(&mut hasher);
 
     // Artifacts compiled for the host should have a different metadata

src/cargo/core/compiler/mod.rs

@@ -12,7 +12,7 @@ mod job;
 mod job_queue;
 mod layout;
 mod links;
-mod lto;
+pub mod lto;
 mod output_depinfo;
 pub mod rustdoc;
 pub mod standard_lib;
@@ -640,10 +640,6 @@ fn rustdoc(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Work> {
         rustdoc.arg("--cfg").arg(&format!("feature=\"{}\"", feat));
     }
 
-    // This is needed so StableCrateId can be computed correctly.
-    let meta = cx.files().metadata(unit);
-    rustdoc.arg("-C").arg(&format!("metadata={}", meta));
-
     add_error_format_and_color(cx, &mut rustdoc, false);
     add_allow_features(cx, &mut rustdoc);
 

src/cargo/ops/cargo_compile.rs

@@ -25,8 +25,10 @@
 use std::collections::{BTreeSet, HashMap, HashSet};
 use std::ffi::OsString;
 use std::hash::{Hash, Hasher};
+use std::iter;
 use std::sync::Arc;
 
+use crate::core::compiler::lto;
 use crate::core::compiler::unit_dependencies::build_unit_dependencies;
 use crate::core::compiler::unit_graph::{self, UnitDep, UnitGraph};
 use crate::core::compiler::Layout;
@@ -649,6 +651,37 @@ pub fn create_bcx<'a, 'cfg>(
                 args.extend(crate_names);
             }
 
+            // Find the check unit corresponding to each documented crate, then add the -C metadata=...
+            // flag to the doc unit for that crate
+            {
+                let mut cx = Context::new(&bcx)?;
+                cx.lto = lto::generate(&bcx)?;
+                cx.prepare_units()?;
+
+                for unit in units.iter() {
+                    let mut root_deps = bcx
+                        .unit_graph
+                        .iter()
+                        .map(|(k, v)| iter::once(k).chain(v.iter().map(|dep| &dep.unit)))
+                        .flatten();
+
+                    let check_unit = root_deps.find(|dep| {
+                        dep.pkg == unit.pkg && dep.target == unit.target && dep.mode.is_check()
+                    });
+
+                    if let Some(check_unit) = check_unit {
+                        let metadata = cx.files().metadata(check_unit);
+                        extra_compiler_args
+                            .entry(unit.clone())
+                            .or_default()
+                            .extend_from_slice(&[
+                                "-C".into(),
+                                OsString::from(format!("metadata={}", metadata)),
+                            ]);
+                    }
+                }
+            }
+
             // Invoke recursive Cargo
             let cx = Context::new(&bcx)?;
             cx.compile(&exec)?;