rust-lang
diff --git a/‎compiler/rustc_mir_build/src/build/matches/mod.rs
+9-13 b/‎compiler/rustc_mir_build/src/build/matches/mod.rs
+9-13
diff --git a/‎tests/mir-opt/building/issue_101867.main.built.after.mir
+11-7 b/‎tests/mir-opt/building/issue_101867.main.built.after.mir
+11-7
diff --git a/‎tests/mir-opt/building/issue_49232.main.built.after.mir
+19-15 b/‎tests/mir-opt/building/issue_49232.main.built.after.mir
+19-15
@@ -2021,19 +2021,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         // The block that we should branch to if none of the
         // `target_candidates` match.
-        let remainder_start = if !remaining_candidates.is_empty() {
-            let remainder_start = self.cfg.start_new_block();
-            self.match_candidates(
-                span,
-                scrutinee_span,
-                remainder_start,
-                otherwise_block,
-                remaining_candidates,
-            );
-            remainder_start
-        } else {
-            otherwise_block
-        };
+        let remainder_start = self.cfg.start_new_block();
 
         // For each outcome of test, process the candidates that still apply.
         let target_blocks: FxIndexMap<_, _> = target_candidates
@@ -2061,6 +2049,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             &test,
             target_blocks,
         );
+
+        self.match_candidates(
+            span,
+            scrutinee_span,
+            remainder_start,
+            otherwise_block,
+            remaining_candidates,
+        );
     }
 }
 
 
