Remove redundant check for Kind::Target.

[cargo.git] / src / cargo / core / compiler / unit_dependencies.rs

//! Constructs the dependency graph for compilation.
//!
//! Rust code is typically organized as a set of Cargo packages. The
//! dependencies between the packages themselves are stored in the
//! `Resolve` struct. However, we can't use that information as is for
//! compilation! A package typically contains several targets, or crates,
//! and these targets has inter-dependencies. For example, you need to
//! compile the `lib` target before the `bin` one, and you need to compile
//! `build.rs` before either of those.
//!
//! So, we need to lower the `Resolve`, which specifies dependencies between
//! *packages*, to a graph of dependencies between their *targets*, and this
//! is exactly what this module is doing! Well, almost exactly: another
//! complication is that we might want to compile the same target several times
//! (for example, with and without tests), so we actually build a dependency
//! graph of `Unit`s, which capture these properties.

use crate::core::compiler::Unit;
use crate::core::compiler::{BuildContext, CompileMode, Kind};
use crate::core::dependency::Kind as DepKind;
use crate::core::package::Downloads;
use crate::core::profiles::{Profile, UnitFor};
use crate::core::resolver::Resolve;
use crate::core::{InternedString, Package, PackageId, Target};
use crate::CargoResult;
use log::trace;
use std::collections::{HashMap, HashSet};

/// The dependency graph of Units.
pub type UnitGraph<'a> = HashMap<Unit<'a>, Vec<UnitDep<'a>>>;

/// A unit dependency.
#[derive(Debug, Clone, Hash, Eq, PartialEq, PartialOrd, Ord)]
pub struct UnitDep<'a> {
    /// The dependency unit.
    pub unit: Unit<'a>,
    /// The purpose of this dependency (a dependency for a test, or a build
    /// script, etc.).
    pub unit_for: UnitFor,
    /// The name the parent uses to refer to this dependency.
    pub extern_crate_name: InternedString,
    /// Whether or not this is a public dependency.
    pub public: bool,
}

/// Collection of stuff used while creating the `UnitGraph`.
struct State<'a, 'cfg> {
    bcx: &'a BuildContext<'a, 'cfg>,
    waiting_on_download: HashSet<PackageId>,
    downloads: Downloads<'a, 'cfg>,
    unit_dependencies: UnitGraph<'a>,
    package_cache: HashMap<PackageId, &'a Package>,
    usr_resolve: &'a Resolve,
    std_resolve: Option<&'a Resolve>,
    /// This flag is `true` while generating the dependencies for the standard
    /// library.
    is_std: bool,
}

