rust: allow `stable_features` lint
Miguel Ojeda
maintainerPATCH 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 defaultThus 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
@@ -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
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 thestable_featureslint warns.For instance, the
new_uninitfeature 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 defaultThus allow the
stable_featureslint 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_VERSIONor maybe with the unstablecfg(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
Signed-off-by Miguel Ojeda <[email protected]>
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 thestable_featureslint warns.For instance, the
new_uninitfeature 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 defaultThus allow the
stable_featureslint 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_VERSIONor maybe with the unstablecfg(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
Alice Ryhl
reviewerQuoted 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 thestable_featureslint warns.For instance, the
new_uninitfeature 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 defaultThus allow the
stable_featureslint 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_VERSIONor maybe with the unstablecfg(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
Miguel Ojeda
AppliedQuoted 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 thestable_featureslint warns.For instance, the
new_uninitfeature 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 defaultThus allow the
stable_featureslint 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_VERSIONor maybe with the unstablecfg(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.Signed-off-by Miguel Ojeda <[email protected]>
Applied to rust-fixes -- thanks everyone!
Cheers,
Miguel