Update based on feedback

- Add/revise comments
- Move helper functions inside the functions being tested
- Remove `inline` annotation for non-async case to make it more similar
  to the async case

Author: bryangarza

tests/pass/move-data-across-await-point.rs

@@ -3,35 +3,49 @@ use std::future::Future;
 // This test:
 // - Compares addresses of non-Copy data before and after moving it
 // - Writes to the pointer after it has moved across the await point
+//
+// This is only meant to assert current behavior, not guarantee that this is
+// how it should work in the future. In fact, upcoming changes to rustc
+// *should* break these tests.
+// See: https://github.com/rust-lang/rust/issues/62958
 async fn data_moved_async() {
+    async fn helper(mut data: Vec<u8>, raw_pointer: *mut Vec<u8>) {
+        let raw_pointer2 = &mut data as *mut Vec<u8>;
+        // When the Vec is moved into the generator upvar, that copies the Vec's
+        // ptr+capacity+len that is on the stack. Because of that, the value of
+        // `raw_pointer2` is different than that of `raw_pointer`.
+        //
+        // When copy propagation is enabled for generator upvars, the pointer
+        // addresses should be equal, becouse there will no longer be a
+        // generator upvar; instead, the function's `data` argument will be
+        // used directly.
+        assert_ne!(raw_pointer, raw_pointer2);
+        unsafe {
+            // This writes into the `x` in `data_moved_async`, re-initializing it.
+            std::ptr::write(raw_pointer, vec![3]);
+        }
+    }
     // Vec<T> is not Copy
     let mut x: Vec<u8> = vec![2];
     let raw_pointer = &mut x as *mut Vec<u8>;
-    helper_async(x, raw_pointer).await;
+    helper(x, raw_pointer).await;
     unsafe {
         assert_eq!(*raw_pointer, vec![3]);
         // Drop to prevent leak.
         std::ptr::drop_in_place(raw_pointer);
     }
 }
 
-async fn helper_async(mut data: Vec<u8>, raw_pointer: *mut Vec<u8>) {
-    let raw_pointer2 = &mut data as *mut Vec<u8>;
-    // Addresses are different because the generator upvar for `data` is a copy.
-    // To be more precise, there is a `move` happening in the MIR of the
-    // generator closure, which copies the pointer.
-    //
-    // When copy propagation is enabled for generator upvars, the pointer addresses
-    // here should be equal.
-    assert_ne!(raw_pointer, raw_pointer2);
-    unsafe {
-        // This writes into the `x` in `data_moved_async`, re-initializing it.
-        std::ptr::write(raw_pointer, vec![3]);
-    }
-}
-
 // Same thing as above, but non-async.
 fn data_moved() {
+    fn helper(mut data: Vec<u8>, raw_pointer: *mut Vec<u8>) {
+        let raw_pointer2 = &mut data as *mut Vec<u8>;
+        assert_ne!(raw_pointer, raw_pointer2);
+        unsafe {
+            std::ptr::write(raw_pointer, vec![3]);
+        }
+    }
+
     let mut x: Vec<u8> = vec![2];
     let raw_pointer = &mut x as *mut Vec<u8>;
     helper(x, raw_pointer);
@@ -41,15 +55,6 @@ fn data_moved() {
     }
 }
 
-#[inline(always)]
-fn helper(mut data: Vec<u8>, raw_pointer: *mut Vec<u8>) {
-    let raw_pointer2 = &mut data as *mut Vec<u8>;
-    assert_ne!(raw_pointer, raw_pointer2);
-    unsafe {
-        std::ptr::write(raw_pointer, vec![3]);
-    }
-}
-
 fn run_fut<T>(fut: impl Future<Output = T>) -> T {
     use std::sync::Arc;
     use std::task::{Context, Poll, Wake, Waker};