Announcing Rust 1.92.0

Source: Rust Blog

Rust 1.92.0 released

The Rust team is happy to announce a new version of Rust, 1.92.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.92.0 with:

rustup update stable

If you don’t have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.92.0.

If you’d like to help us out by testing future releases, consider updating locally to use the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you encounter!

What’s in 1.92.0 stable

Deny‑by‑default never type lints

The language and compiler teams continue to work on stabilization of the never type. In this release the never_type_fallback_flowing_into_unsafe and dependency_on_unit_never_type_fallback future‑compatibility lints were made deny‑by‑default, meaning they will cause a compilation error when detected.

These lints can still be #[allow]ed and only fire when building the affected crates directly (not when they are built as dependencies, though Cargo will emit a warning). Approximately 500 crates are affected. For more justification, see the Language Team’s assessment.

unused_must_use no longer warns about Result

The unused_must_use lint warns when a #[must_use] result is ignored. It now ignores Result (e.g., Result) and ControlFlow, avoiding warnings for errors that can never occur.

use core::convert::Infallible;

fn can_never_fail() -> Result {
    // …
    Ok(())
}

fn main() {
    can_never_fail(); // No warning
}

Useful with traits that have an associated error type that may sometimes be infallible:

trait UsesAssocErrorType {
    type Error;
    fn method(&self) -> Result;
}

struct CannotFail;
impl UsesAssocErrorType for CannotFail {
    type Error = core::convert::Infallible;
    fn method(&self) -> Result {
        Ok(())
    }
}

struct CanFail;
impl UsesAssocErrorType for CanFail {
    type Error = std::io::Error;
    fn method(&self) -> Result {
        Err(std::io::Error::other("something went wrong"))
    }
}

fn main() {
    CannotFail.method(); // No warning
    CanFail.method();    // Warning: unused `Result` that must be used
}

Emit unwind tables even when -Cpanic=abort is enabled on Linux

Previously, backtraces with -Cpanic=abort stopped working after Rust 1.23. A workaround (-Cforce-unwind-tables=yes) was stabilized in 1.45. In Rust 1.92, unwind tables are emitted by default even when -Cpanic=abort is specified. To disable them, use -Cforce-unwind-tables=no.

Validate input to #[macro_export]

The compiler now performs stricter checks on arguments allowed for macro_export, upgraded to a “deny‑by‑default lint” that also reports in dependencies. See the relevant PR for details.

Stabilized APIs

• NonZero::div_ceil
• Location::file_as_c_str
• RwLockWriteGuard::downgrade
• Box::new_zeroed
• Box::new_zeroed_slice
• Rc::new_zeroed
• Rc::new_zeroed_slice
• Arc::new_zeroed
• Arc::new_zeroed_slice
• btree_map::Entry::insert_entry
• btree_map::VacantEntry::insert_entry
• impl Extend for proc_macro::TokenStream
• impl Extend for proc_macro::TokenStream
• impl Extend for proc_macro::TokenStream
• impl Extend for proc_macro::TokenStream

Const‑stable APIs

These previously stable APIs are now stable in const contexts:

• ::rotate_left
• ::rotate_right

Other changes

• Full changelog for Rust 1.92.0:
• Cargo 1.92.0 changelog:
• Clippy 1.92.0 changelog:

Contributors to 1.92.0

Many people came together to create Rust 1.92.0. We couldn’t have done it without all of you. Thanks!