This post was published 34 days ago. The infomation described in this article may have changed.
The Rust team is happy to announce a new version of Rust, 1.72.0. Rust is a programming language empowering everyone to build reliable and efficient software.
If you have a previous version of Rust installed via rustup, you can get 1.72.0 with:
rustup update stable
If you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (
rustup default beta) or the nightly channel (
rustup default nightly). Please report any bugs you might come across!
You can conditionally enable Rust code using
cfg, such as to provide certain
functions only with certain crate features, or only on particular platforms.
Previously, items disabled in this way would be effectively invisible to the
compiler. Now, though, the compiler will remember the name and
of those items, so it can report (for example) if a function you tried to call
is unavailable because you need to enable a crate feature.
Compiling my-project v0.1.0 (/tmp/my-project) error[E0432]: unresolved import `rustix::io_uring` --> src/main.rs:1:5 | 1 | use rustix::io_uring; | ^^^^^^^^^^^^^^^^ no `io_uring` in the root | note: found an item that was configured out --> /home/username/.cargo/registry/src/index.crates.io-6f17d22bba15001f/rustix-0.38.8/src/lib.rs:213:9 | 213 | pub mod io_uring; | ^^^^^^^^ = note: the item is gated behind the `io_uring` feature For more information about this error, try `rustc --explain E0432`. error: could not compile `my-project` (bin "my-project") due to previous error
To prevent user-provided const evaluation from getting into a compile-time infinite loop or otherwise taking unbounded time at compile time, Rust previously limited the maximum number of statements run as part of any given constant evaluation. However, especially creative Rust code could hit these limits and produce a compiler error. Worse, whether code hit the limit could vary wildly based on libraries invoked by the user; if a library you invoked split a statement into two within one of its functions, your code could then fail to compile.
Now, you can do an unlimited amount of const evaluation at compile time. To
avoid having long compilations without feedback, the compiler will always emit
a message after your compile-time code has been running for a while, and repeat
that message after a period that doubles each time. By default, the compiler
will also emit a deny-by-default lint (
const_eval_long_running) after a large
number of steps to catch infinite loops, but you can
allow(const_eval_long_running) to permit especially long const evaluation.
Several lints from Clippy have been pulled into
ManuallyDropdoes not drop its inner value, so calling
std::mem::dropon it does nothing. Instead, the lint will suggest
ManuallyDrop::into_innerfirst, or you may use the unsafe
ManuallyDrop::dropto run the destructor in-place. This lint is denied by default.
std::str::from_utf8_unchecked_mutwith an invalid UTF-8 literal, which violates their safety pre-conditions, resulting in undefined behavior. This lint is denied by default.
std::str::from_utf8_mutwith an invalid UTF-8 literal, which will always return an error. This lint is a warning by default.
f64::NANas one of the operands. NaN does not compare meaningfully to anything – not even itself – so those comparisons are always false. This lint is a warning by default, and will suggest calling the
&mut Twithout using interior mutability, which is immediate undefined behavior, even if the reference is unused. This lint is currently allowed by default due to potential false positives, but it is planned to be denied by default in 1.73 after implementation improvements.
These APIs are now stable in const contexts:
In a future release we're planning to increase the minimum supported Windows version to 10. The accepted proposal in compiler MCP 651 is that Rust 1.75 will be the last to officially support Windows 7, 8, and 8.1. When Rust 1.76 is released in February 2024, only Windows 10 and later will be supported as tier-1 targets. This change will apply both as a host compiler and as a compilation target.
Many people came together to create Rust 1.72.0. We couldn't have done it without all of you. Thanks!🏷️ Rust_feed