Compiler version cfg

This crate provides macros for conditional compilation according to rustc compiler version, analogous to #[cfg(...)] and #[cfg_attr(...)].

[dependencies]
rustversion = "1.0"

Selectors

• #[rustversion::stable] —

True on any stable compiler.

• #[rustversion::stable(1.34)] —

True on exactly the specified stable compiler.

• #[rustversion::beta] —

True on any beta compiler.

• #[rustversion::nightly] —

True on any nightly compiler or dev build.

• #[rustversion::nightly(2025-01-01)] —

True on exactly one nightly.

• #[rustversion::since(1.34)] —

True on that stable release and any later compiler, including beta and nightly.

• #[rustversion::since(2025-01-01)] —

True on that nightly and all newer ones.

• #[rustversion::before(version or date)] —

Negative of #[rustversion::since(...)].

• #[rustversion::not(selector)] —

Negative of any selector; for example #[rustversion::not(nightly)].

• #[rustversion::any(selectors...)] —

True if any of the comma-separated selectors is true; for example #[rustversion::any(stable, beta)].

• #[rustversion::all(selectors...)] —

True if all of the comma-separated selectors are true; for example #[rustversion::all(since(1.31), before(1.34))].

• #[rustversion::attr(selector,attribute)] —

For conditional inclusion of attributes; analogous to cfg_attr.

• rustversion::cfg!(selector) —

An expression form of any of the above attributes; for example if rustversion::cfg!(any(stable, beta)) { ... }.

Use cases

Providing additional trait impls as types are stabilized in the standard library without breaking compatibility with older compilers; in this case Pin\

stabilized in Rust 1.33:

#[rustversion::since(1.33)]
use std::pin::Pin;

#[rustversion::since(1.33)]
impl

 MyTrait for Pin

 {
    /* ... */
}

Similar but for language features; the ability to control alignment greater than 1 of packed structs was stabilized in Rust 1.33.

#[rustversion::attr(before(1.33), repr(packed))]
#[rustversion::attr(since(1.33), repr(packed(2)))]
struct Six(i16, i32);

fn main() {
    println!("{}", std::mem::align_of::<Six>());
}

Augmenting code with const as const impls are stabilized in the standard library. This use of const as an attribute is recognized as a special case by the rustversion::attr macro.

use std::time::Duration;

#[rustversion::attr(since(1.32), const)]
fn duration_as_days(dur: Duration) -> u64 {
    dur.as_secs() / 60 / 60 / 24
}

Emitting Cargo cfg directives from a build script. Note that this requires listing rustversion under [build-dependencies] in Cargo.toml, not [dependencies].

// build.rs

fn main() {
    if rustversion::cfg!(since(1.36)) {
        println!("cargo:rustc-cfg=no_std");
    }
}

// src/lib.rs

#![cfg_attr(no_std, no_std)]

#[cfg(no_std)]
extern crate alloc;

License

^{Licensed under either of Apache License, Version 2.0 or MIT license at your option.}

_{Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.}