Fix issues compiling build scripts

Author: willcrichton

src/bin/cargo/commands/doc.rs

@@ -56,30 +56,21 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
         args.compile_options(config, mode, Some(&ws), ProfileChecking::Custom)?;
     compile_opts.rustdoc_document_private_items = args.is_present("document-private-items");
     compile_opts.rustdoc_scrape_examples = match args.value_of("scrape-examples") {
-        Some(s) => {
-            let (examples, lib) = match s {
-                "all" => (true, true),
-                "examples" => (true, false),
-                "lib" => (false, true),
-                _ => {
-                    return Err(CliError::from(anyhow!(
-                        r#"--scrape-examples must take "all", "examples", or "lib" as an argument"#
-                    )));
-                }
-            };
-            Some(CompileFilter::Only {
-                all_targets: false,
-                lib: if lib { LibRule::True } else { LibRule::False },
-                bins: FilterRule::none(),
-                examples: if examples {
-                    FilterRule::All
-                } else {
-                    FilterRule::none()
-                },
-                benches: FilterRule::none(),
-                tests: FilterRule::none(),
-            })
-        }
+        Some(s) => Some(match s {
+            "all" => CompileFilter::new_all_targets(),
+            "examples" => CompileFilter::new(
+                LibRule::False,
+                FilterRule::none(),
+                FilterRule::none(),
+                FilterRule::All,
+                FilterRule::none(),
+            ),
+            _ => {
+                return Err(CliError::from(anyhow!(
+                    r#"--scrape-examples must take "all", "examples", or "lib" as an argument"#
+                )));
+            }
+        }),
         None => None,
     };
 

src/cargo/core/compiler/mod.rs

@@ -21,6 +21,7 @@ mod unit;
 pub mod unit_dependencies;
 pub mod unit_graph;
 
+use std::collections::HashSet;
 use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fs::{self, File};
@@ -660,33 +661,37 @@ fn rustdoc(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Work> {
             .arg("--scrape-examples-output-path")
             .arg(scrape_output_path(unit)?);
 
-        for root in &cx.bcx.roots {
-            rustdoc
-                .arg("--scrape-examples-target-crate")
-                .arg(root.pkg.name());
+        let root_packages = cx
+            .bcx
+            .roots
+            .iter()
+            .map(|root| root.pkg.name())
+            .collect::<HashSet<_>>();
+        for pkg in root_packages {
+            rustdoc.arg("--scrape-examples-target-crate").arg(pkg);
         }
     } else if cx.bcx.scrape_units.len() > 0 && cx.bcx.roots.contains(unit) {
-        rustdoc.arg("-Zunstable-options");
-
-        for scrape_unit in &cx.bcx.scrape_units {
-            rustdoc
-                .arg("--with-examples")
-                .arg(scrape_output_path(scrape_unit)?);
-        }
-
-        let mut all_units = cx
+        let all_units = cx
             .bcx
             .unit_graph
             .values()
             .map(|deps| deps.iter().map(|dep| &dep.unit))
             .flatten();
-        let check_unit = all_units
-            .find(|other| {
-                unit.pkg == other.pkg && unit.target == other.target && other.mode.is_check()
-            })
-            .with_context(|| format!("Could not find check unit for {:?}", unit))?;
-        let metadata = cx.files().metadata(check_unit);
-        rustdoc.arg("-C").arg(format!("metadata={}", metadata));
+        let check_unit = all_units.into_iter().find(|other| {
+            unit.pkg == other.pkg && unit.target == other.target && other.mode.is_check()
+        });
+        if let Some(check_unit) = check_unit {
+            let metadata = cx.files().metadata(check_unit);
+            rustdoc.arg("-C").arg(format!("metadata={}", metadata));
+
+            rustdoc.arg("-Zunstable-options");
+
+            for scrape_unit in &cx.bcx.scrape_units {
+                rustdoc
+                    .arg("--with-examples")
+                    .arg(scrape_output_path(scrape_unit)?);
+            }
+        }
     }
 
     build_deps_args(&mut rustdoc, cx, unit)?;

src/cargo/core/compiler/unit_dependencies.rs

@@ -100,7 +100,6 @@ pub fn build_unit_dependencies<'a, 'cfg>(
     let std_unit_deps = calc_deps_of_std(&mut state, std_roots)?;
 
     deps_of_roots(roots, &mut state)?;
-    deps_of_roots(scrape_roots, &mut state)?;
     super::links::validate_links(state.resolve(), &state.unit_dependencies)?;
     // Hopefully there aren't any links conflicts with the standard library?
 
@@ -425,15 +424,7 @@ fn compute_deps_doc(
 ) -> CargoResult<Vec<UnitDep>> {
     // 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,
-        },
-    );
+    let deps = state.deps(unit, unit_for, &|dep| dep.kind() == DepKind::Normal);
 
     // To document a library, we depend on dependencies actually being
     // built. If we're documenting *all* libraries, then we also depend on
@@ -483,13 +474,17 @@ fn compute_deps_doc(
     }
 
     for scrape_unit in state.scrape_roots.iter() {
-        ret.push(UnitDep {
-            unit: scrape_unit.clone(),
-            unit_for: unit_for.with_dependency(scrape_unit, &scrape_unit.target),
-            extern_crate_name: InternedString::new(""),
-            public: false,
-            noprelude: false,
-        });
+        let unit_for = UnitFor::new_normal();
+        deps_of(scrape_unit, state, unit_for)?;
+        ret.push(new_unit_dep(
+            state,
+            scrape_unit,
+            &scrape_unit.pkg,
+            &scrape_unit.target,
+            unit_for,
+            scrape_unit.kind,
+            scrape_unit.mode,
+        )?);
     }
 
     Ok(ret)
@@ -720,6 +715,7 @@ fn connect_run_custom_build_deps(state: &mut State<'_, '_>) {
                         && other.unit.target.is_linkable()
                         && other.unit.pkg.manifest().links().is_some()
                 })
+                .filter(|(_, other)| !other.unit.mode.is_doc_scrape())
                 // Skip dependencies induced via dev-dependencies since
                 // connections between `links` and build scripts only happens
                 // via normal dependencies. Otherwise since dev-dependencies can

src/cargo/ops/cargo_compile.rs

@@ -1514,9 +1514,7 @@ fn rebuild_unit_graph_shared(
         .collect();
     let new_scrape_units = scrape_units
         .iter()
-        .map(|unit| {
-            traverse_and_share(interner, &mut memo, &mut result, &unit_graph, unit, to_host)
-        })
+        .map(|unit| memo.get(unit).unwrap().clone())
         .collect();
     (new_roots, new_scrape_units, result)
 }