More test branch coverage fixes

Author: ranger-ross

tests/coverage/branch/match-arms.coverage

@@ -120,6 +120,4 @@
    LL|       |        call_everything(Enum::D(d));
    LL|       |    }
    LL|       |}
-   LL|       |
-   LL|       |// FIXME(#124118) Support match expressions with or-patterns.
 

tests/coverage/branch/match-arms.rs

@@ -86,5 +86,3 @@ fn main() {
         call_everything(Enum::D(d));
     }
 }
-
-// FIXME(#124118) Support match expressions with or-patterns.

tests/coverage/branch/match-or-pattern-nested.coverage

@@ -18,12 +18,10 @@
    LL|       |    }
    LL|      3|}
    LL|       |
-   LL|       |
    LL|       |#[coverage(off)]
    LL|       |fn main() {
    LL|       |    foo(1, 2);
    LL|       |    foo(1, 99);
    LL|       |    foo(2, 5);
    LL|       |}
-   LL|       |
 

tests/coverage/match_or_pattern.cov-map

@@ -1,75 +1,135 @@
 Function name: match_or_pattern::main
-Raw bytes (185): 0x[01, 01, 1c, 01, 05, 09, 0d, 23, 11, 09, 0d, 1f, 15, 23, 11, 09, 0d, 23, 11, 09, 0d, 19, 1d, 43, 21, 19, 1d, 3f, 25, 43, 21, 19, 1d, 43, 21, 19, 1d, 29, 2d, 63, 31, 29, 2d, 5f, 35, 63, 31, 29, 2d, 63, 31, 29, 2d, 39, 3d, 6f, 41, 39, 3d, 19, 01, 01, 01, 08, 0f, 05, 08, 10, 03, 06, 02, 03, 06, 00, 07, 01, 01, 0b, 00, 11, 11, 03, 1b, 00, 1d, 23, 01, 0e, 00, 10, 1f, 02, 08, 00, 0f, 15, 00, 10, 03, 06, 12, 03, 06, 00, 07, 1f, 01, 0b, 00, 11, 21, 01, 1b, 00, 1d, 43, 01, 0e, 00, 10, 3f, 02, 08, 00, 0f, 25, 00, 10, 03, 06, 32, 03, 06, 00, 07, 3f, 01, 0b, 00, 11, 31, 01, 1b, 00, 1d, 63, 01, 0e, 00, 10, 5f, 02, 08, 00, 0f, 35, 00, 10, 03, 06, 52, 03, 06, 00, 07, 5f, 01, 0b, 00, 11, 41, 01, 1b, 00, 1d, 6f, 01, 0e, 00, 10, 6b, 02, 01, 00, 02]
+Raw bytes (366): 0x[01, 01, 54, 01, 05, 5f, 25, 63, 21, 19, 1d, 57, 15, 0d, 11, 53, 5b, 57, 15, 0d, 11, 5f, 25, 63, 21, 19, 1d, 4f, 29, 53, 5b, 57, 15, 0d, 11, 5f, 25, 63, 21, 19, 1d, 53, 5b, 57, 15, 0d, 11, 5f, 25, 63, 21, 19, 1d, bf, 01, 49, c3, 01, 45, 3d, 41, b7, 01, 39, 31, 35, b3, 01, bb, 01, b7, 01, 39, 31, 35, bf, 01, 49, c3, 01, 45, 3d, 41, af, 01, 4d, b3, 01, bb, 01, b7, 01, 39, 31, 35, bf, 01, 49, c3, 01, 45, 3d, 41, b3, 01, bb, 01, b7, 01, 39, 31, 35, bf, 01, 49, c3, 01, 45, 3d, 41, 9f, 02, 6d, a3, 02, 69, 61, 65, 97, 02, 5d, 55, 59, 93, 02, 9b, 02, 97, 02, 5d, 55, 59, 9f, 02, 6d, a3, 02, 69, 61, 65, 8f, 02, 71, 93, 02, 9b, 02, 97, 02, 5d, 55, 59, 9f, 02, 6d, a3, 02, 69, 61, 65, 93, 02, 9b, 02, 97, 02, 5d, 55, 59, 9f, 02, 6d, a3, 02, 69, 61, 65, cb, 02, 91, 01, cf, 02, 8d, 01, 85, 01, 89, 01, c3, 02, 81, 01, 79, 7d, bf, 02, c7, 02, c3, 02, 81, 01, 79, 7d, cb, 02, 91, 01, cf, 02, 8d, 01, 85, 01, 89, 01, 19, 01, 01, 01, 08, 0f, 05, 08, 10, 03, 06, 02, 03, 06, 00, 07, 01, 01, 0b, 00, 11, 5b, 03, 1b, 00, 1d, 53, 01, 0e, 00, 10, 4f, 02, 08, 00, 0f, 29, 00, 10, 03, 06, 32, 03, 06, 00, 07, 4f, 01, 0b, 00, 11, bb, 01, 01, 1b, 00, 1d, b3, 01, 01, 0e, 00, 10, af, 01, 02, 08, 00, 0f, 4d, 00, 10, 03, 06, 92, 01, 03, 06, 00, 07, af, 01, 01, 0b, 00, 11, 9b, 02, 01, 1b, 00, 1d, 93, 02, 01, 0e, 00, 10, 8f, 02, 02, 08, 00, 0f, 71, 00, 10, 03, 06, f2, 01, 03, 06, 00, 07, 8f, 02, 01, 0b, 00, 11, c7, 02, 01, 1b, 00, 1d, bf, 02, 01, 0e, 00, 10, bb, 02, 02, 01, 00, 02]
 Number of files: 1
 - file 0 => global file 1
