Stabilize exhaustive patterns.

Author: cjgillot

compiler/rustc_feature/src/accepted.rs

@@ -154,6 +154,8 @@ declare_features! (
     (accepted, dyn_trait, "1.27.0", Some(44662), None),
     /// Allows integer match exhaustiveness checking (RFC 2591).
     (accepted, exhaustive_integer_patterns, "1.33.0", Some(50907), None),
+    /// Allows exhaustive pattern matching on types that contain uninhabited types.
+    (accepted, exhaustive_patterns, "CURRENT_RUSTC_VERSION", Some(51085), None),
     /// Allows explicit generic arguments specification with `impl Trait` present.
     (accepted, explicit_generic_args_with_impl_trait, "1.63.0", Some(83701), None),
     /// Allows arbitrary expressions in key-value attributes at parse time.

compiler/rustc_feature/src/active.rs

@@ -393,8 +393,6 @@ declare_features! (
     (incomplete, dyn_star, "1.65.0", Some(102425), None),
     /// Allows `X..Y` patterns.
     (active, exclusive_range_pattern, "1.11.0", Some(37854), None),
-    /// Allows exhaustive pattern matching on types that contain uninhabited types.
-    (active, exhaustive_patterns, "1.13.0", Some(51085), None),
     /// Allows explicit tail calls via `become` expression.
     (incomplete, explicit_tail_calls, "CURRENT_RUSTC_VERSION", Some(112788), None),
     /// Allows using `efiapi`, `sysv64` and `win64` as calling convention

compiler/rustc_middle/src/lib.rs

@@ -29,7 +29,7 @@
 #![feature(box_patterns)]
 #![feature(core_intrinsics)]
 #![feature(discriminant_kind)]
-#![feature(exhaustive_patterns)]
+#![cfg_attr(bootstrap, feature(exhaustive_patterns))]
 #![feature(generators)]
 #![feature(get_mut_unchecked)]
 #![feature(if_let_guard)]

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

@@ -262,11 +262,9 @@ 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.tcx.features().exhaustive_patterns
-                            && !v
-                                .inhabited_predicate(self.tcx, adt_def)
-                                .subst(self.tcx, substs)
-                                .apply_ignore_module(self.tcx, self.param_env)
+                        !v.inhabited_predicate(self.tcx, adt_def)
+                            .subst(self.tcx, substs)
+                            .apply_ignore_module(self.tcx, self.param_env)
                     }
                 }) && (adt_def.did().is_local()
                     || !adt_def.is_variant_list_non_exhaustive());

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

@@ -499,8 +499,7 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
         // Emit an extra note if the first uncovered witness would be uninhabited
         // if we disregard visibility.
         let witness_1_is_privately_uninhabited =
-            if cx.tcx.features().exhaustive_patterns
-                && let Some(witness_1) = witnesses.get(0)
+            if let Some(witness_1) = witnesses.get(0)
                 && let ty::Adt(adt, substs) = witness_1.ty().kind()
                 && adt.is_enum()
                 && let Constructor::Variant(variant_index) = witness_1.ctor()

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

@@ -902,9 +902,8 @@ impl<'tcx> SplitWildcard<'tcx> {
         // This determines the set of all possible constructors for the type `pcx.ty`. For numbers,
         // arrays and slices we use ranges and variable-length slices when appropriate.
         //
-        // If the `exhaustive_patterns` feature is enabled, we make sure to omit constructors that
-        // are statically impossible. E.g., for `Option<!>`, we do not include `Some(_)` in the
-        // returned list of constructors.
+        // We omit constructors that are statically impossible. E.g., for `Option<!>`, we do not
+        // include `Some(_)` in the returned list of constructors.
         // Invariant: this is empty if and only if the type is uninhabited (as determined by
         // `cx.is_uninhabited()`).
         let all_ctors = match pcx.ty.kind() {
@@ -941,32 +940,21 @@ impl<'tcx> SplitWildcard<'tcx> {
                 // witness.
                 let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive_enum(pcx.ty);
 
-                let is_exhaustive_pat_feature = cx.tcx.features().exhaustive_patterns;
-
-                // 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() && !is_exhaustive_pat_feature && !pcx.is_top_level;
-
                 let mut ctors: SmallVec<[_; 1]> = def
                     .variants()
                     .iter_enumerated()
                     .filter(|(_, v)| {
-                        // If `exhaustive_patterns` is enabled, we exclude variants known to be
-                        // uninhabited.
-                        !is_exhaustive_pat_feature
-                            || v.inhabited_predicate(cx.tcx, *def).subst(cx.tcx, substs).apply(
-                                cx.tcx,
-                                cx.param_env,
-                                cx.module,
-                            )
+                        // exclude variants known to be uninhabited.
+                        v.inhabited_predicate(cx.tcx, *def).subst(cx.tcx, substs).apply(
+                            cx.tcx,
+                            cx.param_env,
+                            cx.module,
+                        )
                     })
                     .map(|(idx, _)| Variant(idx))
                     .collect();
 
-                if is_secretly_empty || is_declared_nonexhaustive {
+                if is_declared_nonexhaustive {
                     ctors.push(NonExhaustive);
                 }
                 ctors
@@ -998,12 +986,6 @@ impl<'tcx> SplitWildcard<'tcx> {
                 let max = size.truncate(u128::MAX);
                 smallvec![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 => {
-                smallvec![NonExhaustive]
-            }
             ty::Never => smallvec![],
             _ if cx.is_uninhabited(pcx.ty) => smallvec![],
             ty::Adt(..) | ty::Tuple(..) | ty::Ref(..) => smallvec![Single],

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

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

compiler/rustc_target/src/lib.rs

@@ -10,7 +10,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![feature(assert_matches)]
 #![feature(associated_type_bounds)]
-#![feature(exhaustive_patterns)]
+#![cfg_attr(bootstrap, feature(exhaustive_patterns))]
 #![feature(iter_intersperse)]
 #![feature(min_specialization)]
 #![feature(never_type)]

compiler/rustc_traits/src/chalk/lowering.rs

@@ -552,6 +552,7 @@ impl<'tcx> LowerInto<'tcx, Region<'tcx>> for &chalk_ir::Lifetime<RustInterner<'t
             ),
             chalk_ir::LifetimeData::Static => tcx.lifetimes.re_static,
             chalk_ir::LifetimeData::Erased => tcx.lifetimes.re_erased,
+            #[cfg(bootstrap)]
             chalk_ir::LifetimeData::Phantom(void, _) => match *void {},
         }
     }

compiler/rustc_transmute/src/layout/nfa.rs

@@ -86,6 +86,7 @@ where
     pub(crate) fn from_tree(tree: Tree<!, R>) -> Result<Self, Uninhabited> {
         Ok(match tree {
             Tree::Byte(b) => Self::from_byte(b),
+            #[cfg(bootstrap)]
             Tree::Def(..) => unreachable!(),
             Tree::Ref(r) => Self::from_ref(r),
             Tree::Alt(alts) => {