Added smarter match guard branch coverage handling

Author: ranger-ross

compiler/rustc_mir_build/src/build/coverageinfo.rs

@@ -44,14 +44,14 @@ struct NotInfo {
 }
 
 pub(crate) struct MatchArm {
-    pub(crate) source_info: SourceInfo,
     pub(crate) sub_branches: Vec<MatchArmSubBranch>,
 }
 
 #[derive(Debug)]
 pub(crate) struct MatchArmSubBranch {
     pub(crate) source_info: SourceInfo,
-    pub(crate) block: BasicBlock,
+    pub(crate) pre_binding_block: BasicBlock,
+    pub(crate) branch_taken_block: BasicBlock,
 }
 
 #[derive(Default)]
@@ -168,7 +168,6 @@ impl CoverageInfoBuilder {
             // Bail out if branch coverage is not enabled.
             let Some(branch_info) = self.branch_info.as_mut() else { return };
 
-
             // Avoid duplicates coverage markers.
             // When lowering match sub-branches (like or-patterns), `if` guards will
             // be added multiple times for each sub-branch
@@ -206,16 +205,20 @@ impl CoverageInfoBuilder {
 
         let branch_arms = arms
             .iter()
-            .flat_map(|MatchArm { source_info, sub_branches }| {
+            .flat_map(|MatchArm { sub_branches }| {
                 sub_branches
                     .iter()
                     .map(|sub_branch| {
-                        let block = sub_branch.block;
-
-                        let pre_guard_marker =
-                            self.markers.inject_block_marker(cfg, sub_branch.source_info, block);
-                        let arm_taken_marker =
-                            self.markers.inject_block_marker(cfg, *source_info, block);
+                        let pre_guard_marker = self.markers.inject_block_marker(
+                            cfg,
+                            sub_branch.source_info,
+                            sub_branch.pre_binding_block,
+                        );
+                        let arm_taken_marker = self.markers.inject_block_marker(
+                            cfg,
+                            sub_branch.source_info,
+                            sub_branch.branch_taken_block,
+                        );
 
                         BranchArm {
                             span: sub_branch.source_info.span,

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -453,12 +453,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         opt_scrutinee_place,
                     );
 
-                    let sub_branches: Vec<_> = branch
+                    let mut sub_branches: Vec<_> = branch
                         .sub_branches
                         .iter()
                         .map(|b| coverageinfo::MatchArmSubBranch {
                             source_info: this.source_info(b.span),
-                            block: b.success_block,
+                            pre_binding_block: b.success_block,
+                            branch_taken_block: b.success_block,
                         })
                         .collect();
 
@@ -471,11 +472,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         EmitStorageLive::Yes,
                     );
 
+                    // If the match arm has a guard, change the branch_taken_block for all of the
+                    // sub-branches to be the guard block.
+                    if arm.guard.is_some() {
+                        for sub_branch in sub_branches.iter_mut() {
+                            sub_branch.branch_taken_block = arm_block;
+                        }
+                    }
+
                     if let Some(coverage_match_arms) = coverage_match_arms.as_mut() {
-                        coverage_match_arms.push(coverageinfo::MatchArm {
-                            source_info: this.source_info(arm.pattern.span),
-                            sub_branches,
-                        })
+                        coverage_match_arms.push(coverageinfo::MatchArm { sub_branches });
                     }
 
                     this.fixed_temps_scope = old_dedup_scope;