Module cargo::core::compiler::unit_dependencies
source · Expand description
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
Enums
Unit is an artifact or not.Constants
Functions
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.unit_dependencies.deps of unit and add units that build these artifacts
to ret.Unit.RunCustomBuildunit, this function will return the unit to run that build script.parent to pkg and target.