pub fn build_unit_dependencies<'a, 'cfg>(
    bcx: &'a BuildContext<'a, 'cfg>,
    resolve: &'a Resolve,
    std_resolve: Option<&'a Resolve>,
    roots: &[Unit<'a>],
    std_roots: &[Unit<'a>],
) -> CargoResult<UnitGraph<'a>> {
    let mut state = State {
        bcx,
        downloads: bcx.packages.enable_download()?,
        waiting_on_download: HashSet::new(),
        unit_dependencies: HashMap::new(),
        package_cache: HashMap::new(),
        usr_resolve: resolve,
        std_resolve,
        is_std: false,
    };

    let std_unit_deps = calc_deps_of_std(&mut state, std_roots)?;
    let libtest_unit_deps = calc_deps_of_libtest(&mut state, std_roots, roots)?;

    deps_of_roots(roots, &mut state)?;
    super::links::validate_links(state.resolve(), &state.unit_dependencies)?;
    // Hopefully there aren't any links conflicts with the standard library?

    if let Some(mut std_unit_deps) = std_unit_deps {
        if let Some(libtest_unit_deps) = libtest_unit_deps {
            attach_std_test(&mut state, libtest_unit_deps, &std_unit_deps);
        }
        fixup_proc_macro(&mut std_unit_deps);
        attach_std_deps(&mut state, std_roots, std_unit_deps);
    }

    connect_run_custom_build_deps(&mut state.unit_dependencies);

    // Dependencies are used in tons of places throughout the backend, many of
    // which affect the determinism of the build itself. As a result be sure
    // that dependency lists are always sorted to ensure we've always got a
    // deterministic output.
    for list in state.unit_dependencies.values_mut() {
        list.sort();
    }
    trace!("ALL UNIT DEPENDENCIES {:#?}", state.unit_dependencies);

    Ok(state.unit_dependencies)
}

/// Compute all the dependencies for the standard library.
fn calc_deps_of_std<'a, 'cfg>(
    mut state: &mut State<'a, 'cfg>,
    std_roots: &[Unit<'a>],
) -> CargoResult<Option<UnitGraph<'a>>> {
    if std_roots.is_empty() {
        return Ok(None);
    }
    // Compute dependencies for the standard library.
    state.is_std = true;
    deps_of_roots(std_roots, &mut state)?;
    state.is_std = false;
    Ok(Some(std::mem::replace(
        &mut state.unit_dependencies,
        HashMap::new(),
    )))
}

/// Compute all the dependencies for libtest.
/// Returns None if libtest is not needed.
fn calc_deps_of_libtest<'a, 'cfg>(
    mut state: &mut State<'a, 'cfg>,
    std_roots: &[Unit<'a>],
    roots: &[Unit<'a>],
) -> CargoResult<Option<UnitGraph<'a>>> {
    // Conditionally include libtest.
    if std_roots.is_empty()
        || !roots
            .iter()
            .any(|unit| unit.mode.is_rustc_test() && unit.target.harness())
    {
        return Ok(None);
    }
    state.is_std = true;
    let test_id = state.resolve().query("test")?;
    let test_pkg = state.get(test_id)?.expect("test doesn't need downloading");
    let test_target = test_pkg
        .targets()
        .iter()
        .find(|t| t.is_lib())
        .expect("test has a lib");
    let test_unit = new_unit(
        state,
        test_pkg,
        test_target,
        UnitFor::new_normal(),
        Kind::Target,
        CompileMode::Build,
    );
    let res = calc_deps_of_std(state, &[test_unit])?;
    state.is_std = false;
    Ok(res)
}

/// `proc_macro` has an implicit dependency on `std`, add it.
fn fixup_proc_macro<'a>(std_unit_deps: &mut UnitGraph<'a>) {
    // Synthesize a dependency from proc_macro -> std.
    //
    // This is a gross hack. This wouldn't be necessary with `--sysroot`. See
    // also libtest below.
    if let Some(std) = std_unit_deps
        .keys()
        .find(|unit| unit.pkg.name().as_str() == "std" && unit.target.is_lib())
        .cloned()
    {
        for (unit, deps) in std_unit_deps.iter_mut() {
            if unit.pkg.name().as_str() == "proc_macro" {
                deps.push(UnitDep {
                    unit: std,
                    unit_for: UnitFor::new_normal(),
                    extern_crate_name: InternedString::new("std"),
                    public: true,
                });
            }
        }
    }
}

/// Add libtest as a dependency of any test unit that needs it.
fn attach_std_test<'a, 'cfg>(
    state: &mut State<'a, 'cfg>,
    mut libtest_unit_deps: UnitGraph<'a>,
    std_unit_deps: &UnitGraph<'a>,
) {
    // Attach libtest to any test unit.
    let (test_unit, test_deps) = libtest_unit_deps
        .iter_mut()
        .find(|(k, _v)| k.pkg.name().as_str() == "test" && k.target.is_lib())
        .expect("test in deps");
    for (unit, deps) in state.unit_dependencies.iter_mut() {
        if unit.mode.is_rustc_test() && unit.target.harness() {
            // `public` here will need to be driven by toml declaration.
            deps.push(UnitDep {
                unit: *test_unit,
                unit_for: UnitFor::new_normal(),
                extern_crate_name: test_unit.pkg.name(),
                public: false,
            });
        }
    }

    // Synthesize a dependency from libtest -> libc.
    //
    // This is a gross hack. In theory, libtest should explicitly list this,
    // but presumably it would cause libc to be built again when it just uses
    // the version from sysroot. This won't be necessary if Cargo uses
    // `--sysroot`.
    let libc_unit = std_unit_deps
        .keys()
        .find(|unit| unit.pkg.name().as_str() == "libc" && unit.target.is_lib())
        .expect("libc in deps");
    let libc_dep = UnitDep {
        unit: *libc_unit,
        unit_for: UnitFor::new_normal(),
        extern_crate_name: InternedString::new(&libc_unit.target.crate_name()),
        public: false,
    };
    test_deps.push(libc_dep);

    // And also include the dependencies of libtest itself.
    for (unit, deps) in libtest_unit_deps.into_iter() {
        if let Some(other_unit) = state.unit_dependencies.insert(unit, deps) {
            panic!(
                "libtest unit collision with existing unit: {:?}",
                other_unit
            );
        }
    }
}

/// Add the standard library units to the `unit_dependencies`.
fn attach_std_deps<'a, 'cfg>(
    state: &mut State<'a, 'cfg>,
    std_roots: &[Unit<'a>],
    std_unit_deps: UnitGraph<'a>,
) {
    // Attach the standard library as a dependency of every target unit.
    for (unit, deps) in state.unit_dependencies.iter_mut() {
        if unit.kind == Kind::Target && !unit.mode.is_run_custom_build() {
            deps.extend(std_roots.iter().map(|unit| UnitDep {
                unit: *unit,
                unit_for: UnitFor::new_normal(),
                extern_crate_name: unit.pkg.name(),
                // TODO: Does this `public` make sense?
                public: true,
            }));
        }
    }
    // And also include the dependencies of the standard library itself.
    for (unit, deps) in std_unit_deps.into_iter() {
        if let Some(other_unit) = state.unit_dependencies.insert(unit, deps) {
            panic!("std unit collision with existing unit: {:?}", other_unit);
        }
    }
}

/// Compute all the dependencies of the given root units.
/// The result is stored in state.unit_dependencies.
fn deps_of_roots<'a, 'cfg>(roots: &[Unit<'a>], mut state: &mut State<'a, 'cfg>) -> CargoResult<()> {
    // Loop because we are downloading while building the dependency graph.
    // The partially-built unit graph is discarded through each pass of the
    // loop because it is incomplete because not all required Packages have
    // been downloaded.
    loop {
        for unit in roots.iter() {
            state.get(unit.pkg.package_id())?;

            // Dependencies of tests/benches should not have `panic` set.
            // We check the global test mode to see if we are running in `cargo
            // test` in which case we ensure all dependencies have `panic`
            // cleared, and avoid building the lib thrice (once with `panic`, once
            // without, once for `--test`). In particular, the lib included for
            // Doc tests and examples are `Build` mode here.
            let unit_for = if unit.mode.is_any_test() || state.bcx.build_config.test() {
                UnitFor::new_test()
            } else if unit.target.is_custom_build() {
                // This normally doesn't happen, except `clean` aggressively
                // generates all units.
                UnitFor::new_build()
            } else if unit.target.for_host() {
                // Proc macro / plugin should never have panic set.
                UnitFor::new_compiler()
            } else {
                UnitFor::new_normal()
            };
            deps_of(unit, &mut state, unit_for)?;
        }

        if !state.waiting_on_download.is_empty() {
            state.finish_some_downloads()?;
            state.unit_dependencies.clear();
        } else {
            break;
        }
    }
    Ok(())
}

/// Compute the dependencies of a single unit.
fn deps_of<'a, 'cfg>(
    unit: &Unit<'a>,
    state: &mut State<'a, 'cfg>,
    unit_for: UnitFor,
) -> CargoResult<()> {
    // Currently the `unit_dependencies` map does not include `unit_for`. This should
    // be safe for now. `TestDependency` only exists to clear the `panic`
    // flag, and you'll never ask for a `unit` with `panic` set as a
    // `TestDependency`. `CustomBuild` should also be fine since if the
    // requested unit's settings are the same as `Any`, `CustomBuild` can't
    // affect anything else in the hierarchy.
    if !state.unit_dependencies.contains_key(unit) {
        let unit_deps = compute_deps(unit, state, unit_for)?;
        state.unit_dependencies.insert(*unit, unit_deps.clone());
        for unit_dep in unit_deps {
            deps_of(&unit_dep.unit, state, unit_dep.unit_for)?;
        }
    }
    Ok(())
}

/// For a package, returns all targets that are registered as dependencies
/// for that package.
/// This returns a `Vec` of `(Unit, UnitFor)` pairs. The `UnitFor`
/// is the profile type that should be used for dependencies of the unit.
fn compute_deps<'a, 'cfg>(
    unit: &Unit<'a>,
    state: &mut State<'a, 'cfg>,
    unit_for: UnitFor,
) -> CargoResult<Vec<UnitDep<'a>>> {
    if unit.mode.is_run_custom_build() {
        return compute_deps_custom_build(unit, state);
    } else if unit.mode.is_doc() {
        // Note: this does not include doc test.
        return compute_deps_doc(unit, state);
    }

    let bcx = state.bcx;
    let id = unit.pkg.package_id();
    let deps = state.resolve().deps(id).filter(|&(_id, deps)| {
        assert!(!deps.is_empty());
        deps.iter().any(|dep| {
            // If this target is a build command, then we only want build
            // dependencies, otherwise we want everything *other than* build
            // dependencies.
            if unit.target.is_custom_build() != dep.is_build() {
                return false;
            }

            // If this dependency is **not** a transitive dependency, then it
            // only applies to test/example targets.
            if !dep.is_transitive()
                && !unit.target.is_test()
                && !unit.target.is_example()
                && !unit.mode.is_any_test()
            {
                return false;
            }

            // If this dependency is only available for certain platforms,
            // make sure we're only enabling it for that platform.
            if !bcx.dep_platform_activated(dep, unit.kind) {
                return false;
            }

            // If we've gotten past all that, then this dependency is
            // actually used!
            true
        })
    });

    let mut ret = Vec::new();
    for (id, _) in deps {
        let pkg = match state.get(id)? {
            Some(pkg) => pkg,
            None => continue,
        };
        let lib = match pkg.targets().iter().find(|t| t.is_lib()) {
            Some(t) => t,
            None => continue,
        };
        let mode = check_or_build_mode(unit.mode, lib);
        let dep_unit_for = unit_for.with_for_host(lib.for_host());

        if bcx.config.cli_unstable().dual_proc_macros
            && lib.proc_macro()
            && unit.kind == Kind::Target
        {
            let unit_dep = new_unit_dep(state, unit, pkg, lib, dep_unit_for, Kind::Target, mode)?;
            ret.push(unit_dep);
            let unit_dep = new_unit_dep(state, unit, pkg, lib, dep_unit_for, Kind::Host, mode)?;
            ret.push(unit_dep);
        } else {
            let unit_dep = new_unit_dep(
                state,
                unit,
                pkg,
                lib,
                dep_unit_for,
                unit.kind.for_target(lib),
                mode,
            )?;
            ret.push(unit_dep);
        }
    }

    // If this target is a build script, then what we've collected so far is
    // all we need. If this isn't a build script, then it depends on the
    // build script if there is one.
    if unit.target.is_custom_build() {
        return Ok(ret);
    }
    ret.extend(dep_build_script(unit, state)?);

    // If this target is a binary, test, example, etc, then it depends on
    // the library of the same package. The call to `resolve.deps` above
    // didn't include `pkg` in the return values, so we need to special case
    // it here and see if we need to push `(pkg, pkg_lib_target)`.
    if unit.target.is_lib() && unit.mode != CompileMode::Doctest {
        return Ok(ret);
    }
    ret.extend(maybe_lib(unit, state, unit_for)?);

    // If any integration tests/benches are being run, make sure that
    // binaries are built as well.
    if !unit.mode.is_check()
        && unit.mode.is_any_test()
        && (unit.target.is_test() || unit.target.is_bench())
    {
        ret.extend(
            unit.pkg
                .targets()
                .iter()
                .filter(|t| {
                    let no_required_features = Vec::new();

                    t.is_bin() &&
                        // Skip binaries with required features that have not been selected.
                        t.required_features().unwrap_or(&no_required_features).iter().all(|f| {
                            unit.features.contains(&f.as_str())
                        })
                })
                .map(|t| {
                    new_unit_dep(
                        state,
                        unit,
                        unit.pkg,
                        t,
                        UnitFor::new_normal(),
                        unit.kind.for_target(t),
                        CompileMode::Build,
                    )
                })
                .collect::<CargoResult<Vec<UnitDep<'a>>>>()?,
        );
    }

    Ok(ret)
}

/// Returns the dependencies needed to run a build script.
///
/// The `unit` provided must represent an execution of a build script, and
/// the returned set of units must all be run before `unit` is run.
fn compute_deps_custom_build<'a, 'cfg>(
    unit: &Unit<'a>,
    state: &mut State<'a, 'cfg>,
) -> CargoResult<Vec<UnitDep<'a>>> {
    if let Some(links) = unit.pkg.manifest().links() {
        if state.bcx.script_override(links, unit.kind).is_some() {
            // Overridden build scripts don't have any dependencies.
            return Ok(Vec::new());
        }
    }
    // When not overridden, then the dependencies to run a build script are:
    //
    // 1. Compiling the build script itself.
    // 2. For each immediate dependency of our package which has a `links`
    //    key, the execution of that build script.
    //
    // We don't have a great way of handling (2) here right now so this is
    // deferred until after the graph of all unit dependencies has been
    // constructed.
    let unit_dep = new_unit_dep(
        state,
        unit,
        unit.pkg,
        unit.target,
        // All dependencies of this unit should use profiles for custom
        // builds.
        UnitFor::new_build(),
        // Build scripts always compiled for the host.
        Kind::Host,
        CompileMode::Build,
    )?;
    Ok(vec![unit_dep])
}

/// Returns the dependencies necessary to document a package.
fn compute_deps_doc<'a, 'cfg>(
    unit: &Unit<'a>,
    state: &mut State<'a, 'cfg>,
) -> CargoResult<Vec<UnitDep<'a>>> {
    let bcx = state.bcx;
    let deps = state
        .resolve()
        .deps(unit.pkg.package_id())
        .filter(|&(_id, deps)| {
            deps.iter().any(|dep| match dep.kind() {
                DepKind::Normal => bcx.dep_platform_activated(dep, unit.kind),
                _ => false,
            })
        });

    // To document a library, we depend on dependencies actually being
    // built. If we're documenting *all* libraries, then we also depend on
    // the documentation of the library being built.
    let mut ret = Vec::new();
    for (id, _deps) in deps {
        let dep = match state.get(id)? {
            Some(dep) => dep,
            None => continue,
        };
        let lib = match dep.targets().iter().find(|t| t.is_lib()) {
            Some(lib) => lib,
            None => continue,
        };
        // 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_for_host(lib.for_host());
        let lib_unit_dep = new_unit_dep(
            state,
            unit,
            dep,
            lib,
            dep_unit_for,
            unit.kind.for_target(lib),
            mode,
        )?;
        ret.push(lib_unit_dep);
        if let CompileMode::Doc { deps: true } = unit.mode {
            // Document this lib as well.
            let doc_unit_dep = new_unit_dep(
                state,
                unit,
                dep,
                lib,
                dep_unit_for,
                unit.kind.for_target(lib),
                unit.mode,
            )?;
            ret.push(doc_unit_dep);
        }
    }

    // Be sure to build/run the build script for documented libraries.
    ret.extend(dep_build_script(unit, 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())?);
    }
    Ok(ret)
}

