Fix panic with cargo doc and new resolver and proc-macros.

Author: ehuss

src/cargo/core/compiler/unit_dependencies.rs

@@ -225,7 +225,7 @@ fn compute_deps(
         return compute_deps_custom_build(unit, unit_for, state);
     } else if unit.mode.is_doc() {
         // Note: this does not include doc test.
-        return compute_deps_doc(unit, state);
+        return compute_deps_doc(unit, state, unit_for);
     }
 
     let id = unit.pkg.package_id();
@@ -395,9 +395,13 @@ fn compute_deps_custom_build(
 }
 
 /// Returns the dependencies necessary to document a package.
-fn compute_deps_doc(unit: &Unit, state: &mut State<'_, '_>) -> CargoResult<Vec<UnitDep>> {
+fn compute_deps_doc(
+    unit: &Unit,
+    state: &mut State<'_, '_>,
+    unit_for: UnitFor,
+) -> CargoResult<Vec<UnitDep>> {
     let deps = state
-        .deps(unit, UnitFor::new_normal())
+        .deps(unit, unit_for)
         .into_iter()
         .filter(|&(_id, deps)| deps.iter().any(|dep| dep.kind() == DepKind::Normal));
 
@@ -414,7 +418,7 @@ fn compute_deps_doc(unit: &Unit, state: &mut State<'_, '_>) -> CargoResult<Vec<U
         // Rustdoc only needs rmeta files for regular dependencies.
         // However, for plugins/proc macros, deps should be built like normal.
         let mode = check_or_build_mode(unit.mode, lib);
-        let dep_unit_for = UnitFor::new_normal().with_dependency(unit, lib);
+        let dep_unit_for = unit_for.with_dependency(unit, lib);
         let lib_unit_dep = new_unit_dep(
             state,
             unit,
@@ -441,11 +445,11 @@ fn compute_deps_doc(unit: &Unit, state: &mut State<'_, '_>) -> CargoResult<Vec<U
     }
 
     // Be sure to build/run the build script for documented libraries.
-    ret.extend(dep_build_script(unit, UnitFor::new_normal(), state)?);
+    ret.extend(dep_build_script(unit, unit_for, state)?);
 
     // If we document a binary/example, we need the library available.
     if unit.target.is_bin() || unit.target.is_example() {
-        ret.extend(maybe_lib(unit, state, UnitFor::new_normal())?);
+        ret.extend(maybe_lib(unit, state, unit_for)?);
     }
     Ok(ret)
 }

tests/testsuite/features2.rs

@@ -2277,3 +2277,50 @@ fn pm_with_int_shared() {
         )
         .run();
 }
+
+#[cargo_test]
+fn doc_proc_macro() {
+    // Checks for a bug when documenting a proc-macro with a dependency. The
+    // doc unit builder was not carrying the "for host" setting through the
+    // dependencies, and the `pm-dep` dependency was causing a panic because
+    // it was looking for target features instead of host features.
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "foo"
+                version = "0.1.0"
+                resolver = "2"
+
+                [dependencies]
+                pm = { path = "pm" }
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .file(
+            "pm/Cargo.toml",
+            r#"
+                [package]
+                name = "pm"
+                version = "0.1.0"
+
+                [lib]
+                proc-macro = true
+
+                [dependencies]
+                pm-dep = { path = "../pm-dep" }
+            "#,
+        )
+        .file("pm/src/lib.rs", "")
+        .file("pm-dep/Cargo.toml", &basic_manifest("pm-dep", "0.1.0"))
+        .file("pm-dep/src/lib.rs", "")
+        .build();
+
+    // Unfortunately this cannot check the output because what it prints is
+    // nondeterministic. Sometimes it says "Compiling pm-dep" and sometimes
+    // "Checking pm-dep". This is because it is both building it and checking
+    // it in parallel (building so it can build the proc-macro, and checking
+    // so rustdoc can load it).
+    p.cargo("doc").run();
+}