Use query for Variant InhabitedPredicate

Author: camsteffen

compiler/rustc_lint/src/builtin.rs

@@ -2522,8 +2522,9 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
                     // And now, enums.
                     let span = cx.tcx.def_span(adt_def.did());
                     let mut potential_variants = adt_def.variants().iter().filter_map(|variant| {
-                        let definitely_inhabited = match variant
-                            .inhabited_predicate(cx.tcx, *adt_def)
+                        let definitely_inhabited = match cx
+                            .tcx
+                            .inhabited_predicate_adt(variant.def_id)
                             .instantiate(cx.tcx, args)
                             .apply_any_module(cx.tcx, cx.typing_env())
                         {

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

@@ -46,6 +46,7 @@
 use std::assert_matches;
 
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::def::DefKind;
 use rustc_span::def_id::LocalModId;
 use rustc_type_ir::TyKind::*;
 use tracing::instrument;
@@ -69,47 +70,53 @@ pub(crate) fn provide(providers: &mut Providers) {
 /// Returns an `InhabitedPredicate` that is generic over type parameters and
 /// requires calling [`InhabitedPredicate::instantiate`]
 fn inhabited_predicate_adt(tcx: TyCtxt<'_>, def_id: DefId) -> InhabitedPredicate<'_> {
-    if let Some(def_id) = def_id.as_local() {
-        tcx.ensure_ok().check_representability(def_id);
+    match tcx.def_kind(def_id) {
+        DefKind::Enum => {
+            if let Some(def_id) = def_id.as_local() {
+                tcx.ensure_ok().check_representability(def_id);
+            }
+            let adt = tcx.adt_def(def_id);
+            InhabitedPredicate::any(
+                tcx,
+                adt.variants().iter().map(|v| tcx.inhabited_predicate_adt(v.def_id)),
+            )
+        }
+        DefKind::Struct => {
+            if let Some(def_id) = def_id.as_local() {
+                tcx.ensure_ok().check_representability(def_id);
+            }
+            let adt = tcx.adt_def(def_id);
+            variant_inhabited_predicate(tcx, adt.non_enum_variant())
+        }
+        DefKind::Variant => {
+            let adt = tcx.adt_def(tcx.parent(def_id));
+            let variant = adt.variant_with_id(def_id);
+            variant_inhabited_predicate(tcx, variant)
+        }
+        def_kind => bug!("unexpected DefKind: {def_kind:?}"),
     }
+}
 
-    let adt = tcx.adt_def(def_id);
-    InhabitedPredicate::any(
+fn variant_inhabited_predicate<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    variant: &VariantDef,
+) -> InhabitedPredicate<'tcx> {
+    InhabitedPredicate::all(
         tcx,
-        adt.variants().iter().map(|variant| variant.inhabited_predicate(tcx, adt)),
+        variant.fields.iter().map(|field| {
+            let pred = tcx
+                .type_of(field.did)
+                .instantiate_identity()
+                .skip_norm_wip()
+                .inhabited_predicate(tcx);
+            match field.vis {
+                Visibility::Public => pred,
+                Visibility::Restricted(from) => InhabitedPredicate::NotInModule(from).or(tcx, pred),
+            }
+        }),
     )
 }
 
-impl<'tcx> VariantDef {
-    /// Calculates the forest of `DefId`s from which this variant is visibly uninhabited.
-    pub fn inhabited_predicate(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        adt: ty::AdtDef<'_>,
-    ) -> InhabitedPredicate<'tcx> {
-        debug_assert!(!adt.is_union());
-        InhabitedPredicate::all(
-            tcx,
-            self.fields.iter().map(|field| {
-                let pred = tcx
-                    .type_of(field.did)
-                    .instantiate_identity()
-                    .skip_norm_wip()
-                    .inhabited_predicate(tcx);
-                if adt.is_enum() {
-                    return pred;
-                }
-                match field.vis {
-                    Visibility::Public => pred,
-                    Visibility::Restricted(from) => {
-                        InhabitedPredicate::NotInModule(from).or(tcx, pred)
-                    }
-                }
-            }),
-        )
-    }
-}
-
 impl<'tcx> Ty<'tcx> {
     #[instrument(level = "debug", skip(tcx), ret)]
     pub fn inhabited_predicate(self, tcx: TyCtxt<'tcx>) -> InhabitedPredicate<'tcx> {

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

@@ -730,12 +730,11 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         let witness_1_is_privately_uninhabited = if let Some(witness_1) = witnesses.get(0)
             && let ty::Adt(adt, args) = witness_1.ty().kind()
             && adt.is_enum()
-            && let Constructor::Variant(variant_index) = witness_1.ctor()
+            && let Constructor::Variant(variant_index) = *witness_1.ctor()
         {
-            let variant_inhabited = adt
-                .variant(*variant_index)
-                .inhabited_predicate(self.tcx, *adt)
-                .instantiate(self.tcx, args);
+            let variant_def_id = adt.variant(variant_index).def_id;
+            let variant_inhabited =
+                self.tcx.inhabited_predicate_adt(variant_def_id).instantiate(self.tcx, args);
             variant_inhabited.apply(self.tcx, cx.typing_env, cx.module)
                 && !variant_inhabited.apply_ignore_module(self.tcx, cx.typing_env)
         } else {

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -377,10 +377,11 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                     let mut variants =
                         IndexVec::from_elem(VariantVisibility::Visible, def.variants());
                     for (idx, v) in def.variants().iter_enumerated() {
-                        let variant_def_id = def.variant(idx).def_id;
+                        let variant_def_id = v.def_id;
                         // Visibly uninhabited variants.
-                        let is_inhabited = v
-                            .inhabited_predicate(cx.tcx, *def)
+                        let is_inhabited = self
+                            .tcx
+                            .inhabited_predicate_adt(variant_def_id)
                             .instantiate(cx.tcx, args)
                             .apply_revealing_opaque(cx.tcx, cx.typing_env, cx.module, &|key| {
                                 cx.reveal_opaque_key(key)