impl BikeshedGuaranteedNoDrop for MaybeUninit<T>

Author: eggyal

compiler/rustc_middle/src/ty/adt.rs

@@ -59,6 +59,8 @@ bitflags::bitflags! {
         const IS_PIN                        = 1 << 11;
         /// Indicates whether the type is `#[pin_project]`.
         const IS_PIN_PROJECT                = 1 << 12;
+        /// Indicates whether the type is `MaybeUninit`.
+        const IS_MAYBE_UNINIT               = 1 << 13;
     }
 }
 rustc_data_structures::external_bitflags_debug! { AdtFlags }
@@ -224,6 +226,10 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
         self.is_manually_drop()
     }
 
+    fn is_maybe_uninit(self) -> bool {
+        self.is_maybe_uninit()
+    }
+
     fn all_field_tys(
         self,
         tcx: TyCtxt<'tcx>,
@@ -315,6 +321,9 @@ impl AdtDefData {
         if tcx.is_lang_item(did, LangItem::ManuallyDrop) {
             flags |= AdtFlags::IS_MANUALLY_DROP;
         }
+        if tcx.is_lang_item(did, LangItem::MaybeUninit) {
+            flags |= AdtFlags::IS_MAYBE_UNINIT;
+        }
         if tcx.is_lang_item(did, LangItem::UnsafeCell) {
             flags |= AdtFlags::IS_UNSAFE_CELL;
         }
@@ -439,6 +448,12 @@ impl<'tcx> AdtDef<'tcx> {
         self.flags().contains(AdtFlags::IS_MANUALLY_DROP)
     }
 
+    /// Returns `true` if this is `ManuallyDrop<T>`.
+    #[inline]
+    pub fn is_maybe_uninit(self) -> bool {
+        self.flags().contains(AdtFlags::IS_MAYBE_UNINIT)
+    }
+
     /// Returns `true` if this is `Pin<T>`.
     #[inline]
     pub fn is_pin(self) -> bool {

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -701,8 +701,8 @@ where
             match ty.kind() {
                 // `&mut T` and `&T` always implement `BikeshedGuaranteedNoDrop`.
                 ty::Ref(..) => {}
-                // `ManuallyDrop<T>` always implements `BikeshedGuaranteedNoDrop`.
-                ty::Adt(def, _) if def.is_manually_drop() => {}
+                // `ManuallyDrop<T>` and `MaybeUninit<T>` always implement `BikeshedGuaranteedNoDrop`.
+                ty::Adt(def, _) if def.is_manually_drop() || def.is_maybe_uninit() => {}
                 // Arrays and tuples implement `BikeshedGuaranteedNoDrop` only if
                 // their constituent types implement `BikeshedGuaranteedNoDrop`.
                 ty::Tuple(tys) => {

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -1257,8 +1257,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         match *self_ty.skip_binder().kind() {
             // `&mut T` and `&T` always implement `BikeshedGuaranteedNoDrop`.
             ty::Ref(..) => {}
-            // `ManuallyDrop<T>` always implements `BikeshedGuaranteedNoDrop`.
-            ty::Adt(def, _) if def.is_manually_drop() => {}
+            // `ManuallyDrop<T>` and `MaybeUninit<T>` always implement `BikeshedGuaranteedNoDrop`.
+            ty::Adt(def, _) if def.is_manually_drop() || def.is_maybe_uninit() => {}
             // Arrays and tuples implement `BikeshedGuaranteedNoDrop` only if
             // their constituent types implement `BikeshedGuaranteedNoDrop`.
             ty::Tuple(tys) => {

compiler/rustc_type_ir/src/inherent.rs

@@ -566,6 +566,7 @@ pub trait AdtDef<I: Interner>: Copy + Debug + Hash + Eq {
     fn is_phantom_data(self) -> bool;
 
     fn is_manually_drop(self) -> bool;
+    fn is_maybe_uninit(self) -> bool;
 
     // FIXME: perhaps use `all_fields` and expose `FieldDef`.
     fn all_field_tys(self, interner: I) -> ty::EarlyBinder<I, impl IntoIterator<Item = I::Ty>>;

library/core/src/marker.rs

@@ -496,6 +496,7 @@ impl<T: PointeeSized> Copy for &T {}
 /// Implemented for:
 /// * `&T`, `&mut T` for all `T`,
 /// * `ManuallyDrop<T>` for all `T`,
+/// * `MaybeUninit<T>` for all `T`,
 /// * tuples and arrays whose elements implement `BikeshedGuaranteedNoDrop`,
 /// * or otherwise, all types that are `Copy`.
 ///