Enum Stability

pub enum Stability<Toggleability> {
    Stable {
        allow_toggle: Toggleability,
    },
    Unstable {
        nightly_feature: Symbol,
        allow_toggle: Toggleability,
    },
    Forbidden {
        reason: &'static str,
    },
}

Stability information for target features. Toggleability is the type storing whether (un)stable features can be toggled: this is initially a function since it can depend on Target, but for stable hashing it needs to be something hashable to we have to make the type generic.

Variants

Stable

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

Fields

allow_toggle: Toggleability

When enabling/disabling the feature via -Ctarget-feature or #[target_feature], determine if that is allowed.

Unstable

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.

Fields

nightly_feature: Symbol

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

allow_toggle: Toggleability

See Stable::allow_toggle comment above.

Forbidden

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 that change the floating-point ABI.

Fields

reason: &'static str

Implementations

impl<Toggleability> Stability<Toggleability>

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 requires_nightly(&self) -> 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 allow_toggle()
• for cfg(target_feature), check in_cfg

impl Stability<fn(_: &Target, _: bool) -> Result<(), &'static str>>

pub fn compute_toggleability(&self, target: &Target) -> StabilityComputed

pub fn toggle_allowed( &self, target: &Target, enable: bool, ) -> Result<(), &'static str>

impl Stability<AllowToggleComputed>

pub fn toggle_allowed(&self, enable: bool) -> 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 true, so make sure to also check requires_nightly.)

Trait Implementations

impl<Toggleability: Clone> Clone for Stability<Toggleability>

fn clone(&self) -> Stability<Toggleability>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Toggleability: Debug> Debug for Stability<Toggleability>

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

Formats the value using the given formatter.

impl<CTX, Toggleability: HashStable<CTX>> HashStable<CTX> for Stability<Toggleability>

fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher)

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.