Use mir_post_borrowck_cleanup from everywhere else (coroutines only)

Author: tmandry

compiler/rustc_mir_transform/src/lib.rs

@@ -555,7 +555,7 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
 
     tcx.ensure_done().check_liveness(def);
 
-    let (body, _) = tcx.mir_promoted(def);
+    let body = tcx.mir_post_borrowck_cleanup(def);
     let mut body = body.steal();
 
     if let Some(error_reported) = tainted_by_errors {

compiler/rustc_mir_transform/src/remove_dead_drops.rs

@@ -12,6 +12,10 @@ impl<'tcx> crate::MirPass<'tcx> for RemoveDeadDrops {
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        if body.coroutine.is_none() {
+            return;
+        }
+
         let move_data = MoveData::gather_moves(body, tcx, |_| true);
 
         let mut maybe_init_cursor = MaybeInitializedPlaces::new(tcx, body, &move_data)

tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir

@@ -105,7 +105,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
     bb0: {
         _39 = copy (_1.0: &mut {async fn body of b()});
         _38 = discriminant((*_39));
-        switchInt(move _38) -> [0: bb1, 1: bb29, 3: bb27, 4: bb28, otherwise: bb8];
+        switchInt(move _38) -> [0: bb1, 1: bb27, 3: bb25, 4: bb26, otherwise: bb8];
     }
 
     bb1: {
@@ -206,65 +206,61 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
 
     bb12: {
         nop;
-        goto -> bb13;
-    }
-
-    bb13: {
         StorageDead(_4);
         StorageDead(_3);
         StorageLive(_21);
         StorageLive(_22);
-        _22 = a() -> [return: bb14, unwind unreachable];
+        _22 = a() -> [return: bb13, unwind unreachable];
     }
 
-    bb14: {
-        _21 = <{async fn body of a()} as IntoFuture>::into_future(move _22) -> [return: bb15, unwind unreachable];
+    bb13: {
+        _21 = <{async fn body of a()} as IntoFuture>::into_future(move _22) -> [return: bb14, unwind unreachable];
     }
 
-    bb15: {
+    bb14: {
         StorageDead(_22);
         PlaceMention(_21);
         nop;
         (((*_39) as variant#4).0: {async fn body of a()}) = move _21;
-        goto -> bb16;
+        goto -> bb15;
     }
 
-    bb16: {
+    bb15: {
         StorageLive(_24);
         StorageLive(_25);
         StorageLive(_26);
         StorageLive(_27);
         StorageLive(_28);
         _28 = &mut (((*_39) as variant#4).0: {async fn body of a()});
         _27 = &mut (*_28);
-        _26 = Pin::<&mut {async fn body of a()}>::new_unchecked(move _27) -> [return: bb17, unwind unreachable];
+        _26 = Pin::<&mut {async fn body of a()}>::new_unchecked(move _27) -> [return: bb16, unwind unreachable];
     }
 
-    bb17: {
+    bb16: {
         StorageDead(_27);
         StorageLive(_29);
         StorageLive(_30);
         StorageLive(_31);
         _31 = copy _2;
         _30 = move _31;
-        goto -> bb18;
+        goto -> bb17;
     }
 
-    bb18: {
+    bb17: {
         _29 = &mut (*_30);
         StorageDead(_31);
-        _25 = <{async fn body of a()} as Future>::poll(move _26, move _29) -> [return: bb19, unwind unreachable];
+        _25 = <{async fn body of a()} as Future>::poll(move _26, move _29) -> [return: bb18, unwind unreachable];
     }
 
-    bb19: {
+    bb18: {
         StorageDead(_29);
         StorageDead(_26);
         PlaceMention(_25);
         _32 = discriminant(_25);
-        switchInt(move _32) -> [0: bb21, 1: bb20, otherwise: bb8];
+        switchInt(move _32) -> [0: bb20, 1: bb19, otherwise: bb8];
     }
 
-    bb20: {
+    bb19: {
         _24 = const ();
         StorageDead(_30);
         StorageDead(_28);
@@ -281,7 +277,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
         return;
     }
 
-    bb21: {
+    bb20: {
         StorageLive(_33);
         _33 = copy ((_25 as Ready).0: ());
         _37 = copy _33;
@@ -290,38 +286,34 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
         StorageDead(_28);
         StorageDead(_25);
         StorageDead(_24);
-        drop((((*_39) as variant#4).0: {async fn body of a()})) -> [return: bb23, unwind unreachable];
+        drop((((*_39) as variant#4).0: {async fn body of a()})) -> [return: bb22, unwind unreachable];
     }
 
-    bb22: {
+    bb21: {
         StorageDead(_36);
         _2 = move _35;
         StorageDead(_35);
         _7 = const ();
-        goto -> bb16;
+        goto -> bb15;
     }
 
-    bb23: {
+    bb22: {
         nop;
-        goto -> bb24;
-    }
-
-    bb24: {
         StorageDead(_21);
-        goto -> bb26;
+        goto -> bb24;
     }
 
-    bb25: {
+    bb23: {
         _0 = Poll::<()>::Ready(move _37);
         discriminant((*_39)) = 1;
         return;
     }
 
-    bb26: {
-        goto -> bb25;
+    bb24: {
+        goto -> bb23;
     }
 
-    bb27: {
+    bb25: {
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_19);
@@ -330,15 +322,15 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
         goto -> bb11;
     }
 
-    bb28: {
+    bb26: {
         StorageLive(_21);
         StorageLive(_35);
         StorageLive(_36);
         _35 = move _2;
-        goto -> bb22;
+        goto -> bb21;
     }
 
-    bb29: {
-        assert(const false, "`async fn` resumed after completion") -> [success: bb29, unwind unreachable];
+    bb27: {
+        assert(const false, "`async fn` resumed after completion") -> [success: bb27, unwind unreachable];
     }
 }

tests/mir-opt/building/coroutine.main-{closure#0}.StateTransform.after.mir

@@ -45,7 +45,7 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
     bb0: {
         _18 = copy (_1.0: &mut {coroutine@$DIR/coroutine.rs:18:5: 18:18});
         _17 = discriminant((*_18));
-        switchInt(move _17) -> [0: bb1, 1: bb19, 3: bb17, 4: bb18, otherwise: bb20];
+        switchInt(move _17) -> [0: bb1, 1: bb15, 3: bb13, 4: bb14, otherwise: bb16];
     }
 
     bb1: {
@@ -67,10 +67,6 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
     bb3: {
         _4 = (const "first", move _5, move _7);
         StorageDead(_7);
-        goto -> bb4;
-    }
-
-    bb4: {
         StorageDead(_5);
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _4);
         StorageDead(_3);
@@ -79,16 +75,12 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
         return;
     }
 
-    bb5: {
-        goto -> bb6;
-    }
-
-    bb6: {
+    bb4: {
         StorageDead(_4);
-        drop(_3) -> [return: bb7, unwind unreachable];
+        drop(_3) -> [return: bb5, unwind unreachable];
     }
 
-    bb7: {
+    bb5: {
         StorageDead(_3);
         StorageLive(_8);
         StorageLive(_9);
@@ -99,24 +91,20 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
         StorageLive(_12);
         StorageLive(_13);
         _13 = &(((*_18) as variant#4).0: std::string::String);
-        _12 = <String as Clone>::clone(move _13) -> [return: bb8, unwind unreachable];
+        _12 = <String as Clone>::clone(move _13) -> [return: bb6, unwind unreachable];
     }
 
-    bb8: {
+    bb6: {
         StorageDead(_13);
         StorageLive(_14);
         StorageLive(_15);
-        _15 = Location::<'_>::caller() -> [return: bb9, unwind unreachable];
+        _15 = Location::<'_>::caller() -> [return: bb7, unwind unreachable];
     }
 
-    bb9: {
+    bb7: {
         _14 = &(*_15);
         _9 = (move _10, move _12, move _14);
         StorageDead(_14);
-        goto -> bb10;
-    }
-
-    bb10: {
         StorageDead(_12);
         StorageDead(_10);
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Yielded(move _9);
@@ -128,58 +116,54 @@ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine.rs:18:5: 18:18}>, _2
         return;
     }
 
-    bb11: {
-        goto -> bb12;
-    }
-
-    bb12: {
+    bb8: {
         StorageDead(_9);
-        drop(_8) -> [return: bb13, unwind unreachable];
+        drop(_8) -> [return: bb9, unwind unreachable];
     }
 
-    bb13: {
+    bb9: {
         StorageDead(_15);
         StorageDead(_11);
         StorageDead(_8);
         _16 = const ();
-        drop((((*_18) as variant#4).0: std::string::String)) -> [return: bb14, unwind unreachable];
+        drop((((*_18) as variant#4).0: std::string::String)) -> [return: bb10, unwind unreachable];
     }
 
-    bb14: {
-        goto -> bb16;
+    bb10: {
+        goto -> bb12;
     }
 
-    bb15: {
+    bb11: {
         _0 = CoroutineState::<(&str, String, &Location<'_>), ()>::Complete(move _16);
         discriminant((*_18)) = 1;
         return;
     }
 
-    bb16: {
-        goto -> bb15;
+    bb12: {
+        goto -> bb11;
     }
 
-    bb17: {
+    bb13: {
         StorageLive(_3);
         StorageLive(_4);
         _3 = move _2;
-        goto -> bb5;
+        goto -> bb4;
     }
 
-    bb18: {
+    bb14: {
         StorageLive(_8);
         StorageLive(_9);
         StorageLive(_11);
         StorageLive(_15);
         _8 = move _2;
-        goto -> bb11;
+        goto -> bb8;
     }
 
-    bb19: {
-        assert(const false, "coroutine resumed after completion") -> [success: bb19, unwind unreachable];
+    bb15: {
+        assert(const false, "coroutine resumed after completion") -> [success: bb15, unwind unreachable];
     }
 
-    bb20: {
+    bb16: {
         unreachable;
     }
 }