-Number of expressions: 28
+Number of expressions: 84
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
-- expression 1 operands: lhs = Counter(2), rhs = Counter(3)
-- expression 2 operands: lhs = Expression(8, Add), rhs = Counter(4)
-- expression 3 operands: lhs = Counter(2), rhs = Counter(3)
-- expression 4 operands: lhs = Expression(7, Add), rhs = Counter(5)
-- expression 5 operands: lhs = Expression(8, Add), rhs = Counter(4)
-- expression 6 operands: lhs = Counter(2), rhs = Counter(3)
-- expression 7 operands: lhs = Expression(8, Add), rhs = Counter(4)
-- expression 8 operands: lhs = Counter(2), rhs = Counter(3)
-- expression 9 operands: lhs = Counter(6), rhs = Counter(7)
-- expression 10 operands: lhs = Expression(16, Add), rhs = Counter(8)
+- expression 1 operands: lhs = Expression(23, Add), rhs = Counter(9)
+- expression 2 operands: lhs = Expression(24, Add), rhs = Counter(8)
+- expression 3 operands: lhs = Counter(6), rhs = Counter(7)
+- expression 4 operands: lhs = Expression(21, Add), rhs = Counter(5)
+- expression 5 operands: lhs = Counter(3), rhs = Counter(4)
+- expression 6 operands: lhs = Expression(20, Add), rhs = Expression(22, Add)
+- expression 7 operands: lhs = Expression(21, Add), rhs = Counter(5)
+- expression 8 operands: lhs = Counter(3), rhs = Counter(4)
+- expression 9 operands: lhs = Expression(23, Add), rhs = Counter(9)
+- expression 10 operands: lhs = Expression(24, Add), rhs = Counter(8)
 - expression 11 operands: lhs = Counter(6), rhs = Counter(7)