fn maybe_lib<'a>(
    unit: &Unit<'a>,
    state: &mut State<'a, '_>,
    unit_for: UnitFor,
) -> CargoResult<Option<UnitDep<'a>>> {
    unit.pkg
        .targets()
        .iter()
        .find(|t| t.linkable())
        .map(|t| {
            let mode = check_or_build_mode(unit.mode, t);
            new_unit_dep(
                state,
                unit,
                unit.pkg,
                t,
                unit_for,
                unit.kind.for_target(t),
                mode,
            )
        })
        .transpose()
}

/// If a build script is scheduled to be run for the package specified by
/// `unit`, this function will return the unit to run that build script.
///
/// Overriding a build script simply means that the running of the build
/// script itself doesn't have any dependencies, so even in that case a unit
/// of work is still returned. `None` is only returned if the package has no
/// build script.
fn dep_build_script<'a>(
    unit: &Unit<'a>,
    state: &State<'a, '_>,
) -> CargoResult<Option<UnitDep<'a>>> {
    unit.pkg
        .targets()
        .iter()
        .find(|t| t.is_custom_build())
        .map(|t| {
            // The profile stored in the Unit is the profile for the thing
            // the custom build script is running for.
            let profile = state
                .bcx
                .profiles
                .get_profile_run_custom_build(&unit.profile);
            new_unit_dep_with_profile(
                state,
                unit,
                unit.pkg,
                t,
                UnitFor::new_build(),
                unit.kind,
                CompileMode::RunCustomBuild,
                profile,
            )
        })
        .transpose()
}

