Change `unsafe_op_in_unsafe_fn` to be `warn`-by-default from edition 2024 #112038

Nemo157 · 2023-05-28T11:19:39Z

This was previously FCPed: #71668 (comment)

There were two blocking requirements:

Fix the unused_unsafe lint, done in never consider unsafe blocks unused if they would be required with deny(unsafe_op_in_unsafe_fn) #100081
Have cargo fix able to fix the lint, done in Add MVP suggestion for unsafe_op_in_unsafe_fn #112017

rustbot · 2023-05-28T11:19:46Z

r? @b-naber

(rustbot has picked a reviewer for you, use r? to override)

Nemo157 · 2023-05-28T11:23:08Z

compiler/rustc_lint_defs/src/builtin.rs

-    /// This lint is "allow" by default since this will affect a large amount
-    /// of existing code, and the exact plan for increasing the severity is
+    /// This lint is "allow" by default on editions up to 2021, from 2024 it is
+    /// "warn" by default, the plan for increasing severity after this is


It was my impression from the FCP discussion that there is still want to make this deny-by-default or a hard-error in the future, so I have left this mention of increasing the severity in.

We discussed that particular point in lang triage today, and agree with "still being considered".

I think all of "stays warning", "becomes deny-by-default lint", and "hard error" are all on the table still, pending experience we get with doing this in 2024.

b-naber

The change looks good to me. It's not clear to me that the FCP in the tracking issue specifically was about this being made warn-by-default though.

b-naber · 2023-06-05T19:57:55Z

r? rust-lang

rustbot · 2023-06-05T19:57:58Z

Failed to set assignee to rust-lang: cannot assign: HTTP status client error (404 Not Found) for url (https://api.github.com/repos/rust-lang/rust/issues/112038/assignees)

Note: Only org members, users with write permissions, or people who have commented on the PR may be assigned.

b-naber · 2023-06-05T20:00:33Z

r? lang

Nemo157 · 2023-07-23T21:20:18Z

ping @joshtriplett

RalfJung · 2023-09-01T14:03:01Z

compiler/rustc_lint_defs/src/lib.rs

            ..$crate::Lint::default_fields_for_macro()
        };
    );
-    ($(#[$attr:meta])* $vis: vis $NAME: ident, $Level: ident, $desc: expr,
-     $lint_edition: expr => $edition_level: ident


So the old syntax wasn't used at all? Strange...

RalfJung · 2023-09-01T14:03:49Z

I have nominated this PR for lang-team discussion. The question for t-lang is pretty clear -- should the default lint level of unsafe_op_in_unsafe_fn be raised to warn, and if yes, in which editions?

RalfJung · 2023-09-01T14:13:08Z

Here's a link to a prior FCP which says

shall we require unsafe {} for unsafe blocks even inside an unsafe fn, starting in the 2024 edition?

and that was answered in the affirmative. That seems like it would say "make the lint deny-by-default"? Or even a hard error? It's not entirely clear.

Here is a recent argument in favor of not going above warn-by-default.

Nemo157 · 2023-09-01T16:44:08Z

Here's a link to a prior FCP which says

shall we require unsafe {} for unsafe blocks even inside an unsafe fn, starting in the 2024 edition?

and that was answered in the affirmative. That seems like it would say "make the lint deny-by-default"? Or even a hard error? It's not entirely clear.

It also contains

I'm going to reluctantly propose that we only move to warn-by-default in 2024, not deny-by-default.

that was edited in later, following discussion about the fact that unused_unsafe needed fixing still to allow lint free code. That change resolved the concern about exactly what was being proposed.

RalfJung · 2023-09-01T17:21:30Z

Ah, thanks for catching that.

scottmcm · 2023-09-05T18:47:39Z

We discussed this in the lang triage meeting, and agree that it's covered by the pre-existing FCP, and the meeting consensus was that we're still happy with that previous decision. This is good to go following a usual review.

r? compiler

We discussed a bunch of other things, like whether we'd want to maybe do this in previous editions too, or whether this should ever be not-a-lint, but didn't come to any consensus on those. Leaving the door open to more things remains important; we're not going to commit to nor rule out those other things at this point.

compiler/rustc_lint_defs/src/builtin.rs

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since 1) it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`) and 2) it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. Link: rust-lang/rust#112038 [1] Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since 1) it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`) and 2) it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. Link: rust-lang/rust#112038 [1] Signed-off-by: Miguel Ojeda <ojeda@kernel.org> Link: https://lore.kernel.org/r/20240701183625.665574-5-ojeda@kernel.org

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since 1) it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`) and 2) it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. Link: rust-lang/rust#112038 [1] Signed-off-by: Miguel Ojeda <ojeda@kernel.org> Tested-by: Benno Lossin <benno.lossin@proton.me>

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since 1) it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`) and 2) it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. Link: rust-lang/rust#112038 [1] Signed-off-by: Miguel Ojeda <ojeda@kernel.org> Link: https://lore.kernel.org/r/20240701183625.665574-5-ojeda@kernel.org

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. In addition, it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`). `non_ascii_idents` is left unmodified as well, i.e. as an error, since it is unlikely one gains any productivity during development if it were a warning (in fact, it may be worse, since it is likely one made a typo). In addition, it should not have false positives. Finally, put the two `-D` ones at the top and take the chance to do one per line. Link: rust-lang/rust#112038 [1] Reviewed-by: Finn Behrens <me@kloenk.dev> Tested-by: Benno Lossin <benno.lossin@proton.me> Tested-by: Andreas Hindborg <a.hindborg@samsung.com> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. In addition, it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`). `non_ascii_idents` is left unmodified as well, i.e. as an error, since it is unlikely one gains any productivity during development if it were a warning (in fact, it may be worse, since it is likely one made a typo). In addition, it should not have false positives. Finally, put the two `-D` ones at the top and take the chance to do one per line. Link: rust-lang/rust#112038 [1] Reviewed-by: Finn Behrens <me@kloenk.dev> Tested-by: Benno Lossin <benno.lossin@proton.me> Tested-by: Andreas Hindborg <a.hindborg@samsung.com> Signed-off-by: Miguel Ojeda <ojeda@kernel.org> Link: https://lore.kernel.org/r/20240709160615.998336-5-ojeda@kernel.org

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. In addition, it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`). `non_ascii_idents` is left unmodified as well, i.e. as an error, since it is unlikely one gains any productivity during development if it were a warning (in fact, it may be worse, since it is likely one made a typo). In addition, it should not have false positives. Finally, put the two `-D` ones at the top and take the chance to do one per line. Link: rust-lang/rust#112038 [1] Reviewed-by: Finn Behrens <me@kloenk.dev> Tested-by: Benno Lossin <benno.lossin@proton.me> Tested-by: Andreas Hindborg <a.hindborg@samsung.com> Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. In addition, it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`). `non_ascii_idents` is left unmodified as well, i.e. as an error, since it is unlikely one gains any productivity during development if it were a warning (in fact, it may be worse, since it is likely one made a typo). In addition, it should not have false positives. Finally, put the two `-D` ones at the top and take the chance to do one per line. Link: rust-lang/rust#112038 [1] Reviewed-by: Finn Behrens <me@kloenk.dev> Tested-by: Benno Lossin <benno.lossin@proton.me> Tested-by: Andreas Hindborg <a.hindborg@samsung.com> Link: https://lore.kernel.org/r/20240709160615.998336-5-ojeda@kernel.org Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