-- expression 12 operands: lhs = Expression(15, Add), rhs = Counter(9)
-- expression 13 operands: lhs = Expression(16, Add), rhs = Counter(8)
-- expression 14 operands: lhs = Counter(6), rhs = Counter(7)
-- expression 15 operands: lhs = Expression(16, Add), rhs = Counter(8)
-- expression 16 operands: lhs = Counter(6), rhs = Counter(7)
-- expression 17 operands: lhs = Counter(10), rhs = Counter(11)
-- expression 18 operands: lhs = Expression(24, Add), rhs = Counter(12)
-- expression 19 operands: lhs = Counter(10), rhs = Counter(11)
-- expression 20 operands: lhs = Expression(23, Add), rhs = Counter(13)
-- expression 21 operands: lhs = Expression(24, Add), rhs = Counter(12)
-- expression 22 operands: lhs = Counter(10), rhs = Counter(11)
-- expression 23 operands: lhs = Expression(24, Add), rhs = Counter(12)
-- expression 24 operands: lhs = Counter(10), rhs = Counter(11)
-- expression 25 operands: lhs = Counter(14), rhs = Counter(15)
-- expression 26 operands: lhs = Expression(27, Add), rhs = Counter(16)
-- expression 27 operands: lhs = Counter(14), rhs = Counter(15)
+- expression 12 operands: lhs = Expression(19, Add), rhs = Counter(10)
+- expression 13 operands: lhs = Expression(20, Add), rhs = Expression(22, Add)
+- expression 14 operands: lhs = Expression(21, Add), rhs = Counter(5)
+- expression 15 operands: lhs = Counter(3), rhs = Counter(4)
+- expression 16 operands: lhs = Expression(23, Add), rhs = Counter(9)
+- expression 17 operands: lhs = Expression(24, Add), rhs = Counter(8)
+- expression 18 operands: lhs = Counter(6), rhs = Counter(7)
+- expression 19 operands: lhs = Expression(20, Add), rhs = Expression(22, Add)
+- expression 20 operands: lhs = Expression(21, Add), rhs = Counter(5)
+- expression 21 operands: lhs = Counter(3), rhs = Counter(4)
+- expression 22 operands: lhs = Expression(23, Add), rhs = Counter(9)
+- expression 23 operands: lhs = Expression(24, Add), rhs = Counter(8)
+- expression 24 operands: lhs = Counter(6), rhs = Counter(7)
+- expression 25 operands: lhs = Expression(47, Add), rhs = Counter(18)
+- expression 26 operands: lhs = Expression(48, Add), rhs = Counter(17)
+- expression 27 operands: lhs = Counter(15), rhs = Counter(16)
+- expression 28 operands: lhs = Expression(45, Add), rhs = Counter(14)
+- expression 29 operands: lhs = Counter(12), rhs = Counter(13)
+- expression 30 operands: lhs = Expression(44, Add), rhs = Expression(46, Add)
+- expression 31 operands: lhs = Expression(45, Add), rhs = Counter(14)
+- expression 32 operands: lhs = Counter(12), rhs = Counter(13)
+- expression 33 operands: lhs = Expression(47, Add), rhs = Counter(18)
+- expression 34 operands: lhs = Expression(48, Add), rhs = Counter(17)
+- expression 35 operands: lhs = Counter(15), rhs = Counter(16)
+- expression 36 operands: lhs = Expression(43, Add), rhs = Counter(19)
+- expression 37 operands: lhs = Expression(44, Add), rhs = Expression(46, Add)
+- expression 38 operands: lhs = Expression(45, Add), rhs = Counter(14)
+- expression 39 operands: lhs = Counter(12), rhs = Counter(13)
+- expression 40 operands: lhs = Expression(47, Add), rhs = Counter(18)
+- expression 41 operands: lhs = Expression(48, Add), rhs = Counter(17)
+- expression 42 operands: lhs = Counter(15), rhs = Counter(16)
+- expression 43 operands: lhs = Expression(44, Add), rhs = Expression(46, Add)
+- expression 44 operands: lhs = Expression(45, Add), rhs = Counter(14)
+- expression 45 operands: lhs = Counter(12), rhs = Counter(13)
+- expression 46 operands: lhs = Expression(47, Add), rhs = Counter(18)
+- expression 47 operands: lhs = Expression(48, Add), rhs = Counter(17)
+- expression 48 operands: lhs = Counter(15), rhs = Counter(16)
+- expression 49 operands: lhs = Expression(71, Add), rhs = Counter(27)
+- expression 50 operands: lhs = Expression(72, Add), rhs = Counter(26)
+- expression 51 operands: lhs = Counter(24), rhs = Counter(25)
+- expression 52 operands: lhs = Expression(69, Add), rhs = Counter(23)
+- expression 53 operands: lhs = Counter(21), rhs = Counter(22)
+- expression 54 operands: lhs = Expression(68, Add), rhs = Expression(70, Add)
+- expression 55 operands: lhs = Expression(69, Add), rhs = Counter(23)
+- expression 56 operands: lhs = Counter(21), rhs = Counter(22)
+- expression 57 operands: lhs = Expression(71, Add), rhs = Counter(27)
+- expression 58 operands: lhs = Expression(72, Add), rhs = Counter(26)
+- expression 59 operands: lhs = Counter(24), rhs = Counter(25)
+- expression 60 operands: lhs = Expression(67, Add), rhs = Counter(28)
+- expression 61 operands: lhs = Expression(68, Add), rhs = Expression(70, Add)
+- expression 62 operands: lhs = Expression(69, Add), rhs = Counter(23)
+- expression 63 operands: lhs = Counter(21), rhs = Counter(22)
+- expression 64 operands: lhs = Expression(71, Add), rhs = Counter(27)
+- expression 65 operands: lhs = Expression(72, Add), rhs = Counter(26)
+- expression 66 operands: lhs = Counter(24), rhs = Counter(25)
+- expression 67 operands: lhs = Expression(68, Add), rhs = Expression(70, Add)
+- expression 68 operands: lhs = Expression(69, Add), rhs = Counter(23)
+- expression 69 operands: lhs = Counter(21), rhs = Counter(22)
+- expression 70 operands: lhs = Expression(71, Add), rhs = Counter(27)
+- expression 71 operands: lhs = Expression(72, Add), rhs = Counter(26)
+- expression 72 operands: lhs = Counter(24), rhs = Counter(25)
+- expression 73 operands: lhs = Expression(82, Add), rhs = Counter(36)
+- expression 74 operands: lhs = Expression(83, Add), rhs = Counter(35)
+- expression 75 operands: lhs = Counter(33), rhs = Counter(34)
+- expression 76 operands: lhs = Expression(80, Add), rhs = Counter(32)
+- expression 77 operands: lhs = Counter(30), rhs = Counter(31)
+- expression 78 operands: lhs = Expression(79, Add), rhs = Expression(81, Add)
+- expression 79 operands: lhs = Expression(80, Add), rhs = Counter(32)
+- expression 80 operands: lhs = Counter(30), rhs = Counter(31)
+- expression 81 operands: lhs = Expression(82, Add), rhs = Counter(36)
+- expression 82 operands: lhs = Expression(83, Add), rhs = Counter(35)
+- expression 83 operands: lhs = Counter(33), rhs = Counter(34)
 Number of file 0 mappings: 25
 - Code(Counter(0)) at (prev + 1, 1) to (start + 8, 15)
 - Code(Counter(1)) at (prev + 8, 16) to (start + 3, 6)
 - Code(Expression(0, Sub)) at (prev + 3, 6) to (start + 0, 7)
     = (c0 - c1)
 - Code(Counter(0)) at (prev + 1, 11) to (start + 0, 17)
