Factor out the condition for hiding fields

Author: Nadrieril

src/librustc_mir_build/hair/pattern/_match.rs

@@ -620,6 +620,27 @@ impl<'a, 'tcx> MatchCheckCtxt<'a, 'tcx> {
             _ => false,
         }
     }
+
+    /// In the cases of either a `#[non_exhaustive]` field list or a non-public field, we hide
+    /// uninhabited fields in order not to reveal the uninhabitedness of the whole variant.
+    fn hide_uninhabited_field(
+        &self,
+        adt_ty: Ty<'tcx>,
+        variant: &VariantDef,
+        field: &FieldDef,
+    ) -> bool {
+        match adt_ty.kind {
+            ty::Adt(def, substs) => {
+                let is_non_exhaustive = self.is_foreign_non_exhaustive_variant(adt_ty, variant);
+                let field_ty = field.ty(self.tcx, substs);
+                let is_visible =
+                    adt.is_enum() || field.vis.is_accessible_from(self.module, self.tcx);
+                let is_uninhabited = self.is_uninhabited(field_ty);
+                is_uninhabited && (!is_visible || is_non_exhaustive)
+            }
+            _ => false,
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -881,30 +902,19 @@ impl<'tcx> Constructor<'tcx> {
                         vec![Pat::wildcard_from_ty(substs.type_at(0))]
                     } else {
                         let variant = &adt.variants[self.variant_index_for_adt(cx, adt)];
-                        let is_non_exhaustive = cx.is_foreign_non_exhaustive_variant(ty, variant);
                         variant
                             .fields
                             .iter()
                             .map(|field| {
-                                let ty = field.ty(cx.tcx, substs);
-                                let is_visible = adt.is_enum()
-                                    || field.vis.is_accessible_from(cx.module, cx.tcx);
-                                let is_inhabited = !cx.is_uninhabited(ty);
-                                // Treat all uninhabited non-visible fields as `TyErr`. They can't
-                                // appear in any other pattern from this match (because they are
-                                // private), so their type does not matter - but we don't want
-                                // to know they are uninhabited.
-                                // Also treat all uninhabited types in non-exhaustive variants as
-                                // `TyErr`.
-                                let allowed_to_inspect =
-                                    is_inhabited || (is_visible && !is_non_exhaustive);
-
-                                if allowed_to_inspect {
-                                    Pat::wildcard_from_ty(ty)
+                                // Treat hidden fields as TyErr so we don't know they are
+                                // uninhabited.
+                                if cx.hide_uninhabited_field(ty, variant, field) {
+                                    cx.tcx.types.err
                                 } else {
-                                    Pat::wildcard_from_ty(cx.tcx.types.err)
+                                    field.ty(cx.tcx, substs)
                                 }
                             })
+                            .map(Pat::wildcard_from_ty)
                             .collect()
                     }
                 }