coverage. Instrument mcdc for pattern matching

Author: zhuyunxing

compiler/rustc_middle/src/mir/coverage.rs

@@ -300,7 +300,7 @@ pub struct BranchSpan {
     pub false_marker: BlockMarkerId,
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct ConditionInfo {
     pub condition_id: ConditionId,
@@ -389,8 +389,10 @@ impl Default for CandidateCovId {
 }
 
 impl CandidateCovId {
-    pub fn is_valid(&self) -> bool {
-        *self != Self::default()
+    /// Return `true` is this `CandidateCovId` is assigned properly through coverage mechanism
+    /// and can be mapped as a decision.
+    pub fn is_valid(self) -> bool {
+        self != Self::default()
     }
 
     pub fn new_match_info(

compiler/rustc_mir_build/src/build/coverageinfo.rs

@@ -184,9 +184,9 @@ impl CoverageInfoBuilder {
             num_block_markers,
             branch_spans,
             mcdc_degraded_spans,
-            mcdc_spans
-    })
-}
+            mcdc_spans,
+        })
+    }
 }
 
 impl<'tcx> Builder<'_, 'tcx> {

compiler/rustc_mir_build/src/build/coverageinfo/mcdc.rs

@@ -1,7 +1,9 @@
+mod matching;
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::rc::Rc;
 
+use matching::{LateMatchingState, MatchingDecisionCtx};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_middle::bug;
 use rustc_middle::mir::BasicBlock;
@@ -174,14 +176,17 @@ impl BooleanDecisionCtx {
 #[derive(Debug)]
 enum DecisionCtx {
     Boolean(BooleanDecisionCtx),
-    #[allow(unused)]
-    Matching,
+    Matching(MatchingDecisionCtx),
 }
 
 impl DecisionCtx {
     fn new_boolean(id: DecisionId) -> Self {
         Self::Boolean(BooleanDecisionCtx::new(id))
     }
+
+    fn new_matching(info: &[(Span, DecisionId)]) -> Self {
+        Self::Matching(MatchingDecisionCtx::new(info))
+    }
 }
 
 pub(crate) struct MCDCStateGuard {
@@ -270,6 +275,7 @@ pub(crate) struct MCDCInfoBuilder {
     normal_branch_spans: Vec<MCDCBranchSpan>,
     mcdc_targets: FxIndexMap<DecisionId, MCDCTargetInfo>,
     state_stack: Vec<MCDCState>,
+    late_matching_state: LateMatchingState,
     decision_id_gen: DecisionIdGen,
 }
 
@@ -279,6 +285,7 @@ impl MCDCInfoBuilder {
             normal_branch_spans: vec![],
             mcdc_targets: FxIndexMap::default(),
             state_stack: vec![],
+            late_matching_state: Default::default(),
             decision_id_gen: DecisionIdGen::default(),
         }
     }
@@ -293,6 +300,11 @@ impl MCDCInfoBuilder {
         &mut self.state_stack[current_idx]
     }
 
+    fn current_processing_ctx_mut(&mut self) -> Option<&mut DecisionCtx> {
+        self.ensure_active_state();
+        self.state_stack.last_mut().and_then(|state| state.current_ctx.as_mut())
+    }
+
     fn ensure_active_state(&mut self) {
         let mut active_state_idx = None;
         // Down to the first non-stashed state or non-empty state, which can be ensured to be
@@ -353,7 +365,8 @@ impl MCDCInfoBuilder {
         let num_conditions = info.conditions.len();
         match num_conditions {
             0 => {
-                unreachable!("Decision with no condition is not expected");
+                // Irrefutable patterns caused by empty types can lead to here.
+                false
             }
             // Ignore decisions with only one condition given that mcdc for them is completely equivalent to branch coverage.
             2..=MAX_CONDITIONS_IN_DECISION => {
@@ -445,17 +458,26 @@ impl MCDCInfoBuilder {
 
         let (id, decision, conditions) = ctx.into_done();
         let info = MCDCTargetInfo { decision, conditions, nested_decisions_id };
-        let entry_decision_id = self.append_mcdc_info(tcx, id, info).then_some(id);
-        self.on_ctx_finished(tcx, entry_decision_id);
+        if self.late_matching_state.is_guard_decision(id) {
+            self.late_matching_state.add_guard_decision(id, info);
+        } else {
+            let entry_id = self.append_mcdc_info(tcx, id, info).then_some(id);
+            self.on_ctx_finished(tcx, entry_id)
+        }
     }
 
     pub(crate) fn into_done(
         self,
     ) -> (Vec<MCDCBranchSpan>, Vec<(MCDCDecisionSpan, Vec<MCDCBranchSpan>)>) {
+        assert!(
+            !self.has_processing_decision() && self.late_matching_state.is_empty(),
+            "has unfinished decisions"
+        );
         let MCDCInfoBuilder {
             normal_branch_spans,
             mcdc_targets,
             state_stack: _,
+            late_matching_state: _,
             decision_id_gen: _,
         } = self;