rust/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff

- // MIR for `run2::{closure#0}` before Inline
+ // MIR for `run2::{closure#0}` after Inline
  
  fn run2::{closure#0}(_1: {closure@$DIR/inline_coroutine_body.rs:13:9: 13:11}) -> () {
      debug permit => (_1.0: ActionPermit<'_, T>);
      debug ctx => (*(_1.1: &mut std::task::Context<'_>));
      let mut _0: ();
      let mut _2: {async fn body of ActionPermit<'_, T>::perform()};
      let mut _3: ActionPermit<'_, T>;
      let mut _5: &mut {async fn body of ActionPermit<'_, T>::perform()};
      let _6: ();
      let mut _7: std::task::Poll<()>;
      let mut _8: std::pin::Pin<&mut {async fn body of ActionPermit<'_, T>::perform()}>;
      let mut _9: &mut std::task::Context<'_>;
      let mut _10: &mut std::task::Context<'_>;
      scope 1 {
          debug fut => _2;
          let _4: std::pin::Pin<&mut {async fn body of ActionPermit<'_, T>::perform()}>;
          scope 2 {
              debug fut => _4;
              scope 3 {
              }
+             scope 6 (inlined ActionPermit::<'_, T>::perform::{closure#0}) {
+                 let _11: ActionPermit<'_, T>;
+                 let mut _12: std::future::Ready<()>;
+                 let mut _13: std::future::Ready<()>;
+                 let mut _14: ();
+                 let mut _16: ();
+                 let _17: ();
+                 let mut _18: std::task::Poll<()>;
+                 let mut _19: std::pin::Pin<&mut std::future::Ready<()>>;
+                 let mut _20: &mut std::future::Ready<()>;
+                 let mut _21: &mut std::future::Ready<()>;
+                 let mut _22: &mut std::task::Context<'_>;
+                 let mut _23: &mut std::task::Context<'_>;
+                 let mut _24: &mut std::task::Context<'_>;
+                 let mut _25: isize;
+                 let mut _27: !;
+                 let mut _28: &mut std::task::Context<'_>;
+                 let mut _29: ();
+                 let mut _30: ();
+                 let mut _31: &mut std::task::Context<'_>;
+                 let mut _32: u32;
+                 let mut _33: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _34: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _35: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _36: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _37: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _38: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _39: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _40: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _41: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 let mut _42: &mut {async fn body of ActionPermit<'_, T>::perform()};
+                 scope 7 {
+                     let mut _15: std::future::Ready<()>;
+                     scope 8 {
+                         let _26: ();
+                         scope 9 {
+                         }
+                     }
+                     scope 10 (inlined ready::<()>) {
+                         let mut _43: std::option::Option<()>;
+                     }
+                 }
+             }
          }
+         scope 5 (inlined Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}>::new_unchecked) {
+         }
      }
+     scope 4 (inlined ActionPermit::<'_, T>::perform) {
+     }
  
      bb0: {
          StorageLive(_2);
          StorageLive(_3);
          _3 = move (_1.0: ActionPermit<'_, T>);
-         _2 = ActionPermit::<'_, T>::perform(move _3) -> [return: bb1, unwind: bb6];
-     }
- 
-     bb1: {
+         _2 = {coroutine@$DIR/inline_coroutine_body.rs:25:28: 27:6 (#0)} { self: move _3 };
          StorageDead(_3);
          StorageLive(_4);
          StorageLive(_5);
          _5 = &mut _2;
-         _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}>::new_unchecked(move _5) -> [return: bb2, unwind: bb5];
-     }
- 
-     bb2: {
+         _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: copy _5 };
          StorageDead(_5);
          StorageLive(_6);
          StorageLive(_7);
          StorageLive(_8);
          _8 = move _4;
          StorageLive(_9);
          _10 = deref_copy (_1.1: &mut std::task::Context<'_>);
          _9 = &mut (*_10);
-         _7 = <{async fn body of ActionPermit<'_, T>::perform()} as Future>::poll(move _8, move _9) -> [return: bb3, unwind: bb5];
+         StorageLive(_11);
+         StorageLive(_15);
+         StorageLive(_16);
+         StorageLive(_25);
+         StorageLive(_27);
+         StorageLive(_30);
+         StorageLive(_31);
+         StorageLive(_32);
+         StorageLive(_33);
+         StorageLive(_34);
+         StorageLive(_35);
+         StorageLive(_36);
+         StorageLive(_37);
+         StorageLive(_38);
+         StorageLive(_39);
+         StorageLive(_40);
+         StorageLive(_41);
+         StorageLive(_42);
+         _33 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         _32 = discriminant((*_33));
+         switchInt(move _32) -> [0: bb5, 1: bb22, 2: bb21, 3: bb20, otherwise: bb10];
      }
  
-     bb3: {
+     bb1: {
+         StorageDead(_2);
+         return;
+     }
+ 
+     bb2 (cleanup): {
+         drop(_2) -> [return: bb3, unwind terminate(cleanup)];
+     }
+ 
+     bb3 (cleanup): {
+         resume;
+     }
+ 
+     bb4: {
+         StorageDead(_42);
+         StorageDead(_41);
+         StorageDead(_40);
+         StorageDead(_39);
+         StorageDead(_38);
+         StorageDead(_37);
+         StorageDead(_36);
+         StorageDead(_35);
+         StorageDead(_34);
+         StorageDead(_33);
+         StorageDead(_32);
+         StorageDead(_31);
+         StorageDead(_30);
+         StorageDead(_27);
+         StorageDead(_25);
+         StorageDead(_16);
+         StorageDead(_15);
+         StorageDead(_11);
          StorageDead(_9);
          StorageDead(_8);
          StorageDead(_7);
          _6 = const ();
          StorageDead(_6);
          _0 = const ();
          StorageDead(_4);
-         drop(_2) -> [return: bb4, unwind: bb6];
+         drop(_2) -> [return: bb1, unwind: bb3];
      }
  
-     bb4: {
-         StorageDead(_2);
-         return;
+     bb5: {
+         _31 = move _9;
+         _34 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         _35 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         (((*_34) as variant#3).0: ActionPermit<'_, T>) = move ((*_35).0: ActionPermit<'_, T>);
+         StorageLive(_12);
+         StorageLive(_13);
+         StorageLive(_14);
+         _14 = ();
+         StorageLive(_43);
+         _43 = Option::<()>::Some(copy _14);
+         _13 = std::future::Ready::<()>(move _43);
+         StorageDead(_43);
+         StorageDead(_14);
+         _12 = <std::future::Ready<()> as IntoFuture>::into_future(move _13) -> [return: bb6, unwind: bb17];
      }
  
-     bb5 (cleanup): {
-         drop(_2) -> [return: bb6, unwind terminate(cleanup)];
+     bb6: {
+         StorageDead(_13);
+         _36 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         (((*_36) as variant#3).1: std::future::Ready<()>) = move _12;
+         goto -> bb7;
      }
  
-     bb6 (cleanup): {
-         resume;
+     bb7: {
+         StorageLive(_17);
+         StorageLive(_18);
+         StorageLive(_19);
+         StorageLive(_20);
+         StorageLive(_21);
+         _37 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         _21 = &mut (((*_37) as variant#3).1: std::future::Ready<()>);
+         _20 = &mut (*_21);
+         _19 = Pin::<&mut std::future::Ready<()>>::new_unchecked(move _20) -> [return: bb8, unwind: bb15];
+     }
+ 
+     bb8: {
+         StorageDead(_20);
+         StorageLive(_22);
+         StorageLive(_23);
+         StorageLive(_24);
+         _24 = copy _31;
+         _23 = move _24;
+         _22 = &mut (*_23);
+         StorageDead(_24);
+         _18 = <std::future::Ready<()> as Future>::poll(move _19, move _22) -> [return: bb9, unwind: bb14];
+     }
+ 
+     bb9: {
+         StorageDead(_22);
+         StorageDead(_19);
+         _25 = discriminant(_18);
+         switchInt(move _25) -> [0: bb12, 1: bb11, otherwise: bb10];
+     }
+ 
+     bb10: {
+         unreachable;
+     }
+ 
+     bb11: {
+         _17 = const ();
+         StorageDead(_23);
+         StorageDead(_21);
+         StorageDead(_18);
+         StorageDead(_17);
+         StorageLive(_28);
+         StorageLive(_29);
+         _29 = ();
+         _7 = Poll::<()>::Pending;
+         StorageDead(_12);
+         StorageDead(_28);
+         StorageDead(_29);
+         _38 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         discriminant((*_38)) = 3;
+         goto -> bb4;
+     }
+ 
+     bb12: {
+         StorageLive(_26);
+         _26 = copy ((_18 as Ready).0: ());
+         _30 = copy _26;
+         StorageDead(_26);
+         StorageDead(_23);
+         StorageDead(_21);
+         StorageDead(_18);
+         StorageDead(_17);
+         StorageDead(_12);
+         _39 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         drop((((*_39) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb13, unwind: bb19];
+     }
+ 
+     bb13: {
+         _7 = Poll::<()>::Ready(move _30);
+         _40 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         discriminant((*_40)) = 1;
+         goto -> bb4;
+     }
+ 
+     bb14 (cleanup): {
+         StorageDead(_22);
+         StorageDead(_19);
+         StorageDead(_23);
+         goto -> bb16;
+     }
+ 
+     bb15 (cleanup): {
+         StorageDead(_20);
+         StorageDead(_19);
+         goto -> bb16;
+     }
+ 
+     bb16 (cleanup): {
+         StorageDead(_21);
+         StorageDead(_18);
+         StorageDead(_17);
+         goto -> bb18;
+     }
+ 
+     bb17 (cleanup): {
+         StorageDead(_13);
+         goto -> bb18;
+     }
+ 
+     bb18 (cleanup): {
+         StorageDead(_12);
+         _41 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         drop((((*_41) as variant#3).0: ActionPermit<'_, T>)) -> [return: bb19, unwind terminate(cleanup)];
+     }
+ 
+     bb19 (cleanup): {
+         _42 = deref_copy (_8.0: &mut {async fn body of ActionPermit<'_, T>::perform()});
+         discriminant((*_42)) = 2;
+         goto -> bb2;
+     }
+ 
+     bb20: {
+         StorageLive(_12);
+         StorageLive(_28);
+         StorageLive(_29);
+         _28 = move _9;
+         StorageDead(_29);
+         _31 = move _28;
+         StorageDead(_28);
+         _16 = const ();
+         goto -> bb7;
+     }
+ 
+     bb21: {
+         assert(const false, "`async fn` resumed after panicking") -> [success: bb21, unwind: bb2];
+     }
+ 
+     bb22: {
+         assert(const false, "`async fn` resumed after completion") -> [success: bb22, unwind: bb2];
      }
  }