Enum DebugInfo

pub enum DebugInfo {
    Resolved(TomlDebugInfo),
    Deferred(TomlDebugInfo),
}

The debuginfo level setting.

This is semantically a TomlDebugInfo, and should be used as so via the DebugInfo::into_inner method for all intents and purposes.

Internally, it’s used to model a debuginfo level whose value can be deferred for optimization purposes: host dependencies usually don’t need the same level as target dependencies. For dependencies that are shared between the two however, that value also affects reuse: different debuginfo levels would cause to build a unit twice. By deferring the choice until we know whether to choose the optimized value or the default value, we can make sure the unit is only built once and the unit graph is still optimized.

Variants

Resolved(TomlDebugInfo)

A debuginfo level that is fixed and will not change.

This can be set by a profile, user, or default value.

Deferred(TomlDebugInfo)

For internal purposes: a deferred debuginfo level that can be optimized away, but has this value otherwise.

Behaves like Resolved in all situations except for the default build dependencies profile: whenever a build dependency is not shared with runtime dependencies, this level is weakened to a lower level that is faster to build (see DebugInfo::weaken).

In all other situations, this level value will be the one to use.

Implementations

impl DebugInfo

pub fn into_inner(self) -> TomlDebugInfo

The main way to interact with this debuginfo level, turning it into a TomlDebugInfo.

pub(crate) fn is_turned_on(&self) -> bool

Returns true if any debuginfo will be generated. Helper for a common operation on the usual Option representation.

pub(crate) fn is_deferred(&self) -> bool

pub(crate) fn finalize(self) -> Self

Force the deferred, preferred, debuginfo level to a finalized explicit value.

pub(crate) fn weaken(self) -> Self

Reset to the lowest level: no debuginfo.

Trait Implementations

impl Clone for DebugInfo

fn clone(&self) -> DebugInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DebugInfo

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

Formats the value using the given formatter.

impl Hash for DebugInfo

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 DebugInfo

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for DebugInfo

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for DebugInfo

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for DebugInfo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DebugInfo

impl Eq for DebugInfo

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: 2 bytes

Size for each variant:

• Resolved: 1 byte
• Deferred: 1 byte