Struct cargo::core::compiler::Metadata

pub struct Metadata(u64);

The Metadata is a hash used to make unique file names for each unit in a build. It is also used for symbol mangling.

For example:

• A project may depend on crate A and crate B, so the package name must be in the file name.
• Similarly a project may depend on two versions of A, so the version must be in the file name.

In general this must include all things that need to be distinguished in different parts of the same build. This is absolutely required or we override things before we get chance to use them.

It is also used for symbol mangling, because if you have two versions of the same crate linked together, their symbols need to be differentiated.

We use a hash because it is an easy way to guarantee that all the inputs can be converted to a valid path.

This also acts as the main layer of caching provided by Cargo. For example, we want to cache cargo build and cargo doc separately, so that running one does not invalidate the artifacts for the other. We do this by including CompileMode in the hash, thus the artifacts go in different folders and do not override each other. If we don’t add something that we should have, for this reason, we get the correct output but rebuild more than is needed.

Some things that need to be tracked to ensure the correct output should definitely not go in the Metadata. For example, the modification time of a file, should be tracked to make a rebuild when the file changes. However, it would be wasteful to include in the Metadata. The old artifacts are never going to be needed again. We can save space by just overwriting them. If we add something that we should not have, for this reason, we get the correct output but take more space than needed. This makes not including something in Metadata a form of cache invalidation.

You should also avoid anything that would interfere with reproducible builds. For example, any absolute path should be avoided. This is one reason that RUSTFLAGS is not in Metadata, because it often has absolute paths (like --remap-path-prefix which is fundamentally used for reproducible builds and has absolute paths in it). Also, in some cases the mangled symbols need to be stable between different builds with different settings. For example, profile-guided optimizations need to swap RUSTFLAGS between runs, but needs to keep the same symbol names.

Note that the Fingerprint is in charge of tracking everything needed to determine if a rebuild is needed.

Tuple Fields

0: u64

Trait Implementations

impl Clone for Metadata

fn clone(&self) -> Metadata

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Metadata

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Metadata

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Metadata

fn cmp(&self, other: &Metadata) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Metadata> for Metadata

fn eq(&self, other: &Metadata) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Metadata> for Metadata

fn partial_cmp(&self, other: &Metadata) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Metadata

impl Eq for Metadata

impl StructuralEq for Metadata

impl StructuralPartialEq for Metadata

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes