Skip to contentSkip to conversation

rust: allow `stable_features` lint

PATCH Applied Miguel Ojeda 4 participants 5 messages Aug 27, 2024 – Aug 28, 2024

Subsystems (2)
lore
Share & tools
lore

Miguel Ojeda

author maintainer
#0 lore raw

PATCH 1/1 rust: allow `stable_features` lint

Support for several Rust compiler versions started in commit 63b27f4a0074 ("rust: start supporting several compiler versions"). Since we currently need to use a number of unstable features in the kernel, it is a matter of time until one gets stabilized and the stable_features lint warns.

For instance, the new_uninit feature may become stable soon, which would give us multiple warnings like the following:

    warning: the feature `new_uninit` has been stable since 1.82.0-dev
    and no longer requires an attribute to enable
      --> rust/kernel/lib.rs:17:12
       |
    17 | #![feature(new_uninit)]
       |            ^^^^^^^^^^
       |
       = note: `#[warn(stable_features)]` on by default

Thus allow the stable_features lint to avoid such warnings. This is the simplest approach -- we do not have that many cases (and the goal is to stop using unstable features anyway) and cleanups can be easily done when we decide to update the minimum version.

An alternative would be to conditionally enable them based on the compiler version (with the upcoming RUSTC_VERSION or maybe with the unstable cfg(version(...)), but that one apparently will not work for the nightly case). However, doing so is more complex and may not work well for different nightlies of the same version, unless we do not care about older nightlies.

Another alternative is using explicit tests of the feature calling rustc, but that is also more complex and slower.

---
I may take this through rust-fixes too, since it is straightfoward and it could help some developers/CIs if something gets stabilized soon.

 Makefile | 1 +
 1 file changed, 1 insertion(+)
Makefile +1 -0
index 68ebd6d6b444..cf1111476f46 100644
@@ -445,6 +445,7 @@ KBUILD_USERLDFLAGS := $(USERLDFLAGS)
 # host programs.
 export rust_common_flags := --edition=2021 \
 			    -Zbinary_dep_depinfo=y \
+			    -Astable_features \
 			    -Dunsafe_op_in_unsafe_fn \
 			    -Dnon_ascii_idents \
 			    -Wrust_2018_idioms \

--
2.46.0

reviewer Reviewed-by on v1 1/1
#1 lore raw
Quoted 30 lines · Miguel Ojeda

Support for several Rust compiler versions started in commit 63b27f4a0074 ("rust: start supporting several compiler versions"). Since we currently need to use a number of unstable features in the kernel, it is a matter of time until one gets stabilized and the stable_features lint warns.

For instance, the new_uninit feature may become stable soon, which would give us multiple warnings like the following:

    warning: the feature `new_uninit` has been stable since 1.82.0-dev
    and no longer requires an attribute to enable
      --> rust/kernel/lib.rs:17:12
       |
    17 | #![feature(new_uninit)]
       |            ^^^^^^^^^^
       |
       = note: `#[warn(stable_features)]` on by default

Thus allow the stable_features lint to avoid such warnings. This is the simplest approach -- we do not have that many cases (and the goal is to stop using unstable features anyway) and cleanups can be easily done when we decide to update the minimum version.

An alternative would be to conditionally enable them based on the compiler version (with the upcoming RUSTC_VERSION or maybe with the unstable cfg(version(...)), but that one apparently will not work for the nightly case). However, doing so is more complex and may not work well for different nightlies of the same version, unless we do not care about older nightlies.

Quoted 2 lines

Another alternative is using explicit tests of the feature calling rustc, but that is also more complex and slower.

You mention a bunch of alternatives, but I agree that this is the best way forward. It's very simple. Only possible disadvantage could be if we forget to remove features when raising the MSRV, but I don't think that's a big risk.

(You could potentially pass -Astable_features only when the Rust compiler is not the lowest supported version.)

Quoted 1 line
#2 lore raw
Quoted 31 lines · Alice Ryhl
Quoted 30 lines · Miguel Ojeda

Support for several Rust compiler versions started in commit 63b27f4a0074 ("rust: start supporting several compiler versions"). Since we currently need to use a number of unstable features in the kernel, it is a matter of time until one gets stabilized and the stable_features lint warns.

