cargo::core::profiles

# Struct UnitFor

Source

    pub struct UnitFor {
        host: bool,
        host_features: bool,
        panic_setting: PanicSetting,
        root_compile_kind: CompileKind,
        artifact_target_for_features: Option<CompileTarget>,
    }

Expand description

Flags used in creating `Unit`s to indicate the purpose for the target, and to ensure the target’s dependencies have the correct settings.

This means these are passed down from the root of the dependency tree to apply to most child dependencies.

## Fields§

§`host: bool`

A target for `build.rs` or any of its dependencies, or a proc-macro or any of its dependencies. This enables `build-override` profiles for these targets.

An invariant is that if `host_features` is true, `host` must be true.

Note that this is `true` for `RunCustomBuild` units, even though that unit should not use build-override profiles. This is a bit of a special case. When computing the `RunCustomBuild` unit, it manually uses the `get_profile_run_custom_build` method to get the correct profile information for the unit. `host` needs to be true so that all of the dependencies of that `RunCustomBuild` unit have this flag be sticky (and forced to `true` for all further dependencies) — which is the whole point of `UnitFor`.

§`host_features: bool`

A target for a build dependency or proc-macro (or any of its dependencies). This is used for computing features of build dependencies and proc-macros independently of other dependency kinds.

The subtle difference between this and `host` is that the build script for a non-host package sets this to `false` because it wants the features of the non-host package (whereas `host` is true because the build script is being built for the host). `host_features` becomes `true` for build-dependencies or proc-macros, or any of their dependencies. For example, with this dependency tree:

    foo
    ├── foo build.rs
    │   └── shared_dep (BUILD dependency)
    │       └── shared_dep build.rs
    └── shared_dep (Normal dependency)
        └── shared_dep build.rs

In this example, `foo build.rs` is `HOST=true`, `HOST_FEATURES=false`. This is so that `foo build.rs` gets the profile settings for build scripts (`HOST=true`) and features of foo (`HOST_FEATURES=false`) because build scripts need to know which features their package is being built with.

But in the case of `shared_dep`, when built as a build dependency, both flags are true (it only wants the build-dependency features). When `shared_dep` is built as a normal dependency, then `shared_dep build.rs` is `HOST=true`, `HOST_FEATURES=false` for the same reasons that foo’s build script is set that way.

§`panic_setting: PanicSetting`

How Cargo processes the `panic` setting or profiles.

§`root_compile_kind: CompileKind`

The compile kind of the root unit for which artifact dependencies are built. This is required particularly for the `target = "target"` setting of artifact dependencies which mean to inherit the `--target` specified on the command-line. However, that is a multi-value argument and root units are already created to reflect one unit per –target. Thus we have to build one artifact with the correct target for each of these trees. Note that this will always be set as we don’t initially know if there are artifacts that make use of it.

§`artifact_target_for_features: Option<CompileTarget>`

This is only set for artifact dependencies which have their `<target-triple>|target` set. If so, this information is used as part of the key for resolving their features, allowing for target-dependent feature resolution within the entire dependency tree. Note that this target corresponds to the target used to build the units in that dependency tree, too, but this copy of it is specifically used for feature lookup.

## Implementations§

Source§

### impl UnitFor

Source

#### pub fn new_normal(root_compile_kind: CompileKind) -> UnitFor

A unit for a normal target/dependency (i.e., not custom build, proc macro/plugin, or test/bench).

Source

#### pub fn new_host(host_features: bool, root_compile_kind: CompileKind) -> UnitFor

A unit for a custom build script or proc-macro or its dependencies.

The `host_features` parameter is whether or not this is for a build dependency or proc-macro (something that requires being built “on the host”). Build scripts for non-host units should use `false` because they want to use the features of the package they are running for.

Source

#### pub fn new_compiler(root_compile_kind: CompileKind) -> UnitFor

A unit for a compiler plugin or their dependencies.

Source

#### pub fn new_test(gctx: &GlobalContext, root_compile_kind: CompileKind) -> UnitFor

A unit for a test/bench target or their dependencies.

Note that `config` is taken here for unstable CLI features to detect whether `panic=abort` is supported for tests. Historical versions of rustc did not support this, but newer versions do with an unstable compiler flag.

