Auto merge of #66607 - Centril:rollup-yb7cl73, r=Centril

Rollup of 5 pull requests

Successful merges:

 - #65355 (Stabilize `!` in Rust 1.41.0)
 - #65730 (Suggest to add lifetime constraint at explicit ouput of functions)
 - #66468 (Cleanup Miri SIMD intrinsics)
 - #66515 (Reduce size of `hir::Expr` by boxing more of `hir::InlineAsm`)
 - #66602 (Revert "Update Source Code Pro and include italics")

Failed merges:

r? @ghost

159 files changed, 432 insertions, 564 deletions

diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index 14d947ccf24..86dd77f10f3 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -185,7 +185,7 @@ mod impls {
         bool char
     }
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.41.0")]
     impl Clone for ! {
         #[inline]
         fn clone(&self) -> Self {
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 1ac51291b93..1e2e595f1dd 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -1128,24 +1128,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.41.0")]
     impl PartialEq for ! {
         fn eq(&self, _: &!) -> bool {
             *self
         }
     }
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.41.0")]
     impl Eq for ! {}
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.41.0")]
     impl PartialOrd for ! {
         fn partial_cmp(&self, _: &!) -> Option<Ordering> {
             *self
         }
     }
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.41.0")]
     impl Ord for ! {
         fn cmp(&self, _: &!) -> Ordering {
             *self
diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs
index e16c3840260..89a269bdb8e 100644
--- a/src/libcore/convert.rs
+++ b/src/libcore/convert.rs
@@ -40,8 +40,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::fmt;
-
 /// The identity function.
 ///
 /// Two things are important to note about this function:
@@ -426,9 +424,7 @@ pub trait TryInto<T>: Sized {
 /// - `TryFrom<T> for U` implies [`TryInto`]`<U> for T`
 /// - [`try_from`] is reflexive, which means that `TryFrom<T> for T`
 /// is implemented and cannot fail -- the associated `Error` type for
-/// calling `T::try_from()` on a value of type `T` is [`Infallible`].
-/// When the [`!`] type is stabilized [`Infallible`] and [`!`] will be
-/// equivalent.
+/// calling `T::try_from()` on a value of type `T` is [`!`].
 ///
 /// `TryFrom<T>` can be implemented as follows:
 ///
@@ -477,7 +473,6 @@ pub trait TryInto<T>: Sized {
 /// [`TryInto`]: trait.TryInto.html
 /// [`i32::MAX`]: ../../std/i32/constant.MAX.html
 /// [`!`]: ../../std/primitive.never.html
-/// [`Infallible`]: enum.Infallible.html
 #[stable(feature = "try_from", since = "1.34.0")]
 pub trait TryFrom<T>: Sized {
     /// The type returned in the event of a conversion error.
@@ -615,9 +610,9 @@ impl AsRef<str> for str {
 // THE NO-ERROR ERROR TYPE
 ////////////////////////////////////////////////////////////////////////////////
 
-/// The error type for errors that can never happen.
+/// A type alias for [the `!` “never” type][never].
 ///
-/// Since this enum has no variant, a value of this type can never actually exist.
+/// `Infallible` represents types of errors that can never happen since `!` has no valid values.
 /// This can be useful for generic APIs that use [`Result`] and parameterize the error type,
 /// to indicate that the result is always [`Ok`].
 ///
@@ -634,33 +629,10 @@ impl AsRef<str> for str {
 /// }
 /// ```
 ///
-/// # Future compatibility
-///
-/// This enum has the same role as [the `!` “never” type][never],
-/// which is unstable in this version of Rust.
-/// When `!` is stabilized, we plan to make `Infallible` a type alias to it:
-///
-/// ```ignore (illustrates future std change)
-/// pub type Infallible = !;
-/// ```
-///
-/// … and eventually deprecate `Infallible`.
-///
-///
-/// However there is one case where `!` syntax can be used
-/// before `!` is stabilized as a full-fleged type: in the position of a function’s return type.
-/// Specifically, it is possible implementations for two different function pointer types:
-///
-/// ```
-/// trait MyTrait {}
-/// impl MyTrait for fn() -> ! {}
-/// impl MyTrait for fn() -> std::convert::Infallible {}
-/// ```
+/// # Eventual deprecation
 ///
-/// With `Infallible` being an enum, this code is valid.
-/// However when `Infallible` becomes an alias for the never type,
-/// the two `impl`s will start to overlap
-/// and therefore will be disallowed by the language’s trait coherence rules.
+/// Previously, `Infallible` was defined as `enum Infallible {}`.
+/// Now that it is merely a type alias to `!`, we will eventually deprecate `Infallible`.
 ///
 /// [`Ok`]: ../result/enum.Result.html#variant.Ok
 /// [`Result`]: ../result/enum.Result.html
@@ -668,57 +640,4 @@ impl AsRef<str> for str {
 /// [`Into`]: trait.Into.html
 /// [never]: ../../std/primitive.never.html
 #[stable(feature = "convert_infallible", since = "1.34.0")]
-#[derive(Copy)]
-pub enum Infallible {}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Clone for Infallible {
-    fn clone(&self) -> Infallible {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl fmt::Debug for Infallible {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl fmt::Display for Infallible {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl PartialEq for Infallible {
-    fn eq(&self, _: &Infallible) -> bool {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Eq for Infallible {}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl PartialOrd for Infallible {
-    fn partial_cmp(&self, _other: &Self) -> Option<crate::cmp::Ordering> {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl Ord for Infallible {
-    fn cmp(&self, _other: &Self) -> crate::cmp::Ordering {
-        match *self {}
-    }
-}
-
-#[stable(feature = "convert_infallible", since = "1.34.0")]
-impl From<!> for Infallible {
-    fn from(x: !) -> Self {
-        x
-    }
-}
+pub type Infallible = !;
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 5a039144f66..07dca9ad214 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -1935,14 +1935,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.41.0")]
 impl Debug for ! {
     fn fmt(&self, _: &mut Formatter<'_>) -> Result {
         *self
     }
 }
 
-#[unstable(feature = "never_type", issue = "35121")]
+#[stable(feature = "never_type", since = "1.41.0")]
 impl Display for ! {
     fn fmt(&self, _: &mut Formatter<'_>) -> Result {
         *self
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index ea5536eb50c..ec19392450a 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -85,7 +85,7 @@
 #![feature(iter_once_with)]
 #![feature(lang_items)]
 #![feature(link_llvm_intrinsics)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(nll)]
 #![feature(exhaustive_patterns)]
 #![feature(no_core)]
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 2d2fc4102e1..86ee673cea9 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -774,7 +774,7 @@ mod copy_impls {
         bool char
     }
 
-    #[unstable(feature = "never_type", issue = "35121")]
+    #[stable(feature = "never_type", since = "1.41.0")]
     impl Copy for ! {}
 
     #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index b5d61a3fd4e..4313248f263 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -4,7 +4,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::convert::{TryFrom, Infallible};
+use crate::convert::TryFrom;
 use crate::fmt;
 use crate::intrinsics;
 use crate::mem;
@@ -4722,18 +4722,8 @@ impl fmt::Display for TryFromIntError {
 }
 
 #[stable(feature = "try_from", since = "1.34.0")]
-impl From<Infallible> for TryFromIntError {
-    fn from(x: Infallible) -> TryFromIntError {
-        match x {}
-    }
-}
-
-#[unstable(feature = "never_type", issue = "35121")]
 impl From<!> for TryFromIntError {
     fn from(never: !) -> TryFromIntError {
-        // Match rather than coerce to make sure that code like
-        // `From<Infallible> for TryFromIntError` above will keep working
-        // when `Infallible` becomes an alias to `!`.
         match never {}
     }
 }
diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
index 29e3f713276..91c19e269a7 100644
--- a/src/librustc/hir/intravisit.rs
+++ b/src/librustc/hir/intravisit.rs
@@ -1086,10 +1086,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
         ExprKind::Ret(ref optional_expression) => {
             walk_list!(visitor, visit_expr, optional_expression);
         }
-        ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
-            for expr in outputs.iter().chain(inputs.iter()) {
-                visitor.visit_expr(expr)
-            }
+        ExprKind::InlineAsm(ref asm) => {
+            walk_list!(visitor, visit_expr, &asm.outputs_exprs);
+            walk_list!(visitor, visit_expr, &asm.inputs_exprs);
         }
         ExprKind::Yield(ref subexpression, _) => {
             visitor.visit_expr(subexpression);
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index 06a7a6bb301..ac8173f101a 100644
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -2170,6 +2170,16 @@ impl<'a> LoweringContext<'a> {
         impl_trait_return_allow: bool,
         make_ret_async: Option<NodeId>,
     ) -> P<hir::FnDecl> {
+        debug!("lower_fn_decl(\
+            fn_decl: {:?}, \
+            in_band_ty_params: {:?}, \
+            impl_trait_return_allow: {}, \
+            make_ret_async: {:?})",
+            decl,
+            in_band_ty_params,
+            impl_trait_return_allow,
+            make_ret_async,
+        );
         let lt_mode = if make_ret_async.is_some() {
             // In `async fn`, argument-position elided lifetimes
             // must be transformed into fresh generic parameters so that
@@ -2462,7 +2472,7 @@ impl<'a> LoweringContext<'a> {
 
         hir::FunctionRetTy::Return(P(hir::Ty {
             kind: opaque_ty_ref,
-            span,
+            span: opaque_ty_span,
             hir_id: self.next_id(),
         }))
     }
@@ -2572,7 +2582,7 @@ impl<'a> LoweringContext<'a> {
         hir::Lifetime {
             hir_id: self.lower_node_id(id),
             span,
-            name: name,
+            name,
         }
     }
 
diff --git a/src/librustc/hir/lowering/expr.rs b/src/librustc/hir/lowering/expr.rs
index d5d3ff0db2e..929dce7aa0f 100644
--- a/src/librustc/hir/lowering/expr.rs
+++ b/src/librustc/hir/lowering/expr.rs
@@ -966,7 +966,7 @@ impl LoweringContext<'_> {
     }
 
     fn lower_expr_asm(&mut self, asm: &InlineAsm) -> hir::ExprKind {
-        let hir_asm = hir::InlineAsm {
+        let inner = hir::InlineAsmInner {
             inputs: asm.inputs.iter().map(|&(ref c, _)| c.clone()).collect(),
             outputs: asm.outputs
                 .iter()
@@ -984,18 +984,18 @@ impl LoweringContext<'_> {
             alignstack: asm.alignstack,
             dialect: asm.dialect,
         };
-
-        let outputs = asm.outputs
-            .iter()
-            .map(|out| self.lower_expr(&out.expr))
-            .collect();
-
-        let inputs = asm.inputs
-            .iter()
-            .map(|&(_, ref input)| self.lower_expr(input))
-            .collect();
-
-        hir::ExprKind::InlineAsm(P(hir_asm), outputs, inputs)
+        let hir_asm = hir::InlineAsm {
+            inner,
+            inputs_exprs: asm.inputs
+                .iter()
+                .map(|&(_, ref input)| self.lower_expr(input))
+                .collect(),
+            outputs_exprs: asm.outputs
+                .iter()
+                .map(|out| self.lower_expr(&out.expr))
+                .collect(),
+        };
+        hir::ExprKind::InlineAsm(P(hir_asm))
     }
 
     fn lower_field(&mut self, f: &Field) -> hir::Field {
diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index 465673082e5..17b13dae37f 100644
--- a/src/librustc/hir/mod.rs
+++ b/src/librustc/hir/mod.rs
@@ -1457,7 +1457,7 @@ pub struct Expr {
 
 // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(target_arch = "x86_64")]
-static_assert_size!(Expr, 72);
+static_assert_size!(Expr, 64);
 
 impl Expr {
     pub fn precedence(&self) -> ExprPrecedence {
@@ -1656,7 +1656,7 @@ pub enum ExprKind {
     Ret(Option<P<Expr>>),
 
     /// Inline assembly (from `asm!`), with its outputs and inputs.
-    InlineAsm(P<InlineAsm>, HirVec<Expr>, HirVec<Expr>),
+    InlineAsm(P<InlineAsm>),
 
     /// A struct or struct-like variant literal expression.
     ///
@@ -2063,7 +2063,7 @@ pub struct InlineAsmOutput {
 // NOTE(eddyb) This is used within MIR as well, so unlike the rest of the HIR,
 // it needs to be `Clone` and use plain `Vec<T>` instead of `HirVec<T>`.
 #[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)]
-pub struct InlineAsm {
+pub struct InlineAsmInner {
     pub asm: Symbol,
     pub asm_str_style: StrStyle,
     pub outputs: Vec<InlineAsmOutput>,
@@ -2074,6 +2074,13 @@ pub struct InlineAsm {
     pub dialect: AsmDialect,
 }
 
+#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
+pub struct InlineAsm {
+    pub inner: InlineAsmInner,
+    pub outputs_exprs: HirVec<Expr>,
+    pub inputs_exprs: HirVec<Expr>,
+}
+
 /// Represents a parameter in a function header.
 #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
 pub struct Param {
diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
index ba618a1da8c..4cbe0e80991 100644
--- a/src/librustc/hir/print.rs
+++ b/src/librustc/hir/print.rs
@@ -1365,14 +1365,15 @@ impl<'a> State<'a> {
                     self.print_expr_maybe_paren(&expr, parser::PREC_JUMP);
                 }
             }
-            hir::ExprKind::InlineAsm(ref a, ref outputs, ref inputs) => {
+            hir::ExprKind::InlineAsm(ref a) => {
+                let i = &a.inner;
                 self.s.word("asm!");
                 self.popen();
-                self.print_string(&a.asm.as_str(), a.asm_str_style);
+                self.print_string(&i.asm.as_str(), i.asm_str_style);
                 self.word_space(":");
 
                 let mut out_idx = 0;
-                self.commasep(Inconsistent, &a.outputs, |s, out| {
+                self.commasep(Inconsistent, &i.outputs, |s, out| {
                     let constraint = out.constraint.as_str();
                     let mut ch = constraint.chars();
                     match ch.next() {
@@ -1383,7 +1384,7 @@ impl<'a> State<'a> {
                         _ => s.print_string(&constraint, ast::StrStyle::Cooked),
                     }
                     s.popen();
-                    s.print_expr(&outputs[out_idx]);
+                    s.print_expr(&a.outputs_exprs[out_idx]);
                     s.pclose();
                     out_idx += 1;
                 });
@@ -1391,28 +1392,28 @@ impl<'a> State<'a> {
                 self.word_space(":");
 
                 let mut in_idx = 0;
-                self.commasep(Inconsistent, &a.inputs, |s, co| {
+                self.commasep(Inconsistent, &i.inputs, |s, co| {
                     s.print_string(&co.as_str(), ast::StrStyle::Cooked);
                     s.popen();
-                    s.print_expr(&inputs[in_idx]);
+                    s.print_expr(&a.inputs_exprs[in_idx]);
                     s.pclose();
                     in_idx += 1;
                 });
                 self.s.space();
                 self.word_space(":");
 
-                self.commasep(Inconsistent, &a.clobbers, |s, co| {
+                self.commasep(Inconsistent, &i.clobbers, |s, co| {
                     s.print_string(&co.as_str(), ast::StrStyle::Cooked);
                 });
 
                 let mut options = vec![];
-                if a.volatile {
+                if i.volatile {
                     options.push("volatile");
                 }
-                if a.alignstack {
+                if i.alignstack {
                     options.push("alignstack");
                 }
-                if a.dialect == ast::AsmDialect::Intel {
+                if i.dialect == ast::AsmDialect::Intel {
                     options.push("intel");
                 }
 
diff --git a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs
index d7cba87e6b1..a431b541fa4 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs
@@ -45,7 +45,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     ///
     /// It will later be extended to trait objects.
     pub(super) fn try_report_anon_anon_conflict(&self) -> Option<ErrorReported> {
-        let (span, sub, sup) = self.get_regions();
+        let (span, sub, sup) = self.regions();
 
         // Determine whether the sub and sup consist of both anonymous (elided) regions.
         let anon_reg_sup = self.tcx().is_suitable_region(sup)?;
diff --git a/src/librustc/infer/error_reporting/nice_region_error/mod.rs b/src/librustc/infer/error_reporting/nice_region_error/mod.rs
index cd003aa8dab..09cfbf850a5 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/mod.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/mod.rs
@@ -77,7 +77,7 @@ impl<'cx, 'tcx> NiceRegionError<'cx, 'tcx> {
             .or_else(|| self.try_report_impl_not_conforming_to_trait())
     }
 
-    pub fn get_regions(&self) -> (Span, ty::Region<'tcx>, ty::Region<'tcx>) {
+    pub fn regions(&self) -> (Span, ty::Region<'tcx>, ty::Region<'tcx>) {
         match (&self.error, self.regions) {
             (Some(ConcreteFailure(origin, sub, sup)), None) => (origin.span(), sub, sup),
             (Some(SubSupConflict(_, _, origin, sub, _, sup)), None) => (origin.span(), sub, sup),
diff --git a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs
index 36131849191..0abdeb71993 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs
@@ -11,7 +11,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     /// When given a `ConcreteFailure` for a function with parameters containing a named region and
     /// an anonymous region, emit an descriptive diagnostic error.
     pub(super) fn try_report_named_anon_conflict(&self) -> Option<DiagnosticBuilder<'a>> {
-        let (span, sub, sup) = self.get_regions();
+        let (span, sub, sup) = self.regions();
 
         debug!(
             "try_report_named_anon_conflict(sub={:?}, sup={:?}, error={:?})",
diff --git a/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs b/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs
index 9d405d4ea40..01ba748c4e1 100644
--- a/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs
+++ b/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs
@@ -20,8 +20,9 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 ) = error.clone()
             {
                 let anon_reg_sup = self.tcx().is_suitable_region(sup_r)?;
+                let return_ty = self.tcx().return_type_impl_trait(anon_reg_sup.def_id);
                 if sub_r == &RegionKind::ReStatic &&
-                    self.tcx().return_type_impl_trait(anon_reg_sup.def_id).is_some()
+                    return_ty.is_some()
                 {
                     let sp = var_origin.span();
                     let return_sp = sub_origin.span();
@@ -52,17 +53,23 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                         }) => name.to_string(),
                         _ => "'_".to_owned(),
                     };
-                    if let Ok(snippet) = self.tcx().sess.source_map().span_to_snippet(return_sp) {
-                        err.span_suggestion(
-                            return_sp,
-                            &format!(
-                                "you can add a constraint to the return type to make it last \
+                    let fn_return_span = return_ty.unwrap().1;
+                    if let Ok(snippet) =
+                        self.tcx().sess.source_map().span_to_snippet(fn_return_span) {
+                        // only apply this suggestion onto functions with
+                        // explicit non-desugar'able return.
+                        if fn_return_span.desugaring_kind().is_none() {
+                            err.span_suggestion(
+                                fn_return_span,
+                                &format!(
+                                    "you can add a constraint to the return type to make it last \
                                  less than `'static` and match {}",
-                                lifetime,
-                            ),
-                            format!("{} + {}", snippet, lifetime_name),
-                            Applicability::Unspecified,
-                        );
+                                 lifetime,
+                                ),
+                                format!("{} + {}", snippet, lifetime_name),
+                                Applicability::Unspecified,
+                            );
+                        }
                     }
                     err.emit();
                     return Some(ErrorReported);
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index 38877dee711..1fc157eca3e 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -36,7 +36,7 @@
 #![feature(core_intrinsics)]
 #![feature(drain_filter)]
 #![cfg_attr(windows, feature(libc))]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(exhaustive_patterns)]
 #![feature(overlapping_marker_traits)]
 #![feature(extern_types)]
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
index bb7ac5d8dbe..4571f551aa4 100644
--- a/src/librustc/middle/expr_use_visitor.rs
+++ b/src/librustc/middle/expr_use_visitor.rs
@@ -283,15 +283,15 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
                 self.borrow_expr(&base, bk);
             }
 
-            hir::ExprKind::InlineAsm(ref ia, ref outputs, ref inputs) => {
-                for (o, output) in ia.outputs.iter().zip(outputs) {
+            hir::ExprKind::InlineAsm(ref ia) => {
+                for (o, output) in ia.inner.outputs.iter().zip(&ia.outputs_exprs) {
                     if o.is_indirect {
                         self.consume_expr(output);
                     } else {
                         self.mutate_expr(output);
                     }
                 }
-                self.consume_exprs(inputs);
+                self.consume_exprs(&ia.inputs_exprs);
             }
 
             hir::ExprKind::Continue(..) |
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index 79468b68055..b7d0f538db5 100644
--- a/src/librustc/mir/mod.rs
+++ b/src/librustc/mir/mod.rs
@@ -6,7 +6,7 @@
 
 use crate::hir::def::{CtorKind, Namespace};
 use crate::hir::def_id::DefId;
-use crate::hir::{self, InlineAsm as HirInlineAsm};
+use crate::hir;
 use crate::mir::interpret::{PanicInfo, Scalar};
 use crate::mir::visit::MirVisitable;
 use crate::ty::adjustment::PointerCast;
@@ -1638,7 +1638,7 @@ pub enum FakeReadCause {
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
 pub struct InlineAsm<'tcx> {
-    pub asm: HirInlineAsm,
+    pub asm: hir::InlineAsmInner,
     pub outputs: Box<[Place<'tcx>]>,
     pub inputs: Box<[(Span, Operand<'tcx>)]>,
 }
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index 41d069bf6ae..95456581169 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -1529,14 +1529,14 @@ impl<'tcx> TyCtxt<'tcx> {
         return Some(FreeRegionInfo {
             def_id: suitable_region_binding_scope,
             boundregion: bound_region,
-            is_impl_item: is_impl_item,
+            is_impl_item,
         });
     }
 
     pub fn return_type_impl_trait(
         &self,
         scope_def_id: DefId,
-    ) -> Option<Ty<'tcx>> {
+    ) -> Option<(Ty<'tcx>, Span)> {
         // HACK: `type_of_def_id()` will fail on these (#55796), so return `None`.
         let hir_id = self.hir().as_local_hir_id(scope_def_id).unwrap();
         match self.hir().get(hir_id) {
@@ -1557,7 +1557,8 @@ impl<'tcx> TyCtxt<'tcx> {
                 let sig = ret_ty.fn_sig(*self);
                 let output = self.erase_late_bound_regions(&sig.output());
                 if output.is_impl_trait() {
-                    Some(output)
+                    let fn_decl = self.hir().fn_decl_by_hir_id(hir_id).unwrap();
+                    Some((output, fn_decl.output.span()))
                 } else {
                     None
                 }
@@ -2440,10 +2441,10 @@ impl<'tcx> TyCtxt<'tcx> {
 
     #[inline]
     pub fn mk_diverging_default(self) -> Ty<'tcx> {
-        if self.features().never_type {
+        if self.features().never_type_fallback {
             self.types.never
         } else {
-            self.intern_tup(&[])
+            self.types.unit
         }
     }
 
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
index 972452601dd..b9fc5f59b7b 100644
--- a/src/librustc/ty/layout.rs
+++ b/src/librustc/ty/layout.rs
@@ -697,7 +697,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
             // SIMD vector types.
             ty::Adt(def, ..) if def.repr.simd() => {
                 let element = self.layout_of(ty.simd_type(tcx))?;
-                let count = ty.simd_size(tcx) as u64;
+                let count = ty.simd_size(tcx);
                 assert!(count > 0);
                 let scalar = match element.abi {
                     Abi::Scalar(ref scalar) => scalar.clone(),
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
index ccac7720914..8fbd2e4e6b1 100644
--- a/src/librustc/ty/structural_impls.rs
+++ b/src/librustc/ty/structural_impls.rs
@@ -301,7 +301,7 @@ CloneTypeFoldableAndLiftImpls! {
     ::syntax_pos::symbol::Symbol,
     crate::hir::def::Res,
     crate::hir::def_id::DefId,
-    crate::hir::InlineAsm,
+    crate::hir::InlineAsmInner,
     crate::hir::MatchSource,
     crate::hir::Mutability,
     crate::hir::Unsafety,
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
index 07258717cd9..ab6a3bc83b1 100644
--- a/src/librustc/ty/sty.rs
+++ b/src/librustc/ty/sty.rs
@@ -1813,20 +1813,30 @@ impl<'tcx> TyS<'tcx> {
 
     pub fn simd_type(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self.kind {
-            Adt(def, substs) => {
-                def.non_enum_variant().fields[0].ty(tcx, substs)
-            }
+            Adt(def, substs) => def.non_enum_variant().fields[0].ty(tcx, substs),
             _ => bug!("simd_type called on invalid type")
         }
     }
 
-    pub fn simd_size(&self, _cx: TyCtxt<'_>) -> usize {
+    pub fn simd_size(&self, _tcx: TyCtxt<'tcx>) -> u64 {
+        // Parameter currently unused, but probably needed in the future to
+        // allow `#[repr(simd)] struct Simd<T, const N: usize>([T; N]);`.
         match self.kind {
-            Adt(def, _) => def.non_enum_variant().fields.len(),
+            Adt(def, _) => def.non_enum_variant().fields.len() as u64,
             _ => bug!("simd_size called on invalid type")
         }
     }
 
+    pub fn simd_size_and_type(&self, tcx: TyCtxt<'tcx>) -> (u64, Ty<'tcx>) {
+        match self.kind {
+            Adt(def, substs) => {
+                let variant = def.non_enum_variant();
+                (variant.fields.len() as u64, variant.fields[0].ty(tcx, substs))
+            }
+            _ => bug!("simd_size_and_type called on invalid type")
+        }
+    }
+
     #[inline]
     pub fn is_region_ptr(&self) -> bool {
         match self.kind {
diff --git a/src/librustc_codegen_llvm/asm.rs b/src/librustc_codegen_llvm/asm.rs
index b68ee2cb44d..abdd2e3e8db 100644
--- a/src/librustc_codegen_llvm/asm.rs
+++ b/src/librustc_codegen_llvm/asm.rs
@@ -17,7 +17,7 @@ use libc::{c_uint, c_char};
 impl AsmBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     fn codegen_inline_asm(
         &mut self,
-        ia: &hir::InlineAsm,
+        ia: &hir::InlineAsmInner,
         outputs: Vec<PlaceRef<'tcx, &'ll Value>>,
         mut inputs: Vec<&'ll Value>,
         span: Span,
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
index e1ce7f622e2..4277ce1d1f7 100644
--- a/src/librustc_codegen_llvm/intrinsic.rs
+++ b/src/librustc_codegen_llvm/intrinsic.rs
@@ -1105,8 +1105,8 @@ fn generic_simd_intrinsic(
         let m_len = match in_ty.kind {
             // Note that this `.unwrap()` crashes for isize/usize, that's sort
             // of intentional as there's not currently a use case for that.
-            ty::Int(i) => i.bit_width().unwrap(),
-            ty::Uint(i) => i.bit_width().unwrap(),
+            ty::Int(i) => i.bit_width().unwrap() as u64,
+            ty::Uint(i) => i.bit_width().unwrap() as u64,
             _ => return_error!("`{}` is not an integral type", in_ty),
         };
         require_simd!(arg_tys[1], "argument");
@@ -1116,7 +1116,7 @@ fn generic_simd_intrinsic(
                  m_len, v_len
         );
         let i1 = bx.type_i1();
-        let i1xn = bx.type_vector(i1, m_len as u64);
+        let i1xn = bx.type_vector(i1, m_len);
         let m_i1s = bx.bitcast(args[0].immediate(), i1xn);
         return Ok(bx.select(m_i1s, args[1].immediate(), args[2].immediate()));
     }
@@ -1160,7 +1160,7 @@ fn generic_simd_intrinsic(
     }
 
     if name.starts_with("simd_shuffle") {
-        let n: usize = name["simd_shuffle".len()..].parse().unwrap_or_else(|_|
+        let n: u64 = name["simd_shuffle".len()..].parse().unwrap_or_else(|_|
             span_bug!(span, "bad `simd_shuffle` instruction only caught in codegen?"));
 
         require_simd!(ret_ty, "return");
@@ -1175,7 +1175,7 @@ fn generic_simd_intrinsic(
                  in_elem, in_ty,
                  ret_ty, ret_ty.simd_type(tcx));
 
-        let total_len = in_len as u128 * 2;
+        let total_len = u128::from(in_len) * 2;
 
         let vector = args[2].immediate();
 
@@ -1251,7 +1251,7 @@ fn generic_simd_intrinsic(
         // trailing bits.
         let expected_int_bits = in_len.max(8);
         match ret_ty.kind {
-           ty::Uint(i) if i.bit_width() == Some(expected_int_bits) => (),
+           ty::Uint(i) if i.bit_width() == Some(expected_int_bits as usize) => (),
             _ => return_error!(
                 "bitmask `{}`, expected `u{}`",
                 ret_ty, expected_int_bits
@@ -1276,7 +1276,8 @@ fn generic_simd_intrinsic(
 
         // Shift the MSB to the right by "in_elem_bitwidth - 1" into the first bit position.
         let shift_indices = vec![
-            bx.cx.const_int(bx.type_ix(in_elem_bitwidth as _), (in_elem_bitwidth - 1) as _); in_len
+            bx.cx.const_int(bx.type_ix(in_elem_bitwidth as _), (in_elem_bitwidth - 1) as _);
+            in_len as _
         ];
         let i_xn_msb = bx.lshr(i_xn, bx.const_vector(shift_indices.as_slice()));
         // Truncate vector to an <i1 x N>
@@ -1291,7 +1292,7 @@ fn generic_simd_intrinsic(
         name: &str,
         in_elem: &::rustc::ty::TyS<'_>,
         in_ty: &::rustc::ty::TyS<'_>,
-        in_len: usize,
+        in_len: u64,
         bx: &mut Builder<'a, 'll, 'tcx>,
         span: Span,
         args: &[OperandRef<'tcx, &'ll Value>],
@@ -1400,7 +1401,7 @@ fn generic_simd_intrinsic(
     // FIXME: use:
     //  https://github.com/llvm-mirror/llvm/blob/master/include/llvm/IR/Function.h#L182
     //  https://github.com/llvm-mirror/llvm/blob/master/include/llvm/IR/Intrinsics.h#L81
-    fn llvm_vector_str(elem_ty: Ty<'_>, vec_len: usize, no_pointers: usize) -> String {
+    fn llvm_vector_str(elem_ty: Ty<'_>, vec_len: u64, no_pointers: usize) -> String {
         let p0s: String = "p0".repeat(no_pointers);
         match elem_ty.kind {
             ty::Int(v) => format!("v{}{}i{}", vec_len, p0s, v.bit_width().unwrap()),
@@ -1410,7 +1411,7 @@ fn generic_simd_intrinsic(
         }
     }
 
-    fn llvm_vector_ty(cx: &CodegenCx<'ll, '_>, elem_ty: Ty<'_>, vec_len: usize,
+    fn llvm_vector_ty(cx: &CodegenCx<'ll, '_>, elem_ty: Ty<'_>, vec_len: u64,
                       mut no_pointers: usize) -> &'ll Type {
         // FIXME: use cx.layout_of(ty).llvm_type() ?
         let mut elem_ty = match elem_ty.kind {
@@ -1423,7 +1424,7 @@ fn generic_simd_intrinsic(
             elem_ty = cx.type_ptr_to(elem_ty);
             no_pointers -= 1;
         }
-        cx.type_vector(elem_ty, vec_len as u64)
+        cx.type_vector(elem_ty, vec_len)
     }
 
 
@@ -1506,7 +1507,7 @@ fn generic_simd_intrinsic(
         // Truncate the mask vector to a vector of i1s:
         let (mask, mask_ty) = {
             let i1 = bx.type_i1();
-            let i1xn = bx.type_vector(i1, in_len as u64);
+            let i1xn = bx.type_vector(i1, in_len);
             (bx.trunc(args[2].immediate(), i1xn), i1xn)
         };
 
@@ -1606,7 +1607,7 @@ fn generic_simd_intrinsic(
         // Truncate the mask vector to a vector of i1s:
         let (mask, mask_ty) = {
             let i1 = bx.type_i1();
-            let i1xn = bx.type_vector(i1, in_len as u64);
+            let i1xn = bx.type_vector(i1, in_len);
             (bx.trunc(args[2].immediate(), i1xn), i1xn)
         };
 
diff --git a/src/librustc_codegen_ssa/traits/asm.rs b/src/librustc_codegen_ssa/traits/asm.rs
index c9e1ed86e97..612bce2d958 100644
--- a/src/librustc_codegen_ssa/traits/asm.rs
+++ b/src/librustc_codegen_ssa/traits/asm.rs
@@ -1,13 +1,13 @@
 use super::BackendTypes;
 use crate::mir::place::PlaceRef;
-use rustc::hir::{GlobalAsm, InlineAsm};
+use rustc::hir::{GlobalAsm, InlineAsmInner};
 use syntax_pos::Span;
 
 pub trait AsmBuilderMethods<'tcx>: BackendTypes {
     /// Take an inline assembly expression and splat it out via LLVM
     fn codegen_inline_asm(
         &mut self,
-        ia: &InlineAsm,
+        ia: &InlineAsmInner,
         outputs: Vec<PlaceRef<'tcx, Self::Value>>,
         inputs: Vec<Self::Value>,
         span: Span,
diff --git a/src/librustc_codegen_utils/lib.rs b/src/librustc_codegen_utils/lib.rs
index fb2099e71a3..f2739a3b30c 100644
--- a/src/librustc_codegen_utils/lib.rs
+++ b/src/librustc_codegen_utils/lib.rs
@@ -8,7 +8,7 @@
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(core_intrinsics)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(nll)]
 #![feature(in_band_lifetimes)]
 
diff --git a/src/librustc_error_codes/error_codes/E0725.md b/src/librustc_error_codes/error_codes/E0725.md
index 9bd321e5f82..b96a5e694df 100644
--- a/src/librustc_error_codes/error_codes/E0725.md
+++ b/src/librustc_error_codes/error_codes/E0725.md
@@ -4,8 +4,8 @@ command line flags.
 Erroneous code example:
 
 ```ignore (can't specify compiler flags from doctests)
-#![feature(never_type)] // error: the feature `never_type` is not in
-                        // the list of allowed features
+#![feature(specialization)] // error: the feature `specialization` is not in
+                            // the list of allowed features
 ```
 
 Delete the offending feature attribute, or add it to the list of allowed
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
index 26b288cb4b2..e6795dbfd44 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
@@ -715,10 +715,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         if let (Some(f), Some(ty::RegionKind::ReStatic)) =
             (self.to_error_region(fr), self.to_error_region(outlived_fr))
         {
-            if let Some(ty::TyS {
+            if let Some((ty::TyS {
                 kind: ty::Opaque(did, substs),
                 ..
-            }) = infcx
+            }, _)) = infcx
                 .tcx
                 .is_suitable_region(f)
                 .map(|r| r.def_id)
diff --git a/src/librustc_mir/hair/cx/expr.rs b/src/librustc_mir/hair/cx/expr.rs
index 92c9c702c7a..f25e4b0ae86 100644
--- a/src/librustc_mir/hair/cx/expr.rs
+++ b/src/librustc_mir/hair/cx/expr.rs
@@ -533,11 +533,11 @@ fn make_mirror_unadjusted<'a, 'tcx>(
             convert_path_expr(cx, expr, res)
         }
 
-        hir::ExprKind::InlineAsm(ref asm, ref outputs, ref inputs) => {
+        hir::ExprKind::InlineAsm(ref asm) => {
             ExprKind::InlineAsm {
-                asm,
-                outputs: outputs.to_ref(),
-                inputs: inputs.to_ref(),
+                asm: &asm.inner,
+                outputs: asm.outputs_exprs.to_ref(),
+                inputs: asm.inputs_exprs.to_ref(),
             }
         }
 
diff --git a/src/librustc_mir/hair/mod.rs b/src/librustc_mir/hair/mod.rs
index b43042f2b17..78e3a17d766 100644
--- a/src/librustc_mir/hair/mod.rs
+++ b/src/librustc_mir/hair/mod.rs
@@ -93,6 +93,10 @@ pub enum StmtKind<'tcx> {
     },
 }
 
+// `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
+#[cfg(target_arch = "x86_64")]
+rustc_data_structures::static_assert_size!(Expr<'_>, 168);
+
 /// The Hair trait implementor lowers their expressions (`&'tcx H::Expr`)
 /// into instances of this `Expr` enum. This lowering can be done
 /// basically as lazily or as eagerly as desired: every recursive
@@ -264,7 +268,7 @@ pub enum ExprKind<'tcx> {
         user_ty: Option<Canonical<'tcx, UserType<'tcx>>>,
     },
     InlineAsm {
-        asm: &'tcx hir::InlineAsm,
+        asm: &'tcx hir::InlineAsmInner,
         outputs: Vec<ExprRef<'tcx>>,
         inputs: Vec<ExprRef<'tcx>>
     },
diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs
index 6117cf4038a..23f7b1acb54 100644
--- a/src/librustc_mir/interpret/intrinsics.rs
+++ b/src/librustc_mir/interpret/intrinsics.rs
@@ -302,10 +302,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 self.copy_op_transmute(args[0], dest)?;
             }
             "simd_insert" => {
-                let index = self.read_scalar(args[1])?.to_u32()? as u64;
-                let scalar = args[2];
+                let index = u64::from(self.read_scalar(args[1])?.to_u32()?);
+                let elem = args[2];
                 let input = args[0];
-                let (len, e_ty) = self.read_vector_ty(input);
+                let (len, e_ty) = input.layout.ty.simd_size_and_type(self.tcx.tcx);
                 assert!(
                     index < len,
                     "Index `{}` must be in bounds of vector type `{}`: `[0, {})`",
@@ -317,15 +317,15 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     dest.layout.ty, input.layout.ty
                 );
                 assert_eq!(
-                    scalar.layout.ty, e_ty,
-                    "Scalar type `{}` must match vector element type `{}`",
-                    scalar.layout.ty, e_ty
+                    elem.layout.ty, e_ty,
+                    "Scalar element type `{}` must match vector element type `{}`",
+                    elem.layout.ty, e_ty
                 );
 
                 for i in 0..len {
                     let place = self.place_field(dest, i)?;
                     let value = if i == index {
-                        scalar
+                        elem
                     } else {
                         self.operand_field(input, i)?
                     };
@@ -333,8 +333,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 }
             }
             "simd_extract" => {
-                let index = self.read_scalar(args[1])?.to_u32()? as _;
-                let (len, e_ty) = self.read_vector_ty(args[0]);
+                let index = u64::from(self.read_scalar(args[1])?.to_u32()?);
+                let (len, e_ty) = args[0].layout.ty.simd_size_and_type(self.tcx.tcx);
                 assert!(
                     index < len,
                     "index `{}` is out-of-bounds of vector type `{}` with length `{}`",
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
index cfa70164cdc..62797b31304 100644
--- a/src/librustc_mir/interpret/operand.rs
+++ b/src/librustc_mir/interpret/operand.rs
@@ -316,17 +316,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         }
     }
 
-    /// Read vector length and element type
-    pub fn read_vector_ty(
-        &self, op: OpTy<'tcx, M::PointerTag>
-    ) -> (u64, &rustc::ty::TyS<'tcx>) {
-        if let layout::Abi::Vector { .. } = op.layout.abi {
-            (op.layout.ty.simd_size(*self.tcx) as _, op.layout.ty.simd_type(*self.tcx))
-        } else {
-            bug!("Type `{}` is not a SIMD vector type", op.layout.ty)
-        }
-    }
-
     /// Read a scalar from a place
     pub fn read_scalar(
         &self,
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
index 4f9e404b2c6..50c4a249c63 100644
--- a/src/librustc_mir/interpret/terminator.rs
+++ b/src/librustc_mir/interpret/terminator.rs
@@ -264,6 +264,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
         match instance.def {
             ty::InstanceDef::Intrinsic(..) => {
+                assert!(caller_abi == Abi::RustIntrinsic || caller_abi == Abi::PlatformIntrinsic);
+
                 let old_stack = self.cur_frame();
                 let old_bb = self.frame().block;
                 M::call_intrinsic(self, span, instance, args, dest, ret, unwind)?;
diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs
index 6d19cd63bc3..cbb6408126a 100644
--- a/src/librustc_mir/lib.rs
+++ b/src/librustc_mir/lib.rs
@@ -16,7 +16,7 @@ Rust MIR: a lowered representation of Rust. Also: an experiment!
 #![feature(decl_macro)]
 #![feature(drain_filter)]
 #![feature(exhaustive_patterns)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(specialization)]
 #![feature(try_trait)]
 #![feature(unicode_internals)]
diff --git a/src/librustc_passes/liveness.rs b/src/librustc_passes/liveness.rs
index 6847e45458a..8d7a0388122 100644
--- a/src/librustc_passes/liveness.rs
+++ b/src/librustc_passes/liveness.rs
@@ -1184,17 +1184,21 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
                 self.propagate_through_expr(&e, succ)
             }
 
-            hir::ExprKind::InlineAsm(ref ia, ref outputs, ref inputs) => {
+            hir::ExprKind::InlineAsm(ref asm) => {
+                let ia = &asm.inner;
+                let outputs = &asm.outputs_exprs;
+                let inputs = &asm.inputs_exprs;
                 let succ = ia.outputs.iter().zip(outputs).rev().fold(succ, |succ, (o, output)| {
-                // see comment on places
-                // in propagate_through_place_components()
-                if o.is_indirect {
-                    self.propagate_through_expr(output, succ)
-                } else {
-                    let acc = if o.is_rw { ACC_WRITE|ACC_READ } else { ACC_WRITE };
-                    let succ = self.write_place(output, succ, acc);
-                    self.propagate_through_place_components(output, succ)
-                }});
+                    // see comment on places
+                    // in propagate_through_place_components()
+                    if o.is_indirect {
+                        self.propagate_through_expr(output, succ)
+                    } else {
+                        let acc = if o.is_rw { ACC_WRITE|ACC_READ } else { ACC_WRITE };
+                        let succ = self.write_place(output, succ, acc);
+                        self.propagate_through_place_components(output, succ)
+                    }
+                });
 
                 // Inputs are executed first. Propagate last because of rev order
                 self.propagate_through_exprs(inputs, succ)
@@ -1395,13 +1399,13 @@ fn check_expr<'tcx>(this: &mut Liveness<'_, 'tcx>, expr: &'tcx Expr) {
             }
         }
 
-        hir::ExprKind::InlineAsm(ref ia, ref outputs, ref inputs) => {
-            for input in inputs {
+        hir::ExprKind::InlineAsm(ref asm) => {
+            for input in &asm.inputs_exprs {
                 this.visit_expr(input);
             }
 
             // Output operands must be places
-            for (o, output) in ia.outputs.iter().zip(outputs) {
+            for (o, output) in asm.inner.outputs.iter().zip(&asm.outputs_exprs) {
                 if !o.is_indirect {
                     this.check_place(output);
                 }
diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs
index 0ba56ba5b3a..163412f6a16 100644
--- a/src/librustc_typeck/check/expr.rs
+++ b/src/librustc_typeck/check/expr.rs
@@ -244,8 +244,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             ExprKind::Path(ref qpath) => {
                 self.check_expr_path(qpath, expr)
             }
-            ExprKind::InlineAsm(_, ref outputs, ref inputs) => {
-                for expr in outputs.iter().chain(inputs.iter()) {
+            ExprKind::InlineAsm(ref asm) => {
+                for expr in asm.outputs_exprs.iter().chain(asm.inputs_exprs.iter()) {
                     self.check_expr(expr);
                 }
                 tcx.mk_unit()
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 50c1a74fe91..512a49d13e7 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -3129,9 +3129,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     // Tries to apply a fallback to `ty` if it is an unsolved variable.
-    // Non-numerics get replaced with ! or () (depending on whether
-    // feature(never_type) is enabled, unconstrained ints with i32,
-    // unconstrained floats with f64.
+    //
+    // - Unconstrained ints are replaced with `i32`.
+    //
+    // - Unconstrained floats are replaced with with `f64`.
+    //
+    // - Non-numerics get replaced with `!` when `#![feature(never_type_fallback)]`
+    //   is enabled. Otherwise, they are replaced with `()`.
+    //
     // Fallback becomes very dubious if we have encountered type-checking errors.
     // In that case, fallback to Error.
     // The return value indicates whether fallback has occurred.
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index 9289f3c7ef3..0f147f92b5f 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -66,7 +66,7 @@ This API is completely unstable and subject to change.
 #![feature(in_band_lifetimes)]
 #![feature(nll)]
 #![feature(slice_patterns)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 
 #![recursion_limit="256"]
 
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index bd2a6602e16..ba481655bec 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -697,12 +697,10 @@ themePicker.onblur = handleThemeButtonsBlur;
           static_files::source_serif_pro::ITALIC)?;
     write(cx.dst.join("SourceSerifPro-LICENSE.md"),
           static_files::source_serif_pro::LICENSE)?;
-    write(cx.dst.join("SourceCodePro-Regular.ttf.woff"),
+    write(cx.dst.join("SourceCodePro-Regular.woff"),
           static_files::source_code_pro::REGULAR)?;
-    write(cx.dst.join("SourceCodePro-Semibold.ttf.woff"),
+    write(cx.dst.join("SourceCodePro-Semibold.woff"),
           static_files::source_code_pro::SEMIBOLD)?;
-    write(cx.dst.join("SourceCodePro-It.ttf.woff"),
-          static_files::source_code_pro::ITALIC)?;
     write(cx.dst.join("SourceCodePro-LICENSE.txt"),
           static_files::source_code_pro::LICENSE)?;
     write(cx.dst.join("LICENSE-MIT.txt"),
diff --git a/src/librustdoc/html/static/COPYRIGHT.txt b/src/librustdoc/html/static/COPYRIGHT.txt
index 24bdca6544d..af77776cca4 100644
--- a/src/librustdoc/html/static/COPYRIGHT.txt
+++ b/src/librustdoc/html/static/COPYRIGHT.txt
@@ -23,8 +23,7 @@ included, and carry their own copyright notices and license terms:
     Copyright (c) Nicolas Gallagher and Jonathan Neal.
     Licensed under the MIT license (see LICENSE-MIT.txt).
 
-* Source Code Pro (SourceCodePro-Regular.ttf.woff,
-    SourceCodePro-Semibold.ttf.woff, SourceCodePro-It.ttf.woff):
+* Source Code Pro (SourceCodePro-Regular.woff, SourceCodePro-Semibold.woff):
 
     Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/),
     with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark
diff --git a/src/librustdoc/html/static/SourceCodePro-It.ttf.woff b/src/librustdoc/html/static/SourceCodePro-It.ttf.woff
deleted file mode 100644
index ebaaf91de06..00000000000
--- a/src/librustdoc/html/static/SourceCodePro-It.ttf.woff
+++ /dev/null
Binary files differdiff --git a/src/librustdoc/html/static/SourceCodePro-Regular.ttf.woff b/src/librustdoc/html/static/SourceCodePro-Regular.ttf.woff
deleted file mode 100644
index 117c7e5142c..00000000000
--- a/src/librustdoc/html/static/SourceCodePro-Regular.ttf.woff
+++ /dev/null
Binary files differdiff --git a/src/librustdoc/html/static/SourceCodePro-Regular.woff b/src/librustdoc/html/static/SourceCodePro-Regular.woff
new file mode 100644
index 00000000000..5576670903a
--- /dev/null
+++ b/src/librustdoc/html/static/SourceCodePro-Regular.woff
Binary files differdiff --git a/src/librustdoc/html/static/SourceCodePro-Semibold.ttf.woff b/src/librustdoc/html/static/SourceCodePro-Semibold.ttf.woff
deleted file mode 100644
index 270873a86a0..00000000000
--- a/src/librustdoc/html/static/SourceCodePro-Semibold.ttf.woff
+++ /dev/null
Binary files differdiff --git a/src/librustdoc/html/static/SourceCodePro-Semibold.woff b/src/librustdoc/html/static/SourceCodePro-Semibold.woff
new file mode 100644
index 00000000000..ca972a11dc4
--- /dev/null
+++ b/src/librustdoc/html/static/SourceCodePro-Semibold.woff
Binary files differdiff --git a/src/librustdoc/html/static/rustdoc.css b/src/librustdoc/html/static/rustdoc.css
index b2c48bf089b..ca798931953 100644
--- a/src/librustdoc/html/static/rustdoc.css
+++ b/src/librustdoc/html/static/rustdoc.css
@@ -39,19 +39,13 @@
 	font-weight: 400;
 	/* Avoid using locally installed font because bad versions are in circulation:
 	 * see https://github.com/rust-lang/rust/issues/24355 */
-	src: url("SourceCodePro-Regular.ttf.woff") format('woff');
-}
-@font-face {
-	font-family: 'Source Code Pro';
-	font-style: italic;
-	font-weight: 400;
-	src: url("SourceCodePro-It.ttf.woff") format('woff');
+	src: url("SourceCodePro-Regular.woff") format('woff');
 }
 @font-face {
 	font-family: 'Source Code Pro';
 	font-style: normal;
 	font-weight: 600;
-	src: url("SourceCodePro-Semibold.ttf.woff") format('woff');
+	src: url("SourceCodePro-Semibold.woff") format('woff');
 }
 
 * {
diff --git a/src/librustdoc/html/static_files.rs b/src/librustdoc/html/static_files.rs
index 34055f386fb..9fc1d76185f 100644
--- a/src/librustdoc/html/static_files.rs
+++ b/src/librustdoc/html/static_files.rs
@@ -96,15 +96,11 @@ pub mod source_serif_pro {
 
 /// Files related to the Source Code Pro font.
 pub mod source_code_pro {
-    /// The file `SourceCodePro-Regular.ttf.woff`, the Regular variant of the Source Code Pro font.
-    pub static REGULAR: &'static [u8] = include_bytes!("static/SourceCodePro-Regular.ttf.woff");
+    /// The file `SourceCodePro-Regular.woff`, the Regular variant of the Source Code Pro font.
+    pub static REGULAR: &'static [u8] = include_bytes!("static/SourceCodePro-Regular.woff");
 
-    /// The file `SourceCodePro-Semibold.ttf.woff`, the Semibold variant of the Source Code Pro
-    /// font.
-    pub static SEMIBOLD: &'static [u8] = include_bytes!("static/SourceCodePro-Semibold.ttf.woff");
-
-    /// The file `SourceCodePro-It.ttf.woff`, the Italic variant of the Source Code Pro font.
-    pub static ITALIC: &'static [u8] = include_bytes!("static/SourceCodePro-It.ttf.woff");
+    /// The file `SourceCodePro-Semibold.woff`, the Semibold variant of the Source Code Pro font.
+    pub static SEMIBOLD: &'static [u8] = include_bytes!("static/SourceCodePro-Semibold.woff");
 
     /// The file `SourceCodePro-LICENSE.txt`, the license text of the Source Code Pro font.
     pub static LICENSE: &'static [u8] = include_bytes!("static/SourceCodePro-LICENSE.txt");
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 277475f6fff..6ed2d4b8477 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -14,7 +14,7 @@
 #![feature(crate_visibility_modifier)]
 #![feature(const_fn)]
 #![feature(drain_filter)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(unicode_internals)]
 
 #![recursion_limit="256"]
diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs
index e45d56c320c..13d83337f5f 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -11,7 +11,7 @@ Core encoding and decoding interfaces.
 #![feature(box_syntax)]
 #![feature(core_intrinsics)]
 #![feature(specialization)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(nll)]
 #![feature(associated_type_bounds)]
 #![cfg_attr(test, feature(test))]
diff --git a/src/libstd/error.rs b/src/libstd/error.rs
index d1cb0862d82..74a9e7c9e33 100644
--- a/src/libstd/error.rs
+++ b/src/libstd/error.rs
@@ -465,7 +465,7 @@ impl<'a> From<Cow<'a, str>> for Box<dyn Error> {
     }
 }
 
-#[unstable(feature = "never_type", issue = "35121")]
+#[stable(feature = "never_type", since = "1.41.0")]
 impl Error for ! {
     fn description(&self) -> &str { *self }
 }
@@ -551,13 +551,6 @@ impl Error for string::FromUtf16Error {
     }
 }
 
-#[stable(feature = "str_parse_error2", since = "1.8.0")]
-impl Error for string::ParseError {
-    fn description(&self) -> &str {
-        match *self {}
-    }
-}
-
 #[stable(feature = "decode_utf16", since = "1.9.0")]
 impl Error for char::DecodeUtf16Error {
     fn description(&self) -> &str {
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 32023a5b75b..acf53f7f003 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -280,7 +280,7 @@
 #![feature(maybe_uninit_ref)]
 #![feature(maybe_uninit_slice)]
 #![feature(needs_panic_runtime)]
-#![feature(never_type)]
+#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(nll)]
 #![cfg_attr(bootstrap, feature(on_unimplemented))]
 #![feature(optin_builtin_traits)]
diff --git a/src/libstd/primitive_docs.rs b/src/libstd/primitive_docs.rs
index a72951c0346..b4495588c99 100644
--- a/src/libstd/primitive_docs.rs
+++ b/src/libstd/primitive_docs.rs
@@ -71,7 +71,6 @@ mod prim_bool { }
 /// write:
 ///
 /// ```
-/// #![feature(never_type)]
 /// # fn foo() -> u32 {
 /// let x: ! = {
 ///     return 123
@@ -201,7 +200,6 @@ mod prim_bool { }
 /// for example:
 ///
 /// ```
-/// #![feature(never_type)]
 /// # use std::fmt;
 /// # trait Debug {
 /// # fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result;
@@ -239,7 +237,7 @@ mod prim_bool { }
 /// [`Default`]: default/trait.Default.html
 /// [`default()`]: default/trait.Default.html#tymethod.default
 ///
-#[unstable(feature = "never_type", issue = "35121")]
+#[stable(feature = "never_type", since = "1.41.0")]
 mod prim_never { }
 
 #[doc(primitive = "char")]
diff --git a/src/libsyntax/feature_gate/accepted.rs b/src/libsyntax/feature_gate/accepted.rs
index 0107611460b..dab83f48a03 100644
--- a/src/libsyntax/feature_gate/accepted.rs
+++ b/src/libsyntax/feature_gate/accepted.rs
@@ -253,6 +253,8 @@ declare_features! (
     (accepted, const_constructor, "1.40.0", Some(61456), None),
     /// Allows the use of `#[cfg(doctest)]`, set when rustdoc is collecting doctests.
     (accepted, cfg_doctest, "1.40.0", Some(62210), None),
+    /// Allows the `!` type. Does not imply 'exhaustive_patterns' any more.
+    (accepted, never_type, "1.41.0", Some(35121), None),
     /// Allows relaxing the coherence rules such that
     /// `impl<T> ForeignTrait<LocalType> for ForeignType<T>` is permitted.
     (accepted, re_rebalance_coherence, "1.41.0", Some(55437), None),
diff --git a/src/libsyntax/feature_gate/active.rs b/src/libsyntax/feature_gate/active.rs
index 2819ee273d9..bd029514a95 100644
--- a/src/libsyntax/feature_gate/active.rs
+++ b/src/libsyntax/feature_gate/active.rs
@@ -318,9 +318,6 @@ declare_features! (
     /// Allows `X..Y` patterns.
     (active, exclusive_range_pattern, "1.11.0", Some(37854), None),
 
-    /// Allows the `!` type. Does not imply 'exhaustive_patterns' (below) any more.
-    (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", Some(51085), None),
 
@@ -523,6 +520,9 @@ declare_features! (
     /// Allows using the `efiapi` ABI.
     (active, abi_efiapi, "1.40.0", Some(65815), None),
 
+    /// Allows diverging expressions to fall back to `!` rather than `()`.
+    (active, never_type_fallback, "1.41.0", Some(65992), None),
+
     /// Allows using the `#[register_attr]` attribute.
     (active, register_attr, "1.41.0", Some(66080), None),
 
diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs
index abf9adefd3c..f966850254f 100644
--- a/src/libsyntax/feature_gate/check.rs
+++ b/src/libsyntax/feature_gate/check.rs
@@ -521,25 +521,11 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::TyKind::BareFn(ref bare_fn_ty) => {
                 self.check_extern(bare_fn_ty.ext);
             }
-            ast::TyKind::Never => {
-                gate_feature_post!(&self, never_type, ty.span,
-                                   "The `!` type is experimental");
-            }
             _ => {}
         }
         visit::walk_ty(self, ty)
     }
 
-    fn visit_fn_ret_ty(&mut self, ret_ty: &'a ast::FunctionRetTy) {
-        if let ast::FunctionRetTy::Ty(ref output_ty) = *ret_ty {
-            if let ast::TyKind::Never = output_ty.kind {
-                // Do nothing.
-            } else {
-                self.visit_ty(output_ty)
-            }
-        }
-    }
-
     fn visit_expr(&mut self, e: &'a ast::Expr) {
         match e.kind {
             ast::ExprKind::Box(_) => {
@@ -567,10 +553,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         visit::walk_expr(self, e)
     }
 
-    fn visit_arm(&mut self, arm: &'a ast::Arm) {
-        visit::walk_arm(self, arm)
-    }
-
     fn visit_pat(&mut self, pattern: &'a ast::Pat) {
         match &pattern.kind {
             PatKind::Slice(pats) => {
diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs
index 1139bf67a36..979074f17c7 100644
--- a/src/libsyntax_pos/symbol.rs
+++ b/src/libsyntax_pos/symbol.rs
@@ -444,6 +444,7 @@ symbols! {
         negate_unsigned,
         never,
         never_type,
+        never_type_fallback,
         new,
         next,
         __next,
diff --git a/src/test/codegen/enum-debug-niche-2.rs b/src/test/codegen/enum-debug-niche-2.rs
index 0f17976ef49..7e00dc5463f 100644
--- a/src/test/codegen/enum-debug-niche-2.rs
+++ b/src/test/codegen/enum-debug-niche-2.rs
@@ -12,8 +12,6 @@
 // CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Placeholder",{{.*}}extraData: i64 4294967295{{[,)].*}}
 // CHECK: {{.*}}DIDerivedType{{.*}}tag: DW_TAG_member,{{.*}}name: "Error",{{.*}}extraData: i64 0{{[,)].*}}
 
-#![feature(never_type)]
-
 #[derive(Copy, Clone)]
 pub struct Entity {
     private: std::num::NonZeroU32,
diff --git a/src/test/mir-opt/uninhabited-enum.rs b/src/test/mir-opt/uninhabited-enum.rs
index 904a9c43c1b..409be8587cf 100644
--- a/src/test/mir-opt/uninhabited-enum.rs
+++ b/src/test/mir-opt/uninhabited-enum.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 pub enum Void {}
 
 #[no_mangle]
diff --git a/src/test/ui/async-await/issues/issue-62097.nll.stderr b/src/test/ui/async-await/issues/issue-62097.nll.stderr
new file mode 100644
index 00000000000..0c64f90cb9f
--- /dev/null
+++ b/src/test/ui/async-await/issues/issue-62097.nll.stderr
@@ -0,0 +1,29 @@
+error[E0373]: closure may outlive the current function, but it borrows `self`, which is owned by the current function
+  --> $DIR/issue-62097.rs:13:13
+   |
+LL |         foo(|| self.bar()).await;
+   |             ^^ ---- `self` is borrowed here
+   |             |
+   |             may outlive borrowed value `self`
+   |
+note: function requires argument type to outlive `'static`
+  --> $DIR/issue-62097.rs:13:9
+   |
+LL |         foo(|| self.bar()).await;
+   |         ^^^^^^^^^^^^^^^^^^
+help: to force the closure to take ownership of `self` (and any other referenced variables), use the `move` keyword
+   |
+LL |         foo(move || self.bar()).await;
+   |             ^^^^^^^
+
+error[E0521]: borrowed data escapes outside of function
+  --> $DIR/issue-62097.rs:13:9
+   |
+LL |     pub async fn run_dummy_fn(&self) {
+   |                               ----- `self` is a reference that is only valid in the function body
+LL |         foo(|| self.bar()).await;
+   |         ^^^^^^^^^^^^^^^^^^ `self` escapes the function body here
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0373`.
diff --git a/src/test/ui/async-await/issues/issue-62097.rs b/src/test/ui/async-await/issues/issue-62097.rs
new file mode 100644
index 00000000000..ea482d3667e
--- /dev/null
+++ b/src/test/ui/async-await/issues/issue-62097.rs
@@ -0,0 +1,19 @@
+// edition:2018
+async fn foo<F>(fun: F)
+where
+    F: FnOnce() + 'static
+{
+    fun()
+}
+
+struct Struct;
+
+impl Struct {
+    pub async fn run_dummy_fn(&self) { //~ ERROR cannot infer
+        foo(|| self.bar()).await;
+    }
+
+    pub fn bar(&self) {}
+}
+
+fn main() {}
diff --git a/src/test/ui/async-await/issues/issue-62097.stderr b/src/test/ui/async-await/issues/issue-62097.stderr
new file mode 100644
index 00000000000..94afccc06a9
--- /dev/null
+++ b/src/test/ui/async-await/issues/issue-62097.stderr
@@ -0,0 +1,16 @@
+error: cannot infer an appropriate lifetime
+  --> $DIR/issue-62097.rs:12:31
+   |
+LL |     pub async fn run_dummy_fn(&self) {
+   |                               ^^^^^ ...but this borrow...
+LL |         foo(|| self.bar()).await;
+   |         --- this return type evaluates to the `'static` lifetime...
+   |
+note: ...can't outlive the lifetime `'_` as defined on the method body at 12:31
+  --> $DIR/issue-62097.rs:12:31
+   |
+LL |     pub async fn run_dummy_fn(&self) {
+   |                               ^
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/async-await/issues/issue-63388-2.stderr b/src/test/ui/async-await/issues/issue-63388-2.stderr
index efec160588f..7e45d588c6c 100644
--- a/src/test/ui/async-await/issues/issue-63388-2.stderr
+++ b/src/test/ui/async-await/issues/issue-63388-2.stderr
@@ -20,10 +20,6 @@ note: ...can't outlive the lifetime `'_` as defined on the method body at 11:14
    |
 LL |         foo: &dyn Foo, bar: &'a dyn Foo
    |              ^
-help: you can add a constraint to the return type to make it last less than `'static` and match the lifetime `'_` as defined on the method body at 11:14
-   |
-LL |         foo + '_
-   |
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/binding/empty-types-in-patterns.rs b/src/test/ui/binding/empty-types-in-patterns.rs
index 2b8b1b29df8..1864d4bb820 100644
--- a/src/test/ui/binding/empty-types-in-patterns.rs
+++ b/src/test/ui/binding/empty-types-in-patterns.rs
@@ -1,5 +1,5 @@
 // run-pass
-#![feature(never_type)]
+#![feature(never_type_fallback)]
 #![feature(exhaustive_patterns)]
 #![feature(slice_patterns)]
 #![allow(unreachable_patterns)]
diff --git a/src/test/ui/borrowck/assign-never-type.rs b/src/test/ui/borrowck/assign-never-type.rs
index 4f30ea14670..52b2e70d159 100644
--- a/src/test/ui/borrowck/assign-never-type.rs
+++ b/src/test/ui/borrowck/assign-never-type.rs
@@ -2,8 +2,6 @@
 
 // check-pass
 
-#![feature(never_type)]
-
 pub fn main() {
     loop {
         match None {
diff --git a/src/test/ui/break-while-condition.rs b/src/test/ui/break-while-condition.rs
index 6064e6ab002..7aa5682b923 100644
--- a/src/test/ui/break-while-condition.rs
+++ b/src/test/ui/break-while-condition.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 fn main() {
     // The `if false` expressions are simply to
     // make sure we don't avoid checking everything
diff --git a/src/test/ui/break-while-condition.stderr b/src/test/ui/break-while-condition.stderr
index a08edee07ea..bae3b6765e2 100644
--- a/src/test/ui/break-while-condition.stderr
+++ b/src/test/ui/break-while-condition.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/break-while-condition.rs:9:20
+  --> $DIR/break-while-condition.rs:7:20
    |
 LL |           let _: ! = {
    |  ____________________^
@@ -11,7 +11,7 @@ LL | |         };
               found type `()`
 
 error[E0308]: mismatched types
-  --> $DIR/break-while-condition.rs:16:13
+  --> $DIR/break-while-condition.rs:14:13
    |
 LL | /             while false {
 LL | |                 break
@@ -22,7 +22,7 @@ LL | |             }
               found type `()`
 
 error[E0308]: mismatched types
-  --> $DIR/break-while-condition.rs:24:13
+  --> $DIR/break-while-condition.rs:22:13
    |
 LL | /             while false {
 LL | |                 return
diff --git a/src/test/ui/coercion/coerce-issue-49593-box-never.rs b/src/test/ui/coercion/coerce-issue-49593-box-never.rs
index 5038eb3ebf4..55beb7c2528 100644
--- a/src/test/ui/coercion/coerce-issue-49593-box-never.rs
+++ b/src/test/ui/coercion/coerce-issue-49593-box-never.rs
@@ -1,6 +1,5 @@
 // check-pass
-
-#![feature(never_type)]
+#![feature(never_type_fallback)]
 #![allow(unreachable_code)]
 
 use std::error::Error;
diff --git a/src/test/ui/coercion/coerce-to-bang-cast.rs b/src/test/ui/coercion/coerce-to-bang-cast.rs
index 8ef19480846..ea1384a1dab 100644
--- a/src/test/ui/coercion/coerce-to-bang-cast.rs
+++ b/src/test/ui/coercion/coerce-to-bang-cast.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 fn foo(x: usize, y: !, z: usize) { }
 
 fn cast_a() {
diff --git a/src/test/ui/coercion/coerce-to-bang-cast.stderr b/src/test/ui/coercion/coerce-to-bang-cast.stderr
index ff30ebc09c6..0e17f32511f 100644
--- a/src/test/ui/coercion/coerce-to-bang-cast.stderr
+++ b/src/test/ui/coercion/coerce-to-bang-cast.stderr
@@ -1,5 +1,5 @@
 error[E0605]: non-primitive cast: `i32` as `!`
-  --> $DIR/coerce-to-bang-cast.rs:6:13
+  --> $DIR/coerce-to-bang-cast.rs:4:13
    |
 LL |     let y = {return; 22} as !;
    |             ^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     let y = {return; 22} as !;
    = note: an `as` expression can only be used to convert between primitive types. Consider using the `From` trait
 
 error[E0605]: non-primitive cast: `i32` as `!`
-  --> $DIR/coerce-to-bang-cast.rs:11:13
+  --> $DIR/coerce-to-bang-cast.rs:9:13
    |
 LL |     let y = 22 as !;
    |             ^^^^^^^
diff --git a/src/test/ui/coercion/coerce-to-bang.rs b/src/test/ui/coercion/coerce-to-bang.rs
index 1e06934d09f..d52f79fbb7a 100644
--- a/src/test/ui/coercion/coerce-to-bang.rs
+++ b/src/test/ui/coercion/coerce-to-bang.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 fn foo(x: usize, y: !, z: usize) { }
 
 fn call_foo_a() {
diff --git a/src/test/ui/coercion/coerce-to-bang.stderr b/src/test/ui/coercion/coerce-to-bang.stderr
index a46e97da815..b6fd5bf43ab 100644
--- a/src/test/ui/coercion/coerce-to-bang.stderr
+++ b/src/test/ui/coercion/coerce-to-bang.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:6:17
+  --> $DIR/coerce-to-bang.rs:4:17
    |
 LL |     foo(return, 22, 44);
    |                 ^^ expected !, found integer
@@ -8,7 +8,7 @@ LL |     foo(return, 22, 44);
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:18:13
+  --> $DIR/coerce-to-bang.rs:16:13
    |
 LL |     foo(22, 44, return);
    |             ^^ expected !, found integer
@@ -17,7 +17,7 @@ LL |     foo(22, 44, return);
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:26:12
+  --> $DIR/coerce-to-bang.rs:24:12
    |
 LL |     foo(a, b, c); // ... and hence a reference to `a` is expected to diverge.
    |            ^ expected !, found integer
@@ -26,7 +26,7 @@ LL |     foo(a, b, c); // ... and hence a reference to `a` is expected to diverg
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:36:12
+  --> $DIR/coerce-to-bang.rs:34:12
    |
 LL |     foo(a, b, c);
    |            ^ expected !, found integer
@@ -35,7 +35,7 @@ LL |     foo(a, b, c);
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:45:12
+  --> $DIR/coerce-to-bang.rs:43:12
    |
 LL |     foo(a, b, c);
    |            ^ expected !, found integer
@@ -44,7 +44,7 @@ LL |     foo(a, b, c);
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:50:21
+  --> $DIR/coerce-to-bang.rs:48:21
    |
 LL |     let x: [!; 2] = [return, 22];
    |                     ^^^^^^^^^^^^ expected !, found integer
@@ -53,7 +53,7 @@ LL |     let x: [!; 2] = [return, 22];
               found type `[{integer}; 2]`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:55:22
+  --> $DIR/coerce-to-bang.rs:53:22
    |
 LL |     let x: [!; 2] = [22, return];
    |                      ^^ expected !, found integer
@@ -62,7 +62,7 @@ LL |     let x: [!; 2] = [22, return];
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:60:37
+  --> $DIR/coerce-to-bang.rs:58:37
    |
 LL |     let x: (usize, !, usize) = (22, 44, 66);
    |                                     ^^ expected !, found integer
@@ -71,7 +71,7 @@ LL |     let x: (usize, !, usize) = (22, 44, 66);
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:65:41
+  --> $DIR/coerce-to-bang.rs:63:41
    |
 LL |     let x: (usize, !, usize) = (return, 44, 66);
    |                                         ^^ expected !, found integer
@@ -80,7 +80,7 @@ LL |     let x: (usize, !, usize) = (return, 44, 66);
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/coerce-to-bang.rs:76:37
+  --> $DIR/coerce-to-bang.rs:74:37
    |
 LL |     let x: (usize, !, usize) = (22, 44, return);
    |                                     ^^ expected !, found integer
diff --git a/src/test/ui/consts/validate_never_arrays.rs b/src/test/ui/consts/validate_never_arrays.rs
index 9610b7b22f1..1270dc4ee30 100644
--- a/src/test/ui/consts/validate_never_arrays.rs
+++ b/src/test/ui/consts/validate_never_arrays.rs
@@ -1,4 +1,4 @@
-#![feature(const_raw_ptr_deref, never_type)]
+#![feature(const_raw_ptr_deref)]
 
 const FOO: &[!; 1] = unsafe { &*(1_usize as *const [!; 1]) }; //~ ERROR undefined behavior
 
diff --git a/src/test/ui/empty/empty-never-array.rs b/src/test/ui/empty/empty-never-array.rs
index f0ecea42f39..38702f8d28f 100644
--- a/src/test/ui/empty/empty-never-array.rs
+++ b/src/test/ui/empty/empty-never-array.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 enum Helper<T, U> {
     T(T, [!; 0]),
     #[allow(dead_code)]
diff --git a/src/test/ui/empty/empty-never-array.stderr b/src/test/ui/empty/empty-never-array.stderr
index d865b59f0b9..defcd256f7d 100644
--- a/src/test/ui/empty/empty-never-array.stderr
+++ b/src/test/ui/empty/empty-never-array.stderr
@@ -1,5 +1,5 @@
 error[E0005]: refutable pattern in local binding: `T(_, _)` not covered
-  --> $DIR/empty-never-array.rs:10:9
+  --> $DIR/empty-never-array.rs:8:9
    |
 LL | / enum Helper<T, U> {
 LL | |     T(T, [!; 0]),
@@ -20,7 +20,7 @@ LL |     if let Helper::U(u) = Helper::T(t, []) { /* */ }
    |
 
 error[E0381]: use of possibly-uninitialized variable: `u`
-  --> $DIR/empty-never-array.rs:12:5
+  --> $DIR/empty-never-array.rs:10:5
    |
 LL |     u
    |     ^ use of possibly-uninitialized `u`
diff --git a/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.rs b/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.rs
index f0cc9ea7055..c27089d2a05 100644
--- a/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.rs
+++ b/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 fn foo() -> Result<u32, !> {
     Ok(123)
 }
diff --git a/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr b/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr
index 08c36cece4c..e599a9ee150 100644
--- a/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr
+++ b/src/test/ui/feature-gates/feature-gate-exhaustive-patterns.stderr
@@ -1,5 +1,5 @@
 error[E0005]: refutable pattern in local binding: `Err(_)` not covered
-  --> $DIR/feature-gate-exhaustive-patterns.rs:8:9
+  --> $DIR/feature-gate-exhaustive-patterns.rs:6:9
    |
 LL |     let Ok(_x) = foo();
    |         ^^^^^^ pattern `Err(_)` not covered
diff --git a/src/test/ui/feature-gates/feature-gate-never_type.rs b/src/test/ui/feature-gates/feature-gate-never_type.rs
deleted file mode 100644
index be8c27dbb1b..00000000000
--- a/src/test/ui/feature-gates/feature-gate-never_type.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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 = &'static fn(!) -> !; //~ ERROR type is experimental
-type Skwoz = &'static mut !; //~ ERROR type is experimental
-
-impl Foo for Meeshka {
-    type Wub = !; //~ ERROR type is experimental
-}
-
-fn main() {
-}
diff --git a/src/test/ui/feature-gates/feature-gate-never_type.stderr b/src/test/ui/feature-gates/feature-gate-never_type.stderr
deleted file mode 100644
index d86ab99b82b..00000000000
--- a/src/test/ui/feature-gates/feature-gate-never_type.stderr
+++ /dev/null
@@ -1,48 +0,0 @@
-error[E0658]: The `!` type is experimental
-  --> $DIR/feature-gate-never_type.rs:7:17
-   |
-LL | type Ma = (u32, !, i32);
-   |                 ^
-   |
-   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
-   = help: add `#![feature(never_type)]` to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental
-  --> $DIR/feature-gate-never_type.rs:8:20
-   |
-LL | type Meeshka = Vec<!>;
-   |                    ^
-   |
-   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
-   = help: add `#![feature(never_type)]` to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental
-  --> $DIR/feature-gate-never_type.rs:9:24
-   |
-LL | type Mow = &'static fn(!) -> !;
-   |                        ^
-   |
-   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
-   = help: add `#![feature(never_type)]` to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental
-  --> $DIR/feature-gate-never_type.rs:10:27
-   |
-LL | type Skwoz = &'static mut !;
-   |                           ^
-   |
-   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
-   = help: add `#![feature(never_type)]` to the crate attributes to enable
-
-error[E0658]: The `!` type is experimental
-  --> $DIR/feature-gate-never_type.rs:13:16
-   |
-LL |     type Wub = !;
-   |                ^
-   |
-   = note: for more information, see https://github.com/rust-lang/rust/issues/35121
-   = 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/for-loop-while/loop-break-value.rs b/src/test/ui/for-loop-while/loop-break-value.rs
index d7209fc4de8..29848bb0ced 100644
--- a/src/test/ui/for-loop-while/loop-break-value.rs
+++ b/src/test/ui/for-loop-while/loop-break-value.rs
@@ -1,7 +1,6 @@
 // run-pass
 
 #![allow(unreachable_code)]
-#![feature(never_type)]
 
 #[allow(unused)]
 fn never_returns() {
diff --git a/src/test/ui/lint/must_use-unit.rs b/src/test/ui/lint/must_use-unit.rs
index 4dd4798abb7..8f59bab26d3 100644
--- a/src/test/ui/lint/must_use-unit.rs
+++ b/src/test/ui/lint/must_use-unit.rs
@@ -1,4 +1,3 @@
-#![feature(never_type)]
 #![deny(unused_must_use)]
 
 #[must_use]
diff --git a/src/test/ui/lint/must_use-unit.stderr b/src/test/ui/lint/must_use-unit.stderr
index 0a9939b2015..a6d0259a081 100644
--- a/src/test/ui/lint/must_use-unit.stderr
+++ b/src/test/ui/lint/must_use-unit.stderr
@@ -1,17 +1,17 @@
 error: unused return value of `foo` that must be used
-  --> $DIR/must_use-unit.rs:13:5
+  --> $DIR/must_use-unit.rs:12:5
    |
 LL |     foo();
    |     ^^^^^^
    |
 note: lint level defined here
-  --> $DIR/must_use-unit.rs:2:9
+  --> $DIR/must_use-unit.rs:1:9
    |
 LL | #![deny(unused_must_use)]
    |         ^^^^^^^^^^^^^^^
 
 error: unused return value of `bar` that must be used
-  --> $DIR/must_use-unit.rs:15:5
+  --> $DIR/must_use-unit.rs:14:5
    |
 LL |     bar();
    |     ^^^^^^
diff --git a/src/test/ui/lint/uninitialized-zeroed.rs b/src/test/ui/lint/uninitialized-zeroed.rs
index 473be434a75..ed2369fd650 100644
--- a/src/test/ui/lint/uninitialized-zeroed.rs
+++ b/src/test/ui/lint/uninitialized-zeroed.rs
@@ -2,7 +2,7 @@
 // This test checks that calling `mem::{uninitialized,zeroed}` with certain types results
 // in a lint.
 
-#![feature(never_type, rustc_attrs)]
+#![feature(rustc_attrs)]
 #![allow(deprecated)]
 #![deny(invalid_value)]
 
diff --git a/src/test/ui/loops/loop-break-value.rs b/src/test/ui/loops/loop-break-value.rs
index 7c2f63ec51a..8d88aefdb51 100644
--- a/src/test/ui/loops/loop-break-value.rs
+++ b/src/test/ui/loops/loop-break-value.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 fn main() {
     let val: ! = loop { break break; };
     //~^ ERROR mismatched types
diff --git a/src/test/ui/loops/loop-break-value.stderr b/src/test/ui/loops/loop-break-value.stderr
index b2e3ebc53ad..8c4bcd3a9b7 100644
--- a/src/test/ui/loops/loop-break-value.stderr
+++ b/src/test/ui/loops/loop-break-value.stderr
@@ -1,5 +1,5 @@
 warning: denote infinite loops with `loop { ... }`
-  --> $DIR/loop-break-value.rs:26:5
+  --> $DIR/loop-break-value.rs:24:5
    |
 LL |     'while_loop: while true {
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: use `loop`
@@ -7,7 +7,7 @@ LL |     'while_loop: while true {
    = note: `#[warn(while_true)]` on by default
 
 error[E0571]: `break` with value from a `while` loop
-  --> $DIR/loop-break-value.rs:28:9
+  --> $DIR/loop-break-value.rs:26:9
    |
 LL |         break ();
    |         ^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -18,7 +18,7 @@ LL |         break;
    |         ^^^^^
 
 error[E0571]: `break` with value from a `while` loop
-  --> $DIR/loop-break-value.rs:30:13
+  --> $DIR/loop-break-value.rs:28:13
    |
 LL |             break 'while_loop 123;
    |             ^^^^^^^^^^^^^^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -29,7 +29,7 @@ LL |             break;
    |             ^^^^^
 
 error[E0571]: `break` with value from a `while let` loop
-  --> $DIR/loop-break-value.rs:38:12
+  --> $DIR/loop-break-value.rs:36:12
    |
 LL |         if break () {
    |            ^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -40,7 +40,7 @@ LL |         if break {
    |            ^^^^^
 
 error[E0571]: `break` with value from a `while let` loop
-  --> $DIR/loop-break-value.rs:43:9
+  --> $DIR/loop-break-value.rs:41:9
    |
 LL |         break None;
    |         ^^^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -51,7 +51,7 @@ LL |         break;
    |         ^^^^^
 
 error[E0571]: `break` with value from a `while let` loop
-  --> $DIR/loop-break-value.rs:49:13
+  --> $DIR/loop-break-value.rs:47:13
    |
 LL |             break 'while_let_loop "nope";
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -62,7 +62,7 @@ LL |             break;
    |             ^^^^^
 
 error[E0571]: `break` with value from a `for` loop
-  --> $DIR/loop-break-value.rs:56:9
+  --> $DIR/loop-break-value.rs:54:9
    |
 LL |         break ();
    |         ^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -73,7 +73,7 @@ LL |         break;
    |         ^^^^^
 
 error[E0571]: `break` with value from a `for` loop
-  --> $DIR/loop-break-value.rs:57:9
+  --> $DIR/loop-break-value.rs:55:9
    |
 LL |         break [()];
    |         ^^^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -84,7 +84,7 @@ LL |         break;
    |         ^^^^^
 
 error[E0571]: `break` with value from a `for` loop
-  --> $DIR/loop-break-value.rs:64:13
+  --> $DIR/loop-break-value.rs:62:13
    |
 LL |             break 'for_loop Some(17);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ can only break with a value inside `loop` or breakable block
@@ -95,7 +95,7 @@ LL |             break;
    |             ^^^^^
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:4:31
+  --> $DIR/loop-break-value.rs:2:31
    |
 LL |     let val: ! = loop { break break; };
    |                               ^^^^^ expected !, found ()
@@ -104,7 +104,7 @@ LL |     let val: ! = loop { break break; };
               found type `()`
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:11:19
+  --> $DIR/loop-break-value.rs:9:19
    |
 LL |             break 123;
    |                   ^^^ expected &str, found integer
@@ -113,7 +113,7 @@ LL |             break 123;
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:16:15
+  --> $DIR/loop-break-value.rs:14:15
    |
 LL |         break "asdf";
    |               ^^^^^^ expected i32, found reference
@@ -122,7 +122,7 @@ LL |         break "asdf";
               found type `&'static str`
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:21:31
+  --> $DIR/loop-break-value.rs:19:31
    |
 LL |             break 'outer_loop "nope";
    |                               ^^^^^^ expected i32, found reference
@@ -131,7 +131,7 @@ LL |             break 'outer_loop "nope";
               found type `&'static str`
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:73:26
+  --> $DIR/loop-break-value.rs:71:26
    |
 LL |                 break 'c 123;
    |                          ^^^ expected (), found integer
@@ -140,7 +140,7 @@ LL |                 break 'c 123;
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:80:15
+  --> $DIR/loop-break-value.rs:78:15
    |
 LL |         break (break, break);
    |               ^^^^^^^^^^^^^^ expected (), found tuple
@@ -149,7 +149,7 @@ LL |         break (break, break);
               found type `(!, !)`
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:85:15
+  --> $DIR/loop-break-value.rs:83:15
    |
 LL |         break 2;
    |               ^ expected (), found integer
@@ -158,7 +158,7 @@ LL |         break 2;
               found type `{integer}`
 
 error[E0308]: mismatched types
-  --> $DIR/loop-break-value.rs:90:9
+  --> $DIR/loop-break-value.rs:88:9
    |
 LL |         break;
    |         ^^^^^
diff --git a/src/test/ui/mir/mir_calls_to_shims.rs b/src/test/ui/mir/mir_calls_to_shims.rs
index 6f13d5612ce..df7c45ad1d1 100644
--- a/src/test/ui/mir/mir_calls_to_shims.rs
+++ b/src/test/ui/mir/mir_calls_to_shims.rs
@@ -2,7 +2,6 @@
 // ignore-wasm32-bare compiled with panic=abort by default
 
 #![feature(fn_traits)]
-#![feature(never_type)]
 
 use std::panic;
 
diff --git a/src/test/ui/never_type/adjust_never.rs b/src/test/ui/never_type/adjust_never.rs
index 0d7d2c0ed3f..e4d15c8a17d 100644
--- a/src/test/ui/never_type/adjust_never.rs
+++ b/src/test/ui/never_type/adjust_never.rs
@@ -2,8 +2,6 @@
 
 // check-pass
 
-#![feature(never_type)]
-
 fn main() {
     let x: ! = panic!();
     let y: u32 = x;
diff --git a/src/test/ui/never_type/auto-traits.rs b/src/test/ui/never_type/auto-traits.rs
new file mode 100644
index 00000000000..8a02720ab27
--- /dev/null
+++ b/src/test/ui/never_type/auto-traits.rs
@@ -0,0 +1,16 @@
+// check-pass
+
+#![feature(optin_builtin_traits)]
+
+fn main() {
+    enum Void {}
+
+    auto trait Auto {}
+    fn assert_auto<T: Auto>() {}
+    assert_auto::<Void>();
+    assert_auto::<!>();
+
+    fn assert_send<T: Send>() {}
+    assert_send::<Void>();
+    assert_send::<!>();
+}
diff --git a/src/test/ui/never_type/call-fn-never-arg-wrong-type.rs b/src/test/ui/never_type/call-fn-never-arg-wrong-type.rs
index d06637e74a2..a2b44e91f11 100644
--- a/src/test/ui/never_type/call-fn-never-arg-wrong-type.rs
+++ b/src/test/ui/never_type/call-fn-never-arg-wrong-type.rs
@@ -1,7 +1,5 @@
 // Test that we can't pass other types for !
 
-#![feature(never_type)]
-
 fn foo(x: !) -> ! {
     x
 }
diff --git a/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr b/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr
index 7a50fd367d2..e5cbdcbe73b 100644
--- a/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr
+++ b/src/test/ui/never_type/call-fn-never-arg-wrong-type.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/call-fn-never-arg-wrong-type.rs:10:9
+  --> $DIR/call-fn-never-arg-wrong-type.rs:8:9
    |
 LL |     foo("wow");
    |         ^^^^^ expected !, found reference
diff --git a/src/test/ui/never_type/call-fn-never-arg.rs b/src/test/ui/never_type/call-fn-never-arg.rs
index 9d355817ee8..55a7b79157a 100644
--- a/src/test/ui/never_type/call-fn-never-arg.rs
+++ b/src/test/ui/never_type/call-fn-never-arg.rs
@@ -2,7 +2,6 @@
 
 // check-pass
 
-#![feature(never_type)]
 #![allow(unreachable_code)]
 
 fn foo(x: !) -> ! {
diff --git a/src/test/ui/never_type/cast-never.rs b/src/test/ui/never_type/cast-never.rs
index 0139ebe4640..fbba114ab32 100644
--- a/src/test/ui/never_type/cast-never.rs
+++ b/src/test/ui/never_type/cast-never.rs
@@ -2,8 +2,6 @@
 
 // check-pass
 
-#![feature(never_type)]
-
 fn main() {
     let x: ! = panic!();
     let y: u32 = x as u32;
diff --git a/src/test/ui/never_type/defaulted-never-note.rs b/src/test/ui/never_type/defaulted-never-note.rs
index d3fb8a09414..c58b6117484 100644
--- a/src/test/ui/never_type/defaulted-never-note.rs
+++ b/src/test/ui/never_type/defaulted-never-note.rs
@@ -1,6 +1,6 @@
-// We need to opt into the `!` feature in order to trigger the
-// requirement that this is testing.
-#![feature(never_type)]
+// We need to opt into the `never_type_fallback` feature
+// to trigger the requirement that this is testing.
+#![feature(never_type_fallback)]
 
 #![allow(unused)]
 
diff --git a/src/test/ui/never_type/dispatch_from_dyn_zst.rs b/src/test/ui/never_type/dispatch_from_dyn_zst.rs
index 764f58ce9e8..342d5e47915 100644
--- a/src/test/ui/never_type/dispatch_from_dyn_zst.rs
+++ b/src/test/ui/never_type/dispatch_from_dyn_zst.rs
@@ -1,6 +1,6 @@
 // run-pass
 
-#![feature(unsize, dispatch_from_dyn, never_type)]
+#![feature(unsize, dispatch_from_dyn)]
 
 #![allow(dead_code)]
 
diff --git a/src/test/ui/never_type/diverging-fallback-control-flow.rs b/src/test/ui/never_type/diverging-fallback-control-flow.rs
index c68e6364ed4..df04437b1ae 100644
--- a/src/test/ui/never_type/diverging-fallback-control-flow.rs
+++ b/src/test/ui/never_type/diverging-fallback-control-flow.rs
@@ -11,7 +11,7 @@
 // These represent current behavior, but are pretty dubious.  I would
 // like to revisit these and potentially change them. --nmatsakis
 
-#![feature(never_type)]
+#![feature(never_type_fallback)]
 
 trait BadDefault {
     fn default() -> Self;
diff --git a/src/test/ui/never_type/feature-gate-never_type_fallback.rs b/src/test/ui/never_type/feature-gate-never_type_fallback.rs
new file mode 100644
index 00000000000..3b896ec9d70
--- /dev/null
+++ b/src/test/ui/never_type/feature-gate-never_type_fallback.rs
@@ -0,0 +1,12 @@
+// This is a feature gate test for `never_type_fallback`.
+// It works by using a scenario where the type fall backs to `()` rather than ´!`
+// in the case where `#![feature(never_type_fallback)]` would change it to `!`.
+
+fn main() {}
+
+trait T {}
+
+fn should_ret_unit() -> impl T {
+    //~^ ERROR the trait bound `(): T` is not satisfied
+    panic!()
+}
diff --git a/src/test/ui/never_type/feature-gate-never_type_fallback.stderr b/src/test/ui/never_type/feature-gate-never_type_fallback.stderr
new file mode 100644
index 00000000000..837e90d6ceb
--- /dev/null
+++ b/src/test/ui/never_type/feature-gate-never_type_fallback.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the trait bound `(): T` is not satisfied
+  --> $DIR/feature-gate-never_type_fallback.rs:9:25
+   |
+LL | fn should_ret_unit() -> impl T {
+   |                         ^^^^^^ the trait `T` is not implemented for `()`
+   |
+   = note: the return type of a function must have a statically known size
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/never_type/impl-for-never.rs b/src/test/ui/never_type/impl-for-never.rs
index 9423f08858b..cbfda9a2cc0 100644
--- a/src/test/ui/never_type/impl-for-never.rs
+++ b/src/test/ui/never_type/impl-for-never.rs
@@ -1,7 +1,5 @@
 // run-pass
 
-#![feature(never_type)]
-
 // Test that we can call static methods on ! both directly and when it appears in a generic
 
 trait StringifyType {
diff --git a/src/test/ui/never_type/issue-44402.rs b/src/test/ui/never_type/issue-44402.rs
index 699e480dfe7..0e6588bbe78 100644
--- a/src/test/ui/never_type/issue-44402.rs
+++ b/src/test/ui/never_type/issue-44402.rs
@@ -1,7 +1,6 @@
 // check-pass
 
 #![allow(dead_code)]
-#![feature(never_type)]
 #![feature(exhaustive_patterns)]
 
 // Regression test for inhabitedness check. The old
diff --git a/src/test/ui/never_type/never-assign-dead-code.rs b/src/test/ui/never_type/never-assign-dead-code.rs
index 7bb7c87097c..5c1300c7151 100644
--- a/src/test/ui/never_type/never-assign-dead-code.rs
+++ b/src/test/ui/never_type/never-assign-dead-code.rs
@@ -2,7 +2,6 @@
 
 // check-pass
 
-#![feature(never_type)]
 #![warn(unused)]
 
 fn main() {
diff --git a/src/test/ui/never_type/never-assign-dead-code.stderr b/src/test/ui/never_type/never-assign-dead-code.stderr
index 1860150fa8b..1dc15251d1a 100644
--- a/src/test/ui/never_type/never-assign-dead-code.stderr
+++ b/src/test/ui/never_type/never-assign-dead-code.stderr
@@ -1,5 +1,5 @@
 warning: unreachable statement
-  --> $DIR/never-assign-dead-code.rs:10:5
+  --> $DIR/never-assign-dead-code.rs:9:5
    |
 LL |     let x: ! = panic!("aah");
    |                ------------- any code following this expression is unreachable
@@ -7,7 +7,7 @@ LL |     drop(x);
    |     ^^^^^^^^ unreachable statement
    |
 note: lint level defined here
-  --> $DIR/never-assign-dead-code.rs:6:9
+  --> $DIR/never-assign-dead-code.rs:5:9
    |
 LL | #![warn(unused)]
    |         ^^^^^^
@@ -15,7 +15,7 @@ LL | #![warn(unused)]
    = note: this warning originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
 
 warning: unreachable call
-  --> $DIR/never-assign-dead-code.rs:10:5
+  --> $DIR/never-assign-dead-code.rs:9:5
    |
 LL |     drop(x);
    |     ^^^^ - any code following this expression is unreachable
@@ -23,13 +23,13 @@ LL |     drop(x);
    |     unreachable call
 
 warning: unused variable: `x`
-  --> $DIR/never-assign-dead-code.rs:9:9
+  --> $DIR/never-assign-dead-code.rs:8:9
    |
 LL |     let x: ! = panic!("aah");
    |         ^ help: consider prefixing with an underscore: `_x`
    |
 note: lint level defined here
-  --> $DIR/never-assign-dead-code.rs:6:9
+  --> $DIR/never-assign-dead-code.rs:5:9
    |
 LL | #![warn(unused)]
    |         ^^^^^^
diff --git a/src/test/ui/never_type/never-assign-wrong-type.rs b/src/test/ui/never_type/never-assign-wrong-type.rs
index 67e26f5663f..9ca1ac7462d 100644
--- a/src/test/ui/never_type/never-assign-wrong-type.rs
+++ b/src/test/ui/never_type/never-assign-wrong-type.rs
@@ -1,6 +1,5 @@
 // Test that we can't use another type in place of !
 
-#![feature(never_type)]
 #![deny(warnings)]
 
 fn main() {
diff --git a/src/test/ui/never_type/never-assign-wrong-type.stderr b/src/test/ui/never_type/never-assign-wrong-type.stderr
index da2e77d023d..32c9fab6590 100644
--- a/src/test/ui/never_type/never-assign-wrong-type.stderr
+++ b/src/test/ui/never_type/never-assign-wrong-type.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/never-assign-wrong-type.rs:7:16
+  --> $DIR/never-assign-wrong-type.rs:6:16
    |
 LL |     let x: ! = "hello";
    |                ^^^^^^^ expected !, found reference
diff --git a/src/test/ui/never_type/never-associated-type.rs b/src/test/ui/never_type/never-associated-type.rs
index 3bb917c9316..45e54b9bf7c 100644
--- a/src/test/ui/never_type/never-associated-type.rs
+++ b/src/test/ui/never_type/never-associated-type.rs
@@ -2,8 +2,6 @@
 
 // check-pass
 
-#![feature(never_type)]
-
 trait Foo {
     type Wow;
 
diff --git a/src/test/ui/never_type/never-from-impl-is-reserved.rs b/src/test/ui/never_type/never-from-impl-is-reserved.rs
index 9d16015bdc1..df74b6a53f8 100644
--- a/src/test/ui/never_type/never-from-impl-is-reserved.rs
+++ b/src/test/ui/never_type/never-from-impl-is-reserved.rs
@@ -1,7 +1,5 @@
 // check that the `for<T> T: From<!>` impl is reserved
 
-#![feature(never_type)]
-
 pub struct MyFoo;
 pub trait MyTrait {}
 
diff --git a/src/test/ui/never_type/never-from-impl-is-reserved.stderr b/src/test/ui/never_type/never-from-impl-is-reserved.stderr
index 8b8d0f4ea73..8b3155988ea 100644
--- a/src/test/ui/never_type/never-from-impl-is-reserved.stderr
+++ b/src/test/ui/never_type/never-from-impl-is-reserved.stderr
@@ -1,5 +1,5 @@
 error[E0119]: conflicting implementations of trait `MyTrait` for type `MyFoo`:
-  --> $DIR/never-from-impl-is-reserved.rs:10:1
+  --> $DIR/never-from-impl-is-reserved.rs:8:1
    |
 LL | impl MyTrait for MyFoo {}
    | ---------------------- first implementation here
diff --git a/src/test/ui/never_type/never-result.rs b/src/test/ui/never_type/never-result.rs
index 35af37910ef..800553fce87 100644
--- a/src/test/ui/never_type/never-result.rs
+++ b/src/test/ui/never_type/never-result.rs
@@ -5,8 +5,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/never_type/never-type-arg.rs b/src/test/ui/never_type/never-type-arg.rs
index 13cd59e6aa9..3cbb114f43b 100644
--- a/src/test/ui/never_type/never-type-arg.rs
+++ b/src/test/ui/never_type/never-type-arg.rs
@@ -2,8 +2,6 @@
 
 // check-pass
 
-#![feature(never_type)]
-
 struct Wub;
 
 impl PartialEq<!> for Wub {
diff --git a/src/test/ui/never_type/never-type-rvalues.rs b/src/test/ui/never_type/never-type-rvalues.rs
index 9ccc73dbf92..9bfc5572b9e 100644
--- a/src/test/ui/never_type/never-type-rvalues.rs
+++ b/src/test/ui/never_type/never-type-rvalues.rs
@@ -1,6 +1,5 @@
 // run-pass
 
-#![feature(never_type)]
 #![allow(dead_code)]
 #![allow(path_statements)]
 #![allow(unreachable_patterns)]
diff --git a/src/test/ui/never_type/never_transmute_never.rs b/src/test/ui/never_type/never_transmute_never.rs
index fce3ced9aac..cdf04de19e5 100644
--- a/src/test/ui/never_type/never_transmute_never.rs
+++ b/src/test/ui/never_type/never_transmute_never.rs
@@ -2,7 +2,6 @@
 
 #![crate_type="lib"]
 
-#![feature(never_type)]
 #![allow(dead_code)]
 #![allow(unreachable_code)]
 #![allow(unused_variables)]
diff --git a/src/test/ui/never_type/panic-uninitialized-zeroed.rs b/src/test/ui/never_type/panic-uninitialized-zeroed.rs
index e0c30160b9e..e5e0e188de6 100644
--- a/src/test/ui/never_type/panic-uninitialized-zeroed.rs
+++ b/src/test/ui/never_type/panic-uninitialized-zeroed.rs
@@ -3,7 +3,6 @@
 // This test checks that instantiating an uninhabited type via `mem::{uninitialized,zeroed}` results
 // in a runtime panic.
 
-#![feature(never_type)]
 #![allow(deprecated, invalid_value)]
 
 use std::{mem, panic};
diff --git a/src/test/ui/never_type/try_from.rs b/src/test/ui/never_type/try_from.rs
index 50451576f9c..977ea3656b3 100644
--- a/src/test/ui/never_type/try_from.rs
+++ b/src/test/ui/never_type/try_from.rs
@@ -5,8 +5,6 @@
 // This test was added to show the motivation for doing this
 // over `TryFrom` being blanket impl for all `T: From`
 
-#![feature(never_type)]
-
 use std::convert::{TryInto, Infallible};
 
 struct Foo<T> {
diff --git a/src/test/ui/pattern/usefulness/match-privately-empty.rs b/src/test/ui/pattern/usefulness/match-privately-empty.rs
index 315eb03d165..ea608651387 100644
--- a/src/test/ui/pattern/usefulness/match-privately-empty.rs
+++ b/src/test/ui/pattern/usefulness/match-privately-empty.rs
@@ -1,4 +1,3 @@
-#![feature(never_type)]
 #![feature(exhaustive_patterns)]
 
 mod private {
diff --git a/src/test/ui/pattern/usefulness/match-privately-empty.stderr b/src/test/ui/pattern/usefulness/match-privately-empty.stderr
index f79d180a1b8..66d0d958774 100644
--- a/src/test/ui/pattern/usefulness/match-privately-empty.stderr
+++ b/src/test/ui/pattern/usefulness/match-privately-empty.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: `Some(Private { misc: true, .. })` not covered
-  --> $DIR/match-privately-empty.rs:13:11
+  --> $DIR/match-privately-empty.rs:12:11
    |
 LL |     match private::DATA {
    |           ^^^^^^^^^^^^^ pattern `Some(Private { misc: true, .. })` not covered
diff --git a/src/test/ui/print_type_sizes/uninhabited.rs b/src/test/ui/print_type_sizes/uninhabited.rs
index ae4e492456a..3a2ca19d8e0 100644
--- a/src/test/ui/print_type_sizes/uninhabited.rs
+++ b/src/test/ui/print_type_sizes/uninhabited.rs
@@ -4,7 +4,6 @@
 // ^-- needed because `--pass check` does not emit the output needed.
 //     FIXME: consider using an attribute instead of side-effects.
 
-#![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 b45e5daf42c..640c2a2cf8f 100644
--- a/src/test/ui/reachable/expr_add.rs
+++ b/src/test/ui/reachable/expr_add.rs
@@ -1,4 +1,3 @@
-#![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 880dea1cc35..11c41fdc394 100644
--- a/src/test/ui/reachable/expr_add.stderr
+++ b/src/test/ui/reachable/expr_add.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/expr_add.rs:17:13
+  --> $DIR/expr_add.rs:16:13
    |
 LL |     let x = Foo + return;
    |             ^^^^^^------
@@ -8,7 +8,7 @@ LL |     let x = Foo + return;
    |             unreachable expression
    |
 note: lint level defined here
-  --> $DIR/expr_add.rs:3:9
+  --> $DIR/expr_add.rs:2:9
    |
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/expr_assign.rs b/src/test/ui/reachable/expr_assign.rs
index e547f75e269..3914fb32432 100644
--- a/src/test/ui/reachable/expr_assign.rs
+++ b/src/test/ui/reachable/expr_assign.rs
@@ -1,4 +1,3 @@
-#![feature(never_type)]
 #![allow(unused_variables)]
 #![allow(unused_assignments)]
 #![allow(dead_code)]
diff --git a/src/test/ui/reachable/expr_assign.stderr b/src/test/ui/reachable/expr_assign.stderr
index 3004da04063..90aec15e3be 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:10:5
+  --> $DIR/expr_assign.rs:9:5
    |
 LL |     x = return;
    |     ^^^^------
@@ -8,13 +8,13 @@ LL |     x = return;
    |     unreachable expression
    |
 note: lint level defined here
-  --> $DIR/expr_assign.rs:5:9
+  --> $DIR/expr_assign.rs:4:9
    |
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable expression
-  --> $DIR/expr_assign.rs:20:14
+  --> $DIR/expr_assign.rs:19:14
    |
 LL |         *p = return;
    |         --   ^^^^^^ unreachable expression
@@ -22,7 +22,7 @@ LL |         *p = return;
    |         any code following this expression is unreachable
 
 error: unreachable expression
-  --> $DIR/expr_assign.rs:26:15
+  --> $DIR/expr_assign.rs:25:15
    |
 LL |     *{return; &mut i} = 22;
    |       ------  ^^^^^^ unreachable expression
diff --git a/src/test/ui/reachable/expr_call.rs b/src/test/ui/reachable/expr_call.rs
index 1eaa96c3ce7..ce1a94e3c4a 100644
--- a/src/test/ui/reachable/expr_call.rs
+++ b/src/test/ui/reachable/expr_call.rs
@@ -1,4 +1,3 @@
-#![feature(never_type)]
 #![allow(unused_variables)]
 #![allow(unused_assignments)]
 #![allow(dead_code)]
diff --git a/src/test/ui/reachable/expr_call.stderr b/src/test/ui/reachable/expr_call.stderr
index ae8b4dd87b5..613fc31b861 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:13:17
+  --> $DIR/expr_call.rs:12:17
    |
 LL |     foo(return, 22);
    |         ------  ^^ unreachable expression
@@ -7,13 +7,13 @@ LL |     foo(return, 22);
    |         any code following this expression is unreachable
    |
 note: lint level defined here
-  --> $DIR/expr_call.rs:5:9
+  --> $DIR/expr_call.rs:4:9
    |
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable call
-  --> $DIR/expr_call.rs:18:5
+  --> $DIR/expr_call.rs:17:5
    |
 LL |     bar(return);
    |     ^^^ ------ any code following this expression is unreachable
diff --git a/src/test/ui/reachable/expr_cast.rs b/src/test/ui/reachable/expr_cast.rs
index f53bcb97e69..76a7306b9d9 100644
--- a/src/test/ui/reachable/expr_cast.rs
+++ b/src/test/ui/reachable/expr_cast.rs
@@ -2,7 +2,7 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type, type_ascription)]
+#![feature(type_ascription)]
 
 fn a() {
     // the cast is unreachable:
diff --git a/src/test/ui/reachable/expr_method.rs b/src/test/ui/reachable/expr_method.rs
index d917df05b3c..e74a7daec88 100644
--- a/src/test/ui/reachable/expr_method.rs
+++ b/src/test/ui/reachable/expr_method.rs
@@ -1,4 +1,3 @@
-#![feature(never_type)]
 #![allow(unused_variables)]
 #![allow(unused_assignments)]
 #![allow(dead_code)]
diff --git a/src/test/ui/reachable/expr_method.stderr b/src/test/ui/reachable/expr_method.stderr
index 82a0745f062..7475cf7a365 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:16:21
+  --> $DIR/expr_method.rs:15:21
    |
 LL |     Foo.foo(return, 22);
    |             ------  ^^ unreachable expression
@@ -7,13 +7,13 @@ LL |     Foo.foo(return, 22);
    |             any code following this expression is unreachable
    |
 note: lint level defined here
-  --> $DIR/expr_method.rs:5:9
+  --> $DIR/expr_method.rs:4:9
    |
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable call
-  --> $DIR/expr_method.rs:21:9
+  --> $DIR/expr_method.rs:20:9
    |
 LL |     Foo.bar(return);
    |         ^^^ ------ any code following this expression is unreachable
diff --git a/src/test/ui/reachable/expr_type.rs b/src/test/ui/reachable/expr_type.rs
index 8d32397b542..ff647bda0e8 100644
--- a/src/test/ui/reachable/expr_type.rs
+++ b/src/test/ui/reachable/expr_type.rs
@@ -2,7 +2,7 @@
 #![allow(unused_assignments)]
 #![allow(dead_code)]
 #![deny(unreachable_code)]
-#![feature(never_type, type_ascription)]
+#![feature(type_ascription)]
 
 fn a() {
     // the cast is unreachable:
diff --git a/src/test/ui/reachable/expr_unary.rs b/src/test/ui/reachable/expr_unary.rs
index e229d22ebc7..6f221c360cb 100644
--- a/src/test/ui/reachable/expr_unary.rs
+++ b/src/test/ui/reachable/expr_unary.rs
@@ -1,4 +1,3 @@
-#![feature(never_type)]
 #![allow(unused_variables)]
 #![allow(unused_assignments)]
 #![allow(dead_code)]
diff --git a/src/test/ui/reachable/expr_unary.stderr b/src/test/ui/reachable/expr_unary.stderr
index f5c3564217b..a576f920923 100644
--- a/src/test/ui/reachable/expr_unary.stderr
+++ b/src/test/ui/reachable/expr_unary.stderr
@@ -1,11 +1,11 @@
 error[E0600]: cannot apply unary operator `!` to type `!`
-  --> $DIR/expr_unary.rs:8:16
+  --> $DIR/expr_unary.rs:7:16
    |
 LL |     let x: ! = ! { return; };
    |                ^^^^^^^^^^^^^ cannot apply unary operator `!`
 
 error: unreachable expression
-  --> $DIR/expr_unary.rs:8:16
+  --> $DIR/expr_unary.rs:7:16
    |
 LL |     let x: ! = ! { return; };
    |                ^^^^------^^^
@@ -14,7 +14,7 @@ LL |     let x: ! = ! { return; };
    |                unreachable expression
    |
 note: lint level defined here
-  --> $DIR/expr_unary.rs:5:9
+  --> $DIR/expr_unary.rs:4:9
    |
 LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/reachable/unreachable-loop-patterns.rs b/src/test/ui/reachable/unreachable-loop-patterns.rs
index 6f1d2efa1b2..c8ff5653911 100644
--- a/src/test/ui/reachable/unreachable-loop-patterns.rs
+++ b/src/test/ui/reachable/unreachable-loop-patterns.rs
@@ -1,4 +1,4 @@
-#![feature(never_type)]
+#![feature(never_type_fallback)]
 #![feature(exhaustive_patterns)]
 
 #![allow(unreachable_code)]
diff --git a/src/test/ui/reachable/unreachable-try-pattern.rs b/src/test/ui/reachable/unreachable-try-pattern.rs
index 23360e73f4a..e2d89e93a2a 100644
--- a/src/test/ui/reachable/unreachable-try-pattern.rs
+++ b/src/test/ui/reachable/unreachable-try-pattern.rs
@@ -1,5 +1,5 @@
 // check-pass
-#![feature(never_type, exhaustive_patterns)]
+#![feature(exhaustive_patterns)]
 #![warn(unreachable_code)]
 #![warn(unreachable_patterns)]
 
diff --git a/src/test/ui/reachable/unwarned-match-on-never.rs b/src/test/ui/reachable/unwarned-match-on-never.rs
index 71f8fe3a783..c38ea6ab9ad 100644
--- a/src/test/ui/reachable/unwarned-match-on-never.rs
+++ b/src/test/ui/reachable/unwarned-match-on-never.rs
@@ -1,8 +1,6 @@
 #![deny(unreachable_code)]
 #![allow(dead_code)]
 
-#![feature(never_type)]
-
 fn foo(x: !) -> bool {
     // Explicit matches on the never type are unwarned.
     match x {}
diff --git a/src/test/ui/reachable/unwarned-match-on-never.stderr b/src/test/ui/reachable/unwarned-match-on-never.stderr
index 6b2fb4a33c1..6710fcb777f 100644
--- a/src/test/ui/reachable/unwarned-match-on-never.stderr
+++ b/src/test/ui/reachable/unwarned-match-on-never.stderr
@@ -1,5 +1,5 @@
 error: unreachable expression
-  --> $DIR/unwarned-match-on-never.rs:10:5
+  --> $DIR/unwarned-match-on-never.rs:8:5
    |
 LL |     match x {}
    |           - any code following this expression is unreachable
@@ -14,7 +14,7 @@ LL | #![deny(unreachable_code)]
    |         ^^^^^^^^^^^^^^^^
 
 error: unreachable arm
-  --> $DIR/unwarned-match-on-never.rs:15:15
+  --> $DIR/unwarned-match-on-never.rs:13:15
    |
 LL |     match (return) {
    |           -------- any code following this expression is unreachable
@@ -22,7 +22,7 @@ LL |         () => ()
    |               ^^ unreachable arm
 
 error: unreachable expression
-  --> $DIR/unwarned-match-on-never.rs:21:5
+  --> $DIR/unwarned-match-on-never.rs:19:5
    |
 LL |       return;
    |       ------ any code following this expression is unreachable
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/auxiliary/uninhabited.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/auxiliary/uninhabited.rs
index a2735d4cbfb..e074183a049 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/auxiliary/uninhabited.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/auxiliary/uninhabited.rs
@@ -1,5 +1,4 @@
 #![crate_type = "rlib"]
-#![feature(never_type)]
 
 #[non_exhaustive]
 pub enum UninhabitedEnum {
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.rs
index 80b9dc4c1c3..5684ee6b7bf 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.rs
@@ -1,5 +1,4 @@
 // aux-build:uninhabited.rs
-#![feature(never_type)]
 
 extern crate uninhabited;
 
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.stderr
index d05ee1d39ec..dd4b0cd1e87 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/coercions.rs:23:5
+  --> $DIR/coercions.rs:22:5
    |
 LL | fn cannot_coerce_empty_enum_to_anything(x: UninhabitedEnum) -> A {
    |                                                                - expected `A` because of return type
@@ -10,7 +10,7 @@ LL |     x
               found type `uninhabited::UninhabitedEnum`
 
 error[E0308]: mismatched types
-  --> $DIR/coercions.rs:27:5
+  --> $DIR/coercions.rs:26:5
    |
 LL | fn cannot_coerce_empty_tuple_struct_to_anything(x: UninhabitedTupleStruct) -> A {
    |                                                                               - expected `A` because of return type
@@ -21,7 +21,7 @@ LL |     x
               found type `uninhabited::UninhabitedTupleStruct`
 
 error[E0308]: mismatched types
-  --> $DIR/coercions.rs:31:5
+  --> $DIR/coercions.rs:30:5
    |
 LL | fn cannot_coerce_empty_struct_to_anything(x: UninhabitedStruct) -> A {
    |                                                                    - expected `A` because of return type
@@ -32,7 +32,7 @@ LL |     x
               found type `uninhabited::UninhabitedStruct`
 
 error[E0308]: mismatched types
-  --> $DIR/coercions.rs:35:5
+  --> $DIR/coercions.rs:34:5
    |
 LL | fn cannot_coerce_enum_with_empty_variants_to_anything(x: UninhabitedVariants) -> A {
    |                                                                                  - expected `A` because of return type
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.rs
index 6b911dd989c..c3c0ce650d7 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 #[non_exhaustive]
 pub enum UninhabitedEnum {
 }
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.stderr
index a07473dade2..fd49c682398 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/coercions_same_crate.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/coercions_same_crate.rs:30:5
+  --> $DIR/coercions_same_crate.rs:28:5
    |
 LL | fn cannot_coerce_empty_enum_to_anything(x: UninhabitedEnum) -> A {
    |                                                                - expected `A` because of return type
@@ -10,7 +10,7 @@ LL |     x
               found type `UninhabitedEnum`
 
 error[E0308]: mismatched types
-  --> $DIR/coercions_same_crate.rs:34:5
+  --> $DIR/coercions_same_crate.rs:32:5
    |
 LL | fn cannot_coerce_empty_tuple_struct_to_anything(x: UninhabitedTupleStruct) -> A {
    |                                                                               - expected `A` because of return type
@@ -21,7 +21,7 @@ LL |     x
               found type `UninhabitedTupleStruct`
 
 error[E0308]: mismatched types
-  --> $DIR/coercions_same_crate.rs:38:5
+  --> $DIR/coercions_same_crate.rs:36:5
    |
 LL | fn cannot_coerce_empty_struct_to_anything(x: UninhabitedStruct) -> A {
    |                                                                    - expected `A` because of return type
@@ -32,7 +32,7 @@ LL |     x
               found type `UninhabitedStruct`
 
 error[E0308]: mismatched types
-  --> $DIR/coercions_same_crate.rs:42:5
+  --> $DIR/coercions_same_crate.rs:40:5
    |
 LL | fn cannot_coerce_enum_with_empty_variants_to_anything(x: UninhabitedVariants) -> A {
    |                                                                                  - expected `A` because of return type
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.rs
index 98a7fdbc504..511b6b1bf8f 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.rs
@@ -1,5 +1,4 @@
 // aux-build:uninhabited.rs
-#![feature(never_type)]
 
 extern crate uninhabited;
 
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.stderr
index af82022e1da..b903e9b288e 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedEnum` of type `uninhabited::IndirectUninhabitedEnum` is not handled
-  --> $DIR/indirect_match.rs:19:11
+  --> $DIR/indirect_match.rs:18:11
    |
 LL |     match x {}
    |           ^
@@ -7,7 +7,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedStruct` of type `uninhabited::IndirectUninhabitedStruct` is not handled
-  --> $DIR/indirect_match.rs:23:11
+  --> $DIR/indirect_match.rs:22:11
    |
 LL |     match x {}
    |           ^
@@ -15,7 +15,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedTupleStruct` of type `uninhabited::IndirectUninhabitedTupleStruct` is not handled
-  --> $DIR/indirect_match.rs:27:11
+  --> $DIR/indirect_match.rs:26:11
    |
 LL |     match x {}
    |           ^
@@ -23,7 +23,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedVariants` of type `uninhabited::IndirectUninhabitedVariants` is not handled
-  --> $DIR/indirect_match.rs:33:11
+  --> $DIR/indirect_match.rs:32:11
    |
 LL |     match x {}
    |           ^
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.rs
index 8f090fe886a..9c3ec4240a5 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 #[non_exhaustive]
 pub enum UninhabitedEnum {
 }
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.stderr
index c03018a5236..f94616dc64b 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_same_crate.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedEnum` of type `IndirectUninhabitedEnum` is not handled
-  --> $DIR/indirect_match_same_crate.rs:34:11
+  --> $DIR/indirect_match_same_crate.rs:32:11
    |
 LL | pub struct IndirectUninhabitedEnum(UninhabitedEnum);
    | ----------------------------------------------------
@@ -13,7 +13,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedStruct` of type `IndirectUninhabitedStruct` is not handled
-  --> $DIR/indirect_match_same_crate.rs:38:11
+  --> $DIR/indirect_match_same_crate.rs:36:11
    |
 LL | pub struct IndirectUninhabitedStruct(UninhabitedStruct);
    | --------------------------------------------------------
@@ -27,7 +27,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedTupleStruct` of type `IndirectUninhabitedTupleStruct` is not handled
-  --> $DIR/indirect_match_same_crate.rs:42:11
+  --> $DIR/indirect_match_same_crate.rs:40:11
    |
 LL | pub struct IndirectUninhabitedTupleStruct(UninhabitedTupleStruct);
    | ------------------------------------------------------------------
@@ -41,7 +41,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `IndirectUninhabitedVariants` of type `IndirectUninhabitedVariants` is not handled
-  --> $DIR/indirect_match_same_crate.rs:48:11
+  --> $DIR/indirect_match_same_crate.rs:46:11
    |
 LL | pub struct IndirectUninhabitedVariants(UninhabitedVariants);
    | ------------------------------------------------------------
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.rs
index be86519ecb1..68ac42ef587 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.rs
@@ -1,7 +1,6 @@
 // aux-build:uninhabited.rs
 #![deny(unreachable_patterns)]
 #![feature(exhaustive_patterns)]
-#![feature(never_type)]
 
 extern crate uninhabited;
 
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.stderr
index 17a8d010072..2c2e5429341 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: type `uninhabited::IndirectUninhabitedEnum` is non-empty
-  --> $DIR/indirect_match_with_exhaustive_patterns.rs:23:11
+  --> $DIR/indirect_match_with_exhaustive_patterns.rs:22:11
    |
 LL |     match x {}
    |           ^
@@ -7,7 +7,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: type `uninhabited::IndirectUninhabitedStruct` is non-empty
-  --> $DIR/indirect_match_with_exhaustive_patterns.rs:27:11
+  --> $DIR/indirect_match_with_exhaustive_patterns.rs:26:11
    |
 LL |     match x {}
    |           ^
@@ -15,7 +15,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: type `uninhabited::IndirectUninhabitedTupleStruct` is non-empty
-  --> $DIR/indirect_match_with_exhaustive_patterns.rs:31:11
+  --> $DIR/indirect_match_with_exhaustive_patterns.rs:30:11
    |
 LL |     match x {}
    |           ^
@@ -23,7 +23,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: type `uninhabited::IndirectUninhabitedVariants` is non-empty
-  --> $DIR/indirect_match_with_exhaustive_patterns.rs:37:11
+  --> $DIR/indirect_match_with_exhaustive_patterns.rs:36:11
    |
 LL |     match x {}
    |           ^
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs
index 60289aa7803..06c318414f0 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/indirect_match_with_exhaustive_patterns_same_crate.rs
@@ -2,7 +2,6 @@
 
 #![deny(unreachable_patterns)]
 #![feature(exhaustive_patterns)]
-#![feature(never_type)]
 
 #[non_exhaustive]
 pub enum UninhabitedEnum {
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.rs
index e54098d4d48..fd3dbca04c0 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.rs
@@ -1,5 +1,4 @@
 // aux-build:uninhabited.rs
-#![feature(never_type)]
 
 extern crate uninhabited;
 
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.stderr
index de39688f45a..de3fa900cd6 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: type `uninhabited::UninhabitedEnum` is non-empty
-  --> $DIR/match.rs:19:11
+  --> $DIR/match.rs:18:11
    |
 LL |     match x {}
    |           ^
@@ -7,7 +7,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `UninhabitedStruct` of type `uninhabited::UninhabitedStruct` is not handled
-  --> $DIR/match.rs:23:11
+  --> $DIR/match.rs:22:11
    |
 LL |     match x {}
    |           ^
@@ -15,7 +15,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `UninhabitedTupleStruct` of type `uninhabited::UninhabitedTupleStruct` is not handled
-  --> $DIR/match.rs:27:11
+  --> $DIR/match.rs:26:11
    |
 LL |     match x {}
    |           ^
@@ -23,7 +23,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: multiple patterns of type `uninhabited::UninhabitedVariants` are not handled
-  --> $DIR/match.rs:31:11
+  --> $DIR/match.rs:30:11
    |
 LL |     match x {}
    |           ^
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.rs
index ebbdfba15f3..c31688add91 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.rs
@@ -1,5 +1,3 @@
-#![feature(never_type)]
-
 #[non_exhaustive]
 pub enum UninhabitedEnum {
 }
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.stderr
index c39df05a8f7..3dd1a914d55 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_same_crate.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: pattern `UninhabitedStruct` of type `UninhabitedStruct` is not handled
-  --> $DIR/match_same_crate.rs:30:11
+  --> $DIR/match_same_crate.rs:28:11
    |
 LL |   pub struct UninhabitedStruct {
    |   -          ----------------- variant not covered
@@ -15,7 +15,7 @@ LL |       match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: pattern `UninhabitedTupleStruct` of type `UninhabitedTupleStruct` is not handled
-  --> $DIR/match_same_crate.rs:34:11
+  --> $DIR/match_same_crate.rs:32:11
    |
 LL | pub struct UninhabitedTupleStruct(!);
    | -------------------------------------
@@ -29,7 +29,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: multiple patterns of type `UninhabitedVariants` are not handled
-  --> $DIR/match_same_crate.rs:38:11
+  --> $DIR/match_same_crate.rs:36:11
    |
 LL | / pub enum UninhabitedVariants {
 LL | |     #[non_exhaustive] Tuple(!),
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.rs
index 900dfff652e..37d739834d2 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.rs
@@ -1,7 +1,6 @@
 // aux-build:uninhabited.rs
 #![deny(unreachable_patterns)]
 #![feature(exhaustive_patterns)]
-#![feature(never_type)]
 
 extern crate uninhabited;
 
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.stderr
index 48a888bc50b..3b56c689071 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns.stderr
@@ -1,5 +1,5 @@
 error[E0004]: non-exhaustive patterns: type `uninhabited::UninhabitedEnum` is non-empty
-  --> $DIR/match_with_exhaustive_patterns.rs:22:11
+  --> $DIR/match_with_exhaustive_patterns.rs:21:11
    |
 LL |     match x {}
    |           ^
@@ -7,7 +7,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: type `uninhabited::UninhabitedStruct` is non-empty
-  --> $DIR/match_with_exhaustive_patterns.rs:26:11
+  --> $DIR/match_with_exhaustive_patterns.rs:25:11
    |
 LL |     match x {}
    |           ^
@@ -15,7 +15,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: type `uninhabited::UninhabitedTupleStruct` is non-empty
-  --> $DIR/match_with_exhaustive_patterns.rs:30:11
+  --> $DIR/match_with_exhaustive_patterns.rs:29:11
    |
 LL |     match x {}
    |           ^
@@ -23,7 +23,7 @@ LL |     match x {}
    = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
 
 error[E0004]: non-exhaustive patterns: type `uninhabited::UninhabitedVariants` is non-empty
-  --> $DIR/match_with_exhaustive_patterns.rs:34:11
+  --> $DIR/match_with_exhaustive_patterns.rs:33:11
    |
 LL |     match x {}
    |           ^
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs
index de5530485f3..2b2e4b6e77d 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/match_with_exhaustive_patterns_same_crate.rs
@@ -2,7 +2,6 @@
 
 #![deny(unreachable_patterns)]
 #![feature(exhaustive_patterns)]
-#![feature(never_type)]
 
 #[non_exhaustive]
 pub enum UninhabitedEnum {
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.rs b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.rs
index ffc496a975e..3d4cca4505e 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.rs
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.rs
@@ -1,6 +1,5 @@
 #![deny(unreachable_patterns)]
 #![feature(exhaustive_patterns)]
-#![feature(never_type)]
 
 #[non_exhaustive]
 pub enum UninhabitedEnum {
diff --git a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
index e3de94be128..fea883f8912 100644
--- a/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
+++ b/src/test/ui/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
@@ -1,5 +1,5 @@
 error: unreachable pattern
-  --> $DIR/patterns_same_crate.rs:52:9
+  --> $DIR/patterns_same_crate.rs:51:9
    |
 LL |         Some(_x) => (),
    |         ^^^^^^^^
@@ -11,25 +11,25 @@ LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/patterns_same_crate.rs:57:9
+  --> $DIR/patterns_same_crate.rs:56:9
    |
 LL |         Some(_x) => (),
    |         ^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/patterns_same_crate.rs:61:15
+  --> $DIR/patterns_same_crate.rs:60:15
    |
 LL |     while let PartiallyInhabitedVariants::Struct { x } = partially_inhabited_variant() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/patterns_same_crate.rs:65:15
+  --> $DIR/patterns_same_crate.rs:64:15
    |
 LL |     while let Some(_x) = uninhabited_struct() {
    |               ^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/patterns_same_crate.rs:68:15
+  --> $DIR/patterns_same_crate.rs:67:15
    |
 LL |     while let Some(_x) = uninhabited_tuple_struct() {
    |               ^^^^^^^^
diff --git a/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr b/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr
index bce1900ca60..91075ffbdb6 100644
--- a/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr
+++ b/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr
@@ -11,10 +11,6 @@ note: ...can't outlive the lifetime `'_` as defined on the method body at 8:26
    |
 LL |     async fn f(self: Pin<&Self>) -> impl Clone { self }
    |                          ^
-help: you can add a constraint to the return type to make it last less than `'static` and match the lifetime `'_` as defined on the method body at 8:26
-   |
-LL |     async fn f(self: Pin<&Self>) -> impl Clone + '_ { self }
-   |                                     ^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/traits/reservation-impls/reservation-impl-non-lattice-ok.rs b/src/test/ui/traits/reservation-impls/reservation-impl-non-lattice-ok.rs
index f14589ccf84..0e0197803b7 100644
--- a/src/test/ui/traits/reservation-impls/reservation-impl-non-lattice-ok.rs
+++ b/src/test/ui/traits/reservation-impls/reservation-impl-non-lattice-ok.rs
@@ -30,7 +30,7 @@
 //
 // [ii]: http://smallcultfollowing.com/babysteps/blog/2016/09/24/intersection-impls/
 
-#![feature(rustc_attrs, never_type)]
+#![feature(rustc_attrs)]
 
 trait MyTrait {}
 
diff --git a/src/test/ui/type-sizes.rs b/src/test/ui/type-sizes.rs
index 27433fd770b..3dfe0ad7f72 100644
--- a/src/test/ui/type-sizes.rs
+++ b/src/test/ui/type-sizes.rs
@@ -2,7 +2,6 @@
 
 #![allow(non_camel_case_types)]
 #![allow(dead_code)]
-#![feature(never_type)]
 
 use std::mem::size_of;
 
diff --git a/src/test/ui/uninhabited/uninhabited-irrefutable.rs b/src/test/ui/uninhabited/uninhabited-irrefutable.rs
index 48cd92719b4..84daa35484f 100644
--- a/src/test/ui/uninhabited/uninhabited-irrefutable.rs
+++ b/src/test/ui/uninhabited/uninhabited-irrefutable.rs
@@ -1,4 +1,3 @@
-#![feature(never_type)]
 #![feature(exhaustive_patterns)]
 
 mod foo {
diff --git a/src/test/ui/uninhabited/uninhabited-irrefutable.stderr b/src/test/ui/uninhabited/uninhabited-irrefutable.stderr
index 26e1be34ea7..6ba03ee5083 100644
--- a/src/test/ui/uninhabited/uninhabited-irrefutable.stderr
+++ b/src/test/ui/uninhabited/uninhabited-irrefutable.stderr
@@ -1,5 +1,5 @@
 error[E0005]: refutable pattern in local binding: `A(_)` not covered
-  --> $DIR/uninhabited-irrefutable.rs:27:9
+  --> $DIR/uninhabited-irrefutable.rs:26:9
    |
 LL | / enum Foo {
 LL | |     A(foo::SecretlyEmpty),
diff --git a/src/test/ui/uninhabited/uninhabited-patterns.rs b/src/test/ui/uninhabited/uninhabited-patterns.rs
index 1bf01184a08..66a1a7f7735 100644
--- a/src/test/ui/uninhabited/uninhabited-patterns.rs
+++ b/src/test/ui/uninhabited/uninhabited-patterns.rs
@@ -1,6 +1,5 @@
 #![feature(box_patterns)]
 #![feature(box_syntax)]
-#![feature(never_type)]
 #![feature(exhaustive_patterns)]
 #![feature(slice_patterns)]
 #![deny(unreachable_patterns)]
diff --git a/src/test/ui/uninhabited/uninhabited-patterns.stderr b/src/test/ui/uninhabited/uninhabited-patterns.stderr
index 3e5329cfb30..4a793c4510e 100644
--- a/src/test/ui/uninhabited/uninhabited-patterns.stderr
+++ b/src/test/ui/uninhabited/uninhabited-patterns.stderr
@@ -1,35 +1,35 @@
 error: unreachable pattern
-  --> $DIR/uninhabited-patterns.rs:27:9
+  --> $DIR/uninhabited-patterns.rs:26:9
    |
 LL |         &[..] => (),
    |         ^^^^^
    |
 note: lint level defined here
-  --> $DIR/uninhabited-patterns.rs:6:9
+  --> $DIR/uninhabited-patterns.rs:5:9
    |
 LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/uninhabited-patterns.rs:32:9
+  --> $DIR/uninhabited-patterns.rs:31:9
    |
 LL |         Ok(box _) => (),
    |         ^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/uninhabited-patterns.rs:34:9
+  --> $DIR/uninhabited-patterns.rs:33:9
    |
 LL |         Err(&[..]) => (),
    |         ^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/uninhabited-patterns.rs:41:9
+  --> $DIR/uninhabited-patterns.rs:40:9
    |
 LL |         Err(Ok(_y)) => (),
    |         ^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/uninhabited-patterns.rs:44:15
+  --> $DIR/uninhabited-patterns.rs:43:15
    |
 LL |     while let Some(_y) = foo() {
    |               ^^^^^^^^