coverage. Trace Candidate and MatchPair with coverage id

Author: zhuyunxing

compiler/rustc_middle/src/mir/coverage.rs

@@ -348,3 +348,88 @@ impl MCDCDecisionSpan {
         }
     }
 }
+
+/// Identify subcandidates in a candidate.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SubcandidateId(usize);
+
+impl SubcandidateId {
+    pub const ROOT: SubcandidateId = SubcandidateId(0);
+    pub fn is_root(&self) -> bool {
+        *self == Self::ROOT
+    }
+
+    pub fn next_subcandidate_id(&self) -> Self {
+        Self(self.0 + 1)
+    }
+}
+
+/// Identify MatchPair in a candidate.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct MatchPairId(usize);
+
+impl MatchPairId {
+    pub const INVALID: MatchPairId = MatchPairId(0);
+    pub const START: MatchPairId = MatchPairId(1);
+    pub fn next_match_pair_id(&self) -> Self {
+        Self(self.0 + 1)
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct CandidateCovId {
+    pub decision_id: DecisionId,
+    pub subcandidate_id: SubcandidateId,
+}
+
+impl Default for CandidateCovId {
+    fn default() -> Self {
+        Self { decision_id: DecisionId::MAX, subcandidate_id: SubcandidateId(usize::MAX) }
+    }
+}
+
+impl CandidateCovId {
+    pub fn is_valid(&self) -> bool {
+        *self != Self::default()
+    }
+
+    pub fn new_match_info(
+        &mut self,
+        match_id: MatchPairId,
+        span: Span,
+        fully_matched: bool,
+    ) -> MatchCoverageInfo {
+        let key = MatchKey {
+            decision_id: self.decision_id,
+            match_id,
+            subcandidate_id: self.subcandidate_id,
+        };
+        MatchCoverageInfo { key, span, fully_matched }
+    }
+}
+
+/// Key for matched patterns.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct MatchKey {
+    pub decision_id: DecisionId,
+    pub match_id: MatchPairId,
+    pub subcandidate_id: SubcandidateId,
+}
+
+impl Default for MatchKey {
+    fn default() -> Self {
+        Self {
+            decision_id: DecisionId::MAX,
+            match_id: MatchPairId(0),
+            subcandidate_id: SubcandidateId(0),
+        }
+    }
+}
+
+/// Information about matched patterns.
+#[derive(Clone, Copy, Debug)]
+pub struct MatchCoverageInfo {
+    pub key: MatchKey,
+    pub span: Span,
+    pub fully_matched: bool,
+}

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

@@ -250,6 +250,6 @@ impl<'pat, 'tcx> MatchPairTree<'pat, 'tcx> {
             PatKind::Never => TestCase::Never,
         };
 
-        MatchPairTree { place, test_case, subpairs, pattern }
+        MatchPairTree { place, test_case, subpairs, pattern ,coverage_id:Default::default()}
     }
 }

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

@@ -1110,6 +1110,10 @@ struct Candidate<'pat, 'tcx> {
     /// The earliest block that has only candidates >= this one as descendents. Used for false
     /// edges, see the doc for [`Builder::match_expr`].
     false_edge_start_block: Option<BasicBlock>,
+
+    #[allow(unused)]
+    /// The id to identify the candidate in coverage instrument.
+    coverage_id: coverage::CandidateCovId,
 }
 
 impl<'tcx, 'pat> Candidate<'pat, 'tcx> {
@@ -1138,6 +1142,7 @@ impl<'tcx, 'pat> Candidate<'pat, 'tcx> {
             otherwise_block: None,
             pre_binding_block: None,
             false_edge_start_block: None,
+            coverage_id: coverage::CandidateCovId::default(),
         }
     }
 
@@ -1168,6 +1173,31 @@ impl<'tcx, 'pat> Candidate<'pat, 'tcx> {
             |_| {},
         );
     }
+
+    #[allow(unused)]
+    pub(crate) fn set_coverage_id(&mut self, coverage_id: coverage::CandidateCovId) {
+        self.coverage_id = coverage_id;
+        // Assign id for match pairs only if this candidate is the root.
+        if !coverage_id.subcandidate_id.is_root() {
+            return;
+        };
+        let mut latest_match_id = coverage::MatchPairId::START;
+        let mut next_match_id = || {
+            let id = latest_match_id;
+            latest_match_id = id.next_match_pair_id();
+            id
+        };
+        let mut match_pairs = self.match_pairs.iter_mut().collect::<Vec<_>>();
+        while let Some(match_pair) = match_pairs.pop() {
+            match_pair.coverage_id = next_match_id();
+            match_pairs.extend(match_pair.subpairs.iter_mut());
+            if let TestCase::Or { ref mut pats } = match_pair.test_case {
+                match_pairs.extend(
+                    pats.iter_mut().map(|flat_pat| flat_pat.match_pairs.iter_mut()).flatten(),
+                );
+            }
+        }
+    }
 }
 
 /// A depth-first traversal of the `Candidate` and all of its recursive
@@ -1290,6 +1320,10 @@ pub(crate) struct MatchPairTree<'pat, 'tcx> {
 
     /// The pattern this was created from.
     pattern: &'pat Pat<'tcx>,
+
+    #[allow(unused)]
+    /// Key to identify the match pair in coverage.
+    coverage_id: coverage::MatchPairId,
 }
 
 /// See [`Test`] for more.