stabilise feature(never_type)

Replace feature(never_type) with feature(exhaustive_patterns).
feature(exhaustive_patterns) only covers the pattern-exhaustives checks
that used to be covered by feature(never_type)

77 files changed, 89 insertions, 162 deletions

diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 6602643dc51..fdb9946469b 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -882,24 +882,24 @@ mod impls {
 
     ord_impl! { char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.24.0")]
     impl PartialEq for ! {
         fn eq(&self, _: &!) -> bool {
             *self
         }
     }
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.24.0")]
     impl Eq for ! {}
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.24.0")]
     impl PartialOrd for ! {
         fn partial_cmp(&self, _: &!) -> Option<Ordering> {
             *self
         }
     }
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.24.0")]
     impl Ord for ! {
         fn cmp(&self, _: &!) -> Ordering {
             *self
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 213b317f632..3706da7c521 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -1579,14 +1579,14 @@ macro_rules! fmt_refs {
 
 fmt_refs! { Debug, Display, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp }
 
-#[unstable(feature = "never_type", issue = "35121")]
+#[stable(feature = "never_type", since = "1.24.0")]
 impl Debug for ! {
     fn fmt(&self, _: &mut Formatter) -> Result {
         *self
     }
 }
 
-#[unstable(feature = "never_type", issue = "35121")]
+#[stable(feature = "never_type", since = "1.24.0")]
 impl Display for ! {
     fn fmt(&self, _: &mut Formatter) -> Result {
         *self
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index cefcc5ff03f..a947c9f0b7c 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -85,7 +85,7 @@
 #![feature(iterator_repeat_with)]
 #![feature(lang_items)]
 #![feature(link_llvm_intrinsics)]
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![feature(no_core)]
 #![feature(on_unimplemented)]
 #![feature(optin_builtin_traits)]
@@ -103,6 +103,7 @@
 #![feature(unwind_attributes)]
 
 #![cfg_attr(stage0, allow(unused_attributes))]
+#![cfg_attr(stage0, feature(never_type))]
 
 #[prelude_import]
 #[allow(unused)]
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index 77b3a87c0ed..51882385b2e 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -60,7 +60,7 @@
 #![feature(match_default_bindings)]
 #![feature(macro_lifetime_matcher)]
 #![feature(macro_vis_matcher)]
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![feature(non_exhaustive)]
 #![feature(nonzero)]
 #![feature(proc_macro_internals)]
diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs
index 235d733b253..cbc1d7c38d6 100644
--- a/src/librustc_lint/lib.rs
+++ b/src/librustc_lint/lib.rs
@@ -32,6 +32,7 @@
 #![feature(quote)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(slice_patterns)]
+#![cfg_attr(stage0, feature(never_type))]
 
 #[macro_use]
 extern crate syntax;
diff --git a/src/librustc_mir/build/matches/simplify.rs b/src/librustc_mir/build/matches/simplify.rs
index abea5583546..4e95ee6444d 100644
--- a/src/librustc_mir/build/matches/simplify.rs
+++ b/src/librustc_mir/build/matches/simplify.rs
@@ -113,7 +113,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
             PatternKind::Variant { adt_def, substs, variant_index, ref subpatterns } => {
                 let irrefutable = adt_def.variants.iter().enumerate().all(|(i, v)| {
                     i == variant_index || {
-                        self.hir.tcx().features().never_type &&
+                        self.hir.tcx().features().exhaustive_patterns &&
                         self.hir.tcx().is_variant_uninhabited_from_all_modules(v, substs)
                     }
                 });
diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs
index 58aa9b06c64..6f8b1f8e799 100644
--- a/src/librustc_mir/hair/pattern/_match.rs
+++ b/src/librustc_mir/hair/pattern/_match.rs
@@ -219,7 +219,7 @@ impl<'a, 'tcx> MatchCheckCtxt<'a, 'tcx> {
     }
 
     fn is_uninhabited(&self, ty: Ty<'tcx>) -> bool {
-        if self.tcx.features().never_type {
+        if self.tcx.features().exhaustive_patterns {
             self.tcx.is_ty_uninhabited_from(self.module, ty)
         } else {
             false
@@ -245,7 +245,7 @@ impl<'a, 'tcx> MatchCheckCtxt<'a, 'tcx> {
                               substs: &'tcx ty::subst::Substs<'tcx>)
                               -> bool
     {
-        if self.tcx.features().never_type {
+        if self.tcx.features().exhaustive_patterns {
             self.tcx.is_enum_variant_uninhabited_from(self.module, variant, substs)
         } else {
             false
@@ -694,7 +694,7 @@ pub fn is_useful<'p, 'a: 'p, 'tcx: 'a>(cx: &mut MatchCheckCtxt<'a, 'tcx>,
         // test for details.
         //
         // FIXME: currently the only way I know of something can
-        // be a privately-empty enum is when the never_type
+        // be a privately-empty enum is when the exhaustive_patterns
         // feature flag is not present, so this is only
         // needed for that case.
 
diff --git a/src/librustc_mir/hair/pattern/check_match.rs b/src/librustc_mir/hair/pattern/check_match.rs
index 69ed4e6064f..d924baaf005 100644
--- a/src/librustc_mir/hair/pattern/check_match.rs
+++ b/src/librustc_mir/hair/pattern/check_match.rs
@@ -222,7 +222,7 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> {
             let pat_ty = self.tables.node_id_to_type(scrut.hir_id);
             let module = self.tcx.hir.get_module_parent(scrut.id);
             if inlined_arms.is_empty() {
-                let scrutinee_is_uninhabited = if self.tcx.features().never_type {
+                let scrutinee_is_uninhabited = if self.tcx.features().exhaustive_patterns {
                     self.tcx.is_ty_uninhabited_from(module, pat_ty)
                 } else {
                     self.conservative_is_uninhabited(pat_ty)
diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs
index c31e95fd826..5510e219780 100644
--- a/src/librustc_mir/lib.rs
+++ b/src/librustc_mir/lib.rs
@@ -32,13 +32,14 @@ Rust MIR: a lowered representation of Rust. Also: an experiment!
 #![feature(inclusive_range)]
 #![feature(macro_vis_matcher)]
 #![feature(match_default_bindings)]
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![feature(range_contains)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(placement_in_syntax)]
 #![feature(collection_placement)]
 #![feature(nonzero)]
 #![feature(underscore_lifetimes)]
+#![cfg_attr(stage0, feature(never_type))]
 
 extern crate arena;
 #[macro_use]
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index ea90c35cb8f..a97c6e84eab 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -80,13 +80,14 @@ This API is completely unstable and subject to change.
 #![feature(crate_visibility_modifier)]
 #![feature(from_ref)]
 #![feature(match_default_bindings)]
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![feature(option_filter)]
 #![feature(quote)]
 #![feature(refcell_replace_swap)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(slice_patterns)]
 #![feature(i128_type)]
+#![cfg_attr(stage0, feature(never_type))]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/libstd/error.rs b/src/libstd/error.rs
index eb5022ad577..347b8224410 100644
--- a/src/libstd/error.rs
+++ b/src/libstd/error.rs
@@ -234,7 +234,7 @@ impl<'a> From<Cow<'a, str>> for Box<Error> {
     }
 }
 
-#[unstable(feature = "never_type", issue = "35121")]
+#[stable(feature = "never_type", since = "1.24.0")]
 impl Error for ! {
     fn description(&self) -> &str { *self }
 }
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index da15941374d..eea0e6b6752 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -282,7 +282,7 @@
 #![feature(macro_reexport)]
 #![feature(macro_vis_matcher)]
 #![feature(needs_panic_runtime)]
-#![feature(never_type)]
+#![feature(exhaustive_patterns)]
 #![feature(num_bits_bytes)]
 #![feature(old_wrapping)]
 #![feature(on_unimplemented)]
@@ -324,6 +324,7 @@
 #![feature(doc_spotlight)]
 #![cfg_attr(test, feature(update_panic_count))]
 #![cfg_attr(windows, feature(used))]
+#![cfg_attr(stage0, feature(never_type))]
 
 #![default_lib_allocator]
 
diff --git a/src/libstd/primitive_docs.rs b/src/libstd/primitive_docs.rs
index 358aa2c37df..e6e6be2e453 100644
--- a/src/libstd/primitive_docs.rs
+++ b/src/libstd/primitive_docs.rs
@@ -79,7 +79,6 @@ mod prim_bool { }
 /// write:
 ///
 /// ```
-/// #![feature(never_type)]
 /// # fn foo() -> u32 {
 /// let x: ! = {
 ///     return 123
@@ -131,13 +130,15 @@ mod prim_bool { }
 /// [`Result<String, !>`] which we can unpack like this:
 ///
 /// ```ignore (string-from-str-error-type-is-not-never-yet)
+/// #[feature(exhaustive_patterns)]
 /// // NOTE: This does not work today!
 /// let Ok(s) = String::from_str("hello");
 /// ```
 ///
-/// Since the [`Err`] variant contains a `!`, it can never occur. So we can exhaustively match on
-/// [`Result<T, !>`] by just taking the [`Ok`] variant. This illustrates another behaviour of `!` -
-/// it can be used to "delete" certain enum variants from generic types like `Result`.
+/// Since the [`Err`] variant contains a `!`, it can never occur. If the `exhaustive_patterns`
+/// feature is present this means we can exhaustively match on [`Result<T, !>`] by just taking the
+/// [`Ok`] variant. This illustrates another behaviour of `!` - it can be used to "delete" certain
+/// enum variants from generic types like `Result`.
 ///
 /// [`String::from_str`]: str/trait.FromStr.html#tymethod.from_str
 /// [`Result<String, !>`]: result/enum.Result.html
@@ -154,7 +155,6 @@ mod prim_bool { }
 /// for example:
 ///
 /// ```
-/// # #![feature(never_type)]
 /// # use std::fmt;
 /// # trait Debug {
 /// # fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
@@ -192,7 +192,6 @@ mod prim_bool { }
 /// [`Default`]: default/trait.Default.html
 /// [`default()`]: default/trait.Default.html#tymethod.default
 ///
-#[unstable(feature = "never_type", issue = "35121")]
 mod prim_never { }
 
 #[doc(primitive = "char")]
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index ec9a15d9f2b..91364fe6ed4 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -286,8 +286,8 @@ declare_features! (
     // Allows `impl Trait` in function arguments.
     (active, universal_impl_trait, "1.23.0", Some(34511), None),
 
-    // The `!` type
-    (active, never_type, "1.13.0", Some(35121), None),
+    // Allows exhaustive pattern matching on types that contain uninhabited types.
+    (active, exhaustive_patterns, "1.13.0", None, None),
 
     // Allows all literals in attribute lists and values of key-value pairs.
     (active, attr_literals, "1.13.0", Some(34981), None),
@@ -1566,10 +1566,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::TyKind::BareFn(ref bare_fn_ty) => {
                 self.check_abi(bare_fn_ty.abi, ty.span);
             }
-            ast::TyKind::Never => {
-                gate_feature_post!(&self, never_type, ty.span,
-                                   "The `!` type is experimental");
-            },
             ast::TyKind::TraitObject(_, ast::TraitObjectSyntax::Dyn) => {
                 gate_feature_post!(&self, dyn_trait, ty.span,
                                    "`dyn Trait` syntax is unstable");
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..8b3a9ed092d 100644
--- a/src/test/compile-fail/coerce-to-bang-cast.rs
+++ b/src/test/compile-fail/coerce-to-bang-cast.rs
@@ -8,8 +8,6 @@
 // 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)]
diff --git a/src/test/compile-fail/coerce-to-bang.rs b/src/test/compile-fail/coerce-to-bang.rs
index b804bb2981b..b365f142a9b 100644
--- a/src/test/compile-fail/coerce-to-bang.rs
+++ b/src/test/compile-fail/coerce-to-bang.rs
@@ -8,7 +8,6 @@
 // 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) { }
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-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/run-pass/issue-38972.rs b/src/test/ui/feature-gate-exhaustive-patterns.rs
index d5df84e0fb0..477dd1b38eb 100644
--- a/src/test/run-pass/issue-38972.rs
+++ b/src/test/ui/feature-gate-exhaustive-patterns.rs
@@ -1,4 +1,4 @@
-// Copyright 2017 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,18 +8,11 @@
 // 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 }
+fn foo() -> Result<u32, !> {
+    Ok(123)
+}
 
-#[deny(warnings)]
 fn main() {
-    match make_foo() {
-        None => {},
-        Some(_) => {}
-    }
+    let Ok(_x) = foo(); //~ ERROR refutable pattern in local binding
 }
+
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..43a4adf9373
--- /dev/null
+++ b/src/test/ui/feature-gate-exhaustive-patterns.stderr
@@ -0,0 +1,8 @@
+error[E0005]: refutable pattern in local binding: `Err(_)` not covered
+  --> $DIR/feature-gate-exhaustive-patterns.rs:16:9
+   |
+16 |     let Ok(_x) = foo(); //~ ERROR refutable pattern in local binding
+   |         ^^^^^^ pattern `Err(_)` not covered
+
+error: aborting due to previous error
+
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/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..524784934c7 100644
--- a/src/test/ui/reachable/expr_unary.rs
+++ b/src/test/ui/reachable/expr_unary.rs
@@ -13,7 +13,6 @@
 #![allow(dead_code)]
 #![deny(unreachable_code)]
 #![deny(coerce_never)]
-#![feature(never_type)]
 
 fn foo() {
     let x: ! = ! { return; 22 }; //~ ERROR unreachable
diff --git a/src/test/ui/reachable/expr_unary.stderr b/src/test/ui/reachable/expr_unary.stderr
index b09721e5957..1239701cabd 100644
--- a/src/test/ui/reachable/expr_unary.stderr
+++ b/src/test/ui/reachable/expr_unary.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_unary.rs:19:28
+  --> $DIR/expr_unary.rs:18:28
    |
 LL |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
    |                            ^^
@@ -11,7 +11,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: cannot coerce `{integer}` to !
-  --> $DIR/expr_unary.rs:19:28
+  --> $DIR/expr_unary.rs:18:28
    |
 LL |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
    |                            ^^
@@ -25,7 +25,7 @@ LL | #![deny(coerce_never)]
    = 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
+  --> $DIR/expr_unary.rs:18:16
    |
 LL |     let x: ! = ! { return; 22 }; //~ ERROR unreachable
    |                ^^^^^^^^^^^^^^^^
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.");
    |     ^^^^^^^^^^^^^^^^^^^^^^^