Don't consider unstable fields always-inhabited

This reverts the hack in #133889
now that `Pin`'s field is no longer public.

Author: Nadrieril

compiler/rustc_middle/src/ty/inhabitedness/mod.rs

@@ -43,7 +43,6 @@
 //! This code should only compile in modules where the uninhabitedness of `Foo`
 //! is visible.
 
-use rustc_span::sym;
 use rustc_type_ir::TyKind::*;
 use tracing::instrument;
 
@@ -85,21 +84,6 @@ impl<'tcx> VariantDef {
         InhabitedPredicate::all(
             tcx,
             self.fields.iter().map(|field| {
-                // Unstable fields are always considered to be inhabited. In the future,
-                // this could be extended to be conditional on the field being unstable
-                // only within the module that's querying the inhabitedness, like:
-                //     `let pred = pred.or(InhabitedPredicate::IsUnstable(field.did));`
-                // but this is unnecessary for now, since it would only affect nightly-only
-                // code or code within the standard library itself.
-                // HACK: We filter out `rustc_private` fields since with the flag
-                // `-Zforce-unstable-if-unmarked` we consider all unmarked fields to be
-                // unstable when building the compiler.
-                if tcx
-                    .lookup_stability(field.did)
-                    .is_some_and(|stab| stab.is_unstable() && stab.feature != sym::rustc_private)
-                {
-                    return InhabitedPredicate::True;
-                }
                 let pred = tcx.type_of(field.did).instantiate_identity().inhabited_predicate(tcx);
                 if adt.is_enum() {
                     return pred;

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -15,7 +15,7 @@ use rustc_middle::ty::{
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
-use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, sym};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
 use crate::constructor::Constructor::*;
 use crate::constructor::{
@@ -227,10 +227,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                         let is_visible =
                             adt.is_enum() || field.vis.is_accessible_from(cx.module, cx.tcx);
                         let is_uninhabited = cx.is_uninhabited(*ty);
-                        let is_unstable = cx.tcx.lookup_stability(field.did).is_some_and(|stab| {
-                            stab.is_unstable() && stab.feature != sym::rustc_private
-                        });
-                        let skip = is_uninhabited && (!is_visible || is_unstable);
+                        let skip = is_uninhabited && !is_visible;
                         (ty, PrivateUninhabitedField(skip))
                     });
                     cx.dropless_arena.alloc_from_iter(tys)

tests/ui/uninhabited/uninhabited-unstable-field.current.stderr

@@ -1,6 +1,9 @@
 //@ aux-build: staged-api.rs
-//@ revisions: current exhaustive
-#![cfg_attr(exhaustive, feature(exhaustive_patterns))]
+//! The field of `Pin` used to be public, which would cause `Pin<Void>` to be uninhabited. To remedy
+//! this, we temporarily made it so unstable fields are always considered uninhabited. This has now
+//! been reverted, and this file ensures that we don't special-case unstable fields wrt
+//! inhabitedness anymore.
+#![feature(exhaustive_patterns)]
 #![feature(never_type)]
 #![feature(my_coro_state)] // Custom feature from `staged-api.rs`
 #![deny(unreachable_patterns)]
@@ -13,31 +16,29 @@ enum Void {}
 
 fn demo(x: Foo<Void>) {
     match x {}
-    //~^ ERROR non-exhaustive patterns
 }
 
-// Ensure that the pattern is not considered unreachable.
+// Ensure that the pattern is considered unreachable.
 fn demo2(x: Foo<Void>) {
     match x {
-        Foo { .. } => {}
+        Foo { .. } => {} //~ ERROR unreachable
     }
 }
 
 // Same as above, but for wildcard.
 fn demo3(x: Foo<Void>) {
     match x {
-        _ => {}
+        _ => {} //~ ERROR unreachable
     }
 }
 
 fn unstable_enum(x: MyCoroutineState<i32, !>) {
     match x {
-        //~^ ERROR non-exhaustive patterns
         MyCoroutineState::Yielded(_) => {}
     }
     match x {
         MyCoroutineState::Yielded(_) => {}
-        MyCoroutineState::Complete(_) => {}
+        MyCoroutineState::Complete(_) => {} //~ ERROR unreachable
     }
 }
 

tests/ui/uninhabited/uninhabited-unstable-field.exhaustive.stderr

@@ -0,0 +1,40 @@
+error: unreachable pattern
+  --> $DIR/uninhabited-unstable-field.rs:20:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^------
+   |         |
+   |         matches no values because `Foo<Void>` is uninhabited
+   |         help: remove the match arm
+   |
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
+note: the lint level is defined here
+  --> $DIR/uninhabited-unstable-field.rs:5:9
+   |
+LL | #![deny(unreachable_patterns)]
+   |         ^^^^^^^^^^^^^^^^^^^^
+
+error: unreachable pattern
+  --> $DIR/uninhabited-unstable-field.rs:27:9
+   |
+LL |         _ => {}
+   |         ^------
+   |         |
+   |         matches no values because `Foo<Void>` is uninhabited
+   |         help: remove the match arm
+   |
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
+
+error: unreachable pattern
+  --> $DIR/uninhabited-unstable-field.rs:37:9
+   |
+LL |         MyCoroutineState::Complete(_) => {}
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------
+   |         |
+   |         matches no values because `!` is uninhabited
+   |         help: remove the match arm
+   |
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
+
+error: aborting due to 3 previous errors
+