rust/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff

- // MIR for `complicated_match` after SimplifyCfg-initial
+ // MIR for `complicated_match` after ElaborateDrops
  
  fn complicated_match(_1: bool, _2: (bool, bool, String)) -> i32 {
      debug cond => _1;
      debug items => _2;
      let mut _0: i32;
      let mut _3: &bool;
      let mut _4: &bool;
      let _5: bool;
      let _6: &bool;
      let _7: std::string::String;
      let _8: &std::string::String;
      let mut _9: bool;
      let mut _10: bool;
      let mut _11: !;
      let mut _12: bool;
      let mut _13: bool;
      let mut _14: !;
      let _15: bool;
      let _16: std::string::String;
      scope 1 {
          debug a => _5;
          debug a => _6;
          debug s => _7;
          debug s => _8;
      }
      scope 2 {
          debug b => _15;
          debug t => _16;
      }
  
      bb0: {
          PlaceMention(_2);
-         switchInt(copy (_2.0: bool)) -> [0: bb2, otherwise: bb1];
+         switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb1];
      }
  
      bb1: {
-         switchInt(copy (_2.1: bool)) -> [0: bb4, otherwise: bb3];
+         switchInt(copy (_2.1: bool)) -> [0: bb5, otherwise: bb2];
      }
  
      bb2: {
-         falseEdge -> [real: bb9, imaginary: bb1];
+         switchInt(copy (_2.0: bool)) -> [0: bb3, otherwise: bb4];
      }
  
      bb3: {
-         switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb5];
-     }
- 
-     bb4: {
-         falseEdge -> [real: bb8, imaginary: bb3];
-     }
- 
-     bb5: {
-         falseEdge -> [real: bb7, imaginary: bb6];
-     }
- 
-     bb6: {
          StorageLive(_15);
          _15 = copy (_2.1: bool);
          StorageLive(_16);
          _16 = move (_2.2: std::string::String);
-         goto -> bb20;
+         goto -> bb17;
      }
  
-     bb7: {
+     bb4: {
          StorageLive(_15);
          _15 = copy (_2.1: bool);
          StorageLive(_16);
          _16 = move (_2.2: std::string::String);
-         goto -> bb20;
+         goto -> bb17;
      }
  
-     bb8: {
+     bb5: {
          StorageLive(_6);
          _6 = &(_2.0: bool);
          StorageLive(_8);
          _8 = &(_2.2: std::string::String);
-         _3 = &fake shallow (_2.0: bool);
-         _4 = &fake shallow (_2.1: bool);
          StorageLive(_12);
          StorageLive(_13);
          _13 = copy _1;
-         switchInt(move _13) -> [0: bb16, otherwise: bb15];
+         switchInt(move _13) -> [0: bb13, otherwise: bb12];
      }
  
-     bb9: {
+     bb6: {
          StorageLive(_6);
          _6 = &(_2.1: bool);
          StorageLive(_8);
          _8 = &(_2.2: std::string::String);
-         _3 = &fake shallow (_2.0: bool);
-         _4 = &fake shallow (_2.1: bool);
          StorageLive(_9);
          StorageLive(_10);
          _10 = copy _1;
-         switchInt(move _10) -> [0: bb12, otherwise: bb11];
+         switchInt(move _10) -> [0: bb9, otherwise: bb8];
      }
  
-     bb10: {
+     bb7: {
          _0 = const 1_i32;
-         drop(_7) -> [return: bb19, unwind: bb25];
+         drop(_7) -> [return: bb16, unwind: bb22];
      }
  
-     bb11: {
+     bb8: {
          _0 = const 3_i32;
          StorageDead(_10);
          StorageDead(_9);
-         goto -> bb23;
+         goto -> bb20;
      }
  
-     bb12: {
+     bb9: {
          _9 = copy (*_6);
-         switchInt(move _9) -> [0: bb14, otherwise: bb13];
+         switchInt(move _9) -> [0: bb11, otherwise: bb10];
      }
  
-     bb13: {
+     bb10: {
          StorageDead(_10);
          StorageDead(_9);
-         FakeRead(ForMatchGuard, _3);
-         FakeRead(ForMatchGuard, _4);
-         FakeRead(ForGuardBinding, _6);
-         FakeRead(ForGuardBinding, _8);
          StorageLive(_5);
          _5 = copy (_2.1: bool);
          StorageLive(_7);
          _7 = move (_2.2: std::string::String);
-         goto -> bb10;
+         goto -> bb7;
      }
  
-     bb14: {
+     bb11: {
          StorageDead(_10);
          StorageDead(_9);
          StorageDead(_8);
          StorageDead(_6);
-         falseEdge -> [real: bb1, imaginary: bb1];
+         goto -> bb1;
      }
  
-     bb15: {
+     bb12: {
          _0 = const 3_i32;
          StorageDead(_13);
          StorageDead(_12);
-         goto -> bb23;
+         goto -> bb20;
      }
  
-     bb16: {
+     bb13: {
          _12 = copy (*_6);
-         switchInt(move _12) -> [0: bb18, otherwise: bb17];
+         switchInt(move _12) -> [0: bb15, otherwise: bb14];
      }
  
-     bb17: {
+     bb14: {
          StorageDead(_13);
          StorageDead(_12);
-         FakeRead(ForMatchGuard, _3);
-         FakeRead(ForMatchGuard, _4);
-         FakeRead(ForGuardBinding, _6);
-         FakeRead(ForGuardBinding, _8);
          StorageLive(_5);
          _5 = copy (_2.0: bool);
          StorageLive(_7);
          _7 = move (_2.2: std::string::String);
-         goto -> bb10;
+         goto -> bb7;
      }
  
-     bb18: {
+     bb15: {
          StorageDead(_13);
          StorageDead(_12);
          StorageDead(_8);
          StorageDead(_6);
-         falseEdge -> [real: bb3, imaginary: bb3];
+         goto -> bb2;
      }
  
-     bb19: {
+     bb16: {
          StorageDead(_7);
          StorageDead(_5);
          StorageDead(_8);
          StorageDead(_6);
-         goto -> bb22;
+         goto -> bb19;
      }
  
-     bb20: {
+     bb17: {
          _0 = const 2_i32;
-         drop(_16) -> [return: bb21, unwind: bb25];
+         drop(_16) -> [return: bb18, unwind: bb22];
      }
  
-     bb21: {
+     bb18: {
          StorageDead(_16);
          StorageDead(_15);
-         goto -> bb22;
+         goto -> bb19;
      }
  
-     bb22: {
-         drop(_2) -> [return: bb24, unwind: bb26];
+     bb19: {
+         goto -> bb26;
      }
  
-     bb23: {
+     bb20: {
          StorageDead(_8);
          StorageDead(_6);
-         drop(_2) -> [return: bb24, unwind: bb26];
+         drop(_2) -> [return: bb21, unwind: bb23];
      }
  
-     bb24: {
+     bb21: {
          return;
      }
  
-     bb25 (cleanup): {
-         drop(_2) -> [return: bb26, unwind terminate(cleanup)];
+     bb22 (cleanup): {
+         goto -> bb27;
      }
  
-     bb26 (cleanup): {
+     bb23 (cleanup): {
          resume;
+     }
+ 
+     bb24: {
+         goto -> bb21;
+     }
+ 
+     bb25 (cleanup): {
+         goto -> bb23;
+     }
+ 
+     bb26: {
+         goto -> bb24;
+     }
+ 
+     bb27 (cleanup): {
+         goto -> bb23;
      }
  }