coverage: Introduce CoverageKind::Mappings (not yet used)

This new kind of coverage statement only holds source region mappings, and does
not represent a counter-increment or store expression details.

This patch performs the plumbing needed to add a new enum arm, but does not yet
adjust the MIR coverage instrumentor to use it.

Author: Zalathar

compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs

@@ -127,9 +127,9 @@ impl<'tcx> FunctionCoverage<'tcx> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn add_mappings(&mut self, kind: CovTerm, code_regions: &[CodeRegion]) {
+    pub(crate) fn add_mappings(&mut self, term: CovTerm, code_regions: &[CodeRegion]) {
         self.mappings
-            .extend(code_regions.iter().cloned().map(|code_region| Mapping { kind, code_region }));
+            .extend(code_regions.iter().cloned().map(|code_region| Mapping { term, code_region }));
     }
 
     pub(crate) fn finalize(&mut self) {
@@ -240,8 +240,8 @@ impl<'tcx> FunctionCoverage<'tcx> {
     /// Converts this function's coverage mappings into an intermediate form
     /// that will be used by `mapgen` when preparing for FFI.
     pub(crate) fn mappings_for_ffi(&self) -> impl Iterator<Item = (Counter, &CodeRegion)> {
-        self.mappings.iter().map(|&Mapping { kind, ref code_region }| {
-            let counter = Counter::from_term(kind);
+        self.mappings.iter().map(|&Mapping { term, ref code_region }| {
+            let counter = Counter::from_term(term);
             (counter, code_region)
         })
     }

compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs

@@ -141,6 +141,9 @@ impl<'tcx> CoverageInfoBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
             CoverageKind::Unreachable => {
                 func_coverage.add_unreachable_regions(code_regions);
             }
+            CoverageKind::Mappings { term } => {
+                func_coverage.add_mappings(term, code_regions);
+            }
         }
     }
 }

compiler/rustc_middle/src/mir/coverage.rs

@@ -77,6 +77,9 @@ pub enum CoverageKind {
         rhs: CovTerm,
     },
     Unreachable,
+    Mappings {
+        term: CovTerm,
+    },
 }
 
 impl Debug for CoverageKind {
@@ -96,6 +99,7 @@ impl Debug for CoverageKind {
                 rhs,
             ),
             Unreachable => write!(fmt, "Unreachable"),
+            Mappings { term } => fmt.debug_struct("Mappings").field("term", term).finish(),
         }
     }
 }
@@ -144,11 +148,11 @@ pub struct Mapping {
     // Coverage codegen relies on this field order when it sorts a function's mappings.
     pub code_region: CodeRegion,
 
-    /// Kind of coverage region that this mapping represents.
+    /// Indicates whether this mapping uses a counter value, expression value,
+    /// or zero value.
     ///
-    /// Currently we only support ordinary `Code` regions, so the "kind" is
-    /// just a term. When we add support for other region kinds allowed by
-    /// LLVM (e.g. branch regions, expansion regions), we'll need to replace
-    /// this with a dedicated mapping-kind enum.
-    pub kind: CovTerm,
+    /// FIXME: When we add support for mapping kinds other than `Code`
+    /// (e.g. branch regions, expansion regions), replace this with a dedicated
+    /// mapping-kind enum.
+    pub term: CovTerm,
 }

compiler/rustc_mir_transform/src/coverage/query.rs

@@ -69,6 +69,7 @@ impl CoverageVisitor {
                 self.update_from_term(rhs);
             }
             CoverageKind::Unreachable => {}
+            CoverageKind::Mappings { term } => self.update_from_term(term),
         }
     }
 }