…petrochenkov Fix and enforce `unsafe_op_in_unsafe_fn` in compiler In preparation for edition 2024, this PR previews the fallout of enabling the `unsafe_op_in_unsafe_fn` lint in the compiler, since it's defaulting to warn in the new edition (rust-lang#112038). The major annoyance comes primarily from the `rustc_codegen_llvm` module, where there's a ton of unsafe calls. I tended to wrap individual calls to unsafe fns in `unsafe {}`, but there a handful of places I chose to just wrap several calls in an `unsafe {}` block just because it would've been excessive to wrap each call individually. This doesn't enable the lint for the standard library, since I'm not totally certain what T-libs prefers w/ this lint.

Rollup merge of rust-lang#127730 - compiler-errors:ed-2024-unsafe, r=petrochenkov Fix and enforce `unsafe_op_in_unsafe_fn` in compiler In preparation for edition 2024, this PR previews the fallout of enabling the `unsafe_op_in_unsafe_fn` lint in the compiler, since it's defaulting to warn in the new edition (rust-lang#112038). The major annoyance comes primarily from the `rustc_codegen_llvm` module, where there's a ton of unsafe calls. I tended to wrap individual calls to unsafe fns in `unsafe {}`, but there a handful of places I chose to just wrap several calls in an `unsafe {}` block just because it would've been excessive to wrap each call individually. This doesn't enable the lint for the standard library, since I'm not totally certain what T-libs prefers w/ this lint.

