FileCheck uninhabited_enum_branching.

tests/mir-opt/uninhabited_enum_branching2.main.UninhabitedEnumBranching.diff → tests/mir-opt/uninhabited_enum_branching.byref.UninhabitedEnumBranching.diff

@@ -1,12 +1,12 @@
-- // MIR for `main` before UninhabitedEnumBranching
-+ // MIR for `main` after UninhabitedEnumBranching
+- // MIR for `byref` before UninhabitedEnumBranching
++ // MIR for `byref` after UninhabitedEnumBranching
 
- fn main() -> () {
+ fn byref() -> () {
  let mut _0: ();
  let _1: Plop;
- let mut _2: Test1;
+ let mut _2: Test3;
  let _3: &str;
- let mut _4: &Test1;
+ let mut _4: &Test3;
  let mut _5: isize;
  let _6: &str;
  let _7: &str;
@@ -23,12 +23,12 @@
  bb0: {
  StorageLive(_1);
  StorageLive(_2);
- _2 = Test1::C;
- _1 = Plop { xx: const 51_u32, test1: move _2 };
+ _2 = Test3::C;
+ _1 = Plop { xx: const 51_u32, test3: move _2 };
  StorageDead(_2);
  StorageLive(_3);
  StorageLive(_4);
- _4 = &(_1.1: Test1);
+ _4 = &(_1.1: Test3);
  _5 = discriminant((*_4));
 - switchInt(move _5) -> [0: bb3, 1: bb4, 2: bb5, 3: bb1, otherwise: bb2];
 + switchInt(move _5) -> [0: bb12, 1: bb12, 2: bb5, 3: bb1, otherwise: bb12];
@@ -71,7 +71,7 @@
  StorageDead(_4);
  StorageDead(_3);
  StorageLive(_9);
- _10 = discriminant((_1.1: Test1));
+ _10 = discriminant((_1.1: Test3));
 - switchInt(move _10) -> [0: bb8, 1: bb9, 2: bb10, 3: bb7, otherwise: bb2];
 + switchInt(move _10) -> [0: bb12, 1: bb12, 2: bb10, 3: bb7, otherwise: bb12];
  }

tests/mir-opt/uninhabited_enum_branching.custom_discriminant.UninhabitedEnumBranching.diff

@@ -0,0 +1,48 @@
+- // MIR for `custom_discriminant` before UninhabitedEnumBranching
++ // MIR for `custom_discriminant` after UninhabitedEnumBranching
+
+ fn custom_discriminant() -> () {
+ let mut _0: ();
+ let _1: &str;
+ let mut _2: Test2;
+ let mut _3: isize;
+ let _4: &str;
+
+ bb0: {
+ StorageLive(_1);
+ StorageLive(_2);
+ _2 = Test2::D;
+ _3 = discriminant(_2);
+- switchInt(move _3) -> [4: bb3, 5: bb1, otherwise: bb2];
++ switchInt(move _3) -> [4: bb3, 5: bb1, otherwise: bb5];
+ }
+
+ bb1: {
+ StorageLive(_4);
+ _4 = const "E";
+ _1 = &(*_4);
+ StorageDead(_4);
+ goto -> bb4;
+ }
+
+ bb2: {
+ unreachable;
+ }
+
+ bb3: {
+ _1 = const "D";
+ goto -> bb4;
+ }
+
+ bb4: {
+ StorageDead(_2);
+ StorageDead(_1);
+ _0 = const ();
+ return;
++ }
++ 
++ bb5: {
++ unreachable;
+ }
+ }
+

tests/mir-opt/uninhabited_enum_branching.rs

@@ -1,11 +1,11 @@
-// skip-filecheck
-enum Empty { }
+// unit-test: UninhabitedEnumBranching
+enum Empty {}
 
 // test matching an enum with uninhabited variants
 enum Test1 {
  A(Empty),
  B(Empty),
- C
+ C,
 }
 
 // test an enum where the discriminants don't match the variant indexes
@@ -15,17 +15,75 @@ enum Test2 {
  E = 5,
 }
 
-// EMIT_MIR uninhabited_enum_branching.main.UninhabitedEnumBranching.diff
-// EMIT_MIR uninhabited_enum_branching.main.SimplifyCfg-after-uninhabited-enum-branching.after.mir
-fn main() {
+// test matching an enum with uninhabited variants and multiple inhabited
+enum Test3 {
+ A(Empty),
+ B(Empty),
+ C,
+ D,
+}
+
+struct Plop {
+ xx: u32,
+ test3: Test3,
+}
+
+// EMIT_MIR uninhabited_enum_branching.simple.UninhabitedEnumBranching.diff
+fn simple() {
+ // CHECK-LABEL: fn simple(
+ // CHECK: [[discr:_.*]] = discriminant(
+ // CHECK: switchInt(move [[discr]]) -> [0: [[unreachable:bb.*]], 1: [[unreachable]], 2: bb1, otherwise: [[unreachable]]];
+ // CHECK: [[unreachable]]: {
+ // CHECK-NEXT: unreachable;
  match Test1::C {
  Test1::A(_) => "A(Empty)",
  Test1::B(_) => "B(Empty)",
  Test1::C => "C",
  };
+}
 
+// EMIT_MIR uninhabited_enum_branching.custom_discriminant.UninhabitedEnumBranching.diff
+fn custom_discriminant() {
+ // CHECK-LABEL: fn custom_discriminant(
+ // CHECK: [[discr:_.*]] = discriminant(
+ // CHECK: switchInt(move [[discr]]) -> [4: bb3, 5: bb1, otherwise: bb5];
+ // CHECK: bb5: {
+ // CHECK-NEXT: unreachable;
  match Test2::D {
  Test2::D => "D",
  Test2::E => "E",
  };
 }
+
+// EMIT_MIR uninhabited_enum_branching.byref.UninhabitedEnumBranching.diff
+fn byref() {
+ // CHECK-LABEL: fn byref(
+ let plop = Plop { xx: 51, test3: Test3::C };
+
+ // CHECK: [[ref_discr:_.*]] = discriminant((*
+ // CHECK: switchInt(move [[ref_discr]]) -> [0: [[unreachable:bb.*]], 1: [[unreachable]], 2: bb5, 3: bb1, otherwise: [[unreachable]]];
+ match &plop.test3 {
+ Test3::A(_) => "A(Empty)",
+ Test3::B(_) => "B(Empty)",
+ Test3::C => "C",
+ Test3::D => "D",
+ };
+
+ // CHECK: [[discr:_.*]] = discriminant(
+ // CHECK: switchInt(move [[discr]]) -> [0: [[unreachable]], 1: [[unreachable]], 2: bb10, 3: bb7, otherwise: [[unreachable]]];
+ match plop.test3 {
+ Test3::A(_) => "A(Empty)",
+ Test3::B(_) => "B(Empty)",
+ Test3::C => "C",
+ Test3::D => "D",
+ };
+
+ // CHECK: [[unreachable]]: {
+ // CHECK-NEXT: unreachable;
+}
+
+fn main() {
+ simple();
+ custom_discriminant();
+ byref();
+}

tests/mir-opt/uninhabited_enum_branching.main.UninhabitedEnumBranching.diff → tests/mir-opt/uninhabited_enum_branching.simple.UninhabitedEnumBranching.diff

@@ -1,25 +1,21 @@
-- // MIR for `main` before UninhabitedEnumBranching
-+ // MIR for `main` after UninhabitedEnumBranching
+- // MIR for `simple` before UninhabitedEnumBranching
++ // MIR for `simple` after UninhabitedEnumBranching
 
- fn main() -> () {
+ fn simple() -> () {
  let mut _0: ();
  let _1: &str;
  let mut _2: Test1;
  let mut _3: isize;
  let _4: &str;
  let _5: &str;
- let _6: &str;
- let mut _7: Test2;
- let mut _8: isize;
- let _9: &str;
 
  bb0: {
  StorageLive(_1);
  StorageLive(_2);
  _2 = Test1::C;
  _3 = discriminant(_2);
 - switchInt(move _3) -> [0: bb3, 1: bb4, 2: bb1, otherwise: bb2];
-+ switchInt(move _3) -> [0: bb9, 1: bb9, 2: bb1, otherwise: bb9];
++ switchInt(move _3) -> [0: bb6, 1: bb6, 2: bb1, otherwise: bb6];
  }
 
  bb1: {
@@ -50,35 +46,11 @@
  bb5: {
  StorageDead(_2);
  StorageDead(_1);
- StorageLive(_6);
- StorageLive(_7);
- _7 = Test2::D;
- _8 = discriminant(_7);
-- switchInt(move _8) -> [4: bb7, 5: bb6, otherwise: bb2];
-+ switchInt(move _8) -> [4: bb7, 5: bb6, otherwise: bb9];
- }
-
- bb6: {
- StorageLive(_9);
- _9 = const "E";
- _6 = &(*_9);
- StorageDead(_9);
- goto -> bb8;
- }
-
- bb7: {
- _6 = const "D";
- goto -> bb8;
- }
-
- bb8: {
- StorageDead(_7);
- StorageDead(_6);
  _0 = const ();
  return;
 + }
 + 
-+ bb9: {
++ bb6: {
 + unreachable;
  }
  }