nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 08:13:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Mention both release *and* edition breakage for never type lints

Browse Source
This commit is contained in:
Maybe Lapkin 2024-11-13 05:14:26 +01:00
parent db0740446b
commit 46967bd2e9
No known key found for this signature in database
23 changed files with 86 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_lint_defs/src/builtin.rs
View File

@ -4185,7 +4185,7 @@ declare_lint! {
Warn, Warn,
"never type fallback affecting unsafe function calls", "never type fallback affecting unsafe function calls",
@future_incompatible = FutureIncompatibleInfo { @future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::FutureReleaseSemanticsChange, reason: FutureIncompatibilityReason::EditionAndFutureReleaseError(Edition::Edition2024),
reference: "issue #123748 <https://github.com/rust-lang/rust/issues/123748>", reference: "issue #123748 <https://github.com/rust-lang/rust/issues/123748>",
}; };
@edition Edition2024 => Deny; @edition Edition2024 => Deny;
@ -4239,7 +4239,7 @@ declare_lint! {
Warn, Warn,
"never type fallback affecting unsafe function calls", "never type fallback affecting unsafe function calls",
@future_incompatible = FutureIncompatibleInfo { @future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps, reason: FutureIncompatibilityReason::EditionAndFutureReleaseError(Edition::Edition2024),
reference: "issue #123748 <https://github.com/rust-lang/rust/issues/123748>", reference: "issue #123748 <https://github.com/rust-lang/rust/issues/123748>",
}; };
report_in_external_macro report_in_external_macro

24
compiler/rustc_lint_defs/src/lib.rs
View File

