change type of async_drop_in_place to accept &mut _

Author: WaffleLapkin

compiler/rustc_mir_transform/src/elaborate_drop.rs

@@ -354,7 +354,6 @@ where
             let ty::Adt(adt_def, adt_args) = pin_obj_ty.kind() else {
                 bug!();
             };
-            let obj_ptr_ty = Ty::new_mut_ptr(tcx, drop_ty);
             let unwrap_ty = adt_def.non_enum_variant().fields[FieldIdx::ZERO].ty(tcx, adt_args);
             let obj_ref_place = Place::from(self.new_temp(unwrap_ty));
             call_statements.push(self.assign(
@@ -366,11 +365,7 @@ where
                 ))),
             ));
 
-            let obj_ptr_place = Place::from(self.new_temp(obj_ptr_ty));
-
-            let addr = Rvalue::RawPtr(RawPtrKind::Mut, tcx.mk_place_deref(obj_ref_place));
-            call_statements.push(self.assign(obj_ptr_place, addr));
-            obj_ptr_place
+            obj_ref_place
         };
         call_statements
             .push(Statement::new(self.source_info, StatementKind::StorageLive(fut.local)));

compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs

@@ -51,7 +51,7 @@ pub(super) fn build_async_drop_shim<'tcx>(
     let typing_env = ty::TypingEnv::fully_monomorphized();
 
     let drop_ty = parent_args.first().unwrap().expect_ty();
-    let drop_ptr_ty = Ty::new_mut_ptr(tcx, drop_ty);
+    let drop_ptr_ty = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, drop_ty);
 
     assert!(tcx.is_coroutine(def_id));
     let coroutine_kind = tcx.coroutine_kind(def_id).unwrap();
@@ -209,7 +209,7 @@ fn build_adrop_for_coroutine_shim<'tcx>(
     let source_info = SourceInfo::outermost(span);
     // converting `(_1: Pin<&mut CorLayout>, _2: &mut Context<'_>) -> Poll<()>`
     // into `(_1: Pin<&mut ProxyLayout>, _2: &mut Context<'_>) -> Poll<()>`
-    // let mut _x: &mut CorLayout = &*_1.0.0;
+    // let mut _x: &mut CorLayout = &mut *_1.0.0;
     // Replace old _1.0 accesses into _x accesses;
     let body = tcx.optimized_mir(*coroutine_def_id).future_drop_poll().unwrap();
     let mut body: Body<'tcx> = EarlyBinder::bind(body.clone()).instantiate(tcx, impl_args);
@@ -231,7 +231,7 @@ fn build_adrop_for_coroutine_shim<'tcx>(
 
     {
         let mut idx: usize = 0;
-        // _proxy = _1.0 : Pin<&ProxyLayout> ==> &ProxyLayout
+        // _proxy = _1.0 : Pin<&mut ProxyLayout> ==> &mut ProxyLayout
         let proxy_ref_place = Place::from(pin_proxy_layout_local)
             .project_deeper(&[PlaceElem::Field(FieldIdx::ZERO, proxy_ref)], tcx);
         body.basic_blocks_mut()[START_BLOCK].statements.insert(
@@ -245,22 +245,23 @@ fn build_adrop_for_coroutine_shim<'tcx>(
             ),
         );
         idx += 1;