Source

#### pub fn new_host_test( gctx: &GlobalContext, root_compile_kind: CompileKind, ) -> UnitFor

This is a special case for unit tests of a proc-macro.

Proc-macro unit tests are forced to be run on the host.

Source

#### pub fn with_dependency( self, parent: &Unit, dep_target: &Target, root_compile_kind: CompileKind, ) -> UnitFor

Returns a new copy updated based on the target dependency.

This is where the magic happens that the `host`/`host_features` settings transition in a sticky fashion. As the dependency graph is being built, once those flags are set, they stay set for the duration of that portion of tree.

Source

#### pub fn for_custom_build(self) -> UnitFor

Source

#### pub(crate) fn with_artifact_features(self, artifact: &Artifact) -> UnitFor

Set the artifact compile target for use in features using the given `artifact`.

Source

#### pub(crate) fn with_artifact_features_from_resolved_compile_kind( self, kind: Option<CompileKind>, ) -> UnitFor

Set the artifact compile target as determined by a resolved compile target. This is used if `target = "target"`.

Source

#### pub fn is_for_host(&self) -> bool

Returns `true` if this unit is for a build script or any of its dependencies, or a proc macro or any of its dependencies.

Source

#### pub fn is_for_host_features(&self) -> bool

Source

#### fn panic_setting(&self) -> PanicSetting

Returns how `panic` settings should be handled for this profile

Source

#### pub(crate) fn map_to_features_for( &self, dep_artifact: Option<&Artifact>, ) -> FeaturesFor

We might contain a parent artifact compile kind for features already, but will gladly accept the one of this dependency as an override as it defines how the artifact is built. If we are an artifact but don’t specify a `target`, we assume the default compile kind that is suitable in this situation.

Source

#### pub(crate) fn root_compile_kind(&self) -> CompileKind

## Trait Implementations§

Source§

### impl Clone for UnitFor

Source§

#### fn clone(&self) -> UnitFor

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from `source`. Read more
Source§

### impl Debug for UnitFor

Source§

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

Formats the value using the given formatter. Read more
Source§

### impl Hash for UnitFor

Source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · Source§

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

Feeds a slice of this type into the given `Hasher`. Read more
Source§

### impl Ord for UnitFor

Source§

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

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · Source§

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

Compares and returns the maximum of two values. Read more
1.21.0 · Source§

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

Compares and returns the minimum of two values. Read more
1.50.0 · Source§

#### fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
Source§

### impl PartialEq for UnitFor

Source§

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

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source§

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

Tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

### impl PartialOrd for UnitFor

Source§

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

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · Source§

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

Tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · Source§

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

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · Source§

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

Tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · Source§

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

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
Source§

### impl Copy for UnitFor

Source§

### impl Eq for UnitFor

Source§

### impl StructuralPartialEq for UnitFor

## Auto Trait Implementations§

§

### impl Freeze for UnitFor

§

### impl RefUnwindSafe for UnitFor

§

### impl Send for UnitFor

§

### impl Sync for UnitFor

§

### impl Unpin for UnitFor

§

### impl UnwindSafe for UnitFor

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> CloneToUninit for T
where T: Clone,

Source§

#### unsafe fn clone_to_uninit(&self, dst: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dst`. Read more
§

### impl<Q, K> Comparable<K> for Q
where Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn compare(&self, key: &K) -> Ordering

Compare self to `key` and return their ordering.
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
§

### impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [`Span`], returning an `Instrumented` wrapper. Read more
§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> IntoEither for T

Source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
§

### impl<T> Pointable for T

§

#### const ALIGN: usize

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<T> Same for T

Source§

#### type Output = T

Should always be `Self`
Source§

### impl<T> ToOwned for T
where T: Clone,

Source§

#### type Owned = T

The resulting type after obtaining ownership.
Source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

#### fn vzip(self) -> V

§

### impl<T> WithSubscriber for T

§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a [`WithDispatch`] wrapper. Read more
§

### impl<T> ErasedDestructor for T
where T: 'static,

§

### impl<T> MaybeSendSync for T

## 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: 40 bytes