Enum Stability 

pub enum Stability {
    Stable,
    CfgStableToggleUnstable(Symbol),
    Unstable(Symbol),
    InternalOnly {
        reason: &'static str,
        target_modifier: bool,
        hard_error: bool,
    },
}

Stability information for target features.

Variants

Stable

This target feature is stable, it can be used in #[target_feature] and #[cfg(target_feature)].

CfgStableToggleUnstable(Symbol)

This target feature is cfg-stable. It can be used for #[cfg(target_feature)] on stable, but using it in #[target_feature] requires the given nightly feature.

Tuple Fields

0: Symbol

This must be a language feature, or else rustc will ICE when reporting a missing feature gate!

Unstable(Symbol)

This target feature is unstable. It is only present in #[cfg(target_feature)] on nightly and using it in #[target_feature] requires enabling the given nightly feature.

Tuple Fields

0: Symbol

This must be a language feature, or else rustc will ICE when reporting a missing feature gate!

InternalOnly

This is not actually something we expose as a “target feature” to our users. We just manage it internally as a target feature since that’s how LLVM represents it. This feature can not be set via -Ctarget-feature or #[target_feature], it can only be set in the target spec. It is never set in cfg(target_feature). Used in particular for features are actually ABI configuration flags (such as “soft-float” on many targets).

However, “internal” target features can still sometimes be enabled or disabled via -Ctarget-cpu or Rust/LLVM target feature implications. See target_modifier below for how to protect ABI-relevant target features.

Fields

reason: &'static str

target_modifier: bool

Whether this target feature must be consistent across all crates in a crate graph. If this is false, then either it should be fine for the target feature to differ across crates, or the target feature is set by another flag that’s already a target modifier, or it needs to be pinned down via Target::abi_required_features.

hard_error: bool

True if this is always an error, false if this can be reported as a warning when set via -Ctarget-feature (and a hard error when set via #[target_feature]).

Implementations

impl Stability

pub fn in_cfg(&self) -> bool

Returns whether the feature can be used in cfg(target_feature) ever. (It might still be nightly-only even if this returns true, so make sure to also check requires_nightly.)

pub fn is_target_modifier(&self) -> bool

Returns whether this target feature is to be treated as a target modifier.

pub fn requires_nightly(&self, in_cfg: bool) -> Option<Symbol>

Returns the nightly feature that is required to toggle this target feature via #[target_feature]/-Ctarget-feature or to test it via cfg(target_feature). (For cfg we only care whether the feature is nightly or not, we don’t require the feature gate to actually be enabled when using a nightly compiler.)

Before calling this, ensure the feature is even permitted for this use:

• for #[target_feature]/-Ctarget-feature, check toggle_allowed()
• for cfg(target_feature), check in_cfg()

The in_cfg parameter is used to determine whether it will be used in cfg(target_feature) (true) or #[target_feature]/-Ctarget-feature (false)

pub fn is_cfg_stable_toggle_unstable(&self) -> bool

Returns whether the feature is cfg-stable but still requires a nightly feature gate to be used in #[target_feature]/-Ctarget-feature.

pub fn toggle_allowed(&self) -> Result<(), &'static str>

Returns whether the feature may be toggled via #[target_feature] or -Ctarget-feature. (It might still be nightly-only even if this returns Ok(()), so make sure to also check requires_nightly.)

Trait Implementations

impl Clone for Stability

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Stability

impl Debug for Stability

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

Formats the value using the given formatter.

impl StableHash for Stability

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

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

Size for each variant:

• Stable: 0 bytes
• CfgStableToggleUnstable: 7 bytes
• Unstable: 7 bytes
• InternalOnly: 23 bytes