[DO NOT MERGE] Enable exhaustive_patterns by default

compiler/rustc_mir_build/src/build/matches/simplify.rs

@@ -252,15 +252,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             PatKind::Variant { adt_def, substs, variant_index, ref subpatterns } => {
                 let irrefutable = adt_def.variants.iter_enumerated().all(|(i, v)| {
                     i == variant_index || {
-                        self.hir.tcx().features().exhaustive_patterns
-                            && !v
-                                .uninhabited_from(
-                                    self.hir.tcx(),
-                                    substs,
-                                    adt_def.adt_kind(),
-                                    self.hir.param_env,
-                                )
-                                .is_empty()
+                        !v.uninhabited_from(
+                              self.hir.tcx(),
+                              substs,
+                              adt_def.adt_kind(),
+                              self.hir.param_env,
+                         )
+                         .is_empty()
                     }
                 }) && (adt_def.did.is_local()
                     || !adt_def.is_variant_list_non_exhaustive());

compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs

@@ -922,12 +922,12 @@ impl<'tcx> SplitWildcard<'tcx> {
                 // exception is if the pattern is at the top level, because we want empty matches to be
                 // considered exhaustive.
                 let is_secretly_empty = def.variants.is_empty()
-                    && !cx.tcx.features().exhaustive_patterns
+                    && !true
                     && !pcx.is_top_level;
 
                 if is_secretly_empty || is_declared_nonexhaustive {
                     smallvec![NonExhaustive]
-                } else if cx.tcx.features().exhaustive_patterns {
+                } else if true {
                     // If `exhaustive_patterns` is enabled, we exclude variants known to be
                     // uninhabited.
                     def.variants
@@ -972,7 +972,7 @@ impl<'tcx> SplitWildcard<'tcx> {
             // If `exhaustive_patterns` is disabled and our scrutinee is the never type, we cannot
             // expose its emptiness. The exception is if the pattern is at the top level, because we
             // want empty matches to be considered exhaustive.
-            ty::Never if !cx.tcx.features().exhaustive_patterns && !pcx.is_top_level => {
+            ty::Never if !true && !pcx.is_top_level => {
                 smallvec![NonExhaustive]
             }
             ty::Never => smallvec![],

compiler/rustc_mir_build/src/thir/pattern/usefulness.rs

@@ -314,11 +314,7 @@ crate struct MatchCheckCtxt<'a, 'tcx> {
 
 impl<'a, 'tcx> MatchCheckCtxt<'a, 'tcx> {
     pub(super) fn is_uninhabited(&self, ty: Ty<'tcx>) -> bool {
-        if self.tcx.features().exhaustive_patterns {
-            self.tcx.is_ty_uninhabited_from(self.module, ty, self.param_env)
-        } else {
-            false
-        }
+        self.tcx.is_ty_uninhabited_from(self.module, ty, self.param_env)
     }
 
     /// Returns whether the given type is an enum from another crate declared `#[non_exhaustive]`.

compiler/rustc_traits/src/chalk/lowering.rs

@@ -485,6 +485,7 @@ impl<'tcx> LowerInto<'tcx, Region<'tcx>> for &chalk_ir::Lifetime<RustInterner<'t
                 })
             }
             chalk_ir::LifetimeData::Static => ty::RegionKind::ReStatic,
+            #[cfg(bootstrap)]
             chalk_ir::LifetimeData::Phantom(_, _) => unimplemented!(),
         };
         interner.tcx.mk_region(kind)