-        let mut cor_ptr_local = proxy_ref_local;
+
+        // _cor_ref_tmp = (*(*_proxy).0).0...
+        let mut cor_ref_tmp_local = proxy_ref_local;
         proxy_ty.find_async_drop_impl_coroutine(tcx, |ty| {
             if ty != proxy_ty {
-                let ty_ptr = Ty::new_mut_ptr(tcx, ty);
-                let impl_ptr_place = Place::from(cor_ptr_local).project_deeper(
-                    &[PlaceElem::Deref, PlaceElem::Field(FieldIdx::ZERO, ty_ptr)],
+                let ty_ref = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, ty);
+                let impl_ptr_place = Place::from(cor_ref_tmp_local).project_deeper(
+                    &[PlaceElem::Deref, PlaceElem::Field(FieldIdx::ZERO, ty_ref)],
                     tcx,
                 );
-                cor_ptr_local = body.local_decls.push(LocalDecl::new(ty_ptr, span));
-                // _cor_ptr = _proxy.0.0 (... .0)
+                cor_ref_tmp_local = body.local_decls.push(LocalDecl::new(ty_ref, span));
                 body.basic_blocks_mut()[START_BLOCK].statements.insert(
                     idx,
                     Statement::new(
                         source_info,
                         StatementKind::Assign(Box::new((
-                            Place::from(cor_ptr_local),
+                            Place::from(cor_ref_tmp_local),
                             Rvalue::Use(Operand::Copy(impl_ptr_place)),
                         ))),
                     ),
@@ -269,17 +270,15 @@ fn build_adrop_for_coroutine_shim<'tcx>(
             }
         });
 
-        // _cor_ref = &*cor_ptr
-        let reborrow = Rvalue::Ref(
-            tcx.lifetimes.re_erased,
-            BorrowKind::Mut { kind: MutBorrowKind::Default },
-            tcx.mk_place_deref(Place::from(cor_ptr_local)),
-        );
+        // _cor_ref = cor_ref_tmp
         body.basic_blocks_mut()[START_BLOCK].statements.insert(
             idx,
             Statement::new(
                 source_info,
-                StatementKind::Assign(Box::new((Place::from(cor_ref_local), reborrow))),
+                StatementKind::Assign(Box::new((
+                    Place::from(cor_ref_local),
+                    Rvalue::Use(Operand::Move(Place::from(cor_ref_tmp_local))),
+                ))),
             ),
         );
     }
