Module cargo::core::compiler::unit_dependencies

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 Units, which capture these properties.

Structs

• State 🔒
  Collection of stuff used while creating the UnitGraph.

Enums

• IsArtifact
  A boolean-like to indicate if a Unit is an artifact or not.

Constants

• IS_NO_ARTIFACT_DEP 🔒

Functions

• artifact_targets_to_unit_deps 🔒
  Given a parent unit containing a dependency dep whose package is artifact_pkg, find all targets in artifact_pkg which refer to the deps artifact declaration and turn them into units. Due to the nature of artifact dependencies, a single dependency in a manifest can cause one or more targets to be build, for instance with artifact = ["bin:a", "bin:b", "staticlib"], which is very different from normal dependencies which cause only a single unit to be created.
• attach_std_deps 🔒
  Add the standard library units to the unit_dependencies.
• build_unit_dependencies
  Then entry point for building a dependency graph of compilation units.
• calc_artifact_deps 🔒
  Find artifacts for all deps of unit and add units that build these artifacts to ret.
• calc_deps_of_std 🔒
  Compute all the dependencies for the standard library.
• check_or_build_mode 🔒
  Choose the correct mode for dependencies.
• compute_deps 🔒
  Returns the direct unit dependencies for the given Unit.
• compute_deps_custom_build 🔒
  Returns the dependencies needed to run a build script.
• compute_deps_doc 🔒
  Returns the dependencies necessary to document a package.
• connect_run_custom_build_deps 🔒
  Fill in missing dependencies for units of the RunCustomBuild
• dep_build_script 🔒
  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.
• deps_of 🔒
  Compute the dependencies of a single unit, recursively computing all transitive dependencies.
• deps_of_roots 🔒
  Compute all the dependencies of the given root units. The result is stored in state.unit_dependencies.
• maybe_lib 🔒
• new_unit_dep 🔒
  Create a new Unit for a dependency from parent to pkg and target.
• new_unit_dep_with_profile 🔒