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 Unit
s, 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 dep
s 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
.RunCustomBuild
unit
, this function will return the unit to run that build script.parent
to pkg
and target
.