@@ -341,7 +340,7 @@ fn build_adrop_for_adrop_shim<'tcx>(
     let mut cor_ptr_local = proxy_ref_local;
     proxy_ty.find_async_drop_impl_coroutine(tcx, |ty| {
         if ty != proxy_ty {
-            let ty_ptr = Ty::new_mut_ptr(tcx, ty);
+            let ty_ptr = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, ty);
             let impl_ptr_place = Place::from(cor_ptr_local)
                 .project_deeper(&[PlaceElem::Deref, PlaceElem::Field(FieldIdx::ZERO, ty_ptr)], tcx);
             cor_ptr_local = locals.push(LocalDecl::new(ty_ptr, span));

library/core/src/future/async_drop.rs

@@ -52,8 +52,7 @@ pub trait AsyncDrop {
 /// [ptr::drop_in_place]: crate::ptr::drop_in_place()
 #[unstable(feature = "async_drop", issue = "126482")]
 #[lang = "async_drop_in_place"]
-// FIXME: accept a reference here instead
-pub async unsafe fn async_drop_in_place<T: ?Sized>(_to_drop: *mut T) {
+pub async unsafe fn async_drop_in_place<T: ?Sized>(_to_drop: &mut T) {
     // Code here does not matter - this is replaced by the
     // real implementation by the compiler.
 }

src/tools/miri/tests/pass/async-drop.rs

@@ -18,7 +18,7 @@ use core::task::{Context, Poll, Waker};
 
 async fn test_async_drop<T>(x: T) {
     let mut x = mem::MaybeUninit::new(x);
-    let dtor = pin!(unsafe { async_drop_in_place(x.as_mut_ptr()) });
+    let dtor = pin!(unsafe { async_drop_in_place(&mut *x.as_mut_ptr()) });
     test_idempotency(dtor).await;
 }
 
@@ -69,7 +69,7 @@ fn main() {
             .await;
 
         let mut ptr19 = mem::MaybeUninit::new(AsyncInt(19));
-        let async_drop_fut = pin!(unsafe { async_drop_in_place(ptr19.as_mut_ptr()) });
+        let async_drop_fut = pin!(unsafe { async_drop_in_place(&mut *ptr19.as_mut_ptr()) });
         test_idempotency(async_drop_fut).await;
 
         let foo = AsyncInt(20);

tests/ui/async-await/async-drop/async-drop-initial.rs

@@ -11,15 +11,15 @@
 //@ edition: 2021
 
 // FIXME(zetanumbers): consider AsyncDestruct::async_drop cleanup tests
-use core::future::{async_drop_in_place, AsyncDrop, Future};
+use core::future::{AsyncDrop, Future, async_drop_in_place};
 use core::hint::black_box;
 use core::mem::{self, ManuallyDrop};
-use core::pin::{pin, Pin};
+use core::pin::{Pin, pin};
 use core::task::{Context, Poll, Waker};
 
 async fn test_async_drop<T>(x: T, _size: usize) {
     let mut x = mem::MaybeUninit::new(x);
-    let dtor = pin!(unsafe { async_drop_in_place(x.as_mut_ptr()) });
+    let dtor = pin!(unsafe { async_drop_in_place(&mut *x.as_mut_ptr()) });
 
     // FIXME(zetanumbers): This check fully depends on the layout of
     // the coroutine state, since async destructor combinators are just
@@ -60,10 +60,7 @@ fn main() {
         let j = 42;
         test_async_drop(&i, 16).await;
         test_async_drop(&j, 16).await;
-        test_async_drop(
-            AsyncStruct { b: AsyncInt(8), a: AsyncInt(7), i: 6 },
-            136,
-        ).await;
+        test_async_drop(AsyncStruct { b: AsyncInt(8), a: AsyncInt(7), i: 6 }, 136).await;
         test_async_drop(ManuallyDrop::new(AsyncInt(9)), 16).await;
 
         let foo = AsyncInt(10);
@@ -92,7 +89,7 @@ fn main() {
         .await;
 
         let mut ptr19 = mem::MaybeUninit::new(AsyncInt(19));
-        let async_drop_fut = pin!(unsafe { async_drop_in_place(ptr19.as_mut_ptr()) });
+        let async_drop_fut = pin!(unsafe { async_drop_in_place(&mut *ptr19.as_mut_ptr()) });
         test_idempotency(async_drop_fut).await;
 
         let foo = AsyncInt(20);
@@ -228,19 +225,13 @@ union AsyncUnion {
 
 impl Drop for AsyncUnion {
     fn drop(&mut self) {
-        println!(
-            "AsyncUnion::drop: {}, {}",
-            unsafe { self.signed },
-            unsafe { self.unsigned },
-        );
+        println!("AsyncUnion::drop: {}, {}", unsafe { self.signed }, unsafe { self.unsigned },);
     }
 }
 impl AsyncDrop for AsyncUnion {
     async fn drop(self: Pin<&mut Self>) {
-        println!(
-            "AsyncUnion::Dropper::poll: {}, {}",
-            unsafe { self.signed },
-            unsafe { self.unsigned },
-        );
+        println!("AsyncUnion::Dropper::poll: {}, {}", unsafe { self.signed }, unsafe {
+            self.unsigned
+        },);
     }
 }

tests/ui/async-await/async-drop/ex-ice-132103.rs

@@ -6,14 +6,14 @@
 #![feature(async_drop)]
 #![allow(incomplete_features)]
 
-use core::future::{async_drop_in_place, Future};
+use core::future::{Future, async_drop_in_place};
 use core::mem::{self};
 use core::pin::pin;
 use core::task::{Context, Waker};
 
 async fn test_async_drop<T>(x: T) {
     let mut x = mem::MaybeUninit::new(x);
-    pin!(unsafe { async_drop_in_place(x.as_mut_ptr()) });
+    pin!(unsafe { async_drop_in_place(&mut *x.as_mut_ptr()) });
 }
 
 fn main() {

tests/ui/async-await/async-drop/open-drop-error2.rs

@@ -3,19 +3,17 @@
 #![feature(async_drop)]
 #![allow(incomplete_features)]
 
-use std::{
-    future::{Future, async_drop_in_place},
-    pin::pin,
-    task::Context,
-};
+use std::future::{Future, async_drop_in_place};
+use std::pin::pin;
+use std::task::Context;
 
 fn wrong() -> impl Sized {
     //~^ ERROR: the size for values of type `str` cannot be known at compilation time
     *"abc" // Doesn't implement Sized
 }
 fn weird(context: &mut Context<'_>) {
     let mut e = wrong();
-    let h = unsafe { async_drop_in_place(&raw mut e) };
+    let h = unsafe { async_drop_in_place(&mut e) };
     let i = pin!(h);
     i.poll(context);
 }

tests/ui/async-await/async-drop/open-drop-error2.stderr

@@ -1,5 +1,5 @@
 error[E0277]: the size for values of type `str` cannot be known at compilation time
-  --> $DIR/open-drop-error2.rs:12:15
+  --> $DIR/open-drop-error2.rs:10:15
    |
 LL | fn wrong() -> impl Sized {
    |               ^^^^^^^^^^ doesn't have a size known at compile-time