From ac570258743db0105c79a419a0e9a7f77b17bd45 Mon Sep 17 00:00:00 2001 From: Boxy Uwu Date: Wed, 3 Dec 2025 18:15:35 +0000 Subject: [PATCH 01/10] Announce Rust 1.92 stable release --- content/Rust-1.92.0.md | 116 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 content/Rust-1.92.0.md diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md new file mode 100644 index 000000000..e46194e94 --- /dev/null +++ b/content/Rust-1.92.0.md @@ -0,0 +1,116 @@ ++++ +path = "2025/12/11/Rust-1.92.0" +title = "Announcing Rust 1.92.0" +authors = ["The Rust Release Team"] +aliases = ["releases/1.92.0"] + +[extra] +release = true ++++ + +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: + +```console +$ rustup update stable +``` + +If you don't have it already, you can [get `rustup`](https://www.rust-lang.org/install.html) from the appropriate page on our website, and check out the [detailed release notes for 1.92.0](https://doc.rust-lang.org/stable/releases.html#version-1920-2025-12-11). + +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](https://github.com/rust-lang/rust/issues/new/choose) any bugs you might come across! + +## 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](https://doc.rust-lang.org/stable/std/primitive.never.html). In this release the [`never_type_fallback_flowing_into_unsafe`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#dependency-on-unit-never-type-fallback) and [`dependency_on_unit_never_type_fallback`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#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 detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate. + +### `unused_must_use` no longer warns about `Result<(), UninhabitedType>` + +Rust's `unused_must_use` lint warns when ignoring the return value of a function, if the function or its return type is annotated with `#[must_use]`. For instance, this warns if ignoring a return type of `Result`, to remind you to use `?`, or something like `.expect("...")`. + +However, some functions return `Result`, but the error type they use is not actually "inhabited", meaning it can never exist in real code (e.g. the [`!`](https://doc.rust-lang.org/std/primitive.never.html) or [`Infallible`](https://doc.rust-lang.org/std/convert/enum.Infallible.html) types). + +The `unused_must_use` lint now no longer warns on `Result<(), UninhabitedType>`, or on `ControlFlow`. For instance, it will not warn on `Result<(), !>`. This avoids having to check for an error that can never happen. + +```rust +fn can_never_fail() -> Result<(), !> { + // ... + Ok(()) +} + +fn main() { + can_never_fail() +} +``` + +This is particularly useful with the common pattern of a trait with an associated error type, where the error type may *sometimes* be infallible: + +```rust +trait UsesAssocErrorType { + type Error; + fn method(&self) -> Result<(), Self::Error>; +} + +struct CannotFail; +impl UsesAssocErrorType for CannotFail { + type Error = !; + fn method(&self) -> Result<(), Self::Error> { + Ok(()) + } +} + +struct CanFail; +impl UsesAssocErrorType for CanFail { + type Error = std::io::Error; + fn method(&self) -> Result<(), Self::Error> { + Err(std::io::Error::other("something went wrong")) + } +} + +fn main() { + CannotFail.method(); // No error + CanFail.method(); // Error: unused `Result` that must be used +} +``` + +### Emit unwind tables even when `-Cpanic=abort` is enabled on linux + +Backtraces with `-Cpanic=abort` previously worked in Rust 1.22 but were broken in Rust 1.23, as we stopped emitting unwind tables with `-Cpanic=abort`. In Rust 1.45 a workaround in the form of `-Cforce-unwind-tables=yes` was stabilized. + +In Rust 1.92 unwind tables will be emitted by default even when `-Cpanic=abort` is specified, allowing for backtraces to work properly. If unwind tables are not desired then users should use `-Cforce-unwind-tables=no` to explicitly disable them being emitted. + +### Validate input to `#[macro_export]` + +Over the past few releases, many changes were made to the way built-in attributes are processed in the compiler. This should greatly improve the error messages and warnings rust gives for built-in attributes and especially make these diagnostics more consistent among all of the over 100 built-in attributes. + +To give a small example, in this release specifically, Rust became stricter in checking what arguments are allowed to `macro_export` by [upgrading that check to a "deny-by-default lint" that will be reported in dependencies.](https://github.com/rust-lang/rust/pull/143857). + +### Restrictions on user code impls of `DerefMut` for `Pin` + +A soundness issue with `Pin` has been solved by preventing third-party crates from implementing `DerefMut` for `Pin` when `T` is a local type that doesn't implement `DerefMut`. + +### Stabilized APIs + +... + +These previously stable APIs are now stable in const contexts: + +... + +### Platform Support + +Refer to Rust’s [platform support page][platform-support] for more information on Rust’s tiered platform support. + +### Other changes + +Check out everything that changed in [Rust](https://github.com/rust-lang/rust/releases/tag/1.92.0), [Cargo](https://doc.rust-lang.org/nightly/cargo/CHANGELOG.html#cargo-192-2025-12-11), and [Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-192). + +## 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!](https://thanks.rust-lang.org/rust/1.92.0/) + +[platform-support]: https://doc.rust-lang.org/rustc/platform-support.html From 73ca07b06169991947f6b4a0bef3fc7c335fbe8c Mon Sep 17 00:00:00 2001 From: Boxy Uwu Date: Wed, 10 Dec 2025 16:58:57 +0000 Subject: [PATCH 02/10] w --- content/Rust-1.92.0.md | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index e46194e94..57d74d4ff 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -26,7 +26,11 @@ If you'd like to help us out by testing future releases, you might consider upda The language and compiler teams continue to work on stabilization of the [never type](https://doc.rust-lang.org/stable/std/primitive.never.html). In this release the [`never_type_fallback_flowing_into_unsafe`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#dependency-on-unit-never-type-fallback) and [`dependency_on_unit_never_type_fallback`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#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 detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate. +It's worth noting that while this can result in compileration errors, it is still a *lint*, these lints can all be `#[allow`'d. These lints also will only fire when building the affected crates directly, not when built as a dependency (though a warning will be reported by Cargo in such cases). + +These lints detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate graph. + +We believe there to be approximately ~500 crates affected by this lint. Despite that we believe this to be acceptable as lints are not a breaking change and it will allow for stabilizing the never type in the future. For more in depth justification the Language Team's assessement can be read here: [rust-lang/rust#146167#issuecomment-3363795006](https://github.com/rust-lang/rust/pull/146167#issuecomment-3363795006). ### `unused_must_use` no longer warns about `Result<(), UninhabitedType>` @@ -34,16 +38,17 @@ Rust's `unused_must_use` lint warns when ignoring the return value of a function However, some functions return `Result`, but the error type they use is not actually "inhabited", meaning it can never exist in real code (e.g. the [`!`](https://doc.rust-lang.org/std/primitive.never.html) or [`Infallible`](https://doc.rust-lang.org/std/convert/enum.Infallible.html) types). -The `unused_must_use` lint now no longer warns on `Result<(), UninhabitedType>`, or on `ControlFlow`. For instance, it will not warn on `Result<(), !>`. This avoids having to check for an error that can never happen. +The `unused_must_use` lint now no longer warns on `Result<(), UninhabitedType>`, or on `ControlFlow`. For instance, it will not warn on `Result<(), Infallible>`. This avoids having to check for an error that can never happen. ```rust -fn can_never_fail() -> Result<(), !> { +use core::convert::Infallible; +fn can_never_fail() -> Result<(), Infallible> { // ... Ok(()) } fn main() { - can_never_fail() + can_never_fail(); } ``` @@ -57,7 +62,7 @@ trait UsesAssocErrorType { struct CannotFail; impl UsesAssocErrorType for CannotFail { - type Error = !; + type Error = core::convert::Infallible; fn method(&self) -> Result<(), Self::Error> { Ok(()) } @@ -72,8 +77,8 @@ impl UsesAssocErrorType for CanFail { } fn main() { - CannotFail.method(); // No error - CanFail.method(); // Error: unused `Result` that must be used + CannotFail.method(); // No warning + CanFail.method(); // Warning: unused `Result` that must be used } ``` @@ -85,14 +90,10 @@ In Rust 1.92 unwind tables will be emitted by default even when `-Cpanic=abort` ### Validate input to `#[macro_export]` -Over the past few releases, many changes were made to the way built-in attributes are processed in the compiler. This should greatly improve the error messages and warnings rust gives for built-in attributes and especially make these diagnostics more consistent among all of the over 100 built-in attributes. +Over the past few releases, many changes were made to the way built-in attributes are processed in the compiler. This should greatly improve the error messages and warnings Rust gives for built-in attributes and especially make these diagnostics more consistent among all of the over 100 built-in attributes. To give a small example, in this release specifically, Rust became stricter in checking what arguments are allowed to `macro_export` by [upgrading that check to a "deny-by-default lint" that will be reported in dependencies.](https://github.com/rust-lang/rust/pull/143857). -### Restrictions on user code impls of `DerefMut` for `Pin` - -A soundness issue with `Pin` has been solved by preventing third-party crates from implementing `DerefMut` for `Pin` when `T` is a local type that doesn't implement `DerefMut`. - ### Stabilized APIs ... @@ -101,10 +102,6 @@ These previously stable APIs are now stable in const contexts: ... -### Platform Support - -Refer to Rust’s [platform support page][platform-support] for more information on Rust’s tiered platform support. - ### Other changes Check out everything that changed in [Rust](https://github.com/rust-lang/rust/releases/tag/1.92.0), [Cargo](https://doc.rust-lang.org/nightly/cargo/CHANGELOG.html#cargo-192-2025-12-11), and [Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-192). From 99ad5dd78f1807104c5d0f10132cbf3e4274b096 Mon Sep 17 00:00:00 2001 From: Boxy Uwu Date: Wed, 10 Dec 2025 17:00:41 +0000 Subject: [PATCH 03/10] stabilized APIs --- content/Rust-1.92.0.md | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index 57d74d4ff..3e70b601c 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -96,11 +96,26 @@ To give a small example, in this release specifically, Rust became stricter in c ### Stabilized APIs -... +- [`NonZero::div_ceil`](https://doc.rust-lang.org/stable/std/num/struct.NonZero.html#method.div_ceil) +- [`Location::file_as_c_str`](https://doc.rust-lang.org/stable/std/panic/struct.Location.html#method.file_as_c_str) +- [`RwLockWriteGuard::downgrade`](https://doc.rust-lang.org/stable/std/sync/struct.RwLockWriteGuard.html#method.downgrade) +- [`Box::new_zeroed`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_zeroed) +- [`Box::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_zeroed_slice) +- [`Rc::new_zeroed`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.new_zeroed) +- [`Rc::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.new_zeroed_slice) +- [`Arc::new_zeroed`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.new_zeroed) +- [`Arc::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.new_zeroed_slice) +- [`btree_map::Entry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/btree_map/enum.Entry.html#method.insert_entry) +- [`btree_map::VacantEntry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/btree_map/struct.VacantEntry.html#method.insert_entry) +- [`impl Extend for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CGroup%3E-for-TokenStream) +- [`impl Extend for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CLiteral%3E-for-TokenStream) +- [`impl Extend for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CPunct%3E-for-TokenStream) +- [`impl Extend for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CIdent%3E-for-TokenStream) These previously stable APIs are now stable in const contexts: -... +- [`<[_]>::rotate_left`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.rotate_left) +- [`<[_]>::rotate_right`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.rotate_right) ### Other changes From 506ec5eacd25ea56d8edd7ca70f8598ba200808a Mon Sep 17 00:00:00 2001 From: Boxy Uwu Date: Wed, 10 Dec 2025 17:01:47 +0000 Subject: [PATCH 04/10] w --- content/Rust-1.92.0.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index 3e70b601c..d183cacfd 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -30,7 +30,7 @@ It's worth noting that while this can result in compileration errors, it is stil These lints detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate graph. -We believe there to be approximately ~500 crates affected by this lint. Despite that we believe this to be acceptable as lints are not a breaking change and it will allow for stabilizing the never type in the future. For more in depth justification the Language Team's assessement can be read here: [rust-lang/rust#146167#issuecomment-3363795006](https://github.com/rust-lang/rust/pull/146167#issuecomment-3363795006). +We believe there to be approximately ~500 crates affected by this lint. Despite that we believe this to be acceptable as lints are not a breaking change and it will allow for stabilizing the never type in the future. For more in depth justification the Language Team's assessment can be read here: [rust-lang/rust#146167#issuecomment-3363795006](https://github.com/rust-lang/rust/pull/146167#issuecomment-3363795006). ### `unused_must_use` no longer warns about `Result<(), UninhabitedType>` From 542bc38cdd1d8b984a8ac20cf2b9c9fb0da0d3b6 Mon Sep 17 00:00:00 2001 From: Boxy Date: Wed, 10 Dec 2025 17:02:48 +0000 Subject: [PATCH 05/10] Update content/Rust-1.92.0.md Co-authored-by: bjorn3 <17426603+bjorn3@users.noreply.github.com> --- content/Rust-1.92.0.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index d183cacfd..ec222d291 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -26,7 +26,7 @@ If you'd like to help us out by testing future releases, you might consider upda The language and compiler teams continue to work on stabilization of the [never type](https://doc.rust-lang.org/stable/std/primitive.never.html). In this release the [`never_type_fallback_flowing_into_unsafe`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#dependency-on-unit-never-type-fallback) and [`dependency_on_unit_never_type_fallback`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#dependency-on-unit-never-type-fallback) future compatibility lints were made deny-by-default, meaning they will cause a compilation error when detected. -It's worth noting that while this can result in compileration errors, it is still a *lint*, these lints can all be `#[allow`'d. These lints also will only fire when building the affected crates directly, not when built as a dependency (though a warning will be reported by Cargo in such cases). +It's worth noting that while this can result in compileration errors, it is still a *lint*, these lints can all be `#[allow]`'d. These lints also will only fire when building the affected crates directly, not when built as a dependency (though a warning will be reported by Cargo in such cases). These lints detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate graph. From 2814b2d567512a395d4c662f6733d3ebf0055288 Mon Sep 17 00:00:00 2001 From: Boxy Date: Wed, 10 Dec 2025 18:13:10 +0000 Subject: [PATCH 06/10] Update content/Rust-1.92.0.md Co-authored-by: Kevin Reid --- content/Rust-1.92.0.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index ec222d291..0606d3019 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -26,7 +26,7 @@ If you'd like to help us out by testing future releases, you might consider upda The language and compiler teams continue to work on stabilization of the [never type](https://doc.rust-lang.org/stable/std/primitive.never.html). In this release the [`never_type_fallback_flowing_into_unsafe`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#dependency-on-unit-never-type-fallback) and [`dependency_on_unit_never_type_fallback`](https://doc.rust-lang.org/beta/rustc/lints/listing/deny-by-default.html#dependency-on-unit-never-type-fallback) future compatibility lints were made deny-by-default, meaning they will cause a compilation error when detected. -It's worth noting that while this can result in compileration errors, it is still a *lint*, these lints can all be `#[allow]`'d. These lints also will only fire when building the affected crates directly, not when built as a dependency (though a warning will be reported by Cargo in such cases). +It's worth noting that while this can result in compilation errors, it is still a *lint;* these lints can all be `#[allow]`ed. These lints also will only fire when building the affected crates directly, not when they are built as dependencies (though a warning will be reported by Cargo in such cases). These lints detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate graph. From 110f45ff0324a07c379abd3f6e521a832e412aae Mon Sep 17 00:00:00 2001 From: Boxy Date: Wed, 10 Dec 2025 18:13:23 +0000 Subject: [PATCH 07/10] Update content/Rust-1.92.0.md Co-authored-by: Kevin Reid --- content/Rust-1.92.0.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index 0606d3019..4211e0407 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -30,7 +30,7 @@ It's worth noting that while this can result in compilation errors, it is still These lints detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate graph. -We believe there to be approximately ~500 crates affected by this lint. Despite that we believe this to be acceptable as lints are not a breaking change and it will allow for stabilizing the never type in the future. For more in depth justification the Language Team's assessment can be read here: [rust-lang/rust#146167#issuecomment-3363795006](https://github.com/rust-lang/rust/pull/146167#issuecomment-3363795006). +We believe there to be approximately 500 crates affected by this lint. Despite that, we believe this to be acceptable, as lints are not a breaking change and it will allow for stabilizing the never type in the future. For more in-depth justification, the Language Team's assessment can be read here: [rust-lang/rust#146167#issuecomment-3363795006](https://github.com/rust-lang/rust/pull/146167#issuecomment-3363795006). ### `unused_must_use` no longer warns about `Result<(), UninhabitedType>` From 79f9b2844b9e0406665a37916e92dcb043ee893c Mon Sep 17 00:00:00 2001 From: Boxy Date: Wed, 10 Dec 2025 18:13:35 +0000 Subject: [PATCH 08/10] Update content/Rust-1.92.0.md Co-authored-by: Kevin Reid --- content/Rust-1.92.0.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index 4211e0407..2b1c9516a 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -92,7 +92,7 @@ In Rust 1.92 unwind tables will be emitted by default even when `-Cpanic=abort` Over the past few releases, many changes were made to the way built-in attributes are processed in the compiler. This should greatly improve the error messages and warnings Rust gives for built-in attributes and especially make these diagnostics more consistent among all of the over 100 built-in attributes. -To give a small example, in this release specifically, Rust became stricter in checking what arguments are allowed to `macro_export` by [upgrading that check to a "deny-by-default lint" that will be reported in dependencies.](https://github.com/rust-lang/rust/pull/143857). +To give a small example, in this release specifically, Rust became stricter in checking what arguments are allowed to `macro_export` by [upgrading that check to a "deny-by-default lint" that will be reported in dependencies](https://github.com/rust-lang/rust/pull/143857). ### Stabilized APIs From 8143f104c70da57bc5df32aeadb04a26af15b578 Mon Sep 17 00:00:00 2001 From: Boxy Date: Thu, 11 Dec 2025 01:20:37 +0000 Subject: [PATCH 09/10] Update content/Rust-1.92.0.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: León Orell Valerian Liehr --- content/Rust-1.92.0.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index 2b1c9516a..44726d38d 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -36,7 +36,7 @@ We believe there to be approximately 500 crates affected by this lint. Despite t Rust's `unused_must_use` lint warns when ignoring the return value of a function, if the function or its return type is annotated with `#[must_use]`. For instance, this warns if ignoring a return type of `Result`, to remind you to use `?`, or something like `.expect("...")`. -However, some functions return `Result`, but the error type they use is not actually "inhabited", meaning it can never exist in real code (e.g. the [`!`](https://doc.rust-lang.org/std/primitive.never.html) or [`Infallible`](https://doc.rust-lang.org/std/convert/enum.Infallible.html) types). +However, some functions return `Result`, but the error type they use is not actually "inhabited", meaning you cannot construct any values of that type (e.g. the [`!`](https://doc.rust-lang.org/std/primitive.never.html) or [`Infallible`](https://doc.rust-lang.org/std/convert/enum.Infallible.html) types). The `unused_must_use` lint now no longer warns on `Result<(), UninhabitedType>`, or on `ControlFlow`. For instance, it will not warn on `Result<(), Infallible>`. This avoids having to check for an error that can never happen. From 2d4d963e55b3a7ebc5d5674b4d7af2c13c9a356e Mon Sep 17 00:00:00 2001 From: Boxy Date: Thu, 11 Dec 2025 01:20:48 +0000 Subject: [PATCH 10/10] Update content/Rust-1.92.0.md Co-authored-by: Mark Rousskov --- content/Rust-1.92.0.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/Rust-1.92.0.md b/content/Rust-1.92.0.md index 44726d38d..aa0492679 100644 --- a/content/Rust-1.92.0.md +++ b/content/Rust-1.92.0.md @@ -30,7 +30,7 @@ It's worth noting that while this can result in compilation errors, it is still These lints detect code which is likely to be broken by the never type stabilization. It is highly advised to fix them if they are reported in your crate graph. -We believe there to be approximately 500 crates affected by this lint. Despite that, we believe this to be acceptable, as lints are not a breaking change and it will allow for stabilizing the never type in the future. For more in-depth justification, the Language Team's assessment can be read here: [rust-lang/rust#146167#issuecomment-3363795006](https://github.com/rust-lang/rust/pull/146167#issuecomment-3363795006). +We believe there to be approximately 500 crates affected by this lint. Despite that, we believe this to be acceptable, as lints are not a breaking change and it will allow for stabilizing the never type in the future. For more in-depth justification, see the [Language Team's assessment](https://github.com/rust-lang/rust/pull/146167#issuecomment-3363795006). ### `unused_must_use` no longer warns about `Result<(), UninhabitedType>`