Move state transform after optimizations.

Author: cjgillot

compiler/rustc_mir_transform/src/coroutine.rs

@@ -174,6 +174,7 @@ const SELF_ARG: Local = Local::from_u32(1);
 const CTX_ARG: Local = Local::from_u32(2);
 
 /// A `yield` point in the coroutine.
+#[derive(Debug)]
 struct SuspensionPoint<'tcx> {
     /// State discriminant used when suspending or resuming at this point.
     state: usize,
@@ -651,7 +652,7 @@ fn replace_resume_ty_local<'tcx>(
     // We have to replace the `ResumeTy` that is used for type and borrow checking
     // with `&mut Context<'_>` in MIR.
     #[cfg(debug_assertions)]
-    {
+    if local_ty != context_mut_ref {
         if let ty::Adt(resume_ty_adt, _) = local_ty.kind() {
             let expected_adt = tcx.adt_def(tcx.require_lang_item(LangItem::ResumeTy, body.span));
             assert_eq!(*resume_ty_adt, expected_adt);

compiler/rustc_mir_transform/src/lib.rs

@@ -627,7 +627,6 @@ fn run_runtime_lowering_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         &add_retag::AddRetag,
         &erase_deref_temps::EraseDerefTemps,
         &elaborate_box_derefs::ElaborateBoxDerefs,
-        &coroutine::StateTransform,
         &Lint(known_panics_lint::KnownPanicsLint),
     ];
     pm::run_passes_no_validate(tcx, body, passes, Some(MirPhase::Runtime(RuntimePhase::Initial)));
@@ -742,6 +741,7 @@ pub(crate) fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'
             &simplify::SimplifyLocals::Final,
             &multiple_return_terminators::MultipleReturnTerminators,
             &large_enums::EnumSizeOpt { discrepancy: 128 },
+            &coroutine::StateTransform,
             // Some cleanup necessary at least for LLVM and potentially other codegen backends.
             &add_call_guards::CriticalCallEdges,
             // Cleanup for human readability, off by default.

compiler/rustc_mir_transform/src/shim.rs

@@ -150,7 +150,6 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
                     tcx,
                     &mut body,
                     &[
-                        &mentioned_items::MentionedItems,
                         &abort_unwinding_calls::AbortUnwindingCalls,
                         &add_call_guards::CriticalCallEdges,
                     ],

compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs

@@ -216,6 +216,7 @@ fn build_adrop_for_coroutine_shim<'tcx>(
     body.source.instance = instance;
     body.phase = MirPhase::Runtime(RuntimePhase::Initial);
     body.var_debug_info.clear();
+    body.mentioned_items = None;
     let pin_adt_ref = tcx.adt_def(tcx.require_lang_item(LangItem::Pin, span));
     let args = tcx.mk_args(&[proxy_ref.into()]);
     let pin_proxy_ref = Ty::new_adt(tcx, pin_adt_ref, args);

tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-abort.mir

@@ -29,72 +29,68 @@ fn a::{closure#0}(_1: Pin<&mut {async fn body of a<T>()}>, _2: &mut Context<'_>)
     bb0: {
         _20 = copy (_1.0: &mut {async fn body of a<T>()});
         _19 = discriminant((*_20));
-        switchInt(move _19) -> [0: bb9, 3: bb12, 4: bb13, otherwise: bb14];
+        switchInt(move _19) -> [0: bb8, 3: bb11, 4: bb12, otherwise: bb13];
     }
 
     bb1: {
         nop;
         nop;
-        goto -> bb2;
-    }
-
-    bb2: {
         _0 = Poll::<()>::Ready(const ());
         return;
     }
 
-    bb3: {
+    bb2: {
         _0 = Poll::<()>::Pending;
         discriminant((*_20)) = 4;
         return;
     }
 
-    bb4: {
+    bb3: {
         StorageLive(_16);
         _15 = &mut (((*_20) as variant#4).1: impl std::future::Future<Output = ()>);
-        _16 = Pin::<&mut impl Future<Output = ()>>::new_unchecked(move _15) -> [return: bb7, unwind unreachable];
+        _16 = Pin::<&mut impl Future<Output = ()>>::new_unchecked(move _15) -> [return: bb6, unwind unreachable];
     }
 
-    bb5: {
+    bb4: {
         unreachable;
     }
 
-    bb6: {
+    bb5: {
         StorageDead(_16);
         _17 = discriminant(_9);
-        switchInt(move _17) -> [0: bb1, 1: bb3, otherwise: bb5];
+        switchInt(move _17) -> [0: bb1, 1: bb2, otherwise: bb4];
     }
 
-    bb7: {
-        _9 = <impl Future<Output = ()> as Future>::poll(move _16, move _14) -> [return: bb6, unwind unreachable];
+    bb6: {
+        _9 = <impl Future<Output = ()> as Future>::poll(move _16, move _14) -> [return: bb5, unwind unreachable];
     }
 
-    bb8: {
+    bb7: {
         _0 = Poll::<()>::Ready(const ());
         return;
     }
 
+    bb8: {
+        goto -> bb10;
+    }
+
     bb9: {
-        goto -> bb11;
+        goto -> bb7;
     }
 
     bb10: {
-        goto -> bb8;
+        drop(((*_20).0: T)) -> [return: bb9, unwind unreachable];
     }
 
     bb11: {
-        drop(((*_20).0: T)) -> [return: bb10, unwind unreachable];
+        goto -> bb3;
     }
 
     bb12: {
-        goto -> bb4;
+        goto -> bb3;
     }
 
     bb13: {
-        goto -> bb4;
-    }
-
-    bb14: {
         _0 = Poll::<()>::Ready(const ());
         return;
     }

tests/mir-opt/async_drop_live_dead.a-{closure#0}.coroutine_drop_async.0.panic-unwind.mir

@@ -29,95 +29,81 @@ fn a::{closure#0}(_1: Pin<&mut {async fn body of a<T>()}>, _2: &mut Context<'_>)
     bb0: {
         _20 = copy (_1.0: &mut {async fn body of a<T>()});
         _19 = discriminant((*_20));
-        switchInt(move _19) -> [0: bb12, 2: bb18, 3: bb16, 4: bb17, otherwise: bb19];
+        switchInt(move _19) -> [0: bb8, 2: bb15, 3: bb13, 4: bb14, otherwise: bb16];
     }
 
     bb1: {
         nop;
         nop;
-        goto -> bb2;
-    }
-
-    bb2: {
         _0 = Poll::<()>::Ready(const ());
         return;
     }
 
-    bb3 (cleanup): {
-        nop;
-        nop;
-        goto -> bb5;
-    }
-
-    bb4 (cleanup): {
-        goto -> bb15;
-    }
-
-    bb5 (cleanup): {
-        goto -> bb4;
-    }
-
-    bb6: {
+    bb2: {
         _0 = Poll::<()>::Pending;
         discriminant((*_20)) = 4;
         return;
     }
 
-    bb7: {
+    bb3: {
         StorageLive(_16);
         _15 = &mut (((*_20) as variant#4).1: impl std::future::Future<Output = ()>);
-        _16 = Pin::<&mut impl Future<Output = ()>>::new_unchecked(move _15) -> [return: bb10, unwind: bb15];
+        _16 = Pin::<&mut impl Future<Output = ()>>::new_unchecked(move _15) -> [return: bb6, unwind: bb12];
     }
 
-    bb8: {
+    bb4: {
         unreachable;
     }
 
-    bb9: {
+    bb5: {
         StorageDead(_16);
         _17 = discriminant(_9);
-        switchInt(move _17) -> [0: bb1, 1: bb6, otherwise: bb8];
+        switchInt(move _17) -> [0: bb1, 1: bb2, otherwise: bb4];
     }
 
-    bb10: {
-        _9 = <impl Future<Output = ()> as Future>::poll(move _16, move _14) -> [return: bb9, unwind: bb3];
+    bb6: {
+        _9 = <impl Future<Output = ()> as Future>::poll(move _16, move _14) -> [return: bb5, unwind: bb12];
     }
 
-    bb11: {
+    bb7: {
         _0 = Poll::<()>::Ready(const ());
         return;
     }
 
-    bb12: {
-        goto -> bb14;
+    bb8: {
+        goto -> bb11;
     }
 
-    bb13: {
-        goto -> bb11;
+    bb9 (cleanup): {
+        goto -> bb12;
     }
 
-    bb14: {
-        drop(((*_20).0: T)) -> [return: bb13, unwind: bb4];
+    bb10: {
+        goto -> bb7;
     }
 
-    bb15 (cleanup): {
+    bb11: {
+        drop(((*_20).0: T)) -> [return: bb10, unwind: bb9];
+    }
+
+    bb12 (cleanup): {
         discriminant((*_20)) = 2;
         resume;
     }
 
-    bb16: {
-        goto -> bb7;
+    bb13: {
+        goto -> bb3;
     }
 
-    bb17: {
-        goto -> bb7;
+    bb14: {
+        goto -> bb3;
     }
 
-    bb18: {
-        assert(const false, "`async fn` resumed after panicking") -> [success: bb18, unwind continue];
+    bb15: {
+        assert(const false, "`async fn` resumed after panicking") -> [success: bb15, unwind continue];
     }
 
-    bb19: {
+    bb16: {
         _0 = Poll::<()>::Ready(const ());
         return;
     }