use MaybeDangling in std

Author: WaffleLapkin

compiler/rustc_hir/src/lang_items.rs

@@ -353,7 +353,8 @@ language_item_table! {
 
     PhantomData,             sym::phantom_data,        phantom_data,               Target::Struct,         GenericRequirement::Exact(1);
 
-    ManuallyDrop,            sym::manually_drop,       manually_drop,              Target::Struct,         GenericRequirement::None;
+    ManuallyDrop,            sym::manually_drop,       manually_drop,              Target::Struct,         GenericRequirement::Exact(1);
+    MaybeDangling,           sym::maybe_dangling,      maybe_dangling,             Target::Struct,         GenericRequirement::Exact(1);
     BikeshedGuaranteedNoDrop, sym::bikeshed_guaranteed_no_drop, bikeshed_guaranteed_no_drop, Target::Trait, GenericRequirement::Exact(0);
 
     MaybeUninit,             sym::maybe_uninit,        maybe_uninit,               Target::Union,          GenericRequirement::None;

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 `MaybeDangling<_>`.
+        const IS_MAYBE_DANGLING             = 1 << 13;
     }
 }
 rustc_data_structures::external_bitflags_debug! { AdtFlags }
@@ -315,6 +317,9 @@ impl AdtDefData {
         if tcx.is_lang_item(did, LangItem::ManuallyDrop) {
             flags |= AdtFlags::IS_MANUALLY_DROP;
         }
+        if tcx.is_lang_item(did, LangItem::MaybeDangling) {
+            flags |= AdtFlags::IS_MAYBE_DANGLING;
+        }
         if tcx.is_lang_item(did, LangItem::UnsafeCell) {
             flags |= AdtFlags::IS_UNSAFE_CELL;
         }
@@ -439,6 +444,12 @@ impl<'tcx> AdtDef<'tcx> {
         self.flags().contains(AdtFlags::IS_MANUALLY_DROP)
     }
 
+    /// Returns `true` if this is `MaybeDangling<T>`.
+    #[inline]
+    pub fn is_maybe_dangling(self) -> bool {
+        self.flags().contains(AdtFlags::IS_MAYBE_DANGLING)
+    }
+
     /// Returns `true` if this is `Pin<T>`.
     #[inline]
     pub fn is_pin(self) -> bool {

compiler/rustc_middle/src/ty/layout.rs

@@ -1053,6 +1053,12 @@ where
                 })
             }
 
+            ty::Adt(adt_def, ..) if adt_def.is_maybe_dangling() => {
+                // FIXME: what is the exact effect of maybe dangling?
+                Self::ty_and_layout_pointee_info_at(this.field(cx, 0), cx, offset)
+                    .map(|info| PointeeInfo { safe: None, ..info })
+            }
+
             _ => {
                 let mut data_variant = match &this.variants {
                     // Within the discriminant field, only the niche itself is
@@ -1091,7 +1097,7 @@ where
                         }
                     }
                     Variants::Multiple { .. } => None,
-                    _ => Some(this),
+                    Variants::Empty | Variants::Single { .. } => Some(this),
                 };
 
                 if let Some(variant) = data_variant

compiler/rustc_span/src/symbol.rs

@@ -1401,6 +1401,7 @@ symbols! {
         maxnumf128,
         may_dangle,
         may_unwind,
+        maybe_dangling,
         maybe_uninit,
         maybe_uninit_uninit,
         maybe_uninit_zeroed,

library/core/src/mem/maybe_dangling.rs

@@ -61,6 +61,7 @@ use crate::{mem, ptr};
 #[repr(transparent)]
 #[rustc_pub_transparent]
 #[derive(Debug, Copy, Clone, Default)]
+#[lang = "maybe_dangling"]
 pub struct MaybeDangling<P: ?Sized>(P);
 
 impl<P: ?Sized> MaybeDangling<P> {

library/std/src/lib.rs

@@ -345,6 +345,7 @@
 #![feature(int_from_ascii)]
 #![feature(ip)]
 #![feature(lazy_get)]
+#![feature(maybe_dangling)]
 #![feature(maybe_uninit_array_assume_init)]
 #![feature(panic_can_unwind)]
 #![feature(panic_internals)]

library/std/src/thread/lifecycle.rs

@@ -7,7 +7,7 @@ use super::thread::Thread;
 use super::{Result, spawnhook};
 use crate::cell::UnsafeCell;
 use crate::marker::PhantomData;
-use crate::mem::{ManuallyDrop, MaybeUninit};
+use crate::mem::MaybeDangling;
 use crate::sync::Arc;
 use crate::sync::atomic::{Atomic, AtomicUsize, Ordering};
 use crate::sys::thread as imp;
@@ -58,29 +58,8 @@ where
         Arc::new(Packet { scope: scope_data, result: UnsafeCell::new(None), _marker: PhantomData });
     let their_packet = my_packet.clone();
 
-    // Pass `f` in `MaybeUninit` because actually that closure might *run longer than the lifetime of `F`*.
+    // Pass `f` in `MaybeDangling` because actually that closure might *run longer than the lifetime of `F`*.
     // See <https://github.com/rust-lang/rust/issues/101983> for more details.
-    // To prevent leaks we use a wrapper that drops its contents.
-    #[repr(transparent)]
-    struct MaybeDangling<T>(MaybeUninit<T>);
-    impl<T> MaybeDangling<T> {
-        fn new(x: T) -> Self {
-            MaybeDangling(MaybeUninit::new(x))
-        }
-        fn into_inner(self) -> T {
-            // Make sure we don't drop.
-            let this = ManuallyDrop::new(self);
-            // SAFETY: we are always initialized.
-            unsafe { this.0.assume_init_read() }
-        }
-    }
-    impl<T> Drop for MaybeDangling<T> {
-        fn drop(&mut self) {
-            // SAFETY: we are always initialized.
-            unsafe { self.0.assume_init_drop() };
-        }
-    }
-
     let f = MaybeDangling::new(f);
 
     // The entrypoint of the Rust thread, after platform-specific thread

tests/codegen-llvm/manually_drop_refs.rs

@@ -0,0 +1,22 @@
+//@ compile-flags: -Copt-level=3 -Zmerge-functions=disabled
+#![crate_type = "lib"]
+
+use std::mem::ManuallyDrop;
+
+// CHECK: define noundef nonnull ptr @f(ptr noundef nonnull readnone returned {{(captures\(ret: address, provenance\))?}} %x) unnamed_addr
+#[no_mangle]
+pub fn f(x: ManuallyDrop<Box<u8>>) -> ManuallyDrop<Box<u8>> {
+    x
+}
+
+// CHECK: define noundef nonnull ptr @g(ptr noundef nonnull readnone returned {{(captures\(ret: address, provenance\))?}} %x) unnamed_addr
+#[no_mangle]
+pub fn g(x: ManuallyDrop<&u8>) -> ManuallyDrop<&u8> {
+    x
+}
+
+// CHECK: define noundef nonnull ptr @h(ptr noundef nonnull readnone returned {{(captures\(ret: address, provenance\))?}} %x) unnamed_addr
+#[no_mangle]
+pub fn h(x: ManuallyDrop<&mut u8>) -> ManuallyDrop<&mut u8> {
+    x
+}