coverage: Move more branch-condition code out of Builder

Passing all these parameters is a bit more verbose, but is more agreeable to
the borrow-checker.

Author: Zalathar

compiler/rustc_mir_build/src/build/coverageinfo.rs

@@ -3,12 +3,12 @@ use std::collections::hash_map::Entry;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::mir::coverage::{BlockMarkerId, BranchSpan, CoverageKind};
-use rustc_middle::mir::{self, BasicBlock, UnOp};
+use rustc_middle::mir::{self, BasicBlock, SourceInfo, SourceScope, UnOp};
 use rustc_middle::thir::{ExprId, ExprKind, Thir};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::LocalDefId;
 
-use crate::build::Builder;
+use crate::build::{Builder, CFG};
 
 pub(crate) struct BranchInfoBuilder {
     /// Maps condition expressions to their enclosing `!`, for better instrumentation.
@@ -79,12 +79,55 @@ impl BranchInfoBuilder {
         }
     }
 
+    fn visit_coverage_branch_condition<'tcx>(
+        &mut self,
+        cfg: &mut CFG<'tcx>,
+        thir: &Thir<'tcx>,
+        scope: SourceScope,
+        mut expr_id: ExprId,
+        mut then_block: BasicBlock,
+        mut else_block: BasicBlock,
+    ) {
+        // If this condition expression is nested within one or more `!` expressions,
+        // replace it with the enclosing `!` collected by `visit_unary_not`.
+        if let Some(&NotInfo { enclosing_not, is_flipped }) = self.nots.get(&expr_id) {
+            expr_id = enclosing_not;
+            if is_flipped {
+                std::mem::swap(&mut then_block, &mut else_block);
+            }
+        }
+
+        let span = thir[expr_id].span;
+        let source_info = SourceInfo { span, scope };
+        let true_marker = self.inject_block_marker(cfg, source_info, then_block);
+        let false_marker = self.inject_block_marker(cfg, source_info, else_block);
+
+        self.branch_spans.push(BranchSpan { span, true_marker, false_marker });
+    }
+
     fn next_block_marker_id(&mut self) -> BlockMarkerId {
         let id = BlockMarkerId::from_usize(self.num_block_markers);
         self.num_block_markers += 1;
         id
     }
 
+    fn inject_block_marker(
+        &mut self,
+        cfg: &mut CFG<'_>,
+        source_info: SourceInfo,
+        block: BasicBlock,
+    ) -> BlockMarkerId {
+        let id = self.next_block_marker_id();
+
+        let marker_statement = mir::Statement {
+            source_info,
+            kind: mir::StatementKind::Coverage(CoverageKind::BlockMarker { id }),
+        };
+        cfg.push(block, marker_statement);
+
+        id
+    }
+
     pub(crate) fn into_done(self) -> Option<Box<mir::coverage::BranchInfo>> {
         let Self { nots: _, num_block_markers, branch_spans } = self;
 
@@ -102,45 +145,20 @@ impl Builder<'_, '_> {
     /// and `else_block`, and record their IDs in the table of branch spans.
     pub(crate) fn visit_coverage_branch_condition(
         &mut self,
-        mut expr_id: ExprId,
-        mut then_block: BasicBlock,
-        mut else_block: BasicBlock,
+        expr_id: ExprId,
+        then_block: BasicBlock,
+        else_block: BasicBlock,
     ) {
         // Bail out if branch coverage is not enabled for this function.
-        let Some(branch_info) = self.coverage_branch_info.as_ref() else { return };
-
-        // If this condition expression is nested within one or more `!` expressions,
-        // replace it with the enclosing `!` collected by `visit_unary_not`.
-        if let Some(&NotInfo { enclosing_not, is_flipped }) = branch_info.nots.get(&expr_id) {
-            expr_id = enclosing_not;
-            if is_flipped {
-                std::mem::swap(&mut then_block, &mut else_block);
-            }
-        }
-        let source_info = self.source_info(self.thir[expr_id].span);
-
-        // Now that we have `source_info`, we can upgrade to a &mut reference.
-        let branch_info = self.coverage_branch_info.as_mut().expect("upgrading & to &mut");
-
-        let mut inject_branch_marker = |block: BasicBlock| {
-            let id = branch_info.next_block_marker_id();
-
-            let marker_statement = mir::Statement {
-                source_info,
-                kind: mir::StatementKind::Coverage(CoverageKind::BlockMarker { id }),
-            };
-            self.cfg.push(block, marker_statement);
-
-            id
-        };
-
-        let true_marker = inject_branch_marker(then_block);
-        let false_marker = inject_branch_marker(else_block);
-
-        branch_info.branch_spans.push(BranchSpan {
-            span: source_info.span,
-            true_marker,
-            false_marker,
-        });
+        let Some(branch_info) = self.coverage_branch_info.as_mut() else { return };
+
+        branch_info.visit_coverage_branch_condition(
+            &mut self.cfg,
+            &self.thir,
+            self.source_scope,
+            expr_id,
+            then_block,
+            else_block,
+        );
     }
 }