/// Choose the correct mode for dependencies.
fn check_or_build_mode(mode: CompileMode, target: &Target) -> CompileMode {
    match mode {
        CompileMode::Check { .. } | CompileMode::Doc { .. } => {
            if target.for_host() {
                // Plugin and proc macro targets should be compiled like
                // normal.
                CompileMode::Build
            } else {
                // Regular dependencies should not be checked with --test.
                // Regular dependencies of doc targets should emit rmeta only.
                CompileMode::Check { test: false }
            }
        }
        _ => CompileMode::Build,
    }
}

fn new_unit<'a>(
    state: &State<'a, '_>,
    pkg: &'a Package,
    target: &'a Target,
    unit_for: UnitFor,
    kind: Kind,
    mode: CompileMode,
) -> Unit<'a> {
    let profile = state.bcx.profiles.get_profile(
        pkg.package_id(),
        state.bcx.ws.is_member(pkg),
        unit_for,
        mode,
        state.bcx.build_config.release,
    );

    let features = state.resolve().features_sorted(pkg.package_id());
    state
        .bcx
        .units
        .intern(pkg, target, profile, kind, mode, features)
}

fn new_unit_dep<'a>(
    state: &State<'a, '_>,
    parent: &Unit<'a>,
    pkg: &'a Package,
    target: &'a Target,
    unit_for: UnitFor,
    kind: Kind,
    mode: CompileMode,
) -> CargoResult<UnitDep<'a>> {
    let profile = state.bcx.profiles.get_profile(
        pkg.package_id(),
        state.bcx.ws.is_member(pkg),
        unit_for,
        mode,
        state.bcx.build_config.release,
    );
    new_unit_dep_with_profile(state, parent, pkg, target, unit_for, kind, mode, profile)
}