For instance, the new_uninit feature may become stable soon, which would give us multiple warnings like the following:

    warning: the feature `new_uninit` has been stable since 1.82.0-dev
    and no longer requires an attribute to enable
      --> rust/kernel/lib.rs:17:12
       |
    17 | #![feature(new_uninit)]
       |            ^^^^^^^^^^
       |
       = note: `#[warn(stable_features)]` on by default

Thus allow the stable_features lint to avoid such warnings. This is the simplest approach -- we do not have that many cases (and the goal is to stop using unstable features anyway) and cleanups can be easily done when we decide to update the minimum version.

An alternative would be to conditionally enable them based on the compiler version (with the upcoming RUSTC_VERSION or maybe with the unstable cfg(version(...)), but that one apparently will not work for the nightly case). However, doing so is more complex and may not work well for different nightlies of the same version, unless we do not care about older nightlies.

Quoted 7 lines
Quoted 2 lines

Another alternative is using explicit tests of the feature calling rustc, but that is also more complex and slower.

You mention a bunch of alternatives, but I agree that this is the best way forward. It's very simple. Only possible disadvantage could be if we forget to remove features when raising the MSRV, but I don't think that's a big risk.

What even are the risks associated with enabling an already stable feature?

---
Cheers,
Benno

reviewer
#3 lore raw
Quoted 36 lines · Benno Lossin
Quoted 34 lines · Alice Ryhl
Quoted 32 lines · Miguel Ojeda

Support for several Rust compiler versions started in commit 63b27f4a0074 ("rust: start supporting several compiler versions"). Since we currently need to use a number of unstable features in the kernel, it is a matter of time until one gets stabilized and the stable_features lint warns.

For instance, the new_uninit feature may become stable soon, which would give us multiple warnings like the following:

    warning: the feature `new_uninit` has been stable since 1.82.0-dev
    and no longer requires an attribute to enable
      --> rust/kernel/lib.rs:17:12
       |
    17 | #![feature(new_uninit)]
       |            ^^^^^^^^^^
       |
       = note: `#[warn(stable_features)]` on by default

Thus allow the stable_features lint to avoid such warnings. This is the simplest approach -- we do not have that many cases (and the goal is to stop using unstable features anyway) and cleanups can be easily done when we decide to update the minimum version.

An alternative would be to conditionally enable them based on the compiler version (with the upcoming RUSTC_VERSION or maybe with the unstable cfg(version(...)), but that one apparently will not work for the nightly case). However, doing so is more complex and may not work well for different nightlies of the same version, unless we do not care about older nightlies.

Another alternative is using explicit tests of the feature calling rustc, but that is also more complex and slower.

Quoted 7 lines
Quoted 4 lines

You mention a bunch of alternatives, but I agree that this is the best way forward. It's very simple. Only possible disadvantage could be if we forget to remove features when raising the MSRV, but I don't think that's a big risk.

What even are the risks associated with enabling an already stable feature?

Nothing, really. Clutter?

Alice

Applied
#4 lore raw
In reply to Miguel Ojeda
Quoted 30 lines · Miguel Ojeda

Support for several Rust compiler versions started in commit 63b27f4a0074 ("rust: start supporting several compiler versions"). Since we currently need to use a number of unstable features in the kernel, it is a matter of time until one gets stabilized and the stable_features lint warns.

For instance, the new_uninit feature may become stable soon, which would give us multiple warnings like the following:

    warning: the feature `new_uninit` has been stable since 1.82.0-dev
    and no longer requires an attribute to enable
      --> rust/kernel/lib.rs:17:12
       |
    17 | #![feature(new_uninit)]
       |            ^^^^^^^^^^
       |
       = note: `#[warn(stable_features)]` on by default

Thus allow the stable_features lint to avoid such warnings. This is the simplest approach -- we do not have that many cases (and the goal is to stop using unstable features anyway) and cleanups can be easily done when we decide to update the minimum version.

An alternative would be to conditionally enable them based on the compiler version (with the upcoming RUSTC_VERSION or maybe with the unstable cfg(version(...)), but that one apparently will not work for the nightly case). However, doing so is more complex and may not work well for different nightlies of the same version, unless we do not care about older nightlies.

Quoted 4 lines

Another alternative is using explicit tests of the feature calling rustc, but that is also more complex and slower.

Applied to rust-fixes -- thanks everyone!

Cheers,
Miguel