Since we are starting to support several Rust toolchains, lints (including Clippy ones) now may behave differently and lint groups may include new lints. Therefore, to maximize the chances a given version works, relax some deny-level lints to warnings. It may also make our lives a bit easier while developing new code or refactoring. To be clear, the requirements for in-tree code are still the same, since Rust code still needs to be warning-free (patches should be clean under `WERROR=y`) and the set of lints is not changed. `unsafe_op_in_unsafe_fn` is left unmodified, i.e. as an error, since it is becoming the default in the language (warn-by-default in Rust 2024 [1] and ideally an error later on) and thus it should also be very well tested. In addition, it is simple enough that it should not have false positives (unlike e.g. `rust_2018_idioms`'s `explicit_outlives_requirements`). `non_ascii_idents` is left unmodified as well, i.e. as an error, since it is unlikely one gains any productivity during development if it were a warning (in fact, it may be worse, since it is likely one made a typo). In addition, it should not have false positives. Finally, put the two `-D` ones at the top and take the chance to do one per line. Link: rust-lang/rust#112038 [1] Reviewed-by: Finn Behrens <me@kloenk.dev> Tested-by: Benno Lossin <benno.lossin@proton.me> Tested-by: Andreas Hindborg <a.hindborg@samsung.com> Link: https://lore.kernel.org/r/20240709160615.998336-5-ojeda@kernel.org Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

rustbot assigned b-naber May 28, 2023

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels May 28, 2023

Nemo157 commented May 28, 2023

View reviewed changes

Nemo157 added A-lint Area: Lints (warnings about flaws in source code) such as unused_mut. A-edition-2024 Area: The 2024 edition labels May 29, 2023

ojeda mentioned this pull request May 30, 2023

Rust wanted features Rust-for-Linux/linux#354

Open

35 tasks

b-naber approved these changes Jun 5, 2023

View reviewed changes

rustbot assigned joshtriplett and unassigned b-naber Jun 5, 2023

Nemo157 mentioned this pull request Sep 1, 2023

Tracking Issue for "unsafe blocks in unsafe fn" (RFC #2585) #71668

Open

5 tasks

RalfJung added T-lang Relevant to the language team, which will review and decide on the PR/issue. I-lang-nominated Nominated for discussion during a lang team meeting. and removed T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Sep 1, 2023

RalfJung reviewed Sep 1, 2023

View reviewed changes

RalfJung added the S-waiting-on-team Status: Awaiting decision from the relevant subteam (see the T-<team> label). label Sep 1, 2023

rustbot assigned wesleywiser and unassigned joshtriplett Sep 5, 2023

RalfJung reviewed Sep 5, 2023

View reviewed changes

compiler/rustc_lint_defs/src/builtin.rs Outdated Show resolved Hide resolved

Nemo157 force-pushed the edition-2024-unsafe_op_in_unsafe_fn branch from 160f468 to af16716 Compare September 6, 2023 06:53

tmandry mentioned this pull request Jan 10, 2024

Make unsafe_op_in_unsafe_fn auto-migrated in 2024 edition #119823

Closed

tguichaoua mentioned this pull request Jan 28, 2024

Enable the unsafe_op_in_unsafe_fn lint bevyengine/bevy#11590

Open

3 tasks

Urgau mentioned this pull request Jan 31, 2024

Make unsafe_op_in_unsafe_fn warn-by-default starting in 2024 edition #120535

Closed

traviscross mentioned this pull request Apr 14, 2024

Tracking Issue for Rust 2024: Make unsafe_op_in_unsafe_fn warn-by-default #123916

Closed

7 tasks

compiler-errors mentioned this pull request Jul 14, 2024

Fix and enforce unsafe_op_in_unsafe_fn in compiler #127730

Merged

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Change `unsafe_op_in_unsafe_fn` to be `warn`-by-default from edition 2024 #112038

Change `unsafe_op_in_unsafe_fn` to be `warn`-by-default from edition 2024 #112038

Nemo157 commented May 28, 2023 •

edited

Loading

rustbot commented May 28, 2023

Nemo157 May 28, 2023

scottmcm Sep 5, 2023

b-naber left a comment

b-naber commented Jun 5, 2023

rustbot commented Jun 5, 2023

b-naber commented Jun 5, 2023

Nemo157 commented Jul 23, 2023

RalfJung Sep 1, 2023

RalfJung commented Sep 1, 2023

RalfJung commented Sep 1, 2023

Nemo157 commented Sep 1, 2023

RalfJung commented Sep 1, 2023 via email

scottmcm commented Sep 5, 2023

Change unsafe_op_in_unsafe_fn to be warn-by-default from edition 2024 #112038

Change unsafe_op_in_unsafe_fn to be warn-by-default from edition 2024 #112038

Conversation

Nemo157 commented May 28, 2023 • edited Loading

rustbot commented May 28, 2023

Nemo157 May 28, 2023

Choose a reason for hiding this comment

scottmcm Sep 5, 2023

Choose a reason for hiding this comment

b-naber left a comment

Choose a reason for hiding this comment

b-naber commented Jun 5, 2023

rustbot commented Jun 5, 2023

b-naber commented Jun 5, 2023

Nemo157 commented Jul 23, 2023

RalfJung Sep 1, 2023

Choose a reason for hiding this comment

RalfJung commented Sep 1, 2023

RalfJung commented Sep 1, 2023

Nemo157 commented Sep 1, 2023

RalfJung commented Sep 1, 2023 via email

scottmcm commented Sep 5, 2023

Change `unsafe_op_in_unsafe_fn` to be `warn`-by-default from edition 2024 #112038

Change `unsafe_op_in_unsafe_fn` to be `warn`-by-default from edition 2024 #112038

Nemo157 commented May 28, 2023 •

edited

Loading