fn new_unit_dep_with_profile<'a>(
    state: &State<'a, '_>,
    parent: &Unit<'a>,
    pkg: &'a Package,
    target: &'a Target,
    unit_for: UnitFor,
    kind: Kind,
    mode: CompileMode,
    profile: Profile,
) -> CargoResult<UnitDep<'a>> {
    // TODO: consider making extern_crate_name return InternedString?
    let extern_crate_name = InternedString::new(&state.resolve().extern_crate_name(
        parent.pkg.package_id(),
        pkg.package_id(),
        target,
    )?);
    let public = state
        .resolve()
        .is_public_dep(parent.pkg.package_id(), pkg.package_id());
    let features = state.resolve().features_sorted(pkg.package_id());
    let unit = state
        .bcx
        .units
        .intern(pkg, target, profile, kind, mode, features);
    Ok(UnitDep {
        unit,
        unit_for,
        extern_crate_name,
        public,
    })
}

/// Fill in missing dependencies for units of the `RunCustomBuild`
///
/// As mentioned above in `compute_deps_custom_build` each build script
/// execution has two dependencies. The first is compiling the build script
/// itself (already added) and the second is that all crates the package of the
/// build script depends on with `links` keys, their build script execution. (a
/// bit confusing eh?)
///
/// Here we take the entire `deps` map and add more dependencies from execution
/// of one build script to execution of another build script.
fn connect_run_custom_build_deps(unit_dependencies: &mut UnitGraph<'_>) {
    let mut new_deps = Vec::new();

    {
        // First up build a reverse dependency map. This is a mapping of all
        // `RunCustomBuild` known steps to the unit which depends on them. For
        // example a library might depend on a build script, so this map will
        // have the build script as the key and the library would be in the
        // value's set.
        let mut reverse_deps_map = HashMap::new();
        for (unit, deps) in unit_dependencies.iter() {
            for dep in deps {
                if dep.unit.mode == CompileMode::RunCustomBuild {
                    reverse_deps_map
                        .entry(dep.unit)
                        .or_insert_with(HashSet::new)
                        .insert(unit);
                }
            }
        }

        // Next, we take a look at all build scripts executions listed in the
        // dependency map. Our job here is to take everything that depends on
        // this build script (from our reverse map above) and look at the other
        // package dependencies of these parents.
        //
        // If we depend on a linkable target and the build script mentions
        // `links`, then we depend on that package's build script! Here we use
        // `dep_build_script` to manufacture an appropriate build script unit to
        // depend on.
        for unit in unit_dependencies
            .keys()
            .filter(|k| k.mode == CompileMode::RunCustomBuild)
        {
            // This is the lib that runs this custom build.
            let reverse_deps = match reverse_deps_map.get(unit) {
                Some(set) => set,
                None => continue,
            };

            let to_add = reverse_deps
                .iter()
                // Get all deps for lib.
                .flat_map(|reverse_dep| unit_dependencies[reverse_dep].iter())
                // Only deps with `links`.
                .filter(|other| {
                    other.unit.pkg != unit.pkg
                        && other.unit.target.linkable()
                        && other.unit.pkg.manifest().links().is_some()
                })
                // Get the RunCustomBuild for other lib.
                .filter_map(|other| {
                    unit_dependencies[&other.unit]
                        .iter()
                        .find(|other_dep| other_dep.unit.mode == CompileMode::RunCustomBuild)
                        .cloned()
                })
                .collect::<HashSet<_>>();

            if !to_add.is_empty() {
                // (RunCustomBuild, set(other RunCustomBuild))
                new_deps.push((*unit, to_add));
            }
        }
    }

    // And finally, add in all the missing dependencies!
    for (unit, new_deps) in new_deps {
        unit_dependencies.get_mut(&unit).unwrap().extend(new_deps);
    }
}