-- Code(Counter(4)) at (prev + 3, 27) to (start + 0, 29)
-- Code(Expression(8, Add)) at (prev + 1, 14) to (start + 0, 16)
-    = (c2 + c3)
-- Code(Expression(7, Add)) at (prev + 2, 8) to (start + 0, 15)
-    = ((c2 + c3) + c4)
-- Code(Counter(5)) at (prev + 0, 16) to (start + 3, 6)
-- Code(Expression(4, Sub)) at (prev + 3, 6) to (start + 0, 7)
-    = (((c2 + c3) + c4) - c5)
-- Code(Expression(7, Add)) at (prev + 1, 11) to (start + 0, 17)
-    = ((c2 + c3) + c4)
-- Code(Counter(8)) at (prev + 1, 27) to (start + 0, 29)
-- Code(Expression(16, Add)) at (prev + 1, 14) to (start + 0, 16)
-    = (c6 + c7)
-- Code(Expression(15, Add)) at (prev + 2, 8) to (start + 0, 15)
-    = ((c6 + c7) + c8)
-- Code(Counter(9)) at (prev + 0, 16) to (start + 3, 6)
+- Code(Expression(22, Add)) at (prev + 3, 27) to (start + 0, 29)
+    = (((c6 + c7) + c8) + c9)
+- Code(Expression(20, Add)) at (prev + 1, 14) to (start + 0, 16)
+    = ((c3 + c4) + c5)
+- Code(Expression(19, Add)) at (prev + 2, 8) to (start + 0, 15)
+    = (((c3 + c4) + c5) + (((c6 + c7) + c8) + c9))
+- Code(Counter(10)) at (prev + 0, 16) to (start + 3, 6)
 - Code(Expression(12, Sub)) at (prev + 3, 6) to (start + 0, 7)
