Pass metadata flag to rustdoc, ensure that Doc and Check units have same metadata hash

Author: willcrichton

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

@@ -540,7 +540,17 @@ fn compute_metadata(
     // `panic=abort` and `panic=unwind` artifacts, additionally with various
     // settings like debuginfo and whatnot.
     unit.profile.hash(&mut hasher);
-    unit.mode.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),
+    };
+
     cx.lto[unit].hash(&mut hasher);
 
     // Artifacts compiled for the host should have a different metadata

src/cargo/core/compiler/mod.rs

@@ -640,6 +640,10 @@ 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/core/compiler/unit_dependencies.rs

@@ -419,10 +419,17 @@ fn compute_deps_doc(
     state: &mut State<'_, '_>,
     unit_for: UnitFor,
 ) -> CargoResult<Vec<UnitDep>> {
-    let deps = state.deps(unit, unit_for, &|dep| match dep.kind() {
-        DepKind::Normal | DepKind::Development => true,
-        DepKind::Build => false,
-    });
+    // FIXME(wcrichto): target.is_lib() is probably not the correct way to check
+    //   if the unit needs dev-dependencies
+    let deps = state.deps(
+        unit,
+        unit_for,
+        &|dep| match (unit.target.is_lib(), dep.kind()) {
+            (_, DepKind::Normal) => true,
+            (false, DepKind::Development) => true,
+            _ => false,
+        },
+    );
 
     // To document a library, we depend on dependencies actually being
     // built. If we're documenting *all* libraries, then we also depend on

src/cargo/ops/cargo_compile.rs

@@ -540,6 +540,7 @@ pub fn create_bcx<'a, 'cfg>(
     if build_config.mode == (CompileMode::Doc { deps: true }) {
         remove_duplicate_doc(build_config, &units, &mut unit_graph);
     }
+    lift_doc_units_to_root(&mut units, &mut unit_graph);
 
     if build_config
         .requested_kinds
@@ -624,14 +625,28 @@ pub fn create_bcx<'a, 'cfg>(
 
             // Add --scrape-examples to each build unit's rustdoc args
             for (path, unit) in paths.iter().zip(bcx.roots.iter()) {
-                bcx.extra_compiler_args
+                let args = bcx
+                    .extra_compiler_args
                     .entry(unit.clone())
-                    .or_insert_with(Vec::new)
-                    .extend_from_slice(&[
-                        "-Zunstable-options".into(),
-                        "--scrape-examples".into(),
-                        path.clone().into_os_string(),
-                    ]);
+                    .or_insert_with(Vec::new);
+
+                args.extend_from_slice(&[
+                    "-Zunstable-options".into(),
+                    "--scrape-examples-output-path".into(),
+                    path.clone().into_os_string(),
+                ]);
+
+                let crate_names = units
+                    .iter()
+                    .map(|unit| {
+                        vec![
+                            "--scrape-examples-target-crate".into(),
+                            OsString::from(unit.pkg.name().as_str()),
+                        ]
+                        .into_iter()
+                    })
+                    .flatten();
+                args.extend(crate_names);
             }
 
             // Invoke recursive Cargo
@@ -1680,6 +1695,27 @@ fn opt_patterns_and_names(
     Ok((opt_patterns, opt_names))
 }
 
+/// Removes all CompileMode::Doc units from the unit graph and lifts them to the root set.
+///
+/// This is sound because rustdoc has no actual dependency on the generated files from one
+/// invocation to the next.
+///
+/// This is necessary because for RFC #3123, we need Doc and Check units of the same crate
+/// to have the same metadata hash. This pass ensures that they have the same dependency set.
+/// Also it exposes more parallelism during document generation!
+fn lift_doc_units_to_root(root_units: &mut Vec<Unit>, unit_graph: &mut UnitGraph) {
+    for deps in unit_graph.values_mut() {
+        deps.retain(|dep| {
+            if dep.unit.mode.is_doc() {
+                root_units.push(dep.unit.clone());
+                false
+            } else {
+                true
+            }
+        });
+    }
+}
+
 /// Removes duplicate CompileMode::Doc units that would cause problems with
 /// filename collisions.
 ///