1.40.0

1.40.0 (19 December, 2019) #

Language #

You can now use tuple structs and tuple enum variant’s constructors in const contexts. e.g.

pub struct Point(i32, i32);

const ORIGIN: Point = {
    let constructor = Point;

    constructor(0, 0)
};

You can now mark structs, enums, and enum variants with the #[non_exhaustive] attribute to indicate that there may be variants or fields added in the future. For example this requires adding a wild-card branch (_ => {}) to any match statements on a non-exhaustive enum. (RFC 2008)
You can now use function-like procedural macros in extern blocks and in type positions. e.g. type Generated = macro!();
Function-like and attribute procedural macros can now emit macro_rules! items, so you can now have your macros generate macros.
The meta pattern matcher in macro_rules! now correctly matches the modern attribute syntax. For example (#[$m:meta]) now matches #[attr], #[attr{tokens}], #[attr[tokens]], and #[attr(tokens)].

Compiler #

* Refer to Rust’s [platform support page][platform-support-doc] for more information on Rust’s tiered platform support.

Libraries #

The is_power_of_two method on unsigned numeric types is now a const function.

Stabilized APIs #

Cargo #

Misc #

You can now specify the #[cfg(doctest)] attribute to include an item only when running documentation tests with rustdoc.

Compatibility Notes #

As previously announced, any previous NLL warnings in the 2015 edition are now hard errors.
The include! macro will now warn if it failed to include the entire file. The include! macro unintentionally only includes the first expression in a file, and this can be unintuitive. This will become either a hard error in a future release, or the behavior may be fixed to include all expressions as expected.
Using #[inline] on function prototypes and consts now emits a warning under unused_attribute lint. Using #[inline] anywhere else inside traits or extern blocks now correctly emits a hard error.