@ -381,6 +381,8 @@ pub enum FutureIncompatibilityReason {
/// hard errors (and the lint removed). Preferably when there is some /// hard errors (and the lint removed). Preferably when there is some
/// confidence that the number of impacted projects is very small (few /// confidence that the number of impacted projects is very small (few
/// should have a broken dependency in their dependency tree). /// should have a broken dependency in their dependency tree).
///
/// [`EditionAndFutureReleaseError`]: FutureIncompatibilityReason::EditionAndFutureReleaseError
FutureReleaseErrorReportInDeps, FutureReleaseErrorReportInDeps,
/// Code that changes meaning in some way in a /// Code that changes meaning in some way in a
/// future release. /// future release.
@ -419,6 +421,17 @@ pub enum FutureIncompatibilityReason {
/// slightly changes the text of the diagnostic, but is otherwise the /// slightly changes the text of the diagnostic, but is otherwise the
/// same. /// same.
EditionSemanticsChange(Edition), EditionSemanticsChange(Edition),
/// This will be an error in the provided edition *and* in a future
/// release.
///
/// This variant a combination of [`FutureReleaseErrorDontReportInDeps`]
/// and [`EditionError`]. This is useful in rare cases when we
/// want to have "preview" of a breaking change in an edition, but do a
/// breaking change later on all editions anyway.
///
/// [`EditionError`]: FutureIncompatibilityReason::EditionError
/// [`FutureReleaseErrorDontReportInDeps`]: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps
EditionAndFutureReleaseError(Edition),
/// A custom reason. /// A custom reason.
/// ///
/// Choose this variant if the built-in text of the diagnostic of the /// Choose this variant if the built-in text of the diagnostic of the
@ -431,9 +444,14 @@ pub enum FutureIncompatibilityReason {
impl FutureIncompatibilityReason { impl FutureIncompatibilityReason {
pub fn edition(self) -> Option<Edition> { pub fn edition(self) -> Option<Edition> {
match self { match self {
Self::EditionError(e) => Some(e), Self::EditionError(e)
Self::EditionSemanticsChange(e) => Some(e), | Self::EditionSemanticsChange(e)
_ => None, | Self::EditionAndFutureReleaseError(e) => Some(e),
FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps
| FutureIncompatibilityReason::FutureReleaseErrorReportInDeps
| FutureIncompatibilityReason::FutureReleaseSemanticsChange
| FutureIncompatibilityReason::Custom(_) => None,
} }
} }
} }

6
compiler/rustc_middle/src/lint.rs
View File

@ -382,6 +382,12 @@ pub fn lint_level(
FutureIncompatibilityReason::EditionSemanticsChange(edition) => { FutureIncompatibilityReason::EditionSemanticsChange(edition) => {
format!("this changes meaning in Rust {edition}") format!("this changes meaning in Rust {edition}")
} }
FutureIncompatibilityReason::EditionAndFutureReleaseError(edition) => {
format!(
"this was previously accepted by the compiler but is being phased out; \
it will become a hard error in Rust {edition} and in a future release in all editions!"
)
}
FutureIncompatibilityReason::Custom(reason) => reason.to_owned(), FutureIncompatibilityReason::Custom(reason) => reason.to_owned(),
}; };

6
tests/ui/editions/never-type-fallback-breaking.e2021.fixed
View File

@ -16,7 +16,7 @@ fn main() {
fn m() { fn m() {
//[e2021]~^ this function depends on never type fallback being `()` //[e2021]~^ this function depends on never type fallback being `()`
//[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
let x: () = match true { let x: () = match true {
true => Default::default(), true => Default::default(),
//[e2024]~^ error: the trait bound `!: Default` is not satisfied //[e2024]~^ error: the trait bound `!: Default` is not satisfied
@ -28,7 +28,7 @@ fn m() {
fn q() -> Option<()> { fn q() -> Option<()> {
//[e2021]~^ this function depends on never type fallback being `()` //[e2021]~^ this function depends on never type fallback being `()`
//[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
fn deserialize<T: Default>() -> Option<T> { fn deserialize<T: Default>() -> Option<T> {
Some(T::default()) Some(T::default())
} }
@ -45,7 +45,7 @@ fn help<'a: 'a, T: Into<()>, U>(_: U) -> Result<T, ()> {
} }
fn meow() -> Result<(), ()> { fn meow() -> Result<(), ()> {
//[e2021]~^ this function depends on never type fallback being `()` //[e2021]~^ this function depends on never type fallback being `()`
//[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
help::<(), _>(1)?; help::<(), _>(1)?;
//[e2024]~^ error: the trait bound `(): From<!>` is not satisfied //[e2024]~^ error: the trait bound `(): From<!>` is not satisfied
Ok(()) Ok(())

6
tests/ui/editions/never-type-fallback-breaking.e2021.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn m() { LL | fn m() {
| ^^^^^^ | ^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: Default` will fail note: in edition 2024, the requirement `!: Default` will fail
@ -24,7 +24,7 @@ warning: this function depends on never type fallback being `()`
LL | fn q() -> Option<()> { LL | fn q() -> Option<()> {
| ^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: Default` will fail note: in edition 2024, the requirement `!: Default` will fail
@ -43,7 +43,7 @@ warning: this function depends on never type fallback being `()`
LL | fn meow() -> Result<(), ()> { LL | fn meow() -> Result<(), ()> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `(): From<!>` will fail note: in edition 2024, the requirement `(): From<!>` will fail

6
tests/ui/editions/never-type-fallback-breaking.rs
View File

@ -16,7 +16,7 @@ fn main() {
fn m() { fn m() {
//[e2021]~^ this function depends on never type fallback being `()` //[e2021]~^ this function depends on never type fallback being `()`
//[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
let x = match true { let x = match true {
true => Default::default(), true => Default::default(),
//[e2024]~^ error: the trait bound `!: Default` is not satisfied //[e2024]~^ error: the trait bound `!: Default` is not satisfied
@ -28,7 +28,7 @@ fn m() {
fn q() -> Option<()> { fn q() -> Option<()> {
//[e2021]~^ this function depends on never type fallback being `()` //[e2021]~^ this function depends on never type fallback being `()`
//[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
fn deserialize<T: Default>() -> Option<T> { fn deserialize<T: Default>() -> Option<T> {
Some(T::default()) Some(T::default())
} }
@ -45,7 +45,7 @@ fn help<'a: 'a, T: Into<()>, U>(_: U) -> Result<T, ()> {
} }
fn meow() -> Result<(), ()> { fn meow() -> Result<(), ()> {
//[e2021]~^ this function depends on never type fallback being `()` //[e2021]~^ this function depends on never type fallback being `()`
//[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[e2021]~| this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
help(1)?; help(1)?;
//[e2024]~^ error: the trait bound `(): From<!>` is not satisfied //[e2024]~^ error: the trait bound `(): From<!>` is not satisfied
Ok(()) Ok(())

2
tests/ui/never_type/defaulted-never-note.nofallback.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn smeg() { LL | fn smeg() {
| ^^^^^^^^^ | ^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: ImplementedForUnitButNotNever` will fail note: in edition 2024, the requirement `!: ImplementedForUnitButNotNever` will fail

2
tests/ui/never_type/defaulted-never-note.rs
View File

@ -27,7 +27,7 @@ fn foo<T: ImplementedForUnitButNotNever>(_t: T) {}
//[fallback]~| NOTE required by a bound in `foo` //[fallback]~| NOTE required by a bound in `foo`
fn smeg() { fn smeg() {
//[nofallback]~^ warn: this function depends on never type fallback being `()` //[nofallback]~^ warn: this function depends on never type fallback being `()`
//[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
let _x = return; let _x = return;
foo(_x); foo(_x);
//[fallback]~^ ERROR the trait bound //[fallback]~^ ERROR the trait bound

4
tests/ui/never_type/dependency-on-fallback-to-unit.rs
View File

@ -7,7 +7,7 @@ fn main() {
fn def() { fn def() {
//~^ warn: this function depends on never type fallback being `()` //~^ warn: this function depends on never type fallback being `()`
//~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
match true { match true {
false => <_>::default(), false => <_>::default(),
true => return, true => return,
@ -18,7 +18,7 @@ fn def() {
// <https://github.com/rust-lang/rust/issues/39216> // <https://github.com/rust-lang/rust/issues/39216>
fn question_mark() -> Result<(), ()> { fn question_mark() -> Result<(), ()> {
//~^ warn: this function depends on never type fallback being `()` //~^ warn: this function depends on never type fallback being `()`
//~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
deserialize()?; deserialize()?;
Ok(()) Ok(())
} }

4
tests/ui/never_type/dependency-on-fallback-to-unit.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn def() { LL | fn def() {
| ^^^^^^^^ | ^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: Default` will fail note: in edition 2024, the requirement `!: Default` will fail
@ -24,7 +24,7 @@ warning: this function depends on never type fallback being `()`
LL | fn question_mark() -> Result<(), ()> { LL | fn question_mark() -> Result<(), ()> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: Default` will fail note: in edition 2024, the requirement `!: Default` will fail

4
tests/ui/never_type/diverging-fallback-control-flow.nofallback.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn assignment() { LL | fn assignment() {
| ^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: UnitDefault` will fail note: in edition 2024, the requirement `!: UnitDefault` will fail
@ -24,7 +24,7 @@ warning: this function depends on never type fallback being `()`
LL | fn assignment_rev() { LL | fn assignment_rev() {
| ^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: UnitDefault` will fail note: in edition 2024, the requirement `!: UnitDefault` will fail

4
tests/ui/never_type/diverging-fallback-control-flow.rs
View File

@ -29,7 +29,7 @@ impl UnitDefault for () {
fn assignment() { fn assignment() {
//[nofallback]~^ warn: this function depends on never type fallback being `()` //[nofallback]~^ warn: this function depends on never type fallback being `()`
//[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
let x; let x;
if true { if true {
@ -41,7 +41,7 @@ fn assignment() {
fn assignment_rev() { fn assignment_rev() {
//[nofallback]~^ warn: this function depends on never type fallback being `()` //[nofallback]~^ warn: this function depends on never type fallback being `()`
//[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
let x; let x;
if true { if true {

2
tests/ui/never_type/diverging-fallback-no-leak.nofallback.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn main() { LL | fn main() {
| ^^^^^^^^^ | ^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: Test` will fail note: in edition 2024, the requirement `!: Test` will fail

2
tests/ui/never_type/diverging-fallback-no-leak.rs
View File

@ -13,7 +13,7 @@ fn unconstrained_arg<T: Test>(_: T) {}
fn main() { fn main() {
//[nofallback]~^ warn: this function depends on never type fallback being `()` //[nofallback]~^ warn: this function depends on never type fallback being `()`
//[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
// Here the type variable falls back to `!`, // Here the type variable falls back to `!`,
// and hence we get a type error. // and hence we get a type error.

2
tests/ui/never_type/diverging-fallback-unconstrained-return.nofallback.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn main() { LL | fn main() {
| ^^^^^^^^^ | ^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: UnitReturn` will fail note: in edition 2024, the requirement `!: UnitReturn` will fail

2
tests/ui/never_type/diverging-fallback-unconstrained-return.rs
View File

@ -27,7 +27,7 @@ fn unconstrained_return<T: UnitReturn>() -> T {
fn main() { fn main() {
//[nofallback]~^ warn: this function depends on never type fallback being `()` //[nofallback]~^ warn: this function depends on never type fallback being `()`
//[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
// In Ye Olde Days, the `T` parameter of `unconstrained_return` // In Ye Olde Days, the `T` parameter of `unconstrained_return`
// winds up "entangled" with the `!` type that results from // winds up "entangled" with the `!` type that results from

2
tests/ui/never_type/fallback-closure-ret.nofallback.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn main() { LL | fn main() {
| ^^^^^^^^^ | ^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: Bar` will fail note: in edition 2024, the requirement `!: Bar` will fail

2
tests/ui/never_type/fallback-closure-ret.rs
View File

@ -20,6 +20,6 @@ fn foo<R: Bar>(_: impl Fn() -> R) {}
fn main() { fn main() {
//[nofallback]~^ warn: this function depends on never type fallback being `()` //[nofallback]~^ warn: this function depends on never type fallback being `()`
//[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //[nofallback]~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
foo(|| panic!()); foo(|| panic!());
} }

2
tests/ui/never_type/impl_trait_fallback.rs
View File

@ -7,6 +7,6 @@ impl T for () {}
fn should_ret_unit() -> impl T { fn should_ret_unit() -> impl T {
//~^ warn: this function depends on never type fallback being `()` //~^ warn: this function depends on never type fallback being `()`
//~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
panic!() panic!()
} }

2
tests/ui/never_type/impl_trait_fallback.stderr
View File

@ -4,7 +4,7 @@ warning: this function depends on never type fallback being `()`
LL | fn should_ret_unit() -> impl T { LL | fn should_ret_unit() -> impl T {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the types explicitly = help: specify the types explicitly
note: in edition 2024, the requirement `!: T` will fail note: in edition 2024, the requirement `!: T` will fail

20
tests/ui/never_type/lint-never-type-fallback-flowing-into-unsafe.e2015.stderr
View File

@ -4,7 +4,7 @@ warning: never type fallback affects this call to an `unsafe` function
LL | unsafe { mem::zeroed() } LL | unsafe { mem::zeroed() }
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
= note: `#[warn(never_type_fallback_flowing_into_unsafe)]` on by default = note: `#[warn(never_type_fallback_flowing_into_unsafe)]` on by default
@ -19,7 +19,7 @@ warning: never type fallback affects this call to an `unsafe` function
LL | core::mem::transmute(Zst) LL | core::mem::transmute(Zst)
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -33,7 +33,7 @@ warning: never type fallback affects this union access
LL | unsafe { Union { a: () }.b } LL | unsafe { Union { a: () }.b }
| ^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
@ -43,7 +43,7 @@ warning: never type fallback affects this raw pointer dereference
LL | unsafe { *ptr::from_ref(&()).cast() } LL | unsafe { *ptr::from_ref(&()).cast() }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -57,7 +57,7 @@ warning: never type fallback affects this call to an `unsafe` function
LL | unsafe { internally_create(x) } LL | unsafe { internally_create(x) }
| ^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -71,7 +71,7 @@ warning: never type fallback affects this call to an `unsafe` function
LL | unsafe { zeroed() } LL | unsafe { zeroed() }
| ^^^^^^^^ | ^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -85,7 +85,7 @@ warning: never type fallback affects this `unsafe` function
LL | let zeroed = mem::zeroed; LL | let zeroed = mem::zeroed;
| ^^^^^^^^^^^ | ^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -99,7 +99,7 @@ warning: never type fallback affects this `unsafe` function
LL | let f = internally_create; LL | let f = internally_create;
| ^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -113,7 +113,7 @@ warning: never type fallback affects this call to an `unsafe` method
LL | S(marker::PhantomData).create_out_of_thin_air() LL | S(marker::PhantomData).create_out_of_thin_air()
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
@ -126,7 +126,7 @@ LL | match send_message::<_ /* ?0 */>() {
LL | msg_send!(); LL | msg_send!();
| ----------- in this macro invocation | ----------- in this macro invocation
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
= note: this warning originates in the macro `msg_send` (in Nightly builds, run with -Z macro-backtrace for more info) = note: this warning originates in the macro `msg_send` (in Nightly builds, run with -Z macro-backtrace for more info)

20
tests/ui/never_type/lint-never-type-fallback-flowing-into-unsafe.e2024.stderr
View File

@ -4,7 +4,7 @@ error: never type fallback affects this call to an `unsafe` function
LL | unsafe { mem::zeroed() } LL | unsafe { mem::zeroed() }
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
= note: `#[deny(never_type_fallback_flowing_into_unsafe)]` on by default = note: `#[deny(never_type_fallback_flowing_into_unsafe)]` on by default
@ -19,7 +19,7 @@ error: never type fallback affects this call to an `unsafe` function
LL | core::mem::transmute(Zst) LL | core::mem::transmute(Zst)
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -33,7 +33,7 @@ error: never type fallback affects this union access
LL | unsafe { Union { a: () }.b } LL | unsafe { Union { a: () }.b }
| ^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
@ -43,7 +43,7 @@ error: never type fallback affects this raw pointer dereference
LL | unsafe { *ptr::from_ref(&()).cast() } LL | unsafe { *ptr::from_ref(&()).cast() }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -57,7 +57,7 @@ error: never type fallback affects this call to an `unsafe` function
LL | unsafe { internally_create(x) } LL | unsafe { internally_create(x) }
| ^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -71,7 +71,7 @@ error: never type fallback affects this call to an `unsafe` function
LL | unsafe { zeroed() } LL | unsafe { zeroed() }
| ^^^^^^^^ | ^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -85,7 +85,7 @@ error: never type fallback affects this `unsafe` function
LL | let zeroed = mem::zeroed; LL | let zeroed = mem::zeroed;
| ^^^^^^^^^^^ | ^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -99,7 +99,7 @@ error: never type fallback affects this `unsafe` function
LL | let f = internally_create; LL | let f = internally_create;
| ^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
help: use `()` annotations to avoid fallback changes help: use `()` annotations to avoid fallback changes
@ -113,7 +113,7 @@ error: never type fallback affects this call to an `unsafe` method
LL | S(marker::PhantomData).create_out_of_thin_air() LL | S(marker::PhantomData).create_out_of_thin_air()
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
@ -126,7 +126,7 @@ LL | match send_message::<_ /* ?0 */>() {
LL | msg_send!(); LL | msg_send!();
| ----------- in this macro invocation | ----------- in this macro invocation
| |
= warning: this will change its meaning in a future release! = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748> = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
= help: specify the type explicitly = help: specify the type explicitly
= note: this error originates in the macro `msg_send` (in Nightly builds, run with -Z macro-backtrace for more info) = note: this error originates in the macro `msg_send` (in Nightly builds, run with -Z macro-backtrace for more info)

20
tests/ui/never_type/lint-never-type-fallback-flowing-into-unsafe.rs
View File

@ -13,7 +13,7 @@ fn _zero() {
unsafe { mem::zeroed() } unsafe { mem::zeroed() }
//[e2015]~^ warn: never type fallback affects this call to an `unsafe` function //[e2015]~^ warn: never type fallback affects this call to an `unsafe` function
//[e2024]~^^ error: never type fallback affects this call to an `unsafe` function //[e2024]~^^ error: never type fallback affects this call to an `unsafe` function
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
//[e2024]~| warning: the type `!` does not permit zero-initialization //[e2024]~| warning: the type `!` does not permit zero-initialization
} else { } else {
return; return;
@ -30,7 +30,7 @@ fn _trans() {
core::mem::transmute(Zst) core::mem::transmute(Zst)
//[e2015]~^ warn: never type fallback affects this call to an `unsafe` function //[e2015]~^ warn: never type fallback affects this call to an `unsafe` function
//[e2024]~^^ error: never type fallback affects this call to an `unsafe` function //[e2024]~^^ error: never type fallback affects this call to an `unsafe` function
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
} }
} else { } else {
return; return;
@ -47,7 +47,7 @@ fn _union() {
unsafe { Union { a: () }.b } unsafe { Union { a: () }.b }
//[e2015]~^ warn: never type fallback affects this union access //[e2015]~^ warn: never type fallback affects this union access
//[e2024]~^^ error: never type fallback affects this union access //[e2024]~^^ error: never type fallback affects this union access
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
} else { } else {
return; return;
}; };
@ -58,7 +58,7 @@ fn _deref() {
unsafe { *ptr::from_ref(&()).cast() } unsafe { *ptr::from_ref(&()).cast() }
//[e2015]~^ warn: never type fallback affects this raw pointer dereference //[e2015]~^ warn: never type fallback affects this raw pointer dereference
//[e2024]~^^ error: never type fallback affects this raw pointer dereference //[e2024]~^^ error: never type fallback affects this raw pointer dereference
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
} else { } else {
return; return;
}; };
@ -79,7 +79,7 @@ fn _only_generics() {
unsafe { internally_create(x) } unsafe { internally_create(x) }
//[e2015]~^ warn: never type fallback affects this call to an `unsafe` function //[e2015]~^ warn: never type fallback affects this call to an `unsafe` function
//[e2024]~^^ error: never type fallback affects this call to an `unsafe` function //[e2024]~^^ error: never type fallback affects this call to an `unsafe` function
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
x.unwrap() x.unwrap()
} else { } else {
@ -92,12 +92,12 @@ fn _stored_function() {
let zeroed = mem::zeroed; let zeroed = mem::zeroed;
//[e2015]~^ warn: never type fallback affects this `unsafe` function //[e2015]~^ warn: never type fallback affects this `unsafe` function
//[e2024]~^^ error: never type fallback affects this `unsafe` function //[e2024]~^^ error: never type fallback affects this `unsafe` function
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
unsafe { zeroed() } unsafe { zeroed() }
//[e2015]~^ warn: never type fallback affects this call to an `unsafe` function //[e2015]~^ warn: never type fallback affects this call to an `unsafe` function
//[e2024]~^^ error: never type fallback affects this call to an `unsafe` function //[e2024]~^^ error: never type fallback affects this call to an `unsafe` function
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
} else { } else {
return; return;
}; };
@ -115,7 +115,7 @@ fn _only_generics_stored_function() {
let f = internally_create; let f = internally_create;
//[e2015]~^ warn: never type fallback affects this `unsafe` function //[e2015]~^ warn: never type fallback affects this `unsafe` function
//[e2024]~^^ error: never type fallback affects this `unsafe` function //[e2024]~^^ error: never type fallback affects this `unsafe` function
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
unsafe { f(x) } unsafe { f(x) }
@ -140,7 +140,7 @@ fn _method() {
S(marker::PhantomData).create_out_of_thin_air() S(marker::PhantomData).create_out_of_thin_air()
//[e2015]~^ warn: never type fallback affects this call to an `unsafe` method //[e2015]~^ warn: never type fallback affects this call to an `unsafe` method
//[e2024]~^^ error: never type fallback affects this call to an `unsafe` method //[e2024]~^^ error: never type fallback affects this call to an `unsafe` method
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
} }
} else { } else {
return; return;
@ -158,7 +158,7 @@ fn _objc() {
match send_message::<_ /* ?0 */>() { match send_message::<_ /* ?0 */>() {
//[e2015]~^ warn: never type fallback affects this call to an `unsafe` function //[e2015]~^ warn: never type fallback affects this call to an `unsafe` function
//[e2024]~^^ error: never type fallback affects this call to an `unsafe` function //[e2024]~^^ error: never type fallback affects this call to an `unsafe` function
//~| warn: this will change its meaning in a future release! //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
Ok(x) => x, Ok(x) => x,
Err(_) => loop {}, Err(_) => loop {},
} }