Enum UnstableFeatures 

pub enum UnstableFeatures {
    Disallow,
    Allow,
    Cheat,
    AllowSelectedUnstableCompilerFlagsOnly {
        allowed_flags: Vec<String>,
    },
}

Variants

Disallow

Disallow use of unstable features and unstable compiler flags.

Used by default by beta/stable channels.

Allow

Allow use of unstable features and unstable compiler flags.

Used by default by the nightly channel.

Cheat

Allow use of unstable features and unstable compiler flags, even if it is not the default behavior.

Can be used to make a beta/stable channel act like a nightly channel.

Errors are bypassed for bootstrapping. This is required any time during the build that feature-related lints are set to warn or above because the build turns on warnings-as-errors and uses lots of unstable features. As a result, this is always required for building Rust itself.

AllowSelectedUnstableCompilerFlagsOnly

Allow the use of selected unstable compiler flags, but disallow the use of unstable language features.

This mode is designed only for internal testing of rustc.

Specifically, we need it when we want to test how rustc behaves on the stable channel, but at the same time we need to be able to pass it some unstable -Z compiler flags required for the testing infrastructure itself to work.

Fields

allowed_flags: Vec<String>

Unstable compiler flags that we are allowed to use, without their -Z prefix.

Implementations

impl UnstableFeatures

pub fn from_environment(krate: Option<&str>) -> Self

This takes into account RUSTC_BOOTSTRAP.

If krate is Some, then setting RUSTC_BOOTSTRAP=krate will enable the nightly features. Otherwise, only RUSTC_BOOTSTRAP=1 will work.

pub(crate) fn from_environment_value( krate: Option<&str>, env_var_rustc_bootstrap: Result<String, VarError>, ) -> Self

Avoid unsafe std::env::set_var() by allowing tests to inject std::env::var("RUSTC_BOOTSTRAP") with the env_var_rustc_bootstrap arg.

pub fn allow_unstable_compiler_flag(&self, flag: &str) -> bool

Are we allowed to use the given unstable flag? If it is a -Z<flag>, it should be passed without the -Z prefix.

pub fn is_nightly_build(&self) -> bool

Trait Implementations

impl Clone for UnstableFeatures

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnstableFeatures

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

Formats the value using the given formatter.

impl Eq for UnstableFeatures

impl Hash for UnstableFeatures

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 PartialEq for UnstableFeatures

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for UnstableFeatures

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:

• Disallow: 0 bytes
• Allow: 0 bytes
• Cheat: 0 bytes
• AllowSelectedUnstableCompilerFlagsOnly: 24 bytes