-    = (((c6 + c7) + c8) - c9)
-- Code(Expression(15, Add)) at (prev + 1, 11) to (start + 0, 17)
-    = ((c6 + c7) + c8)
-- Code(Counter(12)) at (prev + 1, 27) to (start + 0, 29)
-- Code(Expression(24, Add)) at (prev + 1, 14) to (start + 0, 16)
-    = (c10 + c11)
-- Code(Expression(23, Add)) at (prev + 2, 8) to (start + 0, 15)
-    = ((c10 + c11) + c12)
-- Code(Counter(13)) at (prev + 0, 16) to (start + 3, 6)
-- Code(Expression(20, Sub)) at (prev + 3, 6) to (start + 0, 7)
-    = (((c10 + c11) + c12) - c13)
-- Code(Expression(23, Add)) at (prev + 1, 11) to (start + 0, 17)
-    = ((c10 + c11) + c12)
-- Code(Counter(16)) at (prev + 1, 27) to (start + 0, 29)
-- Code(Expression(27, Add)) at (prev + 1, 14) to (start + 0, 16)
-    = (c14 + c15)
-- Code(Expression(26, Add)) at (prev + 2, 1) to (start + 0, 2)
-    = ((c14 + c15) + c16)
+    = ((((c3 + c4) + c5) + (((c6 + c7) + c8) + c9)) - c10)
+- Code(Expression(19, Add)) at (prev + 1, 11) to (start + 0, 17)
+    = (((c3 + c4) + c5) + (((c6 + c7) + c8) + c9))
+- Code(Expression(46, Add)) at (prev + 1, 27) to (start + 0, 29)
+    = (((c15 + c16) + c17) + c18)
+- Code(Expression(44, Add)) at (prev + 1, 14) to (start + 0, 16)
+    = ((c12 + c13) + c14)
+- Code(Expression(43, Add)) at (prev + 2, 8) to (start + 0, 15)
+    = (((c12 + c13) + c14) + (((c15 + c16) + c17) + c18))
+- Code(Counter(19)) at (prev + 0, 16) to (start + 3, 6)
+- Code(Expression(36, Sub)) at (prev + 3, 6) to (start + 0, 7)
+    = ((((c12 + c13) + c14) + (((c15 + c16) + c17) + c18)) - c19)
+- Code(Expression(43, Add)) at (prev + 1, 11) to (start + 0, 17)
+    = (((c12 + c13) + c14) + (((c15 + c16) + c17) + c18))
+- Code(Expression(70, Add)) at (prev + 1, 27) to (start + 0, 29)
+    = (((c24 + c25) + c26) + c27)
+- Code(Expression(68, Add)) at (prev + 1, 14) to (start + 0, 16)
+    = ((c21 + c22) + c23)
+- Code(Expression(67, Add)) at (prev + 2, 8) to (start + 0, 15)
+    = (((c21 + c22) + c23) + (((c24 + c25) + c26) + c27))
+- Code(Counter(28)) at (prev + 0, 16) to (start + 3, 6)
+- Code(Expression(60, Sub)) at (prev + 3, 6) to (start + 0, 7)
+    = ((((c21 + c22) + c23) + (((c24 + c25) + c26) + c27)) - c28)
+- Code(Expression(67, Add)) at (prev + 1, 11) to (start + 0, 17)
+    = (((c21 + c22) + c23) + (((c24 + c25) + c26) + c27))
+- Code(Expression(81, Add)) at (prev + 1, 27) to (start + 0, 29)
+    = (((c33 + c34) + c35) + c36)
+- Code(Expression(79, Add)) at (prev + 1, 14) to (start + 0, 16)
+    = ((c30 + c31) + c32)
+- Code(Expression(78, Add)) at (prev + 2, 1) to (start + 0, 2)
+    = (((c30 + c31) + c32) + (((c33 + c34) + c35) + c36))
 

tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff

@@ -1,6 +1,6 @@
 - // MIR for `main` before InstrumentCoverage
 + // MIR for `main` after InstrumentCoverage
