tests/mir-opt/coroutine/coroutine_tiny.main-{closure#0}.StateTransform.diff

- // MIR for `main::{closure#0}` before StateTransform
+ // MIR for `main::{closure#0}` after StateTransform
  
- fn main::{closure#0}(_1: {coroutine@$DIR/coroutine_tiny.rs:20:5: 20:13}, _2: u8) -> ()
- yields ()
-  {
+ fn main::{closure#0}(_1: Pin<&mut {coroutine@$DIR/coroutine_tiny.rs:20:5: 20:13}>, _2: u8) -> CoroutineState<(), ()> {
+     coroutine layout {
+         field _s0: HasDrop;
+         variant_fields = {
+             Unresumed(0): [],
+             Returned (1): [],
+             Panicked (2): [],
+             Suspend0 (3): [_s0],
+         }
+         storage_conflicts = BitMatrix(1x1) {(_s0, _s0)}
+     }
      debug _x => _2;
-     let mut _0: ();
+     coroutine debug _d => _s0;
+     let mut _0: std::ops::CoroutineState<(), ()>;
      let _3: HasDrop;
      let mut _4: !;
      let mut _5: ();
      let _6: u8;
      let mut _7: ();
      let _8: ();
+     let mut _9: ();
+     let mut _10: u32;
+     let mut _11: &mut {coroutine@$DIR/coroutine_tiny.rs:20:5: 20:13};
      scope 1 {
-         debug _d => _3;
+         debug _d => (((*_11) as variant#3).0: HasDrop);
      }
  
      bb0: {
-         StorageLive(_3);
-         _3 = HasDrop;
-         StorageLive(_4);
-         goto -> bb1;
+         _11 = copy (_1.0: &mut {coroutine@$DIR/coroutine_tiny.rs:20:5: 20:13});
+         _10 = discriminant((*_11));
+         switchInt(move _10) -> [0: bb6, 3: bb4, otherwise: bb5];
      }
  
      bb1: {
          StorageLive(_6);
          StorageLive(_7);
          _7 = ();
-         _6 = yield(move _7) -> [resume: bb2, drop: bb4];
+         _0 = CoroutineState::<(), ()>::Yielded(move _7);
+         StorageDead(_4);
+         StorageDead(_6);
+         StorageDead(_7);
+         discriminant((*_11)) = 3;
+         return;
      }
  
      bb2: {
          StorageDead(_7);
          StorageDead(_6);
          StorageLive(_8);
          _8 = callee() -> [return: bb3, unwind unreachable];
      }
  
      bb3: {
          StorageDead(_8);
          _5 = const ();
          goto -> bb1;
      }
  
      bb4: {
-         StorageDead(_7);
-         StorageDead(_6);
-         StorageDead(_4);
-         drop(_3) -> [return: bb5, unwind unreachable];
+         StorageLive(_4);
+         StorageLive(_6);
+         StorageLive(_7);
+         _6 = move _2;
+         goto -> bb2;
      }
  
      bb5: {
-         StorageDead(_3);
-         drop(_1) -> [return: bb6, unwind unreachable];
+         unreachable;
      }
  
      bb6: {
-         coroutine_drop;
+         nop;
+         (((*_11) as variant#3).0: HasDrop) = HasDrop;
+         StorageLive(_4);
+         goto -> bb1;
      }
  }