impl<'a, 'cfg> State<'a, 'cfg> {
    fn resolve(&self) -> &'a Resolve {
        if self.is_std {
            self.std_resolve.unwrap()
        } else {
            self.usr_resolve
        }
    }

    fn get(&mut self, id: PackageId) -> CargoResult<Option<&'a Package>> {
        if let Some(pkg) = self.package_cache.get(&id) {
            return Ok(Some(pkg));
        }
        if !self.waiting_on_download.insert(id) {
            return Ok(None);
        }
        if let Some(pkg) = self.downloads.start(id)? {
            self.package_cache.insert(id, pkg);
            self.waiting_on_download.remove(&id);
            return Ok(Some(pkg));
        }
        Ok(None)
    }

    /// Completes at least one downloading, maybe waiting for more to complete.
    ///
    /// This function will block the current thread waiting for at least one
    /// crate to finish downloading. The function may continue to download more
    /// crates if it looks like there's a long enough queue of crates to keep
    /// downloading. When only a handful of packages remain this function
    /// returns, and it's hoped that by returning we'll be able to push more
    /// packages to download into the queue.
    fn finish_some_downloads(&mut self) -> CargoResult<()> {
        assert!(self.downloads.remaining() > 0);
        loop {
            let pkg = self.downloads.wait()?;
            self.waiting_on_download.remove(&pkg.package_id());
            self.package_cache.insert(pkg.package_id(), pkg);

            // Arbitrarily choose that 5 or more packages concurrently download
            // is a good enough number to "fill the network pipe". If we have
            // less than this let's recompute the whole unit dependency graph
            // again and try to find some more packages to download.
            if self.downloads.remaining() < 5 {
                break;
            }
        }
        Ok(())
    }
}