@@ -27,13 +27,13 @@ fn main() -> () {
         StorageLive(_5);
         PlaceMention(_1);
         _6 = discriminant(_1);
-        switchInt(move _6) -> [1: bb4, otherwise: bb3];
+        switchInt(move _6) -> [1: bb5, otherwise: bb4];
     }
 
     bb1: {
         StorageLive(_3);
         StorageLive(_4);
-        _4 = begin_panic::<&str>(const "explicit panic") -> bb8;
+        _4 = begin_panic::<&str>(const "explicit panic") -> bb9;
     }
 
     bb2: {
@@ -43,31 +43,35 @@ fn main() -> () {
     }
 
     bb3: {
-        goto -> bb7;
+        goto -> bb8;
     }
 
     bb4: {
-        falseEdge -> [real: bb6, imaginary: bb3];
+        goto -> bb3;
     }
 
     bb5: {
-        goto -> bb3;
+        falseEdge -> [real: bb7, imaginary: bb3];
     }
 
     bb6: {
+        goto -> bb4;
+    }
+
+    bb7: {
         _5 = ((_1 as Some).0: u8);
         _0 = const ();
         StorageDead(_5);
         StorageDead(_1);
         return;
     }
 
-    bb7: {
+    bb8: {
         StorageDead(_5);
         goto -> bb1;
     }
 
-    bb8 (cleanup): {
+    bb9 (cleanup): {
         resume;
     }
 }
@@ -17,15 +17,15 @@ fn main() -> () {
     }
 
     bb1: {
-        falseUnwind -> [real: bb2, unwind: bb14];
+        falseUnwind -> [real: bb2, unwind: bb15];
     }
 
     bb2: {
         StorageLive(_2);
         StorageLive(_3);
         _3 = const true;
         PlaceMention(_3);
-        switchInt(_3) -> [0: bb4, otherwise: bb6];
+        switchInt(_3) -> [0: bb5, otherwise: bb7];
     }
 
     bb3: {
@@ -34,59 +34,63 @@ fn main() -> () {
     }
 
     bb4: {
-        falseEdge -> [real: bb8, imaginary: bb6];
+        goto -> bb3;
     }
 
     bb5: {
-        goto -> bb3;
+        falseEdge -> [real: bb9, imaginary: bb7];
     }
 
     bb6: {
-        _0 = const ();
-        goto -> bb13;
+        goto -> bb4;
     }
 
     bb7: {
-        goto -> bb3;
+        _0 = const ();
+        goto -> bb14;
     }
 
     bb8: {
-        _2 = const 4_i32;
-        goto -> bb11;
+        goto -> bb4;
     }
 
     bb9: {
-        unreachable;
+        _2 = const 4_i32;
+        goto -> bb12;
     }
 
     bb10: {
-        goto -> bb11;
+        unreachable;
     }
 
     bb11: {
+        goto -> bb12;
+    }
+
+    bb12: {
         FakeRead(ForLet(None), _2);
         StorageDead(_3);
         StorageLive(_5);
         StorageLive(_6);
         _6 = &_2;
-        _5 = std::mem::drop::<&i32>(move _6) -> [return: bb12, unwind: bb14];
+        _5 = std::mem::drop::<&i32>(move _6) -> [return: bb13, unwind: bb15];
     }
 
-    bb12: {
+    bb13: {
         StorageDead(_6);
         StorageDead(_5);
         _1 = const ();
         StorageDead(_2);
         goto -> bb1;
     }
 
-    bb13: {
+    bb14: {
         StorageDead(_3);
         StorageDead(_2);
         return;
     }
 
-    bb14 (cleanup): {
+    bb15 (cleanup): {
         resume;
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -27,13 +27,13 @@ fn main() -> () {`
`27`	`27`	`StorageLive(_5);`
`28`	`28`	`PlaceMention(_1);`
`29`	`29`	`_6 = discriminant(_1);`
`30`		`- switchInt(move _6) -> [1: bb4, otherwise: bb3];`
	`30`	`+ switchInt(move _6) -> [1: bb5, otherwise: bb4];`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`bb1: {`
`34`	`34`	`StorageLive(_3);`
`35`	`35`	`StorageLive(_4);`
`36`		`- _4 = begin_panic::<&str>(const "explicit panic") -> bb8;`
	`36`	`+ _4 = begin_panic::<&str>(const "explicit panic") -> bb9;`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`bb2: {`
`@@ -43,31 +43,35 @@ fn main() -> () {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`bb3: {`
`46`		`- goto -> bb7;`
	`46`	`+ goto -> bb8;`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`bb4: {`
`50`		`- falseEdge -> [real: bb6, imaginary: bb3];`
	`50`	`+ goto -> bb3;`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`bb5: {`
`54`		`- goto -> bb3;`
	`54`	`+ falseEdge -> [real: bb7, imaginary: bb3];`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`bb6: {`
	`58`	`+ goto -> bb4;`
	`59`	`+ }`
	`60`	`+`
	`61`	`+ bb7: {`
`58`	`62`	`_5 = ((_1 as Some).0: u8);`
`59`	`63`	`_0 = const ();`
`60`	`64`	`StorageDead(_5);`
`61`	`65`	`StorageDead(_1);`
`62`	`66`	`return;`
`63`	`67`	`}`
`64`	`68`
`65`		`- bb7: {`
	`69`	`+ bb8: {`
`66`	`70`	`StorageDead(_5);`
`67`	`71`	`goto -> bb1;`
`68`	`72`	`}`
`69`	`73`
`70`		`- bb8 (cleanup): {`
	`74`	`+ bb9 (cleanup): {`
`71`	`75`	`resume;`
`72`	`76`	`}`
`73`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@ fn main() -> () {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`bb1: {`
`20`		`- falseUnwind -> [real: bb2, unwind: bb14];`
	`20`	`+ falseUnwind -> [real: bb2, unwind: bb15];`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`bb2: {`
`24`	`24`	`StorageLive(_2);`
`25`	`25`	`StorageLive(_3);`
`26`	`26`	`_3 = const true;`
`27`	`27`	`PlaceMention(_3);`
`28`		`- switchInt(_3) -> [0: bb4, otherwise: bb6];`
	`28`	`+ switchInt(_3) -> [0: bb5, otherwise: bb7];`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`bb3: {`
`@@ -34,59 +34,63 @@ fn main() -> () {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`bb4: {`
`37`		`- falseEdge -> [real: bb8, imaginary: bb6];`
	`37`	`+ goto -> bb3;`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`bb5: {`
`41`		`- goto -> bb3;`
	`41`	`+ falseEdge -> [real: bb9, imaginary: bb7];`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`bb6: {`
`45`		`- _0 = const ();`
`46`		`- goto -> bb13;`
	`45`	`+ goto -> bb4;`
`47`	`46`	`}`
`48`	`47`
`49`	`48`	`bb7: {`
`50`		`- goto -> bb3;`
	`49`	`+ _0 = const ();`
	`50`	`+ goto -> bb14;`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`bb8: {`
`54`		`- _2 = const 4_i32;`
`55`		`- goto -> bb11;`
	`54`	`+ goto -> bb4;`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`bb9: {`
`59`		`- unreachable;`
	`58`	`+ _2 = const 4_i32;`
	`59`	`+ goto -> bb12;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`bb10: {`
`63`		`- goto -> bb11;`
	`63`	`+ unreachable;`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`bb11: {`
	`67`	`+ goto -> bb12;`
	`68`	`+ }`
	`69`	`+`
	`70`	`+ bb12: {`
`67`	`71`	`FakeRead(ForLet(None), _2);`
`68`	`72`	`StorageDead(_3);`
`69`	`73`	`StorageLive(_5);`
`70`	`74`	`StorageLive(_6);`
`71`	`75`	`_6 = &_2;`
`72`		`- _5 = std::mem::drop::<&i32>(move _6) -> [return: bb12, unwind: bb14];`
	`76`	`+ _5 = std::mem::drop::<&i32>(move _6) -> [return: bb13, unwind: bb15];`
`73`	`77`	`}`
`74`	`78`
`75`		`- bb12: {`
	`79`	`+ bb13: {`
`76`	`80`	`StorageDead(_6);`
`77`	`81`	`StorageDead(_5);`
`78`	`82`	`_1 = const ();`
`79`	`83`	`StorageDead(_2);`
`80`	`84`	`goto -> bb1;`
`81`	`85`	`}`
`82`	`86`
`83`		`- bb13: {`
	`87`	`+ bb14: {`
`84`	`88`	`StorageDead(_3);`
`85`	`89`	`StorageDead(_2);`
`86`	`90`	`return;`
`87`	`91`	`}`
`88`	`92`
`89`		`- bb14 (cleanup): {`
	`93`	`+ bb15 (cleanup): {`
`90`	`94`	`resume;`
`91`	`95`	`}`
`92`	`96`	`}`