expect never type lint in tests which do not test it

Author: WaffleLapkin

tests/ui/never_type/defaulted-never-note.fallback.stderr

@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `!: ImplementedForUnitButNotNever` is not satisfied
-  --> $DIR/defaulted-never-note.rs:30:9
+  --> $DIR/defaulted-never-note.rs:31:9
    |
 LL |     foo(_x);
    |     --- ^^ the trait `ImplementedForUnitButNotNever` is not implemented for `!`
@@ -10,7 +10,7 @@ LL |     foo(_x);
    = note: this error might have been caused by changes to Rust's type-inference algorithm (see issue #48950 <https://github.com/rust-lang/rust/issues/48950> for more information)
    = help: you might have intended to use the type `()` here instead
 note: required by a bound in `foo`
-  --> $DIR/defaulted-never-note.rs:23:11
+  --> $DIR/defaulted-never-note.rs:26:11
    |
 LL | fn foo<T: ImplementedForUnitButNotNever>(_t: T) {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `foo`

tests/ui/never_type/defaulted-never-note.nofallback.stderr

@@ -1,41 +1,16 @@
-error: this function depends on never type fallback being `()`
-  --> $DIR/defaulted-never-note.rs:26:1
-   |
-LL | fn smeg() {
-   | ^^^^^^^^^
-   |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
-   = help: specify the types explicitly
-note: in edition 2024, the requirement `!: ImplementedForUnitButNotNever` will fail
-  --> $DIR/defaulted-never-note.rs:30:9
-   |
-LL |     foo(_x);
-   |         ^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
-help: use `()` annotations to avoid fallback changes
-   |
-LL |     let _x: () = return;
-   |           ++++
-
-error: aborting due to 1 previous error
-
 Future incompatibility report: Future breakage diagnostic:
-error: this function depends on never type fallback being `()`
-  --> $DIR/defaulted-never-note.rs:26:1
+warning: this function depends on never type fallback being `()`
+  --> $DIR/defaulted-never-note.rs:29:1
    |
 LL | fn smeg() {
    | ^^^^^^^^^
    |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
    = help: specify the types explicitly
 note: in edition 2024, the requirement `!: ImplementedForUnitButNotNever` will fail
-  --> $DIR/defaulted-never-note.rs:30:9
+  --> $DIR/defaulted-never-note.rs:31:9
    |
 LL |     foo(_x);
    |         ^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
 help: use `()` annotations to avoid fallback changes
    |
 LL |     let _x: () = return;

tests/ui/never_type/defaulted-never-note.rs

@@ -1,10 +1,13 @@
 //@ revisions: nofallback fallback
+//@[nofallback] run-pass
+//@[fallback] check-fail
 
 // We need to opt into the `never_type_fallback` feature
 // to trigger the requirement that this is testing.
 #![cfg_attr(fallback, feature(never_type, never_type_fallback))]
 
 #![allow(unused)]
+#![expect(dependency_on_unit_never_type_fallback)]
 
 trait Deserialize: Sized {
     fn deserialize() -> Result<Self, String>;
@@ -24,8 +27,6 @@ fn foo<T: ImplementedForUnitButNotNever>(_t: T) {}
 //[fallback]~^ note: required by this bound in `foo`
 //[fallback]~| note: required by a bound in `foo`
 fn smeg() {
-    //[nofallback]~^ error: 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 Rust 2024 and in a future release in all editions!
     let _x = return;
     foo(_x);
     //[fallback]~^ error: the trait bound

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

@@ -1,81 +1,34 @@
-error: this function depends on never type fallback being `()`
-  --> $DIR/diverging-fallback-control-flow.rs:30:1
-   |
-LL | fn assignment() {
-   | ^^^^^^^^^^^^^^^
-   |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
-   = help: specify the types explicitly
-note: in edition 2024, the requirement `!: UnitDefault` will fail
-  --> $DIR/diverging-fallback-control-flow.rs:36:13
-   |
-LL |         x = UnitDefault::default();
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
-help: use `()` annotations to avoid fallback changes
-   |
-LL |     let x: ();
-   |          ++++
-
-error: this function depends on never type fallback being `()`
-  --> $DIR/diverging-fallback-control-flow.rs:42:1
-   |
-LL | fn assignment_rev() {
-   | ^^^^^^^^^^^^^^^^^^^
-   |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
-   = help: specify the types explicitly
-note: in edition 2024, the requirement `!: UnitDefault` will fail
-  --> $DIR/diverging-fallback-control-flow.rs:50:13
-   |
-LL |         x = UnitDefault::default();
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-help: use `()` annotations to avoid fallback changes
-   |
-LL |     let x: ();
-   |          ++++
-
-error: aborting due to 2 previous errors
-
 Future incompatibility report: Future breakage diagnostic:
-error: this function depends on never type fallback being `()`
-  --> $DIR/diverging-fallback-control-flow.rs:30:1
+warning: this function depends on never type fallback being `()`
+  --> $DIR/diverging-fallback-control-flow.rs:32:1
    |
 LL | fn assignment() {
    | ^^^^^^^^^^^^^^^
    |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
    = help: specify the types explicitly
 note: in edition 2024, the requirement `!: UnitDefault` will fail
   --> $DIR/diverging-fallback-control-flow.rs:36:13
    |
 LL |         x = UnitDefault::default();
    |             ^^^^^^^^^^^^^^^^^^^^^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
 help: use `()` annotations to avoid fallback changes
    |
 LL |     let x: ();
    |          ++++
 
 Future breakage diagnostic:
-error: this function depends on never type fallback being `()`
+warning: this function depends on never type fallback being `()`
   --> $DIR/diverging-fallback-control-flow.rs:42:1
    |
 LL | fn assignment_rev() {
    | ^^^^^^^^^^^^^^^^^^^
    |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
    = help: specify the types explicitly
 note: in edition 2024, the requirement `!: UnitDefault` will fail
-  --> $DIR/diverging-fallback-control-flow.rs:50:13
+  --> $DIR/diverging-fallback-control-flow.rs:48:13
    |
 LL |         x = UnitDefault::default();
    |             ^^^^^^^^^^^^^^^^^^^^^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
 help: use `()` annotations to avoid fallback changes
    |
 LL |     let x: ();

tests/ui/never_type/diverging-fallback-control-flow.rs

@@ -1,10 +1,12 @@
 //@ revisions: nofallback fallback
-//@[fallback] check-pass
+//@ check-pass
 
 #![allow(dead_code)]
 #![allow(unused_assignments)]
 #![allow(unused_variables)]
 #![allow(unreachable_code)]
+#![cfg_attr(nofallback, expect(dependency_on_unit_never_type_fallback))]
+
 // Test various cases where we permit an unconstrained variable
 // to fallback based on control-flow. In all of these cases,
 // the type variable winds up being the target of both a `!` coercion
@@ -28,8 +30,6 @@ impl UnitDefault for () {
 }
 
 fn assignment() {
-    //[nofallback]~^ error: 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 Rust 2024 and in a future release in all editions!
     let x;
 
     if true {
@@ -40,8 +40,6 @@ fn assignment() {
 }
 
 fn assignment_rev() {
-    //[nofallback]~^ error: 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 Rust 2024 and in a future release in all editions!
     let x;
 
     if true {

tests/ui/never_type/diverging-fallback-no-leak.fallback.stderr

@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `!: Test` is not satisfied
-  --> $DIR/diverging-fallback-no-leak.rs:19:23
+  --> $DIR/diverging-fallback-no-leak.rs:18:23
    |
 LL |     unconstrained_arg(return);
    |     ----------------- ^^^^^^ the trait `Test` is not implemented for `!`
@@ -12,7 +12,7 @@ LL |     unconstrained_arg(return);
    = note: this error might have been caused by changes to Rust's type-inference algorithm (see issue #48950 <https://github.com/rust-lang/rust/issues/48950> for more information)
    = help: you might have intended to use the type `()` here instead
 note: required by a bound in `unconstrained_arg`
-  --> $DIR/diverging-fallback-no-leak.rs:11:25
+  --> $DIR/diverging-fallback-no-leak.rs:13:25
    |
 LL | fn unconstrained_arg<T: Test>(_: T) {}
    |                         ^^^^ required by this bound in `unconstrained_arg`

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

@@ -1,41 +1,16 @@
-error: this function depends on never type fallback being `()`
-  --> $DIR/diverging-fallback-no-leak.rs:13:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-   |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
-   = help: specify the types explicitly
-note: in edition 2024, the requirement `!: Test` will fail
-  --> $DIR/diverging-fallback-no-leak.rs:19:23
-   |
-LL |     unconstrained_arg(return);
-   |                       ^^^^^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
-help: use `()` annotations to avoid fallback changes
-   |
-LL |     unconstrained_arg::<()>(return);
-   |                      ++++++
-
-error: aborting due to 1 previous error
-
 Future incompatibility report: Future breakage diagnostic:
-error: this function depends on never type fallback being `()`
-  --> $DIR/diverging-fallback-no-leak.rs:13:1
+warning: this function depends on never type fallback being `()`
+  --> $DIR/diverging-fallback-no-leak.rs:15:1
    |
 LL | fn main() {
    | ^^^^^^^^^
    |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
    = help: specify the types explicitly
 note: in edition 2024, the requirement `!: Test` will fail
-  --> $DIR/diverging-fallback-no-leak.rs:19:23
+  --> $DIR/diverging-fallback-no-leak.rs:18:23
    |
 LL |     unconstrained_arg(return);
    |                       ^^^^^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
 help: use `()` annotations to avoid fallback changes
    |
 LL |     unconstrained_arg::<()>(return);

tests/ui/never_type/diverging-fallback-no-leak.rs

@@ -1,6 +1,8 @@
 //@ revisions: nofallback fallback
+//@[nofallback] check-pass
 
 #![cfg_attr(fallback, feature(never_type, never_type_fallback))]
+#![cfg_attr(nofallback, expect(dependency_on_unit_never_type_fallback))]
 
 fn make_unit() {}
 
@@ -11,9 +13,6 @@ impl Test for () {}
 fn unconstrained_arg<T: Test>(_: T) {}
 
 fn main() {
-    //[nofallback]~^ error: 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 Rust 2024 and in a future release in all editions!
-
     // Here the type variable falls back to `!`,
     // and hence we get a type error.
     unconstrained_arg(return);

tests/ui/never_type/fallback-closure-ret.nofallback.stderr

@@ -1,41 +1,16 @@
-error: this function depends on never type fallback being `()`
-  --> $DIR/fallback-closure-ret.rs:21:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-   |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
-   = help: specify the types explicitly
-note: in edition 2024, the requirement `!: Bar` will fail
-  --> $DIR/fallback-closure-ret.rs:24:5
-   |
-LL |     foo(|| panic!());
-   |     ^^^^^^^^^^^^^^^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
-help: use `()` annotations to avoid fallback changes
-   |
-LL |     foo::<()>(|| panic!());
-   |        ++++++
-
-error: aborting due to 1 previous error
-
 Future incompatibility report: Future breakage diagnostic:
-error: this function depends on never type fallback being `()`
-  --> $DIR/fallback-closure-ret.rs:21:1
+warning: this function depends on never type fallback being `()`
+  --> $DIR/fallback-closure-ret.rs:22:1
    |
 LL | fn main() {
    | ^^^^^^^^^
    |
-   = 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 <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
    = help: specify the types explicitly
 note: in edition 2024, the requirement `!: Bar` will fail
-  --> $DIR/fallback-closure-ret.rs:24:5
+  --> $DIR/fallback-closure-ret.rs:23:5
    |
 LL |     foo(|| panic!());
    |     ^^^^^^^^^^^^^^^^
-   = note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
 help: use `()` annotations to avoid fallback changes
    |
 LL |     foo::<()>(|| panic!());

tests/ui/never_type/fallback-closure-ret.rs

@@ -8,9 +8,10 @@
 // ?T`. In the code below, these are `R: Bar` and `Fn::Output = R`.
 //
 //@ revisions: nofallback fallback
-//@[fallback] check-pass
+//@ check-pass
 
 #![cfg_attr(fallback, feature(never_type_fallback))]
+#![cfg_attr(nofallback, expect(dependency_on_unit_never_type_fallback))]
 
 trait Bar {}
 impl Bar for () {}
@@ -19,7 +20,5 @@ impl Bar for u32 {}
 fn foo<R: Bar>(_: impl Fn() -> R) {}
 
 fn main() {
-    //[nofallback]~^ error: 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 Rust 2024 and in a future release in all editions!
     foo(|| panic!());
 }