-
+  
   fn main() -> () {
       let mut _0: ();
       let mut _1: Enum;
@@ -25,20 +25,33 @@
       scope 4 {
           debug a => _9;
       }
-
+  
+      coverage branches {
+          BlockMarkerId(0), BlockMarkerId(1) => $DIR/branch_match_arms.rs:16:9: 16:19 (#0)
+          BlockMarkerId(2), BlockMarkerId(3) => $DIR/branch_match_arms.rs:17:9: 17:19 (#0)
+          BlockMarkerId(4), BlockMarkerId(5) => $DIR/branch_match_arms.rs:18:9: 18:19 (#0)
+          BlockMarkerId(6), BlockMarkerId(7) => $DIR/branch_match_arms.rs:19:9: 19:19 (#0)
+      }
+  
 +     coverage ExpressionId(0) => Expression { lhs: Counter(1), op: Add, rhs: Counter(2) };
 +     coverage ExpressionId(1) => Expression { lhs: Expression(0), op: Add, rhs: Counter(3) };
 +     coverage ExpressionId(2) => Expression { lhs: Counter(0), op: Subtract, rhs: Expression(1) };
 +     coverage ExpressionId(3) => Expression { lhs: Counter(3), op: Add, rhs: Counter(2) };
 +     coverage ExpressionId(4) => Expression { lhs: Expression(3), op: Add, rhs: Counter(1) };
 +     coverage ExpressionId(5) => Expression { lhs: Expression(4), op: Add, rhs: Expression(2) };
++     coverage ExpressionId(6) => Expression { lhs: Expression(2), op: Add, rhs: Counter(1) };
++     coverage ExpressionId(7) => Expression { lhs: Expression(6), op: Add, rhs: Counter(2) };
++     coverage ExpressionId(8) => Expression { lhs: Expression(7), op: Add, rhs: Counter(3) };
++     coverage Branch { true_term: Counter(1), false_term: Expression(2) } => $DIR/branch_match_arms.rs:18:9 - 18:19;
++     coverage Branch { true_term: Counter(2), false_term: Expression(6) } => $DIR/branch_match_arms.rs:17:9 - 17:19;
++     coverage Branch { true_term: Counter(3), false_term: Expression(7) } => $DIR/branch_match_arms.rs:16:9 - 16:19;
 +     coverage Code(Counter(0)) => $DIR/branch_match_arms.rs:14:1 - 15:21;
 +     coverage Code(Counter(3)) => $DIR/branch_match_arms.rs:16:17 - 16:33;
 +     coverage Code(Counter(2)) => $DIR/branch_match_arms.rs:17:17 - 17:33;
 +     coverage Code(Counter(1)) => $DIR/branch_match_arms.rs:18:17 - 18:33;
 +     coverage Code(Expression(2)) => $DIR/branch_match_arms.rs:19:17 - 19:33;
 +     coverage Code(Expression(5)) => $DIR/branch_match_arms.rs:21:1 - 21:2;
-+
++ 
       bb0: {
 +         Coverage::CounterIncrement(0);
           StorageLive(_1);
@@ -47,92 +60,100 @@
           _2 = discriminant(_1);
           switchInt(move _2) -> [0: bb5, 1: bb4, 2: bb3, 3: bb2, otherwise: bb1];
       }
-
+  
       bb1: {
           FakeRead(ForMatchedPlace(None), _1);
           unreachable;
       }
-
+  
       bb2: {
 +         Coverage::CounterIncrement(3);
           falseEdge -> [real: bb8, imaginary: bb3];
       }
-
+  
       bb3: {
 +         Coverage::CounterIncrement(2);
           falseEdge -> [real: bb7, imaginary: bb4];
       }
-
+  
       bb4: {
 +         Coverage::CounterIncrement(1);
           falseEdge -> [real: bb6, imaginary: bb5];
       }
-
+  
       bb5: {
 +         Coverage::ExpressionUsed(2);
           StorageLive(_9);
           _9 = copy ((_1 as A).0: u32);
           StorageLive(_10);
           _10 = copy _9;
+          Coverage::BlockMarker(6);
+          Coverage::BlockMarker(7);
           _0 = consume(move _10) -> [return: bb12, unwind: bb14];
       }
-
+  
       bb6: {
           StorageLive(_7);
           _7 = copy ((_1 as B).0: u32);
           StorageLive(_8);
           _8 = copy _7;
+          Coverage::BlockMarker(4);
+          Coverage::BlockMarker(5);
           _0 = consume(move _8) -> [return: bb11, unwind: bb14];
       }
-
+  
       bb7: {
           StorageLive(_5);
           _5 = copy ((_1 as C).0: u32);
           StorageLive(_6);
           _6 = copy _5;
+          Coverage::BlockMarker(2);
+          Coverage::BlockMarker(3);
           _0 = consume(move _6) -> [return: bb10, unwind: bb14];
       }
-
+  
       bb8: {
           StorageLive(_3);
           _3 = copy ((_1 as D).0: u32);
           StorageLive(_4);
           _4 = copy _3;
+          Coverage::BlockMarker(0);
+          Coverage::BlockMarker(1);
           _0 = consume(move _4) -> [return: bb9, unwind: bb14];
       }
-
+  
       bb9: {
           StorageDead(_4);
           StorageDead(_3);
           goto -> bb13;
       }
-
+  
       bb10: {
           StorageDead(_6);
           StorageDead(_5);
           goto -> bb13;
       }
-
+  
       bb11: {
           StorageDead(_8);
           StorageDead(_7);
           goto -> bb13;
       }
-
+  
       bb12: {
           StorageDead(_10);
           StorageDead(_9);
           goto -> bb13;
       }
-
+  
       bb13: {
 +         Coverage::ExpressionUsed(5);
           StorageDead(_1);
           return;
       }
-
+  
       bb14 (cleanup): {
           resume;
       }
   }
-
+