Auto merge of #47630 - canndrew:exhaustive-patterns, r=nikomatsakis

Stabilise feature(never_type). Introduce feature(exhaustive_patterns)

This stabilizes `!`, removing the feature gate as well as the old defaulting-to-`()` behavior. The pattern exhaustiveness checks which were covered by `feature(never_type)` have been moved behind a new `feature(exhaustive_patterns)` gate.

69 files changed, 83 insertions, 242 deletions

diff --git a/src/test/compile-fail/call-fn-never-arg-wrong-type.rs b/src/test/compile-fail/call-fn-never-arg-wrong-type.rs
index 583befed1e8..c2f157cd35c 100644
--- a/src/test/compile-fail/call-fn-never-arg-wrong-type.rs
+++ b/src/test/compile-fail/call-fn-never-arg-wrong-type.rs
@@ -10,8 +10,6 @@
 
 // Test that we can't pass other types for !
 
-#![feature(never_type)]
-
 fn foo(x: !) -> ! {
     x
 }
diff --git a/src/test/compile-fail/coerce-to-bang-cast.rs b/src/test/compile-fail/coerce-to-bang-cast.rs
index 0d5bf6cd68c..5efb4dadc64 100644
--- a/src/test/compile-fail/coerce-to-bang-cast.rs
+++ b/src/test/compile-fail/coerce-to-bang-cast.rs
@@ -8,15 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
-
 fn foo(x: usize, y: !, z: usize) { }
 
