Enable exhaustive_patterns by default

This doesn't stabilize the feature, it just makes it a no-op. This is to
get a perf run as suggested [here].

[here]: #51085 (comment)

Author: camelid

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

@@ -835,19 +835,10 @@ fn all_constructors<'p, 'tcx>(pcx: PatCtxt<'_, 'p, 'tcx>) -> Vec<Constructor<'tc
             // witness.
             let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive_enum(pcx.ty);
 
-            // If `exhaustive_patterns` is disabled and our scrutinee is an empty enum, we treat it
-            // as though it had an "unknown" constructor to avoid exposing its emptiness. The
-            // 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
-                && !pcx.is_top_level;
-
-            if is_secretly_empty || is_declared_nonexhaustive {
+            if is_declared_nonexhaustive {
                 vec![NonExhaustive]
-            } else if cx.tcx.features().exhaustive_patterns {
-                // If `exhaustive_patterns` is enabled, we exclude variants known to be
-                // uninhabited.
+            } else {
+                // We exclude variants known to be uninhabited.
                 def.variants
                     .iter()
                     .filter(|v| {
@@ -856,8 +847,6 @@ fn all_constructors<'p, 'tcx>(pcx: PatCtxt<'_, 'p, 'tcx>) -> Vec<Constructor<'tc
                     })
                     .map(|v| Variant(v.def_id))
                     .collect()
-            } else {
-                def.variants.iter().map(|v| Variant(v.def_id)).collect()
             }
         }
         ty::Char => {
@@ -887,12 +876,6 @@ fn all_constructors<'p, 'tcx>(pcx: PatCtxt<'_, 'p, 'tcx>) -> Vec<Constructor<'tc
             let max = size.truncate(u128::MAX);
             vec![make_range(0, max)]
         }
-        // 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 => {
-            vec![NonExhaustive]
-        }
         ty::Never => vec![],
         _ if cx.is_uninhabited(pcx.ty) => vec![],
         ty::Adt(..) | ty::Tuple(..) | ty::Ref(..) => vec![Single],

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

@@ -338,11 +338,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

@@ -487,6 +487,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)