coverage. Trace Candidate and MatchPair with coverage id

Author: zhuyunxing

compiler/rustc_middle/src/mir/coverage.rs

@@ -362,3 +362,87 @@ impl CoverageIdsInfo {
         }
     }
 }
+/// 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/builder/matches/match_pair.rs

@@ -173,10 +173,13 @@ impl<'tcx> MatchPairTree<'tcx> {
                 let ascription = place.map(|source| {
                     let span = pattern.span;
                     let parent_id = cx.tcx.typeck_root_def_id(cx.def_id.to_def_id());
-                    let args = ty::InlineConstArgs::new(cx.tcx, ty::InlineConstArgsParts {
-                        parent_args: ty::GenericArgs::identity_for_item(cx.tcx, parent_id),
-                        ty: cx.infcx.next_ty_var(span),
-                    })
+                    let args = ty::InlineConstArgs::new(
+                        cx.tcx,
+                        ty::InlineConstArgsParts {
+                            parent_args: ty::GenericArgs::identity_for_item(cx.tcx, parent_id),
+                            ty: cx.infcx.next_ty_var(span),
+                        },
+                    )
                     .args;
                     let user_ty = cx.infcx.canonicalize_user_type_annotation(ty::UserType::new(
                         ty::UserTypeKind::TypeOf(def_id, ty::UserArgs { args, user_self_ty: None }),
@@ -263,6 +266,7 @@ impl<'tcx> MatchPairTree<'tcx> {
             subpairs,
             pattern_ty: pattern.ty,
             pattern_span: pattern.span,
+            coverage_id: Default::default(),
         }
     }
 }

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

@@ -1109,6 +1109,10 @@ struct Candidate<'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> Candidate<'tcx> {
@@ -1137,6 +1141,7 @@ impl<'tcx> Candidate<'tcx> {
             otherwise_block: None,
             pre_binding_block: None,
             false_edge_start_block: None,
+            coverage_id: coverage::CandidateCovId::default(),
         }
     }
 
@@ -1167,6 +1172,31 @@ impl<'tcx> Candidate<'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
@@ -1291,6 +1321,9 @@ pub(crate) struct MatchPairTree<'tcx> {
     pattern_ty: Ty<'tcx>,
     /// Span field of the pattern this node was created from.
     pattern_span: Span,
+
+    /// Key to identify the match pair in coverage.
+    coverage_id: coverage::MatchPairId,
 }
 
 /// See [`Test`] for more.