-#[deny(coerce_never)]
 fn cast_a() {
     let y = {return; 22} as !;
-    //~^ ERROR cannot coerce `i32` to !
-    //~| hard error
+    //~^ ERROR non-primitive cast
 }
 
 fn cast_b() {
diff --git a/src/test/compile-fail/coerce-to-bang.rs b/src/test/compile-fail/coerce-to-bang.rs
index b804bb2981b..15049232a4d 100644
--- a/src/test/compile-fail/coerce-to-bang.rs
+++ b/src/test/compile-fail/coerce-to-bang.rs
@@ -8,18 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
-#![deny(coerce_never)]
-
 fn foo(x: usize, y: !, z: usize) { }
 
 fn call_foo_a() {
-    // FIXME(#40800) -- accepted because divergence happens **before**
-    // the coercion to `!`, but within same expression. Not clear that
-    // these are the rules we want.
     foo(return, 22, 44);
-    //~^ ERROR cannot coerce `{integer}` to !
-    //~| hard error
+    //~^ ERROR mismatched types
 }
 
 fn call_foo_b() {
@@ -39,8 +32,7 @@ fn call_foo_d() {
     let b = 22;
     let c = 44;
     foo(a, b, c); // ... and hence a reference to `a` is expected to diverge.
-    //~^ ERROR cannot coerce `{integer}` to !
-    //~| hard error
+    //~^ ERROR mismatched types
 }
 
 fn call_foo_e() {
@@ -80,8 +72,7 @@ fn tuple_a() {
 fn tuple_b() {
     // Divergence happens before coercion: OK
     let x: (usize, !, usize) = (return, 44, 66);
-    //~^ ERROR cannot coerce `{integer}` to !
-    //~| hard error
+    //~^ ERROR mismatched types
 }
 
 fn tuple_c() {
diff --git a/src/test/compile-fail/defaulted-unit-warning.rs b/src/test/compile-fail/defaulted-never-note.rs
index 3f4e1cce548..798544f1649 100644
--- a/src/test/compile-fail/defaulted-unit-warning.rs
+++ b/src/test/compile-fail/defaulted-never-note.rs
@@ -25,14 +25,17 @@ trait ImplementedForUnitButNotNever {}
 impl ImplementedForUnitButNotNever for () {}
 
 fn foo<T: ImplementedForUnitButNotNever>(_t: T) {}
+//~^ NOTE required by `foo`
 
 fn smeg() {
     let _x = return;
     foo(_x);
-    //~^ ERROR code relies on type
-    //~| WARNING previously accepted
+    //~^ ERROR the trait bound
+    //~| NOTE the trait `ImplementedForUnitButNotNever` is not implemented
+    //~| NOTE the trait is implemented for `()`
 }
 
 fn main() {
     smeg();
 }
+
diff --git a/src/test/compile-fail/diverging-fn-tail-35849.rs b/src/test/compile-fail/diverging-fn-tail-35849.rs
index a91c000bbf7..9ef5159cb77 100644
--- a/src/test/compile-fail/diverging-fn-tail-35849.rs
+++ b/src/test/compile-fail/diverging-fn-tail-35849.rs
@@ -8,12 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[deny(coerce_never)]
 fn assert_sizeof() -> ! {
     unsafe {
         ::std::mem::transmute::<f64, [u8; 8]>(panic!())
-            //~^ ERROR cannot coerce `[u8; 8]` to !
-            //~| hard error
+            //~^ ERROR mismatched types
     }
 }
 
diff --git a/src/test/compile-fail/inhabitedness-infinite-loop.rs b/src/test/compile-fail/inhabitedness-infinite-loop.rs
index 91b85d7510a..b9741e0add6 100644
--- a/src/test/compile-fail/inhabitedness-infinite-loop.rs
+++ b/src/test/compile-fail/inhabitedness-infinite-loop.rs
@@ -10,7 +10,7 @@
 
 // error-pattern:reached recursion limit
 
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 
 struct Foo<'a, T: 'a> {
     ph: std::marker::PhantomData<T>,
diff --git a/src/test/compile-fail/loop-break-value.rs b/src/test/compile-fail/loop-break-value.rs
index 938f7fba2a0..5ef46bb27fd 100644
--- a/src/test/compile-fail/loop-break-value.rs
+++ b/src/test/compile-fail/loop-break-value.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
-
 fn main() {
     let val: ! = loop { break break; };
     //~^ ERROR mismatched types
diff --git a/src/test/compile-fail/match-privately-empty.rs b/src/test/compile-fail/match-privately-empty.rs
index 3affb1c03e9..e18c7d77ce3 100644
--- a/src/test/compile-fail/match-privately-empty.rs
+++ b/src/test/compile-fail/match-privately-empty.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 
 mod private {
     pub struct Private {
diff --git a/src/test/compile-fail/never-assign-dead-code.rs b/src/test/compile-fail/never-assign-dead-code.rs
index 1e0cc0f5357..4e987d1ddce 100644
--- a/src/test/compile-fail/never-assign-dead-code.rs
+++ b/src/test/compile-fail/never-assign-dead-code.rs
@@ -10,7 +10,7 @@
 
 // Test that an assignment of type ! makes the rest of the block dead code.
 
-#![feature(never_type, rustc_attrs)]
+#![feature(rustc_attrs)]
 #![warn(unused)]
 
 #[rustc_error]
diff --git a/src/test/compile-fail/never-assign-wrong-type.rs b/src/test/compile-fail/never-assign-wrong-type.rs
index c0dd2cab749..8c2de7d68d3 100644
--- a/src/test/compile-fail/never-assign-wrong-type.rs
+++ b/src/test/compile-fail/never-assign-wrong-type.rs
@@ -10,7 +10,6 @@
 
 // Test that we can't use another type in place of !
 
-#![feature(never_type)]
 #![deny(warnings)]
 
 fn main() {
diff --git a/src/test/compile-fail/recursive-types-are-not-uninhabited.rs b/src/test/compile-fail/recursive-types-are-not-uninhabited.rs
index f8d6c3de2ab..fa936697072 100644
--- a/src/test/compile-fail/recursive-types-are-not-uninhabited.rs
+++ b/src/test/compile-fail/recursive-types-are-not-uninhabited.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//#![feature(never_type)]
-
 struct R<'a> {
     r: &'a R<'a>,
 }
diff --git a/src/test/compile-fail/uninhabited-irrefutable.rs b/src/test/compile-fail/uninhabited-irrefutable.rs
index 4755fdd4fd5..72b0afa6bd3 100644
--- a/src/test/compile-fail/uninhabited-irrefutable.rs
+++ b/src/test/compile-fail/uninhabited-irrefutable.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 
 mod foo {
     pub struct SecretlyEmpty {
diff --git a/src/test/compile-fail/uninhabited-patterns.rs b/src/test/compile-fail/uninhabited-patterns.rs
index 4c894b0bdd3..9f943f08232 100644
--- a/src/test/compile-fail/uninhabited-patterns.rs
+++ b/src/test/compile-fail/uninhabited-patterns.rs
@@ -11,7 +11,7 @@
 #![feature(box_patterns)]
 #![feature(slice_patterns)]
 #![feature(box_syntax)]
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![deny(unreachable_patterns)]
 
 mod foo {
diff --git a/src/test/compile-fail/unreachable-loop-patterns.rs b/src/test/compile-fail/unreachable-loop-patterns.rs
index 6147692658f..dca79bdfb87 100644
--- a/src/test/compile-fail/unreachable-loop-patterns.rs
+++ b/src/test/compile-fail/unreachable-loop-patterns.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![deny(unreachable_patterns)]
 
 fn main() {
diff --git a/src/test/compile-fail/unreachable-try-pattern.rs b/src/test/compile-fail/unreachable-try-pattern.rs
index 46ea4a06a3b..0caf7d51234 100644
--- a/src/test/compile-fail/unreachable-try-pattern.rs
+++ b/src/test/compile-fail/unreachable-try-pattern.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type, rustc_attrs)]
+#![feature(exhaustive_patterns, rustc_attrs)]
 #![warn(unreachable_code)]
 #![warn(unreachable_patterns)]
 
diff --git a/src/test/run-fail/adjust_never.rs b/src/test/run-fail/adjust_never.rs
index ccdb1ca15bb..7a4b5e59eeb 100644
--- a/src/test/run-fail/adjust_never.rs
+++ b/src/test/run-fail/adjust_never.rs
@@ -10,8 +10,6 @@
 
 // Test that a variable of type ! can coerce to another type.
 
-#![feature(never_type)]
-
 // error-pattern:explicit
 fn main() {
     let x: ! = panic!();
diff --git a/src/test/run-fail/call-fn-never-arg.rs b/src/test/run-fail/call-fn-never-arg.rs
index 95101e70db9..56454586bb9 100644
--- a/src/test/run-fail/call-fn-never-arg.rs
+++ b/src/test/run-fail/call-fn-never-arg.rs
@@ -12,7 +12,6 @@
 
 // error-pattern:wowzers!
 
-#![feature(never_type)]
 #![allow(unreachable_code)]
 
 fn foo(x: !) -> ! {
diff --git a/src/test/run-fail/cast-never.rs b/src/test/run-fail/cast-never.rs
index acd002494f4..0155332c51d 100644
--- a/src/test/run-fail/cast-never.rs
+++ b/src/test/run-fail/cast-never.rs
@@ -10,8 +10,6 @@
 
 // Test that we can explicitly cast ! to another type
 
-#![feature(never_type)]
-
 // error-pattern:explicit
 fn main() {
     let x: ! = panic!();
diff --git a/src/test/run-fail/never-associated-type.rs b/src/test/run-fail/never-associated-type.rs
index 345674f3f52..d9b8461a1d0 100644
--- a/src/test/run-fail/never-associated-type.rs
+++ b/src/test/run-fail/never-associated-type.rs
@@ -10,8 +10,6 @@
 
 // Test that we can use ! as an associated type.
 
-#![feature(never_type)]
-
 // error-pattern:kapow!
 
 trait Foo {
diff --git a/src/test/run-fail/never-type-arg.rs b/src/test/run-fail/never-type-arg.rs
index 826ca3a08c0..0fe10d43910 100644
--- a/src/test/run-fail/never-type-arg.rs
+++ b/src/test/run-fail/never-type-arg.rs
@@ -12,8 +12,6 @@
 
 // error-pattern:oh no!
 
-#![feature(never_type)]
-
 struct Wub;
 
 impl PartialEq<!> for Wub {
diff --git a/src/test/run-pass/diverging-fallback-control-flow.rs b/src/test/run-pass/diverging-fallback-control-flow.rs
index 723a98bcdfa..a96f98b9efd 100644
--- a/src/test/run-pass/diverging-fallback-control-flow.rs
+++ b/src/test/run-pass/diverging-fallback-control-flow.rs
@@ -14,8 +14,6 @@
 // These represent current behavior, but are pretty dubious.  I would
 // like to revisit these and potentially change them. --nmatsakis
 
-#![feature(never_type)]
-
 trait BadDefault {
     fn default() -> Self;
 }
diff --git a/src/test/run-pass/empty-types-in-patterns.rs b/src/test/run-pass/empty-types-in-patterns.rs
index 033b185a0ef..87db4401929 100644
--- a/src/test/run-pass/empty-types-in-patterns.rs
+++ b/src/test/run-pass/empty-types-in-patterns.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![feature(slice_patterns)]
 #![allow(unreachable_patterns)]
 #![allow(unreachable_code)]
diff --git a/src/test/run-pass/impl-for-never.rs b/src/test/run-pass/impl-for-never.rs
index 794f5969bff..cf54e1c3bd5 100644
--- a/src/test/run-pass/impl-for-never.rs
+++ b/src/test/run-pass/impl-for-never.rs
@@ -10,8 +10,6 @@
 
 // Test that we can call static methods on ! both directly and when it appears in a generic
 
-#![feature(never_type)]
-
 trait StringifyType {
     fn stringify_type() -> &'static str;
 }
diff --git a/src/test/run-pass/issue-38972.rs b/src/test/run-pass/issue-38972.rs
deleted file mode 100644
index d5df84e0fb0..00000000000
--- a/src/test/run-pass/issue-38972.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// This issue tracks a regression (a new warning) without
-// feature(never_type). When we make that the default, please
-// remove this test.
-
-enum Foo { }
-
-fn make_foo() -> Option<Foo> { None }
-
-#[deny(warnings)]
-fn main() {
-    match make_foo() {
-        None => {},
-        Some(_) => {}
-    }
-}
diff --git a/src/test/run-pass/issue-44402.rs b/src/test/run-pass/issue-44402.rs
index 244aa65a3d5..a5a0a5a5794 100644
--- a/src/test/run-pass/issue-44402.rs
+++ b/src/test/run-pass/issue-44402.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 
 // Regression test for inhabitedness check. The old
 // cache used to cause us to incorrectly decide
diff --git a/src/test/run-pass/loop-break-value.rs b/src/test/run-pass/loop-break-value.rs
index 39053769b24..ffdd99ebf6e 100644
--- a/src/test/run-pass/loop-break-value.rs
+++ b/src/test/run-pass/loop-break-value.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
-
 #[allow(unused)]
 fn never_returns() {
     loop {
diff --git a/src/test/run-pass/mir_calls_to_shims.rs b/src/test/run-pass/mir_calls_to_shims.rs
index 9641ed28293..dda7a46f325 100644
--- a/src/test/run-pass/mir_calls_to_shims.rs
+++ b/src/test/run-pass/mir_calls_to_shims.rs
@@ -11,7 +11,6 @@
 // ignore-wasm32-bare compiled with panic=abort by default
 
 #![feature(fn_traits)]
-#![feature(never_type)]
 
 use std::panic;
 
diff --git a/src/test/run-pass/never-result.rs b/src/test/run-pass/never-result.rs
index 5c0af392f44..8aa2a13ed8c 100644
--- a/src/test/run-pass/never-result.rs
+++ b/src/test/run-pass/never-result.rs
@@ -10,8 +10,6 @@
 
 // Test that we can extract a ! through pattern matching then use it as several different types.
 
-#![feature(never_type)]
-
 fn main() {
     let x: Result<u32, !> = Ok(123);
     match x {
diff --git a/src/test/ui/associated-types-ICE-when-projecting-out-of-err.rs b/src/test/ui/associated-types-ICE-when-projecting-out-of-err.rs
index 75b60aa8d10..052575de4c2 100644
--- a/src/test/ui/associated-types-ICE-when-projecting-out-of-err.rs
+++ b/src/test/ui/associated-types-ICE-when-projecting-out-of-err.rs
@@ -31,5 +31,5 @@ trait Add<RHS=Self> {
 fn ice<A>(a: A) {
     let r = loop {};
     r = r + a;
-    //~^ ERROR the trait bound `(): Add<A>` is not satisfied
+    //~^ ERROR the trait bound `!: Add<A>` is not satisfied
 }
diff --git a/src/test/ui/associated-types-ICE-when-projecting-out-of-err.stderr b/src/test/ui/associated-types-ICE-when-projecting-out-of-err.stderr
index 7924ab74444..c22a645385a 100644
--- a/src/test/ui/associated-types-ICE-when-projecting-out-of-err.stderr
+++ b/src/test/ui/associated-types-ICE-when-projecting-out-of-err.stderr
@@ -1,8 +1,8 @@
-error[E0277]: the trait bound `(): Add<A>` is not satisfied
+error[E0277]: the trait bound `!: Add<A>` is not satisfied
   --> $DIR/associated-types-ICE-when-projecting-out-of-err.rs:33:11
    |
 LL |     r = r + a;
-   |           ^ the trait `Add<A>` is not implemented for `()`
+   |           ^ the trait `Add<A>` is not implemented for `!`
 
 error: aborting due to previous error
 
diff --git a/src/test/run-pass/diverging-fn-tail-35849.rs b/src/test/ui/feature-gate-exhaustive-patterns.rs
index dfd99bcc9fb..477dd1b38eb 100644
--- a/src/test/run-pass/diverging-fn-tail-35849.rs
+++ b/src/test/ui/feature-gate-exhaustive-patterns.rs
@@ -1,4 +1,4 @@
-// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[allow(coerce_never)]
-fn assert_sizeof() -> ! {
-    unsafe {
-        ::std::mem::transmute::<f64, [u8; 8]>(panic!())
-    }
+fn foo() -> Result<u32, !> {
+    Ok(123)
+}
+
+fn main() {
+    let Ok(_x) = foo(); //~ ERROR refutable pattern in local binding
 }
 
-fn main() { }
diff --git a/src/test/ui/feature-gate-exhaustive-patterns.stderr b/src/test/ui/feature-gate-exhaustive-patterns.stderr
new file mode 100644
index 00000000000..4afe5b5d5e0
--- /dev/null
+++ b/src/test/ui/feature-gate-exhaustive-patterns.stderr
@@ -0,0 +1,9 @@
+error[E0005]: refutable pattern in local binding: `Err(_)` not covered
+  --> $DIR/feature-gate-exhaustive-patterns.rs:16:9
+   |
+LL |     let Ok(_x) = foo(); //~ ERROR refutable pattern in local binding
+   |         ^^^^^^ pattern `Err(_)` not covered
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0005`.
diff --git a/src/test/ui/feature-gate-never_type.rs b/src/test/ui/feature-gate-never_type.rs
deleted file mode 100644
index 11b9f412957..00000000000
--- a/src/test/ui/feature-gate-never_type.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Test that ! errors when used in illegal positions with feature(never_type) disabled
-
-trait Foo {
-    type Wub;
-}
-
-type Ma = (u32, !, i32); //~ ERROR type is experimental
-type Meeshka = Vec<!>; //~ ERROR type is experimental
-type Mow = &fn(!) -> !; //~ ERROR type is experimental
-type Skwoz = &mut !; //~ ERROR type is experimental
-
-impl Foo for Meeshka {
-    type Wub = !; //~ ERROR type is experimental
-}
-
-fn main() {
-}
-
diff --git a/src/test/ui/feature-gate-never_type.stderr b/src/test/ui/feature-gate-never_type.stderr
deleted file mode 100644
index 187be6d8291..00000000000
--- a/src/test/ui/feature-gate-never_type.stderr
+++ /dev/null
@@ -1,43 +0,0 @@
-error[E0658]: The `!` type is experimental (see issue #35121)
-  --> $DIR/feature-gate-never_type.rs:17:17
-   |
-LL | type Ma = (u32, !, i32); //~ ERROR type is experimental
-   |                 ^
-   |
-   = help: add #![feature(never_type)] to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental (see issue #35121)
-  --> $DIR/feature-gate-never_type.rs:18:20
-   |
-LL | type Meeshka = Vec<!>; //~ ERROR type is experimental
-   |                    ^
-   |
-   = help: add #![feature(never_type)] to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental (see issue #35121)
-  --> $DIR/feature-gate-never_type.rs:19:16
-   |
-LL | type Mow = &fn(!) -> !; //~ ERROR type is experimental
-   |                ^
-   |
-   = help: add #![feature(never_type)] to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental (see issue #35121)
-  --> $DIR/feature-gate-never_type.rs:20:19
-   |
-LL | type Skwoz = &mut !; //~ ERROR type is experimental
-   |                   ^
-   |
-   = help: add #![feature(never_type)] to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental (see issue #35121)
-  --> $DIR/feature-gate-never_type.rs:23:16
-   |
-LL |     type Wub = !; //~ ERROR type is experimental
-   |                ^
-   |
-   = help: add #![feature(never_type)] to the crate attributes to enable
-
-error: aborting due to 5 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/print_type_sizes/uninhabited.rs b/src/test/ui/print_type_sizes/uninhabited.rs
index 4d0396903e5..7e8eff02c20 100644
--- a/src/test/ui/print_type_sizes/uninhabited.rs
+++ b/src/test/ui/print_type_sizes/uninhabited.rs
@@ -11,7 +11,6 @@
 // compile-flags: -Z print-type-sizes
 // must-compile-successfully
 
-#![feature(never_type)]
 #![feature(start)]
 
 #[start]
diff --git a/src/test/ui/reachable/expr_add.rs b/src/test/ui/reachable/expr_add.rs
index dd43c58de6d..3e39b75d8c0 100644
--- a/src/test/ui/reachable/expr_add.rs
+++ b/src/test/ui/reachable/expr_add.rs
@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(never_type)]
 #![allow(unused_variables)]
 #![deny(unreachable_code)]
 
diff --git a/src/test/ui/reachable/expr_add.stderr b/src/test/ui/reachable/expr_add.stderr
index d3e1da0e718..f49a781ce33 100644
--- a/src/test/ui/reachable/expr_add.stderr
+++ b/src/test/ui/reachable/expr_add.stderr
@@ -1,11 +1,11 @@
 error: unreachable expression
-  --> $DIR/expr_add.rs:27:13
+  --> $DIR/expr_add.rs:26:13
    |
 LL |     let x = Foo + return; //~ ERROR unreachable
    |             ^^^^^^^^^^^^
    |
 note: lint level defined here
-  --> $DIR/expr_add.rs:13:9
+  --> $DIR/expr_add.rs:12:9
    |
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_array.rs b/src/test/ui/reachable/expr_array.rs
index 31229668796..323a5752e22 100644
--- a/src/test/ui/reachable/expr_array.rs
+++ b/src/test/ui/reachable/expr_array.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 #![feature(type_ascription)]
 
 fn a() {
@@ -21,7 +20,7 @@ fn a() {
 }
 
 fn b() {
-    // the `array is unreachable:
+    // the array is unreachable:
     let x: [usize; 2] = [22, return]; //~ ERROR unreachable
 }
 
diff --git a/src/test/ui/reachable/expr_array.stderr b/src/test/ui/reachable/expr_array.stderr
index 3257514ea50..78ac76a6137 100644
--- a/src/test/ui/reachable/expr_array.stderr
+++ b/src/test/ui/reachable/expr_array.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_array.rs:20:34
+  --> $DIR/expr_array.rs:19:34
    |
 LL |     let x: [usize; 2] = [return, 22]; //~ ERROR unreachable
    |                                  ^^
@@ -11,7 +11,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_array.rs:25:25
+  --> $DIR/expr_array.rs:24:25
    |
 LL |     let x: [usize; 2] = [22, return]; //~ ERROR unreachable
    |                         ^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_assign.rs b/src/test/ui/reachable/expr_assign.rs
index e6fb46a5bac..73083af34d9 100644
--- a/src/test/ui/reachable/expr_assign.rs
+++ b/src/test/ui/reachable/expr_assign.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 fn foo() {
     // No error here.
diff --git a/src/test/ui/reachable/expr_assign.stderr b/src/test/ui/reachable/expr_assign.stderr
index 15dcf2c2401..628bfbf6217 100644
--- a/src/test/ui/reachable/expr_assign.stderr
+++ b/src/test/ui/reachable/expr_assign.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_assign.rs:20:5
+  --> $DIR/expr_assign.rs:19:5
    |
 LL |     x = return; //~ ERROR unreachable
    |     ^^^^^^^^^^
@@ -11,13 +11,13 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_assign.rs:30:14
+  --> $DIR/expr_assign.rs:29:14
    |
 LL |         *p = return; //~ ERROR unreachable
    |              ^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_assign.rs:36:15
+  --> $DIR/expr_assign.rs:35:15
    |
 LL |     *{return; &mut i} = 22; //~ ERROR unreachable
    |               ^^^^^^
diff --git a/src/test/ui/reachable/expr_block.rs b/src/test/ui/reachable/expr_block.rs
index 57b5d3cabce..93bce43f76d 100644
--- a/src/test/ui/reachable/expr_block.rs
+++ b/src/test/ui/reachable/expr_block.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 fn a() {
     // Here the tail expression is considered unreachable:
diff --git a/src/test/ui/reachable/expr_block.stderr b/src/test/ui/reachable/expr_block.stderr
index a0cef6449f7..5f5696aadb3 100644
--- a/src/test/ui/reachable/expr_block.stderr
+++ b/src/test/ui/reachable/expr_block.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_block.rs:21:9
+  --> $DIR/expr_block.rs:20:9
    |
 LL |         22 //~ ERROR unreachable
    |         ^^
@@ -11,7 +11,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable statement
-  --> $DIR/expr_block.rs:36:9
+  --> $DIR/expr_block.rs:35:9
    |
 LL |         println!("foo");
    |         ^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_call.rs b/src/test/ui/reachable/expr_call.rs
index 86b95aad9c2..2772dd429d1 100644
--- a/src/test/ui/reachable/expr_call.rs
+++ b/src/test/ui/reachable/expr_call.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 fn foo(x: !, y: usize) { }
 
diff --git a/src/test/ui/reachable/expr_call.stderr b/src/test/ui/reachable/expr_call.stderr
index 455e5ab3653..414d29ec2a7 100644
--- a/src/test/ui/reachable/expr_call.stderr
+++ b/src/test/ui/reachable/expr_call.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_call.rs:23:17
+  --> $DIR/expr_call.rs:22:17
    |
 LL |     foo(return, 22); //~ ERROR unreachable
    |                 ^^
@@ -11,7 +11,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_call.rs:28:5
+  --> $DIR/expr_call.rs:27:5
    |
 LL |     bar(return); //~ ERROR unreachable
    |     ^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_cast.rs b/src/test/ui/reachable/expr_cast.rs
index 76b00c00ad9..88846b63841 100644
--- a/src/test/ui/reachable/expr_cast.rs
+++ b/src/test/ui/reachable/expr_cast.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 #![feature(type_ascription)]
 
 fn a() {
diff --git a/src/test/ui/reachable/expr_cast.stderr b/src/test/ui/reachable/expr_cast.stderr
index 8c37759aa46..458334e2af9 100644
--- a/src/test/ui/reachable/expr_cast.stderr
+++ b/src/test/ui/reachable/expr_cast.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_cast.rs:20:13
+  --> $DIR/expr_cast.rs:19:13
    |
 LL |     let x = {return} as !; //~ ERROR unreachable
    |             ^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_if.rs b/src/test/ui/reachable/expr_if.rs
index 2a265e772f3..d2fb1044e48 100644
--- a/src/test/ui/reachable/expr_if.rs
+++ b/src/test/ui/reachable/expr_if.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 fn foo() {
     if {return} {
diff --git a/src/test/ui/reachable/expr_if.stderr b/src/test/ui/reachable/expr_if.stderr
index c14cdbfc2bc..6e8afd1c5be 100644
--- a/src/test/ui/reachable/expr_if.stderr
+++ b/src/test/ui/reachable/expr_if.stderr
@@ -1,5 +1,5 @@
 error: unreachable statement
-  --> $DIR/expr_if.rs:38:5
+  --> $DIR/expr_if.rs:37:5
    |
 LL |     println!("But I am.");
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_loop.rs b/src/test/ui/reachable/expr_loop.rs
index 3ed4b2dcf0c..533cdac0968 100644
--- a/src/test/ui/reachable/expr_loop.rs
+++ b/src/test/ui/reachable/expr_loop.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 fn a() {
     loop { return; }
diff --git a/src/test/ui/reachable/expr_loop.stderr b/src/test/ui/reachable/expr_loop.stderr
index 7f834567de3..a51ef293acf 100644
--- a/src/test/ui/reachable/expr_loop.stderr
+++ b/src/test/ui/reachable/expr_loop.stderr
@@ -1,5 +1,5 @@
 error: unreachable statement
-  --> $DIR/expr_loop.rs:19:5
+  --> $DIR/expr_loop.rs:18:5
    |
 LL |     println!("I am dead.");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(unreachable_code)]
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
 error: unreachable statement
-  --> $DIR/expr_loop.rs:31:5
+  --> $DIR/expr_loop.rs:30:5
    |
 LL |     println!("I am dead.");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     println!("I am dead.");
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
 error: unreachable statement
-  --> $DIR/expr_loop.rs:41:5
+  --> $DIR/expr_loop.rs:40:5
    |
 LL |     println!("I am dead.");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_match.rs b/src/test/ui/reachable/expr_match.rs
index d2b96e51a95..193edd77435 100644
--- a/src/test/ui/reachable/expr_match.rs
+++ b/src/test/ui/reachable/expr_match.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 fn a() {
     // The match is considered unreachable here, because the `return`
diff --git a/src/test/ui/reachable/expr_match.stderr b/src/test/ui/reachable/expr_match.stderr
index d4cf21cef28..dfc1417f3d2 100644
--- a/src/test/ui/reachable/expr_match.stderr
+++ b/src/test/ui/reachable/expr_match.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_match.rs:20:5
+  --> $DIR/expr_match.rs:19:5
    |
 LL |     match {return} { } //~ ERROR unreachable
    |     ^^^^^^^^^^^^^^^^^^
@@ -11,7 +11,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable statement
-  --> $DIR/expr_match.rs:25:5
+  --> $DIR/expr_match.rs:24:5
    |
 LL |     println!("I am dead");
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     println!("I am dead");
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
 error: unreachable statement
-  --> $DIR/expr_match.rs:35:5
+  --> $DIR/expr_match.rs:34:5
    |
 LL |     println!("I am dead");
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_method.rs b/src/test/ui/reachable/expr_method.rs
index 8be71e464b2..7dabb307097 100644
--- a/src/test/ui/reachable/expr_method.rs
+++ b/src/test/ui/reachable/expr_method.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 struct Foo;
 
diff --git a/src/test/ui/reachable/expr_method.stderr b/src/test/ui/reachable/expr_method.stderr
index b9348b5d481..6d67bfcd54a 100644
--- a/src/test/ui/reachable/expr_method.stderr
+++ b/src/test/ui/reachable/expr_method.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_method.rs:26:21
+  --> $DIR/expr_method.rs:25:21
    |
 LL |     Foo.foo(return, 22); //~ ERROR unreachable
    |                     ^^
@@ -11,7 +11,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_method.rs:31:5
+  --> $DIR/expr_method.rs:30:5
    |
 LL |     Foo.bar(return); //~ ERROR unreachable
    |     ^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_repeat.rs b/src/test/ui/reachable/expr_repeat.rs
index 47ee2ba62b8..fd9fca413a7 100644
--- a/src/test/ui/reachable/expr_repeat.rs
+++ b/src/test/ui/reachable/expr_repeat.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 #![feature(type_ascription)]
 
 fn a() {
diff --git a/src/test/ui/reachable/expr_repeat.stderr b/src/test/ui/reachable/expr_repeat.stderr
index 90cc3183c72..36393de90b7 100644
--- a/src/test/ui/reachable/expr_repeat.stderr
+++ b/src/test/ui/reachable/expr_repeat.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_repeat.rs:20:25
+  --> $DIR/expr_repeat.rs:19:25
    |
 LL |     let x: [usize; 2] = [return; 2]; //~ ERROR unreachable
    |                         ^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_return.rs b/src/test/ui/reachable/expr_return.rs
index fac1116dc68..9bbbe6f9099 100644
--- a/src/test/ui/reachable/expr_return.rs
+++ b/src/test/ui/reachable/expr_return.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 #![feature(type_ascription)]
 
 fn a() {
diff --git a/src/test/ui/reachable/expr_return.stderr b/src/test/ui/reachable/expr_return.stderr
index 3876da6541d..2dcc50944c5 100644
--- a/src/test/ui/reachable/expr_return.stderr
+++ b/src/test/ui/reachable/expr_return.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_return.rs:21:22
+  --> $DIR/expr_return.rs:20:22
    |
 LL |     let x = {return {return {return;}}}; //~ ERROR unreachable
    |                      ^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_struct.rs b/src/test/ui/reachable/expr_struct.rs
index b5acd395be6..66414f6084b 100644
--- a/src/test/ui/reachable/expr_struct.rs
+++ b/src/test/ui/reachable/expr_struct.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 #![feature(type_ascription)]
 
 struct Foo {
diff --git a/src/test/ui/reachable/expr_struct.stderr b/src/test/ui/reachable/expr_struct.stderr
index 43985bbbb5c..3f0ecb20479 100644
--- a/src/test/ui/reachable/expr_struct.stderr
+++ b/src/test/ui/reachable/expr_struct.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_struct.rs:25:13
+  --> $DIR/expr_struct.rs:24:13
    |
 LL |     let x = Foo { a: 22, b: 33, ..return }; //~ ERROR unreachable
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -11,19 +11,19 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_struct.rs:30:33
+  --> $DIR/expr_struct.rs:29:33
    |
 LL |     let x = Foo { a: return, b: 33, ..return }; //~ ERROR unreachable
    |                                 ^^
 
 error: unreachable expression
-  --> $DIR/expr_struct.rs:35:39
+  --> $DIR/expr_struct.rs:34:39
    |
 LL |     let x = Foo { a: 22, b: return, ..return }; //~ ERROR unreachable
    |                                       ^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_struct.rs:40:13
+  --> $DIR/expr_struct.rs:39:13
    |
 LL |     let x = Foo { a: 22, b: return }; //~ ERROR unreachable
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_tup.rs b/src/test/ui/reachable/expr_tup.rs
index 089020bf385..e2c10090248 100644
--- a/src/test/ui/reachable/expr_tup.rs
+++ b/src/test/ui/reachable/expr_tup.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 #![feature(type_ascription)]
 
 fn a() {
diff --git a/src/test/ui/reachable/expr_tup.stderr b/src/test/ui/reachable/expr_tup.stderr
index ff9aa666d8e..d372373ced0 100644
--- a/src/test/ui/reachable/expr_tup.stderr
+++ b/src/test/ui/reachable/expr_tup.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_tup.rs:20:38
+  --> $DIR/expr_tup.rs:19:38
    |
 LL |     let x: (usize, usize) = (return, 2); //~ ERROR unreachable
    |                                      ^
@@ -11,7 +11,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_tup.rs:25:29
+  --> $DIR/expr_tup.rs:24:29
    |
 LL |     let x: (usize, usize) = (2, return); //~ ERROR unreachable
    |                             ^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_type.rs b/src/test/ui/reachable/expr_type.rs
index 29c59d5304f..2381ea2ac7a 100644
--- a/src/test/ui/reachable/expr_type.rs
+++ b/src/test/ui/reachable/expr_type.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 #![feature(type_ascription)]
 
 fn a() {
diff --git a/src/test/ui/reachable/expr_type.stderr b/src/test/ui/reachable/expr_type.stderr
index d6b9f75edf1..9b165d6b3ee 100644
--- a/src/test/ui/reachable/expr_type.stderr
+++ b/src/test/ui/reachable/expr_type.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_type.rs:20:13
+  --> $DIR/expr_type.rs:19:13
    |
 LL |     let x = {return}: !; //~ ERROR unreachable
    |             ^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_unary.rs b/src/test/ui/reachable/expr_unary.rs
index ad12cb876fe..4096865f4c6 100644
--- a/src/test/ui/reachable/expr_unary.rs
+++ b/src/test/ui/reachable/expr_unary.rs
@@ -12,13 +12,9 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![deny(coerce_never)]
-#![feature(never_type)]
 
 fn foo() {
-    let x: ! = ! { return; 22 }; //~ ERROR unreachable
-    //~^ ERROR cannot coerce
-    //~| hard error
+    let x: ! = ! { return; }; //~ ERROR unreachable
     //~| ERROR cannot apply unary operator `!` to type `!`
 }
 
diff --git a/src/test/ui/reachable/expr_unary.stderr b/src/test/ui/reachable/expr_unary.stderr
index b09721e5957..165eccd4239 100644
--- a/src/test/ui/reachable/expr_unary.stderr
+++ b/src/test/ui/reachable/expr_unary.stderr
@@ -1,8 +1,14 @@
+error[E0600]: cannot apply unary operator `!` to type `!`
+  --> $DIR/expr_unary.rs:17:16
+   |
+LL |     let x: ! = ! { return; }; //~ ERROR unreachable
+   |                ^^^^^^^^^^^^^
+
 error: unreachable expression
-  --> $DIR/expr_unary.rs:19:28
+  --> $DIR/expr_unary.rs:17:16
    |
-LL |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
-   |                            ^^
+LL |     let x: ! = ! { return; }; //~ ERROR unreachable
+   |                ^^^^^^^^^^^^^
    |
 note: lint level defined here
   --> $DIR/expr_unary.rs:14:9
@@ -10,26 +16,6 @@ note: lint level defined here
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
-error: cannot coerce `{integer}` to !
-  --> $DIR/expr_unary.rs:19:28
-   |
-LL |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
-   |                            ^^
-   |
-note: lint level defined here
-  --> $DIR/expr_unary.rs:15:9
-   |
-LL | #![deny(coerce_never)]
-   |         ^^^^^^^^^^^^
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #46325 <https://github.com/rust-lang/rust/issues/46325>
-
-error[E0600]: cannot apply unary operator `!` to type `!`
-  --> $DIR/expr_unary.rs:19:16
-   |
-LL |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
-   |                ^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0600`.
diff --git a/src/test/ui/reachable/expr_while.rs b/src/test/ui/reachable/expr_while.rs
index 7dcd609fbc8..79fa69a9289 100644
--- a/src/test/ui/reachable/expr_while.rs
+++ b/src/test/ui/reachable/expr_while.rs
@@ -12,7 +12,6 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type)]
 
 fn foo() {
     while {return} {
diff --git a/src/test/ui/reachable/expr_while.stderr b/src/test/ui/reachable/expr_while.stderr
index cd093906615..90c35bfaa7a 100644
--- a/src/test/ui/reachable/expr_while.stderr
+++ b/src/test/ui/reachable/expr_while.stderr
@@ -1,5 +1,5 @@
 error: unreachable statement
-  --> $DIR/expr_while.rs:19:9
+  --> $DIR/expr_while.rs:18:9
    |
 LL |         println!("Hello, world!");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12,7 +12,7 @@ LL | #![deny(unreachable_code)]
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
 error: unreachable statement
-  --> $DIR/expr_while.rs:33:9
+  --> $DIR/expr_while.rs:32:9
    |
 LL |         println!("I am dead.");
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |         println!("I am dead.");
    = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
 error: unreachable statement
-  --> $DIR/expr_while.rs:35:5
+  --> $DIR/expr_while.rs:34:5
    |
 LL |     println!("I am, too.");
    |     ^^^^^^^^^^^^^^^^^^^^^^^