Rust coverage before splitting instrument_coverage.rs

214 files changed, 9821 insertions, 1243 deletions

diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
index c1163a871cf..41827a91ba4 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
@@ -129,7 +129,7 @@ impl CoverageMapGenerator {
                 let (filenames_index, _) = self.filenames.insert_full(c_filename);
                 virtual_file_mapping.push(filenames_index as u32);
             }
-            debug!("Adding counter {:?} to map for {:?}", counter, region,);
+            debug!("Adding counter {:?} to map for {:?}", counter, region);
             mapping_regions.push(CounterMappingRegion::code_region(
                 counter,
                 current_file_id,
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
index 7fdbe1a5512..c4b4032fd47 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
@@ -12,7 +12,7 @@ use rustc_codegen_ssa::traits::{
 use rustc_data_structures::fx::FxHashMap;
 use rustc_llvm::RustString;
 use rustc_middle::mir::coverage::{
-    CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionIndex, Op,
+    CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionId, Op,
 };
 use rustc_middle::ty::Instance;
 
@@ -27,8 +27,8 @@ const COVMAP_VAR_ALIGN_BYTES: usize = 8;
 
 /// A context object for maintaining all state needed by the coverageinfo module.
 pub struct CrateCoverageContext<'tcx> {
-    // Coverage region data for each instrumented function identified by DefId.
-    pub(crate) function_coverage_map: RefCell<FxHashMap<Instance<'tcx>, FunctionCoverage>>,
+    // Coverage data for each instrumented function identified by DefId.
+    pub(crate) function_coverage_map: RefCell<FxHashMap<Instance<'tcx>, FunctionCoverage<'tcx>>>,
 }
 
 impl<'tcx> CrateCoverageContext<'tcx> {
@@ -36,7 +36,7 @@ impl<'tcx> CrateCoverageContext<'tcx> {
         Self { function_coverage_map: Default::default() }
     }
 
-    pub fn take_function_coverage_map(&self) -> FxHashMap<Instance<'tcx>, FunctionCoverage> {
+    pub fn take_function_coverage_map(&self) -> FxHashMap<Instance<'tcx>, FunctionCoverage<'tcx>> {
         self.function_coverage_map.replace(FxHashMap::default())
     }
 }
@@ -58,7 +58,23 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         unsafe { llvm::LLVMRustCoverageCreatePGOFuncNameVar(llfn, mangled_fn_name.as_ptr()) }
     }
 
-    fn add_counter_region(
+    fn set_function_source_hash(&mut self, instance: Instance<'tcx>, function_source_hash: u64) -> bool {
+        if let Some(coverage_context) = self.coverage_context() {
+            debug!(
+                "ensuring function source hash is set for instance={:?}; function_source_hash={}",
+                instance, function_source_hash,
+            );
+            let mut coverage_map = coverage_context.function_coverage_map.borrow_mut();
+            coverage_map
+                .entry(instance)
+                .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
+                .set_function_source_hash(function_source_hash);
+        } else {
+            false
+        }
+    }
+
+    fn add_coverage_counter(
         &mut self,
         instance: Instance<'tcx>,
         function_source_hash: u64,
@@ -67,59 +83,53 @@ impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     ) -> bool {
         if let Some(coverage_context) = self.coverage_context() {
             debug!(
-                "adding counter to coverage_regions: instance={:?}, function_source_hash={}, id={:?}, \
+                "adding counter to coverage_map: instance={:?}, function_source_hash={}, id={:?}, \
                 at {:?}",
                 instance, function_source_hash, id, region,
             );
-            let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
-            coverage_regions
+            let mut coverage_map = coverage_context.function_coverage_map.borrow_mut();
+            coverage_map
                 .entry(instance)
                 .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
                 .add_counter(function_source_hash, id, region);
-            true
         } else {
             false
         }
     }
 
-    fn add_counter_expression_region(
+    fn add_coverage_counter_expression(
         &mut self,
         instance: Instance<'tcx>,
-        id: InjectedExpressionIndex,
+        id: InjectedExpressionId,
         lhs: ExpressionOperandId,
         op: Op,
         rhs: ExpressionOperandId,
-        region: CodeRegion,
-    ) -> bool {
-        if let Some(coverage_context) = self.coverage_context() {
+        region: Option<CodeRegion>,
+    ) {
+        if let Some(coverage_context) = self.coverage_context() -> bool {
             debug!(
-                "adding counter expression to coverage_regions: instance={:?}, id={:?}, {:?} {:?} {:?}, \
-                at {:?}",
+                "adding counter expression to coverage_map: instance={:?}, id={:?}, {:?} {:?} {:?}; \
+                region: {:?}",
                 instance, id, lhs, op, rhs, region,
             );
-            let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
-            coverage_regions
+            let mut coverage_map = coverage_context.function_coverage_map.borrow_mut();
+            coverage_map
                 .entry(instance)
                 .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
                 .add_counter_expression(id, lhs, op, rhs, region);
-            true
         } else {
             false
         }
     }
 
-    fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool {
+    fn add_coverage_unreachable(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool {
         if let Some(coverage_context) = self.coverage_context() {
-            debug!(
-                "adding unreachable code to coverage_regions: instance={:?}, at {:?}",
-                instance, region,
-            );
-            let mut coverage_regions = coverage_context.function_coverage_map.borrow_mut();
-            coverage_regions
+            debug!("adding unreachable code to coverage_map: instance={:?}, at {:?}", instance, region,);
+            let mut coverage_map = coverage_context.function_coverage_map.borrow_mut();
+            coverage_map
                 .entry(instance)
                 .or_insert_with(|| FunctionCoverage::new(self.tcx, instance))
                 .add_unreachable_region(region);
-            true
         } else {
             false
         }
diff --git a/compiler/rustc_codegen_ssa/src/coverageinfo/ffi.rs b/compiler/rustc_codegen_ssa/src/coverageinfo/ffi.rs
index a266d179a42..bcac2c90fdc 100644
--- a/compiler/rustc_codegen_ssa/src/coverageinfo/ffi.rs
+++ b/compiler/rustc_codegen_ssa/src/coverageinfo/ffi.rs
@@ -3,7 +3,7 @@ use rustc_middle::mir::coverage::{CounterValueReference, MappedExpressionIndex};
 /// Aligns with [llvm::coverage::Counter::CounterKind](https://github.com/rust-lang/llvm-project/blob/rustc/10.0-2020-05-05/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L91)
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
-enum CounterKind {
+pub enum CounterKind {
     Zero = 0,
     CounterValueReference = 1,
     Expression = 2,
@@ -23,8 +23,8 @@ enum CounterKind {
 #[repr(C)]
 pub struct Counter {
     // Important: The layout (order and types of fields) must match its C++ counterpart.
-    kind: CounterKind,
-    id: u32,
+    pub kind: CounterKind,
+    pub id: u32,
 }
 
 impl Counter {
@@ -55,9 +55,9 @@ pub enum ExprKind {
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct CounterExpression {
-    kind: ExprKind,
-    lhs: Counter,
-    rhs: Counter,
+    pub kind: ExprKind,
+    pub lhs: Counter,
+    pub rhs: Counter,
 }
 
 impl CounterExpression {
diff --git a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
index d8bde8ee705..006d6662196 100644
--- a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
+++ b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
@@ -2,18 +2,18 @@ pub use super::ffi::*;
 
 use rustc_index::vec::IndexVec;
 use rustc_middle::mir::coverage::{
-    CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionIndex,
-    MappedExpressionIndex, Op,
+    CodeRegion, CounterValueReference, ExpressionOperandId, InjectedExpressionId,
+    InjectedExpressionIndex, MappedExpressionIndex, Op,
 };
 use rustc_middle::ty::Instance;
 use rustc_middle::ty::TyCtxt;
 
 #[derive(Clone, Debug)]
-pub struct ExpressionRegion {
+pub struct Expression {
     lhs: ExpressionOperandId,
     op: Op,
     rhs: ExpressionOperandId,
-    region: CodeRegion,
+    region: Option<CodeRegion>,
 }
 
 /// Collects all of the coverage regions associated with (a) injected counters, (b) counter
@@ -28,17 +28,23 @@ pub struct ExpressionRegion {
 /// only whitespace or comments). According to LLVM Code Coverage Mapping documentation, "A count
 /// for a gap area is only used as the line execution count if there are no other regions on a
 /// line."
-pub struct FunctionCoverage {
+pub struct FunctionCoverage<'tcx> {
+    instance: Instance<'tcx>,
     source_hash: u64,
     counters: IndexVec<CounterValueReference, Option<CodeRegion>>,
-    expressions: IndexVec<InjectedExpressionIndex, Option<ExpressionRegion>>,
+    expressions: IndexVec<InjectedExpressionIndex, Option<Expression>>,
     unreachable_regions: Vec<CodeRegion>,
 }
 
-impl FunctionCoverage {
-    pub fn new<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Self {
+impl<'tcx> FunctionCoverage<'tcx> {
+    pub fn new(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Self {
         let coverageinfo = tcx.coverageinfo(instance.def_id());
+        debug!(
+            "FunctionCoverage::new(instance={:?}) has coverageinfo={:?}",
+            instance, coverageinfo
+        );
         Self {
+            instance,
             source_hash: 0, // will be set with the first `add_counter()`
             counters: IndexVec::from_elem_n(None, coverageinfo.num_counters as usize),
             expressions: IndexVec::from_elem_n(None, coverageinfo.num_expressions as usize),
@@ -46,6 +52,19 @@ impl FunctionCoverage {
         }
     }
 
+    /// Although every function should have at least one `Counter`, the `Counter` isn't required to
+    /// have a `CodeRegion`. (The `CodeRegion` may be associated only with `Expressions`.) This
+    /// method supports the ability to ensure the `function_source_hash` is set from `Counters` that
+    /// do not trigger the call to `add_counter()` because they don't have an associated
+    /// `CodeRegion` to add.
+    pub fn set_function_source_hash(&mut self, source_hash: u64) {
+        if self.source_hash == 0 {
+            self.source_hash = source_hash;
+        } else {
+            debug_assert_eq!(source_hash, self.source_hash);
+        }
+    }
+
     /// Adds a code region to be counted by an injected counter intrinsic.
     /// The source_hash (computed during coverage instrumentation) should also be provided, and
     /// should be the same for all counters in a given function.
@@ -74,15 +93,19 @@ impl FunctionCoverage {
     /// counters and expressions have been added.
     pub fn add_counter_expression(
         &mut self,
-        expression_id: InjectedExpressionIndex,
+        expression_id: InjectedExpressionId,
         lhs: ExpressionOperandId,
         op: Op,
         rhs: ExpressionOperandId,
-        region: CodeRegion,
+        region: Option<CodeRegion>,
     ) {
+        debug!(
+            "add_counter_expression({:?}, lhs={:?}, op={:?}, rhs={:?} at {:?}",
+            expression_id, lhs, op, rhs, region
+        );
         let expression_index = self.expression_index(u32::from(expression_id));
         self.expressions[expression_index]
-            .replace(ExpressionRegion { lhs, op, rhs, region })
+            .replace(Expression { lhs, op, rhs, region })
             .expect_none("add_counter_expression called with duplicate `id_descending_from_max`");
     }
 
@@ -103,7 +126,11 @@ impl FunctionCoverage {
     pub fn get_expressions_and_counter_regions<'a>(
         &'a self,
     ) -> (Vec<CounterExpression>, impl Iterator<Item = (Counter, &'a CodeRegion)>) {
-        assert!(self.source_hash != 0);
+        assert!(
+            self.source_hash != 0,
+            "No counters provided the source_hash for function: {:?}",
+            self.instance
+        );
 
         let counter_regions = self.counter_regions();
         let (counter_expressions, expression_regions) = self.expressions_with_regions();
@@ -129,54 +156,60 @@ impl FunctionCoverage {
     ) -> (Vec<CounterExpression>, impl Iterator<Item = (Counter, &'a CodeRegion)>) {
         let mut counter_expressions = Vec::with_capacity(self.expressions.len());
         let mut expression_regions = Vec::with_capacity(self.expressions.len());
-        let mut new_indexes =
-            IndexVec::from_elem_n(MappedExpressionIndex::from(u32::MAX), self.expressions.len());
-        // Note, the initial value shouldn't matter since every index in use in `self.expressions`
-        // will be set, and after that, `new_indexes` will only be accessed using those same
-        // indexes.
-
-        // Note that an `ExpressionRegion`s at any given index can include other expressions as
+        let mut new_indexes = IndexVec::from_elem_n(None, self.expressions.len());
+        // Note that an `Expression`s at any given index can include other expressions as
         // operands, but expression operands can only come from the subset of expressions having
-        // `expression_index`s lower than the referencing `ExpressionRegion`. Therefore, it is
+        // `expression_index`s lower than the referencing `Expression`. Therefore, it is
         // reasonable to look up the new index of an expression operand while the `new_indexes`
         // vector is only complete up to the current `ExpressionIndex`.
         let id_to_counter =
-            |new_indexes: &IndexVec<InjectedExpressionIndex, MappedExpressionIndex>,
+            |new_indexes: &IndexVec<InjectedExpressionIndex, Option<MappedExpressionIndex>>,
              id: ExpressionOperandId| {
                 if id == ExpressionOperandId::ZERO {
                     Some(Counter::zero())
                 } else if id.index() < self.counters.len() {
+                    // Note: Some codegen-injected Counters may be only referenced by `Expression`s,
+                    // and may not have their own `CodeRegion`s,
                     let index = CounterValueReference::from(id.index());
-                    self.counters
-                        .get(index)
-                        .unwrap() // pre-validated
-                        .as_ref()
-                        .map(|_| Counter::counter_value_reference(index))
+                    Some(Counter::counter_value_reference(index))
                 } else {
                     let index = self.expression_index(u32::from(id));
                     self.expressions
                         .get(index)
                         .expect("expression id is out of range")
                         .as_ref()
-                        .map(|_| Counter::expression(new_indexes[index]))
+                        // If an expression was optimized out, assume it would have produced a count
+                        // of zero. This ensures that expressions dependent on optimized-out
+                        // expressions are still valid.
+                        .map_or(Some(Counter::zero()), |_| {
+                            new_indexes[index].map(|new_index| Counter::expression(new_index))
+                        })
                 }
             };
 
-        for (original_index, expression_region) in
+        for (original_index, expression) in
             self.expressions.iter_enumerated().filter_map(|(original_index, entry)| {
                 // Option::map() will return None to filter out missing expressions. This may happen
                 // if, for example, a MIR-instrumented expression is removed during an optimization.
-                entry.as_ref().map(|region| (original_index, region))
+                entry.as_ref().map(|expression| (original_index, expression))
             })
         {
-            let region = &expression_region.region;
-            let ExpressionRegion { lhs, op, rhs, .. } = *expression_region;
+            let optional_region = &expression.region;
+            let Expression { lhs, op, rhs, .. } = *expression;
 
             if let Some(Some((lhs_counter, rhs_counter))) =
                 id_to_counter(&new_indexes, lhs).map(|lhs_counter| {
                     id_to_counter(&new_indexes, rhs).map(|rhs_counter| (lhs_counter, rhs_counter))
                 })
             {
+                debug_assert!(
+                    (lhs_counter.id as usize)
+                        < usize::max(self.counters.len(), self.expressions.len())
+                );
+                debug_assert!(
+                    (rhs_counter.id as usize)
+                        < usize::max(self.counters.len(), self.expressions.len())
+                );
                 // Both operands exist. `Expression` operands exist in `self.expressions` and have
                 // been assigned a `new_index`.
                 let mapped_expression_index =
@@ -190,12 +223,20 @@ impl FunctionCoverage {
                     rhs_counter,
                 );
                 debug!(
-                    "Adding expression {:?} = {:?} at {:?}",
-                    mapped_expression_index, expression, region
+                    "Adding expression {:?} = {:?}, region: {:?}",
+                    mapped_expression_index, expression, optional_region
                 );
                 counter_expressions.push(expression);
-                new_indexes[original_index] = mapped_expression_index;
-                expression_regions.push((Counter::expression(mapped_expression_index), region));
+                new_indexes[original_index] = Some(mapped_expression_index);
+                if let Some(region) = optional_region {
+                    expression_regions.push((Counter::expression(mapped_expression_index), region));
+                }
+            } else {
+                debug!(
+                    "Ignoring expression with one or more missing operands: \
+                    original_index={:?}, lhs={:?}, op={:?}, rhs={:?}, region={:?}",
+                    original_index, lhs, op, rhs, optional_region,
+                )
             }
         }
         (counter_expressions, expression_regions.into_iter())
diff --git a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs
index 4811adea9ec..e52f952e932 100644
--- a/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/coverageinfo.rs
@@ -10,7 +10,15 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let Coverage { kind, code_region } = coverage;
         match kind {
             CoverageKind::Counter { function_source_hash, id } => {
-                if bx.add_counter_region(self.instance, function_source_hash, id, code_region) {
+                let covmap_updated = if let Some(code_region) = code_region {
+                    // Note: Some counters do not have code regions, but may still be referenced from
+                    // expressions.
+                    bx.add_coverage_counter(self.instance, function_source_hash, id, code_region)
+                } else {
+                    bx.set_function_source_hash(self.instance, function_source_hash)
+                };
+
+                if covmap_updated {
                     let coverageinfo = bx.tcx().coverageinfo(self.instance.def_id());
 
                     let fn_name = bx.create_pgo_func_name_var(self.instance);
@@ -21,14 +29,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         "codegen intrinsic instrprof.increment(fn_name={:?}, hash={:?}, num_counters={:?}, index={:?})",
                         fn_name, hash, num_counters, id,
                     );
-                    bx.instrprof_increment(fn_name, hash, num_counters, id);
+                    bx.instrprof_increment(fn_name, hash, num_counters, index);
                 }
             }
             CoverageKind::Expression { id, lhs, op, rhs } => {
-                bx.add_counter_expression_region(self.instance, id, lhs, op, rhs, code_region);
+                bx.add_coverage_counter_expression(self.instance, id, lhs, op, rhs, code_region);
             }
             CoverageKind::Unreachable => {
-                bx.add_unreachable_region(self.instance, code_region);
+                bx.add_coverage_unreachable(
+                    self.instance,
+                    code_region.expect("unreachable regions always have code regions"),
+                );
             }
         }
     }
diff --git a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs
index 3b1654f3ad4..5aa0950b399 100644
--- a/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/coverageinfo.rs
@@ -9,9 +9,13 @@ pub trait CoverageInfoMethods: BackendTypes {
 pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
     fn create_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Self::Value;
 
+    /// Returns true if the function source hash was added to the coverage map; false if
+    /// `-Z instrument-coverage` is not enabled (a coverage map is not being generated).
+    fn set_function_source_hash(&mut self, instance: Instance<'tcx>, function_source_hash: u64) -> bool;
+
     /// Returns true if the counter was added to the coverage map; false if `-Z instrument-coverage`
     /// is not enabled (a coverage map is not being generated).
-    fn add_counter_region(
+    fn add_coverage_counter(
         &mut self,
         instance: Instance<'tcx>,
         function_source_hash: u64,
@@ -21,17 +25,17 @@ pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes {
 
     /// Returns true if the expression was added to the coverage map; false if
     /// `-Z instrument-coverage` is not enabled (a coverage map is not being generated).
-    fn add_counter_expression_region(
+    fn add_coverage_counter_expression(
         &mut self,
         instance: Instance<'tcx>,
-        id: InjectedExpressionIndex,
+        id: InjectedExpressionId,
         lhs: ExpressionOperandId,
         op: Op,
         rhs: ExpressionOperandId,
-        region: CodeRegion,
-    ) -> bool;
+        region: Option<CodeRegion>,
+    );
 
     /// Returns true if the region was added to the coverage map; false if `-Z instrument-coverage`
     /// is not enabled (a coverage map is not being generated).
-    fn add_unreachable_region(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool;
+    fn add_coverage_unreachable(&mut self, instance: Instance<'tcx>, region: CodeRegion) -> bool;
 }
diff --git a/compiler/rustc_graphviz/src/lib.rs b/compiler/rustc_graphviz/src/lib.rs
index d332466160c..9653ff022f1 100644
--- a/compiler/rustc_graphviz/src/lib.rs
+++ b/compiler/rustc_graphviz/src/lib.rs
@@ -643,6 +643,7 @@ where
     }
     if options.contains(&RenderOption::DarkTheme) {
         graph_attrs.push(r#"bgcolor="black""#);
+        graph_attrs.push(r#"fontcolor="white""#);
         content_attrs.push(r#"color="white""#);
         content_attrs.push(r#"fontcolor="white""#);
     }
diff --git a/compiler/rustc_middle/src/mir/coverage.rs b/compiler/rustc_middle/src/mir/coverage.rs
index 0421eabc2dc..ad0ba292d02 100644
--- a/compiler/rustc_middle/src/mir/coverage.rs
+++ b/compiler/rustc_middle/src/mir/coverage.rs
@@ -7,6 +7,10 @@ use std::cmp::Ord;
 use std::fmt::{self, Debug, Formatter};
 
 rustc_index::newtype_index! {
+    /// An ExpressionOperandId value is assigned directly from either a
+    /// CounterValueReference.as_u32() (which ascend from 1) or an ExpressionOperandId.as_u32()
+    /// (which _*descend*_ from u32::MAX). Id value `0` (zero) represents a virtual counter with a
+    /// constant value of `0`.
     pub struct ExpressionOperandId {
         derive [HashStable]
         DEBUG_FORMAT = "ExpressionOperandId({})",
@@ -42,6 +46,20 @@ impl CounterValueReference {
 }
 
 rustc_index::newtype_index! {
+    /// InjectedExpressionId.as_u32() converts to ExpressionOperandId.as_u32()
+    ///
+    /// Values descend from u32::MAX.
+    pub struct InjectedExpressionId {
+        derive [HashStable]
+        DEBUG_FORMAT = "InjectedExpressionId({})",
+        MAX = 0xFFFF_FFFF,
+    }
+}
+
+rustc_index::newtype_index! {
+    /// InjectedExpressionIndex.as_u32() translates to u32::MAX - ExpressionOperandId.as_u32()
+    ///
+    /// Values ascend from 0.
     pub struct InjectedExpressionIndex {
         derive [HashStable]
         DEBUG_FORMAT = "InjectedExpressionIndex({})",
@@ -50,6 +68,9 @@ rustc_index::newtype_index! {
 }
 
 rustc_index::newtype_index! {
+    /// MappedExpressionIndex values ascend from zero, and are recalculated indexes based on their
+    /// array position in the LLVM coverage map "Expressions" array, which is assembled during the
+    /// "mapgen" process. They cannot be computed algorithmically, from the other `newtype_index`s.
     pub struct MappedExpressionIndex {
         derive [HashStable]
         DEBUG_FORMAT = "MappedExpressionIndex({})",
@@ -64,21 +85,35 @@ impl From<CounterValueReference> for ExpressionOperandId {
     }
 }
 
-impl From<InjectedExpressionIndex> for ExpressionOperandId {
+impl From<&mut CounterValueReference> for ExpressionOperandId {
     #[inline]
-    fn from(v: InjectedExpressionIndex) -> ExpressionOperandId {
+    fn from(v: &mut CounterValueReference) -> ExpressionOperandId {
         ExpressionOperandId::from(v.as_u32())
     }
 }
 
-#[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
+impl From<InjectedExpressionId> for ExpressionOperandId {
+    #[inline]
+    fn from(v: InjectedExpressionId) -> ExpressionOperandId {
+        ExpressionOperandId::from(v.as_u32())
+    }
+}
+
+impl From<&mut InjectedExpressionId> for ExpressionOperandId {
+    #[inline]
+    fn from(v: &mut InjectedExpressionId) -> ExpressionOperandId {
+        ExpressionOperandId::from(v.as_u32())
+    }
+}
+
+#[derive(Clone, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
 pub enum CoverageKind {
     Counter {
         function_source_hash: u64,
         id: CounterValueReference,
     },
     Expression {
-        id: InjectedExpressionIndex,
+        id: InjectedExpressionId,
         lhs: ExpressionOperandId,
         op: Op,
         rhs: ExpressionOperandId,
@@ -88,12 +123,47 @@ pub enum CoverageKind {
 
 impl CoverageKind {
     pub fn as_operand_id(&self) -> ExpressionOperandId {
+        use CoverageKind::*;
         match *self {
-            CoverageKind::Counter { id, .. } => ExpressionOperandId::from(id),
-            CoverageKind::Expression { id, .. } => ExpressionOperandId::from(id),
-            CoverageKind::Unreachable => {
-                bug!("Unreachable coverage cannot be part of an expression")
-            }
+            Counter { id, .. } => ExpressionOperandId::from(id),
+            Expression { id, .. } => ExpressionOperandId::from(id),
+            Unreachable => bug!("Unreachable coverage cannot be part of an expression"),
+        }
+    }
+
+    pub fn is_counter(&self) -> bool {
+        match self {
+            Self::Counter { .. } => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_expression(&self) -> bool {
+        match self {
+            Self::Expression { .. } => true,
+            _ => false,
+        }
+    }
+
+    pub fn is_unreachable(&self) -> bool {
+        *self == Self::Unreachable
+    }
+}
+
+impl Debug for CoverageKind {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        use CoverageKind::*;
+        match self {
+            Counter { id, .. } => write!(fmt, "Counter({:?})", id.index()),
+            Expression { id, lhs, op, rhs } => write!(
+                fmt,
+                "Expression({:?}) = {} {} {}",
+                id.index(),
+                lhs.index(),
+                if *op == Op::Add { "+" } else { "-" },
+                rhs.index(),
+            ),
+            Unreachable => write!(fmt, "Unreachable"),
         }
     }
 }
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index bf091201e10..5fe7b0f647d 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -1585,21 +1585,10 @@ impl Debug for Statement<'_> {
                 write!(fmt, "AscribeUserType({:?}, {:?}, {:?})", place, variance, c_ty)
             }
             Coverage(box ref coverage) => {
-                let rgn = &coverage.code_region;
-                match coverage.kind {
-                    CoverageKind::Counter { id, .. } => {
-                        write!(fmt, "Coverage::Counter({:?}) for {:?}", id.index(), rgn)
-                    }
-                    CoverageKind::Expression { id, lhs, op, rhs } => write!(
-                        fmt,
-                        "Coverage::Expression({:?}) = {} {} {} for {:?}",
-                        id.index(),
-                        lhs.index(),
-                        if op == coverage::Op::Add { "+" } else { "-" },
-                        rhs.index(),
-                        rgn
-                    ),
-                    CoverageKind::Unreachable => write!(fmt, "Coverage::Unreachable for {:?}", rgn),
+                if let Some(rgn) = &coverage.code_region {
+                    write!(fmt, "Coverage::{:?} for {:?}", coverage.kind, rgn)
+                } else {
+                    write!(fmt, "Coverage::{:?}", coverage.kind)
                 }
             }
             Nop => write!(fmt, "nop"),
@@ -1610,7 +1599,7 @@ impl Debug for Statement<'_> {
 #[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)]
 pub struct Coverage {
     pub kind: CoverageKind,
-    pub code_region: CodeRegion,
+    pub code_region: Option<CodeRegion>,
 }
 
 ///////////////////////////////////////////////////////////////////////////
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 431225e2767..89fd803fe51 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -300,6 +300,7 @@ CloneTypeFoldableAndLiftImpls! {
     ::rustc_target::spec::abi::Abi,
     crate::mir::coverage::ExpressionOperandId,
     crate::mir::coverage::CounterValueReference,
+    crate::mir::coverage::InjectedExpressionId,
     crate::mir::coverage::InjectedExpressionIndex,
     crate::mir::coverage::MappedExpressionIndex,
     crate::mir::Local,
diff --git a/compiler/rustc_mir/src/transform/instrument_coverage.rs b/compiler/rustc_mir/src/transform/instrument_coverage.rs
index 6824c73ab60..cb6798f2ee7 100644
--- a/compiler/rustc_mir/src/transform/instrument_coverage.rs
+++ b/compiler/rustc_mir/src/transform/instrument_coverage.rs
@@ -1,9 +1,10 @@
 use crate::transform::MirPass;
 use crate::util::pretty;
-use crate::util::spanview::{self, SpanViewable};
+use crate::util::spanview::{self, source_range_no_file, SpanViewable};
 
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::graph::dominators::Dominators;
+use rustc_data_structures::graph::WithNumNodes;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::Lrc;
 use rustc_index::bit_set::BitSet;
@@ -16,7 +17,7 @@ use rustc_middle::mir::coverage::*;
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{
     AggregateKind, BasicBlock, BasicBlockData, Coverage, CoverageInfo, FakeReadCause, Location,
-    Rvalue, SourceInfo, Statement, StatementKind, Terminator, TerminatorKind,
+    Rvalue, Statement, StatementKind, Terminator, TerminatorKind,
 };
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::TyCtxt;
@@ -28,11 +29,6 @@ use std::cmp::Ordering;
 
 const ID_SEPARATOR: &str = ",";
 
-/// Inserts `StatementKind::Coverage` statements that either instrument the binary with injected
-/// counters, via intrinsic `llvm.instrprof.increment`, and/or inject metadata used during codegen
-/// to construct the coverage map.
-pub struct InstrumentCoverage;
-
 /// The `query` provider for `CoverageInfo`, requested by `codegen_coverage()` (to inject each
 /// counter) and `FunctionCoverage::new()` (to extract the coverage map metadata from the MIR).
 pub(crate) fn provide(providers: &mut Providers) {
@@ -54,23 +50,72 @@ pub(crate) fn provide(providers: &mut Providers) {
 /// are still included in the total `num_counters` or `num_expressions`.) Simply counting the
 /// calls may not work; but computing the number of counters or expressions by adding `1` to the
 /// highest ID (for a given instrumented function) is valid.
+///
+/// This visitor runs twice, first with `add_missing_operands` set to `false`, to find the maximum
+/// counter ID and maximum expression ID based on their enum variant `id` fields; then, as a
+/// safeguard, with `add_missing_operands` set to `true`, to find any other counter or expression
+/// IDs referenced by expression operands, if not already seen.
+///
+/// Ideally, every expression operand in the MIR will have a corresponding Counter or Expression,
+/// but since current or future MIR optimizations can theoretically optimize out segments of a
+/// MIR, it may not be possible to guarantee this, so the second pass ensures the `CoverageInfo`
+/// counts include all referenced IDs.
 struct CoverageVisitor {
     info: CoverageInfo,
+    add_missing_operands: bool,
+}
+
+impl CoverageVisitor {
+    // If an expression operand is encountered with an ID outside the range of known counters and
+    // expressions, the only way to determine if the ID is a counter ID or an expression ID is to
+    // assume a maximum possible counter ID value.
+    const MAX_COUNTER_GUARD: u32 = (u32::MAX / 2) + 1;
+
+    #[inline(always)]
+    fn update_num_counters(&mut self, counter_id: u32) {
+        self.info.num_counters = std::cmp::max(self.info.num_counters, counter_id + 1);
+    }
+
+    #[inline(always)]
+    fn update_num_expressions(&mut self, expression_id: u32) {
+        let expression_index = u32::MAX - expression_id;
+        self.info.num_expressions = std::cmp::max(self.info.num_expressions, expression_index + 1);
+    }
+
+    fn update_from_expression_operand(&mut self, operand_id: u32) {
+        if operand_id >= self.info.num_counters {
+            let operand_as_expression_index = u32::MAX - operand_id;
+            if operand_as_expression_index >= self.info.num_expressions {
+                if operand_id <= Self::MAX_COUNTER_GUARD {
+                    self.update_num_counters(operand_id)
+                } else {
+                    self.update_num_expressions(operand_id)
+                }
+            }
+        }
+    }
 }
 
 impl Visitor<'_> for CoverageVisitor {
     fn visit_coverage(&mut self, coverage: &Coverage, _location: Location) {
-        match coverage.kind {
-            CoverageKind::Counter { id, .. } => {
-                let counter_id = u32::from(id);
-                self.info.num_counters = std::cmp::max(self.info.num_counters, counter_id + 1);
+        if self.add_missing_operands {
+            match coverage.kind {
+                CoverageKind::Expression { lhs, rhs, .. } => {
+                    self.update_from_expression_operand(u32::from(lhs));
+                    self.update_from_expression_operand(u32::from(rhs));
+                }
+                _ => {}
             }
-            CoverageKind::Expression { id, .. } => {
-                let expression_index = u32::MAX - u32::from(id);
-                self.info.num_expressions =
-                    std::cmp::max(self.info.num_expressions, expression_index + 1);
+        } else {
+            match coverage.kind {
+                CoverageKind::Counter { id, .. } => {
+                    self.update_num_counters(u32::from(id));
+                }
+                CoverageKind::Expression { id, .. } => {
+                    self.update_num_expressions(u32::from(id));
+                }
+                _ => {}
             }
-            _ => {}
         }
     }
 }
@@ -78,45 +123,58 @@ impl Visitor<'_> for CoverageVisitor {
 fn coverageinfo_from_mir<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> CoverageInfo {
     let mir_body = tcx.optimized_mir(def_id);
 
-    let mut coverage_visitor =
-        CoverageVisitor { info: CoverageInfo { num_counters: 0, num_expressions: 0 } };
+    let mut coverage_visitor = CoverageVisitor {
+        info: CoverageInfo { num_counters: 0, num_expressions: 0 },
+        add_missing_operands: false,
+    };
 
     coverage_visitor.visit_body(mir_body);
+
+    coverage_visitor.add_missing_operands = true;
+    coverage_visitor.visit_body(mir_body);
+
     coverage_visitor.info
 }
+/// Inserts `StatementKind::Coverage` statements that either instrument the binary with injected
+/// counters, via intrinsic `llvm.instrprof.increment`, and/or inject metadata used during codegen
+/// to construct the coverage map.
+pub struct InstrumentCoverage;
 
 impl<'tcx> MirPass<'tcx> for InstrumentCoverage {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, mir_body: &mut mir::Body<'tcx>) {
+        let mir_source = mir_body.source;
+
         // If the InstrumentCoverage pass is called on promoted MIRs, skip them.
         // See: https://github.com/rust-lang/rust/pull/73011#discussion_r438317601
-        if mir_body.source.promoted.is_some() {
+        if mir_source.promoted.is_some() {
             trace!(
                 "InstrumentCoverage skipped for {:?} (already promoted for Miri evaluation)",
-                mir_body.source.def_id()
+                mir_source.def_id()
             );
             return;
         }
 
-        let hir_id = tcx.hir().local_def_id_to_hir_id(mir_body.source.def_id().expect_local());
+        let hir_id = tcx.hir().local_def_id_to_hir_id(mir_source.def_id().expect_local());
         let is_fn_like = FnLikeNode::from_node(tcx.hir().get(hir_id)).is_some();
 
         // Only instrument functions, methods, and closures (not constants since they are evaluated
         // at compile time by Miri).
-        // FIXME(#73156): Handle source code coverage in const eval
+        // FIXME(#73156): Handle source code coverage in const eval, but note, if and when const
+        // expressions get coverage spans, we will probably have to "carve out" space for const
+        // expressions from coverage spans in enclosing MIR's, like we do for closures. (That might
+        // be tricky if const expressions have no corresponding statements in the enclosing MIR.
+        // Closures are carved out by their initial `Assign` statement.)
         if !is_fn_like {
-            trace!(
-                "InstrumentCoverage skipped for {:?} (not an FnLikeNode)",
-                mir_body.source.def_id(),
-            );
+            trace!("InstrumentCoverage skipped for {:?} (not an FnLikeNode)", mir_source.def_id());
             return;
         }
         // FIXME(richkadel): By comparison, the MIR pass `ConstProp` includes associated constants,
         // with functions, methods, and closures. I assume Miri is used for associated constants as
         // well. If not, we may need to include them here too.
 
-        trace!("InstrumentCoverage starting for {:?}", mir_body.source.def_id());
+        trace!("InstrumentCoverage starting for {:?}", mir_source.def_id());
         Instrumentor::new(&self.name(), tcx, mir_body).inject_counters();
-        trace!("InstrumentCoverage starting for {:?}", mir_body.source.def_id());
+        trace!("InstrumentCoverage starting for {:?}", mir_source.def_id());
     }
 }
 
@@ -184,12 +242,16 @@ impl BasicCoverageBlocks {
     }
 
     pub fn iter(&self) -> impl Iterator<Item = &BasicCoverageBlock> {
-        self.vec.iter().filter_map(|option| option.as_ref())
+        self.vec.iter().filter_map(|bcb| bcb.as_ref())
+    }
+
+    pub fn num_nodes(&self) -> usize {
+        self.vec.len()
     }
 
-    fn extract_from_mir(&mut self, mir_body: &mir::Body<'tcx>) {
+    pub fn extract_from_mir(&mut self, mir_body: &mir::Body<'tcx>) {
         // Traverse the CFG but ignore anything following an `unwind`
-        let cfg_without_unwind = ShortCircuitPreorder::new(mir_body, |term_kind| {
+        let cfg_without_unwind = ShortCircuitPreorder::new(&mir_body, |term_kind| {
             let mut successors = term_kind.successors();
             match &term_kind {
                 // SwitchInt successors are never unwind, and all of them should be traversed.
@@ -337,20 +399,20 @@ impl CoverageStatement {
     pub fn format(&self, tcx: TyCtxt<'tcx>, mir_body: &'a mir::Body<'tcx>) -> String {
         match *self {
             Self::Statement(bb, span, stmt_index) => {
-                let stmt = &mir_body.basic_blocks()[bb].statements[stmt_index];
+                let stmt = &mir_body[bb].statements[stmt_index];
                 format!(
                     "{}: @{}[{}]: {:?}",
-                    spanview::source_range_no_file(tcx, &span),
+                    source_range_no_file(tcx, &span),
                     bb.index(),
                     stmt_index,
                     stmt
                 )
             }
             Self::Terminator(bb, span) => {
-                let term = mir_body.basic_blocks()[bb].terminator();
+                let term = mir_body[bb].terminator();
                 format!(
                     "{}: @{}.{}: {:?}",
-                    spanview::source_range_no_file(tcx, &span),
+                    source_range_no_file(tcx, &span),
                     bb.index(),
                     term_type(&term.kind),
                     term.kind
@@ -366,6 +428,8 @@ impl CoverageStatement {
     }
 }
 
+/// Returns a simple string representation of a `TerminatorKind` variant, indenpendent of any
+/// values it might hold.
 fn term_type(kind: &TerminatorKind<'tcx>) -> &'static str {
     match kind {
         TerminatorKind::Goto { .. } => "Goto",
@@ -398,10 +462,10 @@ fn term_type(kind: &TerminatorKind<'tcx>) -> &'static str {
 /// `is_dominated_by()` the `BasicBlock`s in this `CoverageSpan`.
 #[derive(Debug, Clone)]
 struct CoverageSpan {
-    span: Span,
-    bcb_leader_bb: BasicBlock,
-    coverage_statements: Vec<CoverageStatement>,
-    is_closure: bool,
+    pub span: Span,
+    pub bcb_leader_bb: BasicBlock,
+    pub coverage_statements: Vec<CoverageStatement>,
+    pub is_closure: bool,
 }
 
 impl CoverageSpan {
@@ -428,7 +492,7 @@ impl CoverageSpan {
         }
     }
 
-    pub fn for_terminator(span: Span, bcb: &'a BasicCoverageBlock, bb: BasicBlock) -> Self {
+    pub fn for_terminator(span: Span, bcb: &BasicCoverageBlock, bb: BasicBlock) -> Self {
         Self {
             span,
             bcb_leader_bb: bcb.leader_bb(),
@@ -455,132 +519,119 @@ impl CoverageSpan {
         }
     }
 
-    pub fn is_dominated_by(
-        &self,
-        other: &CoverageSpan,
-        dominators: &Dominators<BasicBlock>,
-    ) -> bool {
-        debug_assert!(!self.is_in_same_bcb(other));
-        dominators.is_dominated_by(self.bcb_leader_bb, other.bcb_leader_bb)
-    }
-
+    #[inline]
     pub fn is_mergeable(&self, other: &Self) -> bool {
         self.is_in_same_bcb(other) && !(self.is_closure || other.is_closure)
     }
 
+    #[inline]
     pub fn is_in_same_bcb(&self, other: &Self) -> bool {
         self.bcb_leader_bb == other.bcb_leader_bb
     }
+
+    pub fn format_coverage_statements(
+        &self,
+        tcx: TyCtxt<'tcx>,
+        mir_body: &'a mir::Body<'tcx>,
+    ) -> String {
+        let mut sorted_coverage_statements = self.coverage_statements.clone();
+        sorted_coverage_statements.sort_unstable_by_key(|covstmt| match *covstmt {
+            CoverageStatement::Statement(bb, _, index) => (bb, index),
+            CoverageStatement::Terminator(bb, _) => (bb, usize::MAX),
+        });
+        sorted_coverage_statements
+            .iter()
+            .map(|covstmt| covstmt.format(tcx, mir_body))
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
 }
 
 struct Instrumentor<'a, 'tcx> {
     pass_name: &'a str,
     tcx: TyCtxt<'tcx>,
     mir_body: &'a mut mir::Body<'tcx>,
-    hir_body: &'tcx rustc_hir::Body<'tcx>,
-    dominators: Option<Dominators<BasicBlock>>,
-    basic_coverage_blocks: Option<BasicCoverageBlocks>,
-    function_source_hash: Option<u64>,
-    next_counter_id: u32,
-    num_expressions: u32,
+    body_span: Span,
+    basic_coverage_blocks: BasicCoverageBlocks,
+    coverage_counters: CoverageCounters,
 }
 
 impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
     fn new(pass_name: &'a str, tcx: TyCtxt<'tcx>, mir_body: &'a mut mir::Body<'tcx>) -> Self {
         let hir_body = hir_body(tcx, mir_body.source.def_id());
+        let body_span = hir_body.value.span;
+        let function_source_hash = hash_mir_source(tcx, hir_body);
+        let basic_coverage_blocks = BasicCoverageBlocks::from_mir(mir_body);
         Self {
             pass_name,
             tcx,
             mir_body,
-            hir_body,
-            dominators: None,
-            basic_coverage_blocks: None,
-            function_source_hash: None,
-            next_counter_id: CounterValueReference::START.as_u32(),
-            num_expressions: 0,
+            body_span,
+            basic_coverage_blocks,
+            coverage_counters: CoverageCounters::new(function_source_hash),
         }
     }
 
-    /// Counter IDs start from one and go up.
-    fn next_counter(&mut self) -> CounterValueReference {
-        assert!(self.next_counter_id < u32::MAX - self.num_expressions);
-        let next = self.next_counter_id;
-        self.next_counter_id += 1;
-        CounterValueReference::from(next)
-    }
-
-    /// Expression IDs start from u32::MAX and go down because a CounterExpression can reference
-    /// (add or subtract counts) of both Counter regions and CounterExpression regions. The counter
-    /// expression operand IDs must be unique across both types.
-    fn next_expression(&mut self) -> InjectedExpressionIndex {
-        assert!(self.next_counter_id < u32::MAX - self.num_expressions);
-        let next = u32::MAX - self.num_expressions;
-        self.num_expressions += 1;
-        InjectedExpressionIndex::from(next)
-    }
+    fn inject_counters(&'a mut self) {
+        let tcx = self.tcx;
+        let source_map = tcx.sess.source_map();
+        let mir_source = self.mir_body.source;
+        let def_id = mir_source.def_id();
+        let body_span = self.body_span;
 
-    fn dominators(&self) -> &Dominators<BasicBlock> {
-        self.dominators.as_ref().expect("dominators must be initialized before calling")
-    }
+        debug!("instrumenting {:?}, span: {}", def_id, source_map.span_to_string(body_span));
 
-    fn basic_coverage_blocks(&self) -> &BasicCoverageBlocks {
-        self.basic_coverage_blocks
-            .as_ref()
-            .expect("basic_coverage_blocks must be initialized before calling")
-    }
+        ////////////////////////////////////////////////////
+        // Compute `CoverageSpan`s from the `BasicCoverageBlocks`.
+        let coverage_spans = CoverageSpans::generate_coverage_spans(
+            &self.mir_body,
+            body_span,
+            &self.basic_coverage_blocks,
+        );
 
-    fn function_source_hash(&mut self) -> u64 {
-        match self.function_source_hash {
-            Some(hash) => hash,
-            None => {
-                let hash = hash_mir_source(self.tcx, self.hir_body);
-                self.function_source_hash.replace(hash);
-                hash
-            }
+        if pretty::dump_enabled(tcx, self.pass_name, def_id) {
+            dump_coverage_spanview(
+                tcx,
+                self.mir_body,
+                &self.basic_coverage_blocks,
+                self.pass_name,
+                &coverage_spans,
+            );
         }
+
+        self.inject_coverage_span_counters(coverage_spans);
     }
 
-    fn inject_counters(&mut self) {
+    /// Inject a counter for each `CoverageSpan`. There can be multiple `CoverageSpan`s for a given
+    /// BCB, but only one actual counter needs to be incremented per BCB. `bcb_counters` maps each
+    /// `bcb` to its `Counter`, when injected. Subsequent `CoverageSpan`s for a BCB that already has
+    /// a `Counter` will inject an `Expression` instead, and compute its value by adding `ZERO` to
+    /// the BCB `Counter` value.
+    fn inject_coverage_span_counters(&mut self, coverage_spans: Vec<CoverageSpan>) {
         let tcx = self.tcx;
         let source_map = tcx.sess.source_map();
-        let def_id = self.mir_body.source.def_id();
-        let mir_body = &self.mir_body;
-        let body_span = self.body_span();
+        let body_span = self.body_span;
         let source_file = source_map.lookup_source_file(body_span.lo());
         let file_name = Symbol::intern(&source_file.name.to_string());
 
-        debug!("instrumenting {:?}, span: {}", def_id, source_map.span_to_string(body_span));
-
-        self.dominators.replace(mir_body.dominators());
-        self.basic_coverage_blocks.replace(BasicCoverageBlocks::from_mir(mir_body));
-
-        let coverage_spans = self.coverage_spans();
-
-        let span_viewables = if pretty::dump_enabled(tcx, self.pass_name, def_id) {
-            Some(self.span_viewables(&coverage_spans))
-        } else {
-            None
-        };
-
-        // Inject a counter for each `CoverageSpan`. There can be multiple `CoverageSpan`s for a
-        // given BCB, but only one actual counter needs to be incremented per BCB. `bb_counters`
-        // maps each `bcb_leader_bb` to its `Counter`, when injected. Subsequent `CoverageSpan`s
-        // for a BCB that already has a `Counter` will inject a `CounterExpression` instead, and
-        // compute its value by adding `ZERO` to the BCB `Counter` value.
-        let mut bb_counters = IndexVec::from_elem_n(None, mir_body.basic_blocks().len());
+        let mut bb_counters = IndexVec::from_elem_n(None, self.mir_body.basic_blocks().len());
         for CoverageSpan { span, bcb_leader_bb: bb, .. } in coverage_spans {
             if let Some(&counter_operand) = bb_counters[bb].as_ref() {
-                let expression =
-                    self.make_expression(counter_operand, Op::Add, ExpressionOperandId::ZERO);
+                let expression = self.coverage_counters.make_expression(
+                    counter_operand,
+                    Op::Add,
+                    ExpressionOperandId::ZERO,
+                );
                 debug!(
                     "Injecting counter expression {:?} at: {:?}:\n{}\n==========",
                     expression,
                     span,
                     source_map.span_to_snippet(span).expect("Error getting source for span"),
                 );
-                self.inject_statement(file_name, &source_file, expression, span, bb);
+                let code_region = make_code_region(file_name, &source_file, span, body_span);
+                inject_statement(self.mir_body, expression, bb, Some(code_region));
             } else {
-                let counter = self.make_counter();
+                let counter = self.coverage_counters.make_counter();
                 debug!(
                     "Injecting counter {:?} at: {:?}:\n{}\n==========",
                     counter,
@@ -589,126 +640,212 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
                 );
                 let counter_operand = counter.as_operand_id();
                 bb_counters[bb] = Some(counter_operand);
-                self.inject_statement(file_name, &source_file, counter, span, bb);
+                let code_region = make_code_region(file_name, &source_file, span, body_span);
+                inject_statement(self.mir_body, counter, bb, Some(code_region));
             }
         }
+    }
+}
 
-        if let Some(span_viewables) = span_viewables {
-            let mut file = pretty::create_dump_file(
-                tcx,
-                "html",
-                None,
-                self.pass_name,
-                &0,
-                self.mir_body.source,
-            )
-            .expect("Unexpected error creating MIR spanview HTML file");
-            let crate_name = tcx.crate_name(def_id.krate);
-            let item_name = tcx.def_path(def_id).to_filename_friendly_no_crate();
-            let title = format!("{}.{} - Coverage Spans", crate_name, item_name);
-            spanview::write_document(tcx, def_id, span_viewables, &title, &mut file)
-                .expect("Unexpected IO error dumping coverage spans as HTML");
+/// Generates the MIR pass `CoverageSpan`-specific spanview dump file.
+fn dump_coverage_spanview(
+    tcx: TyCtxt<'tcx>,
+    mir_body: &mir::Body<'tcx>,
+    basic_coverage_blocks: &BasicCoverageBlocks,
+    pass_name: &str,
+    coverage_spans: &Vec<CoverageSpan>,
+) {
+    let mir_source = mir_body.source;
+    let def_id = mir_source.def_id();
+
+    let span_viewables = span_viewables(tcx, mir_body, basic_coverage_blocks, &coverage_spans);
+    let mut file = pretty::create_dump_file(tcx, "html", None, pass_name, &0, mir_source)
+        .expect("Unexpected error creating MIR spanview HTML file");
+    let crate_name = tcx.crate_name(def_id.krate);
+    let item_name = tcx.def_path(def_id).to_filename_friendly_no_crate();
+    let title = format!("{}.{} - Coverage Spans", crate_name, item_name);
+    spanview::write_document(tcx, def_id, span_viewables, &title, &mut file)
+        .expect("Unexpected IO error dumping coverage spans as HTML");
+}
+
+/// Converts the computed `BasicCoverageBlock`s into `SpanViewable`s.
+fn span_viewables(
+    tcx: TyCtxt<'tcx>,
+    mir_body: &mir::Body<'tcx>,
+    basic_coverage_blocks: &BasicCoverageBlocks,
+    coverage_spans: &Vec<CoverageSpan>,
+) -> Vec<SpanViewable> {
+    let mut span_viewables = Vec::new();
+    for coverage_span in coverage_spans {
+        let tooltip = coverage_span.format_coverage_statements(tcx, mir_body);
+        let CoverageSpan { span, bcb_leader_bb: bb, .. } = coverage_span;
+        let bcb = &basic_coverage_blocks[*bb];
+        let id = bcb.id();
+        let leader_bb = bcb.leader_bb();
+        span_viewables.push(SpanViewable { bb: leader_bb, span: *span, id, tooltip });
+    }
+    span_viewables
+}
+
+/// Manages the counter and expression indexes/IDs to generate `CoverageKind` components for MIR
+/// `Coverage` statements.
+struct CoverageCounters {
+    function_source_hash: u64,
+    next_counter_id: u32,
+    num_expressions: u32,
+}
+
+impl CoverageCounters {
+    pub fn new(function_source_hash: u64) -> Self {
+        Self {
+            function_source_hash,
+            next_counter_id: CounterValueReference::START.as_u32(),
+            num_expressions: 0,
         }
     }
 
-    fn make_counter(&mut self) -> CoverageKind {
+    pub fn make_counter(&mut self) -> CoverageKind {
         CoverageKind::Counter {
-            function_source_hash: self.function_source_hash(),
+            function_source_hash: self.function_source_hash,
             id: self.next_counter(),
         }
     }
 
-    fn make_expression(
+    pub fn make_expression(
         &mut self,
         lhs: ExpressionOperandId,
         op: Op,
         rhs: ExpressionOperandId,
     ) -> CoverageKind {
-        CoverageKind::Expression { id: self.next_expression(), lhs, op, rhs }
+        let id = self.next_expression();
+        CoverageKind::Expression { id, lhs, op, rhs }
     }
 
-    fn inject_statement(
-        &mut self,
-        file_name: Symbol,
-        source_file: &Lrc<SourceFile>,
-        coverage_kind: CoverageKind,
-        span: Span,
-        block: BasicBlock,
-    ) {
-        let code_region = make_code_region(file_name, source_file, span);
-        debug!("  injecting statement {:?} covering {:?}", coverage_kind, code_region);
-
-        let data = &mut self.mir_body[block];
-        let source_info = data.terminator().source_info;
-        let statement = Statement {
-            source_info,
-            kind: StatementKind::Coverage(box Coverage { kind: coverage_kind, code_region }),
-        };
-        data.statements.push(statement);
+    /// Counter IDs start from one and go up.
+    fn next_counter(&mut self) -> CounterValueReference {
+        assert!(self.next_counter_id < u32::MAX - self.num_expressions);
+        let next = self.next_counter_id;
+        self.next_counter_id += 1;
+        CounterValueReference::from(next)
     }
 
-    /// Converts the computed `BasicCoverageBlock`s into `SpanViewable`s.
-    fn span_viewables(&self, coverage_spans: &Vec<CoverageSpan>) -> Vec<SpanViewable> {
-        let tcx = self.tcx;
-        let mir_body = &self.mir_body;
-        let mut span_viewables = Vec::new();
-        for coverage_span in coverage_spans {
-            let bcb = self.bcb_from_coverage_span(coverage_span);
-            let CoverageSpan { span, bcb_leader_bb: bb, coverage_statements, .. } = coverage_span;
-            let id = bcb.id();
-            let mut sorted_coverage_statements = coverage_statements.clone();
-            sorted_coverage_statements.sort_unstable_by_key(|covstmt| match *covstmt {
-                CoverageStatement::Statement(bb, _, index) => (bb, index),
-                CoverageStatement::Terminator(bb, _) => (bb, usize::MAX),
-            });
-            let tooltip = sorted_coverage_statements
-                .iter()
-                .map(|covstmt| covstmt.format(tcx, mir_body))
-                .collect::<Vec<_>>()
-                .join("\n");
-            span_viewables.push(SpanViewable { bb: *bb, span: *span, id, tooltip });
-        }
-        span_viewables
+    /// Expression IDs start from u32::MAX and go down because a Expression can reference
+    /// (add or subtract counts) of both Counter regions and Expression regions. The counter
+    /// expression operand IDs must be unique across both types.
+    fn next_expression(&mut self) -> InjectedExpressionId {
+        assert!(self.next_counter_id < u32::MAX - self.num_expressions);
+        let next = u32::MAX - self.num_expressions;
+        self.num_expressions += 1;
+        InjectedExpressionId::from(next)
     }
+}
+fn inject_statement(
+    mir_body: &mut mir::Body<'tcx>,
+    counter_kind: CoverageKind,
+    bb: BasicBlock,
+    some_code_region: Option<CodeRegion>,
+) {
+    debug!(
+        "  injecting statement {:?} for {:?} at code region: {:?}",
+        counter_kind, bb, some_code_region
+    );
+    let data = &mut mir_body[bb];
+    let source_info = data.terminator().source_info;
+    let statement = Statement {
+        source_info,
+        kind: StatementKind::Coverage(box Coverage {
+            kind: counter_kind,
+            code_region: some_code_region,
+        }),
+    };
+    data.statements.push(statement);
+}
 
-    #[inline(always)]
-    fn bcb_from_coverage_span(&self, coverage_span: &CoverageSpan) -> &BasicCoverageBlock {
-        &self.basic_coverage_blocks()[coverage_span.bcb_leader_bb]
-    }
+/// Converts the initial set of `CoverageSpan`s (one per MIR `Statement` or `Terminator`) into a
+/// minimal set of `CoverageSpan`s, using the BCB CFG to determine where it is safe and useful to:
+///
+///  * Remove duplicate source code coverage regions
+///  * Merge spans that represent continuous (both in source code and control flow), non-branching
+///    execution
+///  * Carve out (leave uncovered) any span that will be counted by another MIR (notably, closures)
+pub struct CoverageSpans<'a, 'tcx> {
+    /// The MIR, used to look up `BasicBlockData`.
+    mir_body: &'a mir::Body<'tcx>,
+
+    /// A snapshot of the MIR CFG dominators before injecting any coverage statements.
+    dominators: Dominators<BasicBlock>,
+
+    /// A `Span` covering the function body of the MIR (typically from left curly brace to right
+    /// curly brace).
+    body_span: Span,
+
+    /// The BasicCoverageBlock Control Flow Graph (BCB CFG).
+    basic_coverage_blocks: &'a BasicCoverageBlocks,
+
+    /// The initial set of `CoverageSpan`s, sorted by `Span` (`lo` and `hi`) and by relative
+    /// dominance between the `BasicCoverageBlock`s of equal `Span`s.
+    sorted_spans_iter: Option<std::vec::IntoIter<CoverageSpan>>,
+
+    /// The current `CoverageSpan` to compare to its `prev`, to possibly merge, discard, force the
+    /// discard of the `prev` (and or `pending_dups`), or keep both (with `prev` moved to
+    /// `pending_dups`). If `curr` is not discarded or merged, it becomes `prev` for the next
+    /// iteration.
+    some_curr: Option<CoverageSpan>,
 
-    #[inline(always)]
-    fn body_span(&self) -> Span {
-        self.hir_body.value.span
-    }
+    /// The original `span` for `curr`, in case the `curr` span is modified.
+    curr_original_span: Span,
 
-    // Generate a set of `CoverageSpan`s from the filtered set of `Statement`s and `Terminator`s of
-    // the `BasicBlock`(s) in the given `BasicCoverageBlock`. One `CoverageSpan` is generated for
-    // each `Statement` and `Terminator`. (Note that subsequent stages of coverage analysis will
-    // merge some `CoverageSpan`s, at which point a `CoverageSpan` may represent multiple
-    // `Statement`s and/or `Terminator`s.)
-    fn extract_spans(&self, bcb: &'a BasicCoverageBlock) -> Vec<CoverageSpan> {
-        let body_span = self.body_span();
-        let mir_basic_blocks = self.mir_body.basic_blocks();
-        bcb.blocks
-            .iter()
-            .map(|bbref| {
-                let bb = *bbref;
-                let data = &mir_basic_blocks[bb];
-                data.statements
-                    .iter()
-                    .enumerate()
-                    .filter_map(move |(index, statement)| {
-                        filtered_statement_span(statement, body_span).map(|span| {
-                            CoverageSpan::for_statement(statement, span, bcb, bb, index)
-                        })
-                    })
-                    .chain(
-                        filtered_terminator_span(data.terminator(), body_span)
-                            .map(|span| CoverageSpan::for_terminator(span, bcb, bb)),
-                    )
-            })
-            .flatten()
-            .collect()
+    /// The CoverageSpan from a prior iteration; typically assigned from that iteration's `curr`.
+    /// If that `curr` was discarded, `prev` retains its value from the previous iteration.
+    some_prev: Option<CoverageSpan>,
+
+    /// Assigned from `curr_original_span` from the previous iteration.
+    prev_original_span: Span,
+
+    /// One or more `CoverageSpan`s with the same `Span` but different `BasicCoverageBlock`s, and
+    /// no `BasicCoverageBlock` in this list dominates another `BasicCoverageBlock` in the list.
+    /// If a new `curr` span also fits this criteria (compared to an existing list of
+    /// `pending_dups`), that `curr` `CoverageSpan` moves to `prev` before possibly being added to
+    /// the `pending_dups` list, on the next iteration. As a result, if `prev` and `pending_dups`
+    /// have the same `Span`, the criteria for `pending_dups` holds for `prev` as well: a `prev`
+    /// with a matching `Span` does not dominate any `pending_dup` and no `pending_dup` dominates a
+    /// `prev` with a matching `Span`)
+    pending_dups: Vec<CoverageSpan>,
+
+    /// The final `CoverageSpan`s to add to the coverage map. A `Counter` or `Expression`
+    /// will also be injected into the MIR for each `CoverageSpan`.
+    refined_spans: Vec<CoverageSpan>,
+}
+
+impl<'a, 'tcx> CoverageSpans<'a, 'tcx> {
+    fn generate_coverage_spans(
+        mir_body: &'a mir::Body<'tcx>,
+        body_span: Span,
+        basic_coverage_blocks: &'a BasicCoverageBlocks,
+    ) -> Vec<CoverageSpan> {
+        let dominators = mir_body.dominators();
+        let mut coverage_spans = CoverageSpans {
+            mir_body,
+            dominators,
+            body_span,
+            basic_coverage_blocks,
+            sorted_spans_iter: None,
+            refined_spans: Vec::with_capacity(basic_coverage_blocks.num_nodes() * 2),
+            some_curr: None,
+            curr_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)),
+            some_prev: None,
+            prev_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)),
+            pending_dups: Vec::new(),
+        };
+
+        let sorted_spans = coverage_spans.mir_to_initial_sorted_coverage_spans();
+
+        coverage_spans.sorted_spans_iter = Some(sorted_spans.into_iter());
+        coverage_spans.some_prev = coverage_spans.sorted_spans_iter.as_mut().unwrap().next();
+        coverage_spans.prev_original_span =
+            coverage_spans.some_prev.as_ref().expect("at least one span").span;
+
+        coverage_spans.to_refined_spans()
     }
 
     /// Generate a minimal set of `CoverageSpan`s, each representing a contiguous code region to be
@@ -732,11 +869,10 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
     ///
     /// Note the resulting vector of `CoverageSpan`s does may not be fully sorted (and does not need
     /// to be).
-    fn coverage_spans(&self) -> Vec<CoverageSpan> {
-        let mut initial_spans =
-            Vec::<CoverageSpan>::with_capacity(self.mir_body.basic_blocks().len() * 2);
-        for bcb in self.basic_coverage_blocks().iter() {
-            for coverage_span in self.extract_spans(bcb) {
+    fn mir_to_initial_sorted_coverage_spans(&self) -> Vec<CoverageSpan> {
+        let mut initial_spans = Vec::<CoverageSpan>::with_capacity(self.mir_body.num_nodes() * 2);
+        for bcb in self.basic_coverage_blocks.iter() {
+            for coverage_span in self.bcb_to_initial_coverage_spans(bcb) {
                 initial_spans.push(coverage_span);
             }
         }
@@ -757,14 +893,14 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
                         // dominators always come after the dominated equal spans). When later
                         // comparing two spans in order, the first will either dominate the second,
                         // or they will have no dominator relationship.
-                        self.dominators().rank_partial_cmp(b.bcb_leader_bb, a.bcb_leader_bb)
+                        self.dominators.rank_partial_cmp(b.bcb_leader_bb, a.bcb_leader_bb)
                     }
                 } else {
                     // Sort hi() in reverse order so shorter spans are attempted after longer spans.
-                    // This guarantees that, if a `prev` span overlaps, and is not equal to, a `curr`
-                    // span, the prev span either extends further left of the curr span, or they
-                    // start at the same position and the prev span extends further right of the end
-                    // of the curr span.
+                    // This guarantees that, if a `prev` span overlaps, and is not equal to, a
+                    // `curr` span, the prev span either extends further left of the curr span, or
+                    // they start at the same position and the prev span extends further right of
+                    // the end of the curr span.
                     b.span.hi().partial_cmp(&a.span.hi())
                 }
             } else {
@@ -773,41 +909,7 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
             .unwrap()
         });
 
-        let refinery = CoverageSpanRefinery::from_sorted_spans(initial_spans, self.dominators());
-        refinery.to_refined_spans()
-    }
-}
-
-struct CoverageSpanRefinery<'a> {
-    sorted_spans_iter: std::vec::IntoIter<CoverageSpan>,
-    dominators: &'a Dominators<BasicBlock>,
-    some_curr: Option<CoverageSpan>,
-    curr_original_span: Span,
-    some_prev: Option<CoverageSpan>,
-    prev_original_span: Span,
-    pending_dups: Vec<CoverageSpan>,
-    refined_spans: Vec<CoverageSpan>,
-}
-
-impl<'a> CoverageSpanRefinery<'a> {
-    fn from_sorted_spans(
-        sorted_spans: Vec<CoverageSpan>,
-        dominators: &'a Dominators<BasicBlock>,
-    ) -> Self {
-        let refined_spans = Vec::with_capacity(sorted_spans.len());
-        let mut sorted_spans_iter = sorted_spans.into_iter();
-        let prev = sorted_spans_iter.next().expect("at least one span");
-        let prev_original_span = prev.span;
-        Self {
-            sorted_spans_iter,
-            dominators,
-            refined_spans,
-            some_curr: None,
-            curr_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)),
-            some_prev: Some(prev),
-            prev_original_span,
-            pending_dups: Vec::new(),
-        }
+        initial_spans
     }
 
     /// Iterate through the sorted `CoverageSpan`s, and return the refined list of merged and
@@ -826,7 +928,7 @@ impl<'a> CoverageSpanRefinery<'a> {
                     self.prev()
                 );
                 let prev = self.take_prev();
-                self.add_refined_span(prev);
+                self.refined_spans.push(prev);
             } else if self.prev().is_closure {
                 // drop any equal or overlapping span (`curr`) and keep `prev` to test again in the
                 // next iter
@@ -839,38 +941,72 @@ impl<'a> CoverageSpanRefinery<'a> {
             } else if self.curr().is_closure {
                 self.carve_out_span_for_closure();
             } else if self.prev_original_span == self.curr().span {
+                // Note that this compares the new span to `prev_original_span`, which may not
+                // be the full `prev.span` (if merged during the previous iteration).
                 self.hold_pending_dups_unless_dominated();
             } else {
                 self.cutoff_prev_at_overlapping_curr();
             }
         }
+
         debug!("    AT END, adding last prev={:?}", self.prev());
-        let pending_dups = self.pending_dups.split_off(0);
-        for dup in pending_dups.into_iter() {
+        let prev = self.take_prev();
+        let CoverageSpans {
+            mir_body, basic_coverage_blocks, pending_dups, mut refined_spans, ..
+        } = self;
+        for dup in pending_dups {
             debug!("    ...adding at least one pending dup={:?}", dup);
-            self.add_refined_span(dup);
+            refined_spans.push(dup);
         }
-        let prev = self.take_prev();
-        self.add_refined_span(prev);
-
-        // FIXME(richkadel): Replace some counters with expressions if they can be calculated based
-        // on branching. (For example, one branch of a SwitchInt can be computed from the counter
-        // for the CoverageSpan just prior to the SwitchInt minus the sum of the counters of all
-        // other branches).
-
-        self.to_refined_spans_without_closures()
-    }
+        refined_spans.push(prev);
+
+        // Remove `CoverageSpan`s with empty spans ONLY if the empty `CoverageSpan`s BCB also has at
+        // least one other non-empty `CoverageSpan`.
+        let mut has_coverage = BitSet::new_empty(basic_coverage_blocks.num_nodes());
+        for covspan in &refined_spans {
+            if !covspan.span.is_empty() {
+                has_coverage.insert(covspan.bcb_leader_bb);
+            }
+        }
+        refined_spans.retain(|covspan| {
+            !(covspan.span.is_empty()
+                && is_goto(&mir_body[covspan.bcb_leader_bb].terminator().kind)
+                && has_coverage.contains(covspan.bcb_leader_bb))
+        });
 
-    fn add_refined_span(&mut self, coverage_span: CoverageSpan) {
-        self.refined_spans.push(coverage_span);
+        // Remove `CoverageSpan`s derived from closures, originally added to ensure the coverage
+        // regions for the current function leave room for the closure's own coverage regions
+        // (injected separately, from the closure's own MIR).
+        refined_spans.retain(|covspan| !covspan.is_closure);
+        refined_spans
     }
 
-    /// Remove `CoverageSpan`s derived from closures, originally added to ensure the coverage
-    /// regions for the current function leave room for the closure's own coverage regions
-    /// (injected separately, from the closure's own MIR).
-    fn to_refined_spans_without_closures(mut self) -> Vec<CoverageSpan> {
-        self.refined_spans.retain(|covspan| !covspan.is_closure);
-        self.refined_spans
+    // Generate a set of `CoverageSpan`s from the filtered set of `Statement`s and `Terminator`s of
+    // the `BasicBlock`(s) in the given `BasicCoverageBlock`. One `CoverageSpan` is generated
+    // for each `Statement` and `Terminator`. (Note that subsequent stages of coverage analysis will
+    // merge some `CoverageSpan`s, at which point a `CoverageSpan` may represent multiple
+    // `Statement`s and/or `Terminator`s.)
+    fn bcb_to_initial_coverage_spans(&self, bcb: &BasicCoverageBlock) -> Vec<CoverageSpan> {
+        bcb.blocks
+            .iter()
+            .map(|bbref| {
+                let bb = *bbref;
+                let data = &self.mir_body[bb];
+                data.statements
+                    .iter()
+                    .enumerate()
+                    .filter_map(move |(index, statement)| {
+                        filtered_statement_span(statement, self.body_span).map(|span| {
+                            CoverageSpan::for_statement(statement, span, bcb, bb, index)
+                        })
+                    })
+                    .chain(
+                        filtered_terminator_span(data.terminator(), self.body_span)
+                            .map(|span| CoverageSpan::for_terminator(span, bcb, bb)),
+                    )
+            })
+            .flatten()
+            .collect()
     }
 
     fn curr(&self) -> &CoverageSpan {
@@ -904,9 +1040,10 @@ impl<'a> CoverageSpanRefinery<'a> {
     /// If there are `pending_dups` but `prev` is not a matching dup (`prev.span` doesn't match the
     /// `pending_dups` spans), then one of the following two things happened during the previous
     /// iteration:
-    ///   * the `span` of prev was modified (by `curr_mut().merge_from(prev)`); or
-    ///   * the `span` of prev advanced past the end of the span of pending_dups
-    ///     (`prev().span.hi() <= curr().span.lo()`)
+    ///   * the previous `curr` span (which is now `prev`) was not a duplicate of the pending_dups
+    ///     (in which case there should be at least two spans in `pending_dups`); or
+    ///   * the `span` of `prev` was modified by `curr_mut().merge_from(prev)` (in which case
+    ///     `pending_dups` could have as few as one span)
     /// In either case, no more spans will match the span of `pending_dups`, so
     /// add the `pending_dups` if they don't overlap `curr`, and clear the list.
     fn check_pending_dups(&mut self) {
@@ -920,7 +1057,7 @@ impl<'a> CoverageSpanRefinery<'a> {
                     let pending_dups = self.pending_dups.split_off(0);
                     for dup in pending_dups.into_iter() {
                         debug!("    ...adding at least one pending={:?}", dup);
-                        self.add_refined_span(dup);
+                        self.refined_spans.push(dup);
                     }
                 } else {
                     self.pending_dups.clear();
@@ -935,7 +1072,7 @@ impl<'a> CoverageSpanRefinery<'a> {
             self.some_prev = Some(curr);
             self.prev_original_span = self.curr_original_span;
         }
-        while let Some(curr) = self.sorted_spans_iter.next() {
+        while let Some(curr) = self.sorted_spans_iter.as_mut().unwrap().next() {
             debug!("FOR curr={:?}", curr);
             if self.prev_starts_after_next(&curr) {
                 debug!(
@@ -994,10 +1131,10 @@ impl<'a> CoverageSpanRefinery<'a> {
                 for mut dup in pending_dups.iter().cloned() {
                     dup.span = dup.span.with_hi(left_cutoff);
                     debug!("    ...and at least one pre_closure dup={:?}", dup);
-                    self.add_refined_span(dup);
+                    self.refined_spans.push(dup);
                 }
             }
-            self.add_refined_span(pre_closure);
+            self.refined_spans.push(pre_closure);
         }
         if has_post_closure_span {
             // Update prev.span to start after the closure (and discard curr)
@@ -1013,33 +1150,56 @@ impl<'a> CoverageSpanRefinery<'a> {
         }
     }
 
+    /// Called if `curr.span` equals `prev_original_span` (and potentially equal to all
+    /// `pending_dups` spans, if any); but keep in mind, `prev.span` may start at a `Span.lo()` that
+    /// is less than (further left of) `prev_original_span.lo()`.
+    ///
     /// When two `CoverageSpan`s have the same `Span`, dominated spans can be discarded; but if
     /// neither `CoverageSpan` dominates the other, both (or possibly more than two) are held,
     /// until their disposition is determined. In this latter case, the `prev` dup is moved into
     /// `pending_dups` so the new `curr` dup can be moved to `prev` for the next iteration.
     fn hold_pending_dups_unless_dominated(&mut self) {
-        // equal coverage spans are ordered by dominators before dominated (if any)
-        debug_assert!(!self.prev().is_dominated_by(self.curr(), self.dominators));
-
-        if self.curr().is_dominated_by(&self.prev(), self.dominators) {
-            // If one span dominates the other, assocate the span with the dominator only.
-            //
-            // For example:
-            //     match somenum {
-            //         x if x < 1 => { ... }
-            //     }...
-            // The span for the first `x` is referenced by both the pattern block (every
-            // time it is evaluated) and the arm code (only when matched). The counter
-            // will be applied only to the dominator block.
-            //
-            // The dominator's (`prev`) execution count may be higher than the dominated
-            // block's execution count, so drop `curr`.
+        // Equal coverage spans are ordered by dominators before dominated (if any), so it should be
+        // impossible for `curr` to dominate any previous `CoverageSpan`.
+        debug_assert!(!self.span_bcb_is_dominated_by(self.prev(), self.curr()));
+
+        let initial_pending_count = self.pending_dups.len();
+        if initial_pending_count > 0 {
+            let mut pending_dups = self.pending_dups.split_off(0);
+            pending_dups.retain(|dup| !self.span_bcb_is_dominated_by(self.curr(), dup));
+            self.pending_dups.append(&mut pending_dups);
+            if self.pending_dups.len() < initial_pending_count {
+                debug!(
+                    "  discarded {} of {} pending_dups that dominated curr",
+                    initial_pending_count - self.pending_dups.len(),
+                    initial_pending_count
+                );
+            }
+        }
+
+        if self.span_bcb_is_dominated_by(self.curr(), self.prev()) {
             debug!(
-                "  different bcbs but SAME spans, and prev dominates curr. Drop curr and \
-                keep prev for next iter. prev={:?}",
+                "  different bcbs but SAME spans, and prev dominates curr. Discard prev={:?}",
                 self.prev()
             );
-            self.discard_curr();
+            self.cutoff_prev_at_overlapping_curr();
+        // If one span dominates the other, assocate the span with the code from the dominated
+        // block only (`curr`), and discard the overlapping portion of the `prev` span. (Note
+        // that if `prev.span` is wider than `prev_original_span`, a `CoverageSpan` will still
+        // be created for `prev`s block, for the non-overlapping portion, left of `curr.span`.)
+        //
+        // For example:
+        //     match somenum {
+        //         x if x < 1 => { ... }
+        //     }...
+        //
+        // The span for the first `x` is referenced by both the pattern block (every time it is
+        // evaluated) and the arm code (only when matched). The counter will be applied only to
+        // the dominated block. This allows coverage to track and highlight things like the
+        // assignment of `x` above, if the branch is matched, making `x` available to the arm
+        // code; and to track and highlight the question mark `?` "try" operator at the end of
+        // a function call returning a `Result`, so the `?` is covered when the function returns
+        // an `Err`, and not counted as covered if the function always returns `Ok`.
         } else {
             // Save `prev` in `pending_dups`. (`curr` will become `prev` in the next iteration.)
             // If the `curr` CoverageSpan is later discarded, `pending_dups` can be discarded as
@@ -1064,7 +1224,7 @@ impl<'a> CoverageSpanRefinery<'a> {
     fn cutoff_prev_at_overlapping_curr(&mut self) {
         debug!(
             "  different bcbs, overlapping spans, so ignore/drop pending and only add prev \
-            if it has statements that end before curr={:?}",
+            if it has statements that end before curr; prev={:?}",
             self.prev()
         );
         if self.pending_dups.is_empty() {
@@ -1075,13 +1235,17 @@ impl<'a> CoverageSpanRefinery<'a> {
             } else {
                 debug!("  ... adding modified prev={:?}", self.prev());
                 let prev = self.take_prev();
-                self.add_refined_span(prev);
+                self.refined_spans.push(prev);
             }
         } else {
             // with `pending_dups`, `prev` cannot have any statements that don't overlap
             self.pending_dups.clear();
         }
     }
+
+    fn span_bcb_is_dominated_by(&self, covspan: &CoverageSpan, dom_covspan: &CoverageSpan) -> bool {
+        self.dominators.is_dominated_by(covspan.bcb_leader_bb, dom_covspan.bcb_leader_bb)
+    }
 }
 
 fn filtered_statement_span(statement: &'a Statement<'tcx>, body_span: Span) -> Option<Span> {
@@ -1126,7 +1290,7 @@ fn filtered_statement_span(statement: &'a Statement<'tcx>, body_span: Span) -> O
         | StatementKind::LlvmInlineAsm(_)
         | StatementKind::Retag(_, _)
         | StatementKind::AscribeUserType(_, _) => {
-            Some(source_info_span(&statement.source_info, body_span))
+            Some(function_source_span(statement.source_info.span, body_span))
         }
     }
 }
@@ -1138,15 +1302,43 @@ fn filtered_terminator_span(terminator: &'a Terminator<'tcx>, body_span: Span) -
         // an `if condition { block }` has a span that includes the executed block, if true,
         // but for coverage, the code region executed, up to *and* through the SwitchInt,
         // actually stops before the if's block.)
-        TerminatorKind::Unreachable // Unreachable blocks are not connected to the CFG
+        TerminatorKind::Unreachable // Unreachable blocks are not connected to the MIR CFG
         | TerminatorKind::Assert { .. }
         | TerminatorKind::Drop { .. }
         | TerminatorKind::DropAndReplace { .. }
         | TerminatorKind::SwitchInt { .. }
-        | TerminatorKind::Goto { .. }
         // For `FalseEdge`, only the `real` branch is taken, so it is similar to a `Goto`.
+        // FIXME(richkadel): Note that `Goto` was moved to it's own match arm, for the reasons
+        // described below. Add tests to confirm whether or not similar cases also apply to
+        // `FalseEdge`.
         | TerminatorKind::FalseEdge { .. } => None,
 
+        // FIXME(richkadel): Note that `Goto` was initially filtered out (by returning `None`, as
+        // with the `TerminatorKind`s above) because its `Span` was way to broad to be beneficial,
+        // and, at the time, `Goto` didn't seem to provide any additional contributions to the
+        // coverage analysis. Upon further review, `Goto` terminated blocks do appear to benefit
+        // the coverage analysis, and the BCB CFG. To overcome the issues with the `Spans`, the
+        // coverage algorithms--and the final coverage map generation--include some exceptional
+        // behaviors.
+        //
+        // `Goto`s are often the targets of `SwitchInt` branches, and certain important
+        // optimizations to replace some `Counter`s with `Expression`s require a separate
+        // `BasicCoverageBlock` for each branch, to support the `Counter`, when needed.
+        //
+        // Also, some test cases showed that `Goto` terminators, and to some degree their `Span`s,
+        // provided useful context for coverage, such as to count and show when `if` blocks
+        // _without_ `else` blocks execute the `false` case (counting when the body of the `if`
+        // was _not_ taken). In these cases, the `Goto` span is ultimately given a `CoverageSpan`
+        // of 1 character, at the end of it's original `Span`.
+        //
+        // However, in other cases, a visible `CoverageSpan` is not wanted, but the `Goto`
+        // block must still be counted (for example, to contribute its count to an `Expression`
+        // that reports the execution count for some other block). In these cases, the code region
+        // is set to `None`.
+        TerminatorKind::Goto { .. } => {
+            Some(function_source_span(terminator.source_info.span.shrink_to_hi(), body_span))
+        }
+
         // Retain spans from all other terminators
         TerminatorKind::Resume
         | TerminatorKind::Abort
@@ -1156,25 +1348,38 @@ fn filtered_terminator_span(terminator: &'a Terminator<'tcx>, body_span: Span) -
         | TerminatorKind::GeneratorDrop
         | TerminatorKind::FalseUnwind { .. }
         | TerminatorKind::InlineAsm { .. } => {
-            Some(source_info_span(&terminator.source_info, body_span))
+            Some(function_source_span(terminator.source_info.span, body_span))
         }
     }
 }
 
 #[inline(always)]
-fn source_info_span(source_info: &SourceInfo, body_span: Span) -> Span {
-    let span = original_sp(source_info.span, body_span).with_ctxt(SyntaxContext::root());
+fn function_source_span(span: Span, body_span: Span) -> Span {
+    let span = original_sp(span, body_span).with_ctxt(SyntaxContext::root());
     if body_span.contains(span) { span } else { body_span }
 }
 
+#[inline(always)]
+fn is_goto(term_kind: &TerminatorKind<'tcx>) -> bool {
+    match term_kind {
+        TerminatorKind::Goto { .. } => true,
+        _ => false,
+    }
+}
+
 /// Convert the Span into its file name, start line and column, and end line and column
-fn make_code_region(file_name: Symbol, source_file: &Lrc<SourceFile>, span: Span) -> CodeRegion {
+fn make_code_region(
+    file_name: Symbol,
+    source_file: &Lrc<SourceFile>,
+    span: Span,
+    body_span: Span,
+) -> CodeRegion {
     let (start_line, mut start_col) = source_file.lookup_file_pos(span.lo());
     let (end_line, end_col) = if span.hi() == span.lo() {
         let (end_line, mut end_col) = (start_line, start_col);
         // Extend an empty span by one character so the region will be counted.
         let CharPos(char_pos) = start_col;
-        if char_pos > 0 {
+        if span.hi() == body_span.hi() {
             start_col = CharPos(char_pos - 1);
         } else {
             end_col = CharPos(char_pos + 1);
diff --git a/compiler/rustc_mir/src/util/graphviz.rs b/compiler/rustc_mir/src/util/graphviz.rs
index e04f07774ed..625f1a3e684 100644
--- a/compiler/rustc_mir/src/util/graphviz.rs
+++ b/compiler/rustc_mir/src/util/graphviz.rs
@@ -62,6 +62,7 @@ where
     let dark_mode = tcx.sess.opts.debugging_opts.graphviz_dark_mode;
     if dark_mode {
         graph_attrs.push(r#"bgcolor="black""#);
+        graph_attrs.push(r#"fontcolor="white""#);
         content_attrs.push(r#"color="white""#);
         content_attrs.push(r#"fontcolor="white""#);
     }
@@ -112,7 +113,8 @@ where
 
     // Basic block number at the top.
     let (blk, bgcolor) = if data.is_cleanup {
-        (format!("{} (cleanup)", block.index()), "lightblue")
+        let color = if dark_mode { "royalblue" } else { "lightblue" };
+        (format!("{} (cleanup)", block.index()), color)
     } else {
         let color = if dark_mode { "dimgray" } else { "gray" };
         (format!("{}", block.index()), color)
diff --git a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
index 598727e677c..ddc65085e80 100644
--- a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
+++ b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
@@ -26,13 +26,15 @@
       }
   
       bb3: {
-+         Coverage::Counter(2) for /the/src/instrument_coverage.rs:13:13 - 16:2; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10
++         Coverage::Counter(2) for /the/src/instrument_coverage.rs:13:13 - 13:18; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10
++         Coverage::Expression(4294967295) = 2 + 0 for /the/src/instrument_coverage.rs:16:1 - 16:2; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10
           falseEdge -> [real: bb5, imaginary: bb4]; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10
       }
   
       bb4: {
           _1 = const ();                   // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10
           StorageDead(_2);                 // scope 0 at /the/src/instrument_coverage.rs:15:5: 15:6
++         Coverage::Counter(3) for /the/src/instrument_coverage.rs:15:6 - 15:7; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6
           goto -> bb0;                     // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6
       }
   
diff --git a/src/test/mir-opt/instrument_coverage.rs b/src/test/mir-opt/instrument_coverage.rs
index d9c8e8d43a4..18863edac97 100644
--- a/src/test/mir-opt/instrument_coverage.rs
+++ b/src/test/mir-opt/instrument_coverage.rs
@@ -1,10 +1,10 @@
-// Test that the initial version of Rust coverage injects Coverage statements at the top of each
-// function. The Coverage Counter statements are later converted into LLVM instrprof.increment
-// intrinsics, during codegen.
+// Test that `-Z instrument-coverage` injects Coverage statements. The Coverage Counter statements
+// are later converted into LLVM instrprof.increment intrinsics, during codegen.
 
 // needs-profiler-support
 // ignore-windows
-// compile-flags: -Zinstrument-coverage --remap-path-prefix={{src-base}}=/the/src
+// compile-flags: -Z instrument-coverage --remap-path-prefix={{src-base}}=/the/src
+
 // EMIT_MIR instrument_coverage.main.InstrumentCoverage.diff
 // EMIT_MIR instrument_coverage.bar.InstrumentCoverage.diff
 fn main() {
diff --git a/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt b/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt
index 0a3c4aedd55..bd2a2475d9e 100644
--- a/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt
+++ b/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt
@@ -34,7 +34,7 @@ CHECK-SAME:   section "llvm.metadata"
 
 CHECK:        [[DEFINE_INTERNAL]] { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} {
 CHECK-NEXT:   start:
-CHECK-NOT:    bb{{[0-9]+}}:
+CHECK-NOT:    [[DEFINE_INTERNAL]]
 CHECK:        %pgocount = load i64, i64* getelementptr inbounds
 CHECK-SAME:   * @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called,
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/Makefile b/src/test/run-make-fulldeps/coverage-reports-base/Makefile
index 880d7fdb1b0..bfecc5fd7f5 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/Makefile
+++ b/src/test/run-make-fulldeps/coverage-reports-base/Makefile
@@ -21,6 +21,7 @@ clear_expected_if_blessed:
 ifdef RUSTC_BLESS_TEST
 	rm -f expected_export_coverage.*.json
 	rm -f expected_show_coverage.*.txt
+	rm -f expected_show_coverage_counters.*.txt
 endif
 
 -include clear_expected_if_blessed
@@ -54,14 +55,19 @@ endif
 	# when comparing the JSON `export`, the `show` output may be useful when
 	# debugging.
 	"$(LLVM_BIN_DIR)"/llvm-cov show \
+			--debug \
 			--Xdemangler="$(RUST_DEMANGLER)" \
 			--show-line-counts-or-regions \
 			--instr-profile="$(TMPDIR)"/$@.profdata \
 			$(call BIN,"$(TMPDIR)"/$@) \
-		> "$(TMPDIR)"/actual_show_coverage.$@.txt
+		> "$(TMPDIR)"/actual_show_coverage.$@.txt \
+		2> "$(TMPDIR)"/actual_show_coverage_counters.$@.txt
 
 ifdef RUSTC_BLESS_TEST
-	cp "$(TMPDIR)"/actual_show_coverage.$@.txt expected_show_coverage.$@.txt
+	cp "$(TMPDIR)"/actual_show_coverage.$@.txt \
+			expected_show_coverage.$@.txt
+	cp "$(TMPDIR)"/actual_show_coverage_counters.$@.txt \
+			expected_show_coverage_counters.$@.txt
 else
 	# Compare the show coverage output (`--bless` refreshes `typical` files)
 	# Note `llvm-cov show` output for some programs can vary, but can be ignored
@@ -75,6 +81,14 @@ else
 			false \
 		)
 
+	$(DIFF) expected_show_coverage_counters.$@.txt "$(TMPDIR)"/actual_show_coverage_counters.$@.txt || \
+		( grep -q '^\/\/ ignore-llvm-cov-show-diffs' $(SOURCEDIR)/$@.rs && \
+			>&2 echo 'diff failed, but suppressed with `// ignore-llvm-cov-show-diffs` in $(SOURCEDIR)/$@.rs' \
+		) || \
+		( >&2 echo 'diff failed, and not suppressed without `// ignore-llvm-cov-show-diffs` in $(SOURCEDIR)/$@.rs'; \
+			false \
+		)
+
 endif
 
 	# Generate a coverage report in JSON, using `llvm-cov export`, and fail if
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json
index 8c6edae2803..bff55300b3c 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json
@@ -17,14 +17,14 @@
             },
             "lines": {
               "count": 91,
-              "covered": 75,
-              "percent": 82.41758241758241
+              "covered": 77,
+              "percent": 84.61538461538461
             },
             "regions": {
-              "count": 21,
-              "covered": 11,
-              "notcovered": 10,
-              "percent": 52.38095238095239
+              "count": 25,
+              "covered": 13,
+              "notcovered": 12,
+              "percent": 52
             }
           }
         }
@@ -42,14 +42,14 @@
         },
         "lines": {
           "count": 91,
-          "covered": 75,
-          "percent": 82.41758241758241
+          "covered": 77,
+          "percent": 84.61538461538461
         },
         "regions": {
-          "count": 21,
-          "covered": 11,
-          "notcovered": 10,
-          "percent": 52.38095238095239
+          "count": 25,
+          "covered": 13,
+          "notcovered": 12,
+          "percent": 52
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json
index bd2e2d56d4a..7a7e4c04f00 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json
@@ -21,8 +21,8 @@
               "percent": 100
             },
             "regions": {
-              "count": 5,
-              "covered": 5,
+              "count": 6,
+              "covered": 6,
               "notcovered": 0,
               "percent": 100
             }
@@ -46,8 +46,8 @@
           "percent": 100
         },
         "regions": {
-          "count": 5,
-          "covered": 5,
+          "count": 6,
+          "covered": 6,
           "notcovered": 0,
           "percent": 100
         }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json
index a50f4657e20..1025cd3de80 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json
@@ -21,8 +21,8 @@
               "percent": 100
             },
             "regions": {
-              "count": 6,
-              "covered": 6,
+              "count": 7,
+              "covered": 7,
               "notcovered": 0,
               "percent": 100
             }
@@ -46,8 +46,8 @@
           "percent": 100
         },
         "regions": {
-          "count": 6,
-          "covered": 6,
+          "count": 7,
+          "covered": 7,
           "notcovered": 0,
           "percent": 100
         }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json
index 2ff53ad33fa..84dcc251f3f 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json
@@ -21,10 +21,10 @@
               "percent": 100
             },
             "regions": {
-              "count": 4,
+              "count": 5,
               "covered": 4,
-              "notcovered": 0,
-              "percent": 100
+              "notcovered": 1,
+              "percent": 80
             }
           }
         }
@@ -46,10 +46,10 @@
           "percent": 100
         },
         "regions": {
-          "count": 4,
+          "count": 5,
           "covered": 4,
-          "notcovered": 0,
-          "percent": 100
+          "notcovered": 1,
+          "percent": 80
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json
index 36f81ceae19..2d2ad1dbe3f 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 28,
-              "covered": 19,
-              "percent": 67.85714285714286
+              "count": 29,
+              "covered": 21,
+              "percent": 72.41379310344827
             },
             "regions": {
-              "count": 7,
-              "covered": 5,
+              "count": 9,
+              "covered": 7,
               "notcovered": 2,
-              "percent": 71.42857142857143
+              "percent": 77.77777777777779
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 28,
-          "covered": 19,
-          "percent": 67.85714285714286
+          "count": 29,
+          "covered": 21,
+          "percent": 72.41379310344827
         },
         "regions": {
-          "count": 7,
-          "covered": 5,
+          "count": 9,
+          "covered": 7,
           "notcovered": 2,
-          "percent": 71.42857142857143
+          "percent": 77.77777777777779
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json
index a24e6a33a33..c178e7f9347 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json
@@ -21,10 +21,10 @@
               "percent": 100
             },
             "regions": {
-              "count": 13,
+              "count": 15,
               "covered": 13,
-              "notcovered": 0,
-              "percent": 100
+              "notcovered": 2,
+              "percent": 86.66666666666667
             }
           }
         }
@@ -46,10 +46,10 @@
           "percent": 100
         },
         "regions": {
-          "count": 13,
+          "count": 15,
           "covered": 13,
-          "notcovered": 0,
-          "percent": 100
+          "notcovered": 2,
+          "percent": 86.66666666666667
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json
index 585346dc32a..95a1dcd3b8e 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 21,
-              "covered": 19,
-              "percent": 90.47619047619048
+              "count": 40,
+              "covered": 32,
+              "percent": 80
             },
             "regions": {
-              "count": 16,
-              "covered": 14,
-              "notcovered": 2,
-              "percent": 87.5
+              "count": 39,
+              "covered": 28,
+              "notcovered": 11,
+              "percent": 71.7948717948718
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 21,
-          "covered": 19,
-          "percent": 90.47619047619048
+          "count": 40,
+          "covered": 32,
+          "percent": 80
         },
         "regions": {
-          "count": 16,
-          "covered": 14,
-          "notcovered": 2,
-          "percent": 87.5
+          "count": 39,
+          "covered": 28,
+          "notcovered": 11,
+          "percent": 71.7948717948718
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loops_and_branches.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loops_and_branches.json
new file mode 100644
index 00000000000..aec85cd0329
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loops_and_branches.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/loops_and_branches.rs",
+          "summary": {
+            "functions": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "lines": {
+              "count": 11,
+              "covered": 11,
+              "percent": 100
+            },
+            "regions": {
+              "count": 10,
+              "covered": 8,
+              "notcovered": 2,
+              "percent": 80
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "lines": {
+          "count": 11,
+          "covered": 11,
+          "percent": 100
+        },
+        "regions": {
+          "count": 10,
+          "covered": 8,
+          "notcovered": 2,
+          "percent": 80
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.nested_loops.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.nested_loops.json
new file mode 100644
index 00000000000..dbe4f9ca6fd
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.nested_loops.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/nested_loops.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 21,
+              "covered": 17,
+              "percent": 80.95238095238095
+            },
+            "regions": {
+              "count": 20,
+              "covered": 16,
+              "notcovered": 4,
+              "percent": 80
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 21,
+          "covered": 17,
+          "percent": 80.95238095238095
+        },
+        "regions": {
+          "count": 20,
+          "covered": 16,
+          "notcovered": 4,
+          "percent": 80
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.partial_eq_counter_without_region.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.partial_eq_counter_without_region.json
new file mode 100644
index 00000000000..8081fba9e22
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.partial_eq_counter_without_region.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/partial_eq_counter_without_region.rs",
+          "summary": {
+            "functions": {
+              "count": 5,
+              "covered": 5,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 5,
+              "covered": 5,
+              "percent": 100
+            },
+            "lines": {
+              "count": 15,
+              "covered": 15,
+              "percent": 100
+            },
+            "regions": {
+              "count": 6,
+              "covered": 6,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 5,
+          "covered": 5,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 5,
+          "covered": 5,
+          "percent": 100
+        },
+        "lines": {
+          "count": 15,
+          "covered": 15,
+          "percent": 100
+        },
+        "regions": {
+          "count": 6,
+          "covered": 6,
+          "notcovered": 0,
+          "percent": 100
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json
index 38bc96898ea..ada6bb062dd 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 18,
-              "covered": 18,
+              "count": 19,
+              "covered": 19,
               "percent": 100
             },
             "regions": {
-              "count": 7,
-              "covered": 7,
-              "notcovered": 0,
-              "percent": 100
+              "count": 9,
+              "covered": 8,
+              "notcovered": 1,
+              "percent": 88.88888888888889
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 18,
-          "covered": 18,
+          "count": 19,
+          "covered": 19,
           "percent": 100
         },
         "regions": {
-          "count": 7,
-          "covered": 7,
-          "notcovered": 0,
-          "percent": 100
+          "count": 9,
+          "covered": 8,
+          "notcovered": 1,
+          "percent": 88.88888888888889
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json
index f9d91d66f1d..63d1ae74c5f 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 26,
-              "covered": 26,
+              "count": 24,
+              "covered": 24,
               "percent": 100
             },
             "regions": {
-              "count": 9,
-              "covered": 9,
-              "notcovered": 0,
-              "percent": 100
+              "count": 15,
+              "covered": 14,
+              "notcovered": 1,
+              "percent": 93.33333333333333
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 26,
-          "covered": 26,
+          "count": 24,
+          "covered": 24,
           "percent": 100
         },
         "regions": {
-          "count": 9,
-          "covered": 9,
-          "notcovered": 0,
-          "percent": 100
+          "count": 15,
+          "covered": 14,
+          "notcovered": 1,
+          "percent": 93.33333333333333
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.tight_infinite_loop.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.tight_infinite_loop.json
new file mode 100644
index 00000000000..3fa6821cd1d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.tight_infinite_loop.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/tight_infinite_loop.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "regions": {
+              "count": 2,
+              "covered": 2,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "regions": {
+          "count": 2,
+          "covered": 2,
+          "notcovered": 0,
+          "percent": 100
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json
index e6ef2c1ab89..e845ee29fa4 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 16,
-              "covered": 15,
-              "percent": 93.75
+              "count": 20,
+              "covered": 19,
+              "percent": 95
             },
             "regions": {
-              "count": 13,
-              "covered": 12,
-              "notcovered": 1,
-              "percent": 92.3076923076923
+              "count": 20,
+              "covered": 17,
+              "notcovered": 3,
+              "percent": 85
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 16,
-          "covered": 15,
-          "percent": 93.75
+          "count": 20,
+          "covered": 19,
+          "percent": 95
         },
         "regions": {
-          "count": 13,
-          "covered": 12,
-          "notcovered": 1,
-          "percent": 92.3076923076923
+          "count": 20,
+          "covered": 17,
+          "notcovered": 3,
+          "percent": 85
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json
index 410821ea335..464bb614ea1 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json
@@ -21,10 +21,10 @@
               "percent": 46.93877551020408
             },
             "regions": {
-              "count": 51,
+              "count": 70,
               "covered": 19,
-              "notcovered": 32,
-              "percent": 37.254901960784316
+              "notcovered": 51,
+              "percent": 27.142857142857142
             }
           }
         }
@@ -46,10 +46,10 @@
           "percent": 46.93877551020408
         },
         "regions": {
-          "count": 51,
+          "count": 70,
           "covered": 19,
-          "notcovered": 32,
-          "percent": 37.254901960784316
+          "notcovered": 51,
+          "percent": 27.142857142857142
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while.json
new file mode 100644
index 00000000000..27862087ed5
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/while.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 4,
+              "covered": 3,
+              "percent": 75
+            },
+            "regions": {
+              "count": 5,
+              "covered": 3,
+              "notcovered": 2,
+              "percent": 60
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 4,
+          "covered": 3,
+          "percent": 75
+        },
+        "regions": {
+          "count": 5,
+          "covered": 3,
+          "notcovered": 2,
+          "percent": 60
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json
index 865b705fa20..555ac745d53 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json
@@ -17,14 +17,14 @@
             },
             "lines": {
               "count": 18,
-              "covered": 16,
-              "percent": 88.88888888888889
+              "covered": 15,
+              "percent": 83.33333333333334
             },
             "regions": {
-              "count": 9,
-              "covered": 7,
-              "notcovered": 2,
-              "percent": 77.77777777777779
+              "count": 11,
+              "covered": 8,
+              "notcovered": 3,
+              "percent": 72.72727272727273
             }
           }
         }
@@ -42,14 +42,14 @@
         },
         "lines": {
           "count": 18,
-          "covered": 16,
-          "percent": 88.88888888888889
+          "covered": 15,
+          "percent": 83.33333333333334
         },
         "regions": {
-          "count": 9,
-          "covered": 7,
-          "notcovered": 2,
-          "percent": 77.77777777777779
+          "count": 11,
+          "covered": 8,
+          "notcovered": 3,
+          "percent": 72.72727272727273
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt
index 17054490e9b..aef26a62e25 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt
@@ -62,7 +62,7 @@
    62|      1|                let mut countdown = 0;
    63|      1|                if is_false {
    64|      0|                    countdown = 10;
-   65|      0|                }
+   65|      1|                }
    66|      1|                "alt string 3".to_owned()
    67|      1|            }
    68|      1|        )
@@ -77,7 +77,7 @@
    77|      1|        let mut countdown = 0;
    78|      1|        if is_false {
    79|      0|            countdown = 10;
-   80|      0|        }
+   80|      1|        }
    81|      1|        "alt string 4".to_owned()
    82|      1|    };
    83|      1|    println!(
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt
index 72aa020ca16..43592df1059 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt
@@ -24,7 +24,7 @@
    24|       |    let _ = Firework { strength: 1000 };
    25|       |
    26|       |    Ok(())
-   27|      1|}
+   27|      2|}
    28|       |
    29|       |// Expected program output:
    30|       |//   Exiting with error...
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt
index 86199d74763..11dc0aa65e2 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt
@@ -57,7 +57,7 @@
    35|       |    let _ = Firework { strength: 1000 };
    36|       |
    37|       |    Ok(())
-   38|      1|}
+   38|      2|}
    39|       |
    40|       |// Expected program output:
    41|       |//   Exiting with error...
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt
index bc2f9b108b2..85e6440ab37 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt
@@ -25,5 +25,6 @@
    25|      1|            10
    26|      1|        ;
    27|      1|    }
+                   ^0
    28|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt
index 5f899723e25..64cbc262521 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt
@@ -20,7 +20,7 @@
    20|      0|        countdown
    21|      0|        =
    22|      0|            100
-   23|       |    }
+   23|      1|    }
    24|       |
    25|       |    if
    26|      1|        is_true
@@ -36,6 +36,6 @@
    36|      0|        =
    37|      0|            100
    38|      0|        ;
-   39|      0|    }
+   39|      1|    }
    40|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt
index b13ca83d018..4a51f842a4b 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt
@@ -10,6 +10,7 @@
    10|      1|    if is_true {
    11|      1|        countdown = 10;
    12|      1|    }
+                   ^0
    13|       |
    14|       |    mod in_mod {
    15|       |        const IN_MOD_CONST: u32 = 1000;
@@ -48,6 +49,7 @@
    48|      1|    if is_true {
    49|      1|        in_func(countdown);
    50|      1|    }
+                   ^0
    51|       |
    52|      1|    let mut val = InStruct {
    53|      1|        in_struct_field: 101,
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt
index ded43697515..f01f69f2496 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt
@@ -12,12 +12,14 @@
    12|      1|        b = 10;
    13|      1|        c = 100;
    14|      1|    }
+                   ^0
    15|       |    let
    16|      1|        somebool
    17|       |        =
    18|      1|            a < b
    19|       |        ||
-   20|      0|            b < c
+   20|      1|            b < c
+                          ^0
    21|       |    ;
    22|       |    let
    23|      1|        somebool
@@ -26,19 +28,38 @@
    26|       |        ||
    27|      1|            b < c
    28|       |    ;
-   29|       |    let
-   30|      1|        somebool
-   31|       |        =
-   32|      1|            a < b
-   33|       |        &&
-   34|      1|            b < c
-   35|       |    ;
-   36|       |    let
-   37|      1|        somebool
-   38|       |        =
-   39|      1|            b < a
-   40|       |        &&
-   41|      0|            b < c
-   42|       |    ;
-   43|      1|}
+   29|      1|    let somebool = a < b && b < c;
+   30|      1|    let somebool = b < a && b < c;
+                                          ^0
+   31|       |
+   32|       |    if
+   33|      1|        !
+   34|      1|        is_true
+   35|      0|    {
+   36|      0|        a = 2
+   37|      0|        ;
+   38|      1|    }
+   39|       |
+   40|       |    if
+   41|      1|        is_true
+   42|      1|    {
+   43|      1|        b = 30
+   44|      1|        ;
+   45|      1|    }
+   46|       |    else
+   47|      0|    {
+   48|      0|        c = 400
+   49|      0|        ;
+   50|      1|    }
+   51|       |
+   52|      1|    if !is_true {
+   53|      0|        a = 2;
+   54|      1|    }
+   55|       |
+   56|      1|    if is_true {
+   57|      1|        b = 30;
+   58|      1|    } else {
+   59|      0|        c = 400;
+   60|      1|    }
+   61|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loops_and_branches.txt
new file mode 100644
index 00000000000..3a969a6b898
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loops_and_branches.txt
@@ -0,0 +1,38 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
+    4|       |// structure of this `fmt` function.
+    5|       |
+    6|       |struct DebugTest;
+    7|       |
+    8|       |impl std::fmt::Debug for DebugTest {
+    9|       |    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+   10|      1|        if true {
+   11|      1|            if false {
+   12|       |                while true {
+   13|       |                }
+   14|      1|            }
+   15|      1|            write!(f, "error")?;
+                                            ^0
+   16|       |        } else {
+   17|      1|        }
+   18|      1|        Ok(())
+   19|      1|    }
+   20|       |}
+   21|       |
+   22|      1|fn main() {
+   23|      1|    let debug_test = DebugTest;
+   24|      1|    println!("{:?}", debug_test);
+   25|      1|}
+   26|       |
+   27|       |/*
+   28|       |
+   29|       |This is the error message generated, before the issue was fixed:
+   30|       |
+   31|       |error: internal compiler error: compiler/rustc_mir/src/transform/coverage/mod.rs:374:42:
+   32|       |Error processing: DefId(0:6 ~ bug_incomplete_cov_graph_traversal_simplified[317d]::{impl#0}::fmt):
+   33|       |Error { message: "`TraverseCoverageGraphWithLoops` missed some `BasicCoverageBlock`s:
+   34|       |[bcb6, bcb7, bcb9]" }
+   35|       |
+   36|       |*/
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.nested_loops.txt
new file mode 100644
index 00000000000..e0545c76f78
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.nested_loops.txt
@@ -0,0 +1,26 @@
+    1|       |fn main() {
+    2|      1|    let is_true = std::env::args().len() == 1;
+    3|      1|    let mut countdown = 10;
+    4|       |
+    5|      1|    'outer: while countdown > 0 {
+    6|      1|        let mut a = 100;
+    7|      1|        let mut b = 100;
+    8|      3|        for _ in 0..50 {
+    9|      3|            if a < 30 {
+   10|      0|                break;
+   11|       |            }
+   12|      3|            a -= 5;
+   13|      3|            b -= 5;
+   14|      3|            if b < 90 {
+   15|      1|                a -= 10;
+   16|      1|                if is_true {
+   17|      1|                    break 'outer;
+   18|       |                } else {
+   19|      0|                    a -= 2;
+   20|      0|                }
+   21|      2|            }
+   22|      3|        }
+   23|      0|        countdown -= 1;
+   24|      1|    }
+   25|      1|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.partial_eq_counter_without_region.txt
new file mode 100644
index 00000000000..310bf13a695
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.partial_eq_counter_without_region.txt
@@ -0,0 +1,101 @@
+    1|       |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
+    2|       |// structure of this test.
+    3|       |
+    4|      2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+                                                    ^1       ^1
+    5|       |pub struct Version {
+    6|       |    major: usize,
+    7|      1|    minor: usize,
+    8|       |    patch: usize,
+    9|       |}
+   10|       |
+   11|       |impl Version {
+   12|       |    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
+   13|      2|        Self {
+   14|      2|            major,
+   15|      2|            minor,
+   16|      2|            patch,
+   17|      2|        }
+   18|      2|    }
+   19|       |}
+   20|       |
+   21|      1|fn main() {
+   22|      1|    let version_3_2_1 = Version::new(3, 2, 1);
+   23|      1|    let version_3_3_0 = Version::new(3, 3, 0);
+   24|      1|
+   25|      1|    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0);
+   26|      1|}
+   27|       |
+   28|       |/*
+   29|       |
+   30|       |This test verifies a bug was fixed that otherwise generated this error:
+   31|       |
+   32|       |thread 'rustc' panicked at 'No counters provided the source_hash for function:
+   33|       |    Instance {
+   34|       |        def: Item(WithOptConstParam {
+   35|       |            did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp),
+   36|       |            const_param_did: None
+   37|       |        }),
+   38|       |        substs: []
+   39|       |    }'
+   40|       |The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage
+   41|       |without a code region associated with any `Counter`. Code regions were associated with at least
+   42|       |one expression, which is allowed, but the `function_source_hash` was only passed to the codegen
+   43|       |(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the
+   44|       |`function_source_hash` without a code region, if necessary.
+   45|       |
+   46|       |*/
+   47|       |
+   48|       |// FIXME(richkadel): It may be worth investigating why the coverage report for this test produces
+   49|       |// the following results:
+   50|       |
+   51|       |/*
+   52|       |
+   53|       |1. Why are their two counts below different characters (first and last) of `PartialOrd`, on line 17?
+   54|       |
+   55|       |2. Line 17 is counted twice, but the `::lt` instance shows a line count of 1? Is there a missing
+   56|       |   line count with a different instance? Or was it really only called once?
+   57|       |
+   58|       |3. Line 20 shows another line count (of 1) for a line within a `struct` declaration (on only one of
+   59|       |   its 3 fields). I doubt the specific field (`minor`) is relevant, but rather I suspect there's a
+   60|       |   problem computing the file position here, for some reason.
+   61|       |
+   62|       |<snip>
+   63|       |   16|       |
+   64|       |   17|      2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+   65|       |                                                    ^1       ^1
+   66|       |------------------
+   67|       ||Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::gt
+   68|       |------------------
+   69|       ||Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::le
+   70|       |------------------
+   71|       ||Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::ge
+   72|       |------------------
+   73|       ||<partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::lt:
+   74|       ||  17|      1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+   75|       |------------------
+   76|       |   18|       |pub struct Version {
+   77|       |   19|       |    major: usize,
+   78|       |   20|      1|    minor: usize,
+   79|       |   21|       |    patch: usize,
+   80|       |   22|       |}
+   81|       |   23|       |
+   82|       |   24|       |impl Version {
+   83|       |   25|       |    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
+   84|       |   26|      2|        Version {
+   85|       |   27|      2|            major,
+   86|       |   28|      2|            minor,
+   87|       |   29|      2|            patch,
+   88|       |   30|      2|        }
+   89|       |   31|      2|    }
+   90|       |   32|       |}
+   91|       |   33|       |
+   92|       |   34|      1|fn main() {
+   93|       |   35|      1|    let version_3_2_1 = Version::new(3, 2, 1);
+   94|       |   36|      1|    let version_3_3_0 = Version::new(3, 3, 0);
+   95|       |   37|      1|
+   96|       |   38|      1|    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version
+   97|       |_3_3_0);
+   98|       |   39|      1|}
+   99|       |*/
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt
index f1acb7c5459..064930dd75c 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt
@@ -16,6 +16,7 @@
    16|      1|            10
    17|      1|        ;
    18|      1|    }
+                   ^0
    19|       |
    20|       |    loop
    21|       |    {
@@ -31,6 +32,6 @@
    31|     10|        -=
    32|     10|        1
    33|       |        ;
-   34|       |    }
+   34|      1|    }
    35|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt
index e42f22cd047..1f7e71d3eb0 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt
@@ -10,22 +10,24 @@
    10|      1|    if is_true {
    11|      1|        countdown = 0;
    12|      1|    }
+                   ^0
    13|       |
-   14|      3|    for
-   15|      3|        _
+   14|       |    for
+   15|      2|        _
    16|       |    in
-   17|      1|        0..2
+   17|      3|        0..2
    18|       |    {
    19|       |        let z
    20|       |        ;
    21|       |        match
    22|      2|            countdown
-   23|      2|        {
-   24|      2|            x
-   25|      2|            if
+   23|       |        {
+   24|      1|            x
+   25|       |            if
    26|      2|                x
    27|      2|                    <
    28|      2|                1
+                               ^1
    29|       |            =>
    30|      1|            {
    31|      1|                z = countdown
@@ -39,6 +41,6 @@
    39|       |            =>
    40|      1|            {}
    41|       |        }
-   42|       |    }
+   42|      3|    }
    43|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.tight_infinite_loop.txt
new file mode 100644
index 00000000000..e02eac03a6b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.tight_infinite_loop.txt
@@ -0,0 +1,6 @@
+    1|       |fn main() {
+    2|      1|    if false {
+    3|       |        loop {}
+    4|       |    }
+    5|      1|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt
index ae288d7d7a0..05d72d0de46 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt
@@ -6,22 +6,22 @@
     6|      1|        Err(())
     7|       |    } else {
     8|      5|        Ok(())
-    9|       |    }
+    9|      1|    }
    10|      6|}
    11|       |
    12|       |fn main() -> Result<(),()> {
    13|      1|    let mut
    14|      1|        countdown = 10
    15|       |    ;
-   16|      6|    for
+   16|       |    for
    17|      6|        _
    18|       |    in
-   19|      1|        0..10
+   19|      6|        0..10
    20|       |    {
    21|      6|        countdown
    22|      6|            -= 1
-   23|       |        ;
-   24|       |        if
+   23|      6|        ;
+   24|      6|        if
    25|      6|            countdown < 5
    26|       |        {
    27|      1|            call(/*return_error=*/ true)?;
@@ -29,8 +29,9 @@
    29|       |        else
    30|       |        {
    31|      5|            call(/*return_error=*/ false)?;
-   32|       |        }
-   33|       |    }
+                                                       ^0
+   32|      5|        }
+   33|      6|    }
    34|      0|    Ok(())
-   35|      1|}
+   35|      2|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt
index 173ff4aa4c4..e0efe75043d 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt
@@ -65,5 +65,5 @@
    64|       |    } else {
    65|      0|        return;
    66|       |    };
-   67|      1|}
+   67|      2|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while.txt
new file mode 100644
index 00000000000..194325b6b9e
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while.txt
@@ -0,0 +1,6 @@
+    1|       |fn main() {
+    2|      1|    let num = 9;
+    3|      1|    while num >= 10 {
+    4|      0|    }
+    5|      1|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt
index 7dce94f25f3..2e0c4022bed 100644
--- a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt
@@ -3,7 +3,7 @@
     3|       |
     4|       |fn main() -> Result<(),u8> {
     5|      1|    let mut countdown = 10;
-    6|      7|    while
+    6|       |    while
     7|      7|        countdown
     8|      7|            >
     9|      7|        0
@@ -24,7 +24,7 @@
    24|       |                else
    25|       |                {
    26|      1|                    Err(1)
-   27|       |                }
+   27|      0|                }
    28|       |                ;
    29|       |        }
    30|      6|        countdown
@@ -33,7 +33,7 @@
    33|       |        ;
    34|       |    }
    35|      0|    Ok(())
-   36|      1|}
+   36|      2|}
    37|       |
    38|       |// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and
    39|       |// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt
new file mode 100644
index 00000000000..3eb07757c0d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.closure.txt
@@ -0,0 +1,95 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/closure.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/closure 
+Counter in file 0 20:21 -> 20:38, #1
+Counter in file 0 21:20 -> 21:28, (#1 + 0)
+Counter in file 0 21:29 -> 23:18, #2
+Counter in file 0 23:18 -> 23:19, #3
+Counter in file 0 24:17 -> 25:14, #4
+Counter in file 0 3:11 -> 18:13, #1
+Counter in file 0 25:14 -> 33:9, (#1 + 0)
+Counter in file 0 40:6 -> 60:13, (#1 + 0)
+Counter in file 0 67:14 -> 75:9, (#1 + 0)
+Counter in file 0 82:6 -> 93:2, (#1 + 0)
+Counter in file 0 77:13 -> 77:30, #1
+Counter in file 0 78:12 -> 78:20, (#1 + 0)
+Counter in file 0 78:21 -> 80:10, #2
+Counter in file 0 80:10 -> 80:11, #3
+Counter in file 0 81:9 -> 82:6, #4
+Counter in file 0 62:21 -> 62:38, #1
+Counter in file 0 63:20 -> 63:28, (#1 + 0)
+Counter in file 0 63:29 -> 65:18, #2
+Counter in file 0 65:18 -> 65:19, #3
+Counter in file 0 66:17 -> 67:14, #4
+Counter in file 0 35:13 -> 35:30, #1
+Counter in file 0 36:12 -> 36:20, (#1 + 0)
+Counter in file 0 36:21 -> 38:10, #2
+Counter in file 0 38:10 -> 38:11, #3
+Counter in file 0 39:9 -> 40:6, #4
+Emitting segments for file: ../coverage/closure.rs
+Combined regions:
+  3:11 -> 18:13 (count=1)
+  20:21 -> 20:38 (count=0)
+  21:20 -> 21:28 (count=0)
+  21:29 -> 23:18 (count=0)
+  23:18 -> 23:19 (count=0)
+  24:17 -> 25:14 (count=0)
+  25:14 -> 33:9 (count=1)
+  35:13 -> 35:30 (count=0)
+  36:12 -> 36:20 (count=0)
+  36:21 -> 38:10 (count=0)
+  38:10 -> 38:11 (count=0)
+  39:9 -> 40:6 (count=0)
+  40:6 -> 60:13 (count=1)
+  62:21 -> 62:38 (count=1)
+  63:20 -> 63:28 (count=1)
+  63:29 -> 65:18 (count=0)
+  65:18 -> 65:19 (count=1)
+  66:17 -> 67:14 (count=1)
+  67:14 -> 75:9 (count=1)
+  77:13 -> 77:30 (count=1)
+  78:12 -> 78:20 (count=1)
+  78:21 -> 80:10 (count=0)
+  80:10 -> 80:11 (count=1)
+  81:9 -> 82:6 (count=1)
+  82:6 -> 93:2 (count=1)
+Segment at 3:11 (count = 1), RegionEntry
+Segment at 18:13 (count = 0), Skipped
+Segment at 20:21 (count = 0), RegionEntry
+Segment at 20:38 (count = 0), Skipped
+Segment at 21:20 (count = 0), RegionEntry
+Segment at 21:28 (count = 0), Skipped
+Segment at 21:29 (count = 0), RegionEntry
+Segment at 23:18 (count = 0), RegionEntry
+Segment at 23:19 (count = 0), Skipped
+Segment at 24:17 (count = 0), RegionEntry
+Segment at 25:14 (count = 1), RegionEntry
+Segment at 33:9 (count = 0), Skipped
+Segment at 35:13 (count = 0), RegionEntry
+Segment at 35:30 (count = 0), Skipped
+Segment at 36:12 (count = 0), RegionEntry
+Segment at 36:20 (count = 0), Skipped
+Segment at 36:21 (count = 0), RegionEntry
+Segment at 38:10 (count = 0), RegionEntry
+Segment at 38:11 (count = 0), Skipped
+Segment at 39:9 (count = 0), RegionEntry
+Segment at 40:6 (count = 1), RegionEntry
+Segment at 60:13 (count = 0), Skipped
+Segment at 62:21 (count = 1), RegionEntry
+Segment at 62:38 (count = 0), Skipped
+Segment at 63:20 (count = 1), RegionEntry
+Segment at 63:28 (count = 0), Skipped
+Segment at 63:29 (count = 0), RegionEntry
+Segment at 65:18 (count = 1), RegionEntry
+Segment at 65:19 (count = 0), Skipped
+Segment at 66:17 (count = 1), RegionEntry
+Segment at 67:14 (count = 1), RegionEntry
+Segment at 75:9 (count = 0), Skipped
+Segment at 77:13 (count = 1), RegionEntry
+Segment at 77:30 (count = 0), Skipped
+Segment at 78:12 (count = 1), RegionEntry
+Segment at 78:20 (count = 0), Skipped
+Segment at 78:21 (count = 0), RegionEntry
+Segment at 80:10 (count = 1), RegionEntry
+Segment at 80:11 (count = 0), Skipped
+Segment at 81:9 (count = 1), RegionEntry
+Segment at 82:6 (count = 1), RegionEntry
+Segment at 93:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt
new file mode 100644
index 00000000000..447c3c89562
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.drop_trait.txt
@@ -0,0 +1,24 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/drop_trait.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/drop_trait 
+Counter in file 0 9:24 -> 11:6, #1
+Counter in file 0 15:9 -> 17:42, #1
+Counter in file 0 19:8 -> 19:12, (#1 + 0)
+Counter in file 0 20:9 -> 21:22, #2
+Counter in file 0 27:1 -> 27:2, #4
+Counter in file 0 27:1 -> 27:2, (#2 + 0)
+Emitting segments for file: ../coverage/drop_trait.rs
+Combined regions:
+  9:24 -> 11:6 (count=2)
+  15:9 -> 17:42 (count=1)
+  19:8 -> 19:12 (count=1)
+  20:9 -> 21:22 (count=1)
+  27:1 -> 27:2 (count=2)
+Segment at 9:24 (count = 2), RegionEntry
+Segment at 11:6 (count = 0), Skipped
+Segment at 15:9 (count = 1), RegionEntry
+Segment at 17:42 (count = 0), Skipped
+Segment at 19:8 (count = 1), RegionEntry
+Segment at 19:12 (count = 0), Skipped
+Segment at 20:9 (count = 1), RegionEntry
+Segment at 21:22 (count = 0), Skipped
+Segment at 27:1 (count = 2), RegionEntry
+Segment at 27:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt
new file mode 100644
index 00000000000..5843b917588
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.generics.txt
@@ -0,0 +1,50 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/generics.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/generics 
+Counter in file 0 17:24 -> 19:6, #1
+Counter in file 0 17:24 -> 19:6, #1
+Counter in file 0 23:9 -> 28:28, #1
+Counter in file 0 30:8 -> 30:12, (#1 + 0)
+Counter in file 0 31:9 -> 32:22, #2
+Counter in file 0 38:1 -> 38:2, #4
+Counter in file 0 38:1 -> 38:2, (#2 + 0)
+Counter in file 0 10:49 -> 12:6, #1
+Counter in file 0 10:49 -> 12:6, #1
+Emitting segments for file: ../coverage/generics.rs
+Combined regions:
+  10:49 -> 12:6 (count=3)
+  17:24 -> 19:6 (count=2)
+  23:9 -> 28:28 (count=1)
+  30:8 -> 30:12 (count=1)
+  31:9 -> 32:22 (count=1)
+  38:1 -> 38:2 (count=2)
+Segment at 10:49 (count = 3), RegionEntry
+Segment at 12:6 (count = 0), Skipped
+Segment at 17:24 (count = 2), RegionEntry
+Segment at 19:6 (count = 0), Skipped
+Segment at 23:9 (count = 1), RegionEntry
+Segment at 28:28 (count = 0), Skipped
+Segment at 30:8 (count = 1), RegionEntry
+Segment at 30:12 (count = 0), Skipped
+Segment at 31:9 (count = 1), RegionEntry
+Segment at 32:22 (count = 0), Skipped
+Segment at 38:1 (count = 2), RegionEntry
+Segment at 38:2 (count = 0), Skipped
+Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworkdE12set_strengthB2_
+Combined regions:
+  10:49 -> 12:6 (count=2)
+Segment at 10:49 (count = 2), RegionEntry
+Segment at 12:6 (count = 0), Skipped
+Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworklE12set_strengthB2_
+Combined regions:
+  10:49 -> 12:6 (count=1)
+Segment at 10:49 (count = 1), RegionEntry
+Segment at 12:6 (count = 0), Skipped
+Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworklENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_
+Combined regions:
+  17:24 -> 19:6 (count=1)
+Segment at 17:24 (count = 1), RegionEntry
+Segment at 19:6 (count = 0), Skipped
+Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworkdENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_
+Combined regions:
+  17:24 -> 19:6 (count=1)
+Segment at 17:24 (count = 1), RegionEntry
+Segment at 19:6 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt
new file mode 100644
index 00000000000..2f063de5a39
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if.txt
@@ -0,0 +1,22 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/if.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/if 
+Counter in file 0 8:5 -> 18:10, #1
+Counter in file 0 21:9 -> 21:16, (#1 + 0)
+Counter in file 0 22:5 -> 27:6, #2
+Counter in file 0 27:6 -> 27:7, #3
+Counter in file 0 28:1 -> 28:2, #4
+Emitting segments for file: ../coverage/if.rs
+Combined regions:
+  8:5 -> 18:10 (count=1)
+  21:9 -> 21:16 (count=1)
+  22:5 -> 27:6 (count=1)
+  27:6 -> 27:7 (count=0)
+  28:1 -> 28:2 (count=1)
+Segment at 8:5 (count = 1), RegionEntry
+Segment at 18:10 (count = 0), Skipped
+Segment at 21:9 (count = 1), RegionEntry
+Segment at 21:16 (count = 0), Skipped
+Segment at 22:5 (count = 1), RegionEntry
+Segment at 27:6 (count = 0), RegionEntry
+Segment at 27:7 (count = 0), Skipped
+Segment at 28:1 (count = 1), RegionEntry
+Segment at 28:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt
new file mode 100644
index 00000000000..660e85f91f5
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.if_else.txt
@@ -0,0 +1,38 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/if_else.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/if_else 
+Counter in file 0 7:9 -> 11:16, #1
+Counter in file 0 12:5 -> 17:6, #2
+Counter in file 0 20:9 -> 22:16, #3
+Counter in file 0 23:6 -> 23:7, (#2 + 0)
+Counter in file 0 26:9 -> 26:16, #4
+Counter in file 0 27:5 -> 32:6, #5
+Counter in file 0 34:5 -> 39:6, #6
+Counter in file 0 39:6 -> 39:7, (#5 + 0)
+Counter in file 0 40:1 -> 40:2, #7
+Emitting segments for file: ../coverage/if_else.rs
+Combined regions:
+  7:9 -> 11:16 (count=1)
+  12:5 -> 17:6 (count=1)
+  20:9 -> 22:16 (count=0)
+  23:6 -> 23:7 (count=1)
+  26:9 -> 26:16 (count=1)
+  27:5 -> 32:6 (count=1)
+  34:5 -> 39:6 (count=0)
+  39:6 -> 39:7 (count=1)
+  40:1 -> 40:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 11:16 (count = 0), Skipped
+Segment at 12:5 (count = 1), RegionEntry
+Segment at 17:6 (count = 0), Skipped
+Segment at 20:9 (count = 0), RegionEntry
+Segment at 22:16 (count = 0), Skipped
+Segment at 23:6 (count = 1), RegionEntry
+Segment at 23:7 (count = 0), Skipped
+Segment at 26:9 (count = 1), RegionEntry
+Segment at 26:16 (count = 0), Skipped
+Segment at 27:5 (count = 1), RegionEntry
+Segment at 32:6 (count = 0), Skipped
+Segment at 34:5 (count = 0), RegionEntry
+Segment at 39:6 (count = 1), RegionEntry
+Segment at 39:7 (count = 0), Skipped
+Segment at 40:1 (count = 1), RegionEntry
+Segment at 40:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt
new file mode 100644
index 00000000000..fb863c73a63
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.inner_items.txt
@@ -0,0 +1,61 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/inner_items.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/inner_items 
+Counter in file 0 19:13 -> 19:18, #1
+Counter in file 0 20:13 -> 20:14, #2
+Counter in file 0 20:17 -> 20:22, (#1 + 0)
+Counter in file 0 21:9 -> 22:6, (#2 + 0)
+Counter in file 0 7:9 -> 9:26, #1
+Counter in file 0 10:8 -> 10:15, (#1 + 0)
+Counter in file 0 10:16 -> 12:6, #2
+Counter in file 0 12:6 -> 12:7, #3
+Counter in file 0 48:8 -> 48:15, #4
+Counter in file 0 48:16 -> 50:6, #5
+Counter in file 0 50:6 -> 50:7, #6
+Counter in file 0 52:9 -> 57:2, #7
+Counter in file 0 33:42 -> 36:10, #1
+Counter in file 0 41:37 -> 41:41, #1
+Counter in file 0 42:13 -> 43:10, #2
+Emitting segments for file: ../coverage/inner_items.rs
+Combined regions:
+  7:9 -> 9:26 (count=1)
+  10:8 -> 10:15 (count=1)
+  10:16 -> 12:6 (count=1)
+  12:6 -> 12:7 (count=0)
+  19:13 -> 19:18 (count=3)
+  20:13 -> 20:14 (count=3)
+  20:17 -> 20:22 (count=3)
+  21:9 -> 22:6 (count=3)
+  33:42 -> 36:10 (count=1)
+  41:37 -> 41:41 (count=1)
+  42:13 -> 43:10 (count=1)
+  48:8 -> 48:15 (count=1)
+  48:16 -> 50:6 (count=1)
+  50:6 -> 50:7 (count=0)
+  52:9 -> 57:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:26 (count = 0), Skipped
+Segment at 10:8 (count = 1), RegionEntry
+Segment at 10:15 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 12:6 (count = 0), RegionEntry
+Segment at 12:7 (count = 0), Skipped
+Segment at 19:13 (count = 3), RegionEntry
+Segment at 19:18 (count = 0), Skipped
+Segment at 20:13 (count = 3), RegionEntry
+Segment at 20:14 (count = 0), Skipped
+Segment at 20:17 (count = 3), RegionEntry
+Segment at 20:22 (count = 0), Skipped
+Segment at 21:9 (count = 3), RegionEntry
+Segment at 22:6 (count = 0), Skipped
+Segment at 33:42 (count = 1), RegionEntry
+Segment at 36:10 (count = 0), Skipped
+Segment at 41:37 (count = 1), RegionEntry
+Segment at 41:41 (count = 0), Skipped
+Segment at 42:13 (count = 1), RegionEntry
+Segment at 43:10 (count = 0), Skipped
+Segment at 48:8 (count = 1), RegionEntry
+Segment at 48:15 (count = 0), Skipped
+Segment at 48:16 (count = 1), RegionEntry
+Segment at 50:6 (count = 0), RegionEntry
+Segment at 50:7 (count = 0), Skipped
+Segment at 52:9 (count = 1), RegionEntry
+Segment at 57:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt
new file mode 100644
index 00000000000..dd93c3a9392
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.lazy_boolean.txt
@@ -0,0 +1,138 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/lazy_boolean.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/lazy_boolean 
+Counter in file 0 7:9 -> 9:42, #1
+Counter in file 0 10:8 -> 10:15, (#1 + 0)
+Counter in file 0 10:16 -> 14:6, #2
+Counter in file 0 14:6 -> 14:7, #3
+Counter in file 0 16:9 -> 16:17, #4
+Counter in file 0 18:13 -> 18:18, #5
+Counter in file 0 20:13 -> 20:18, #6
+Counter in file 0 20:18 -> 20:19, #7
+Counter in file 0 20:18 -> 20:19, #8
+Counter in file 0 23:9 -> 23:17, #9
+Counter in file 0 25:13 -> 25:18, (#4 + 0)
+Counter in file 0 27:13 -> 27:18, #10
+Counter in file 0 27:18 -> 27:19, #11
+Counter in file 0 27:18 -> 27:19, #12
+Counter in file 0 29:9 -> 29:17, #13
+Counter in file 0 29:20 -> 29:25, (#9 + 0)
+Counter in file 0 29:29 -> 29:34, #14
+Counter in file 0 29:34 -> 29:35, #15
+Counter in file 0 29:34 -> 29:35, #16
+Counter in file 0 30:9 -> 30:17, #17
+Counter in file 0 30:20 -> 30:25, (#13 + 0)
+Counter in file 0 30:29 -> 30:34, #18
+Counter in file 0 30:34 -> 30:35, #19
+Counter in file 0 30:34 -> 30:35, #20
+Counter in file 0 33:9 -> 34:16, (#17 + 0)
+Counter in file 0 35:5 -> 38:6, #21
+Counter in file 0 38:6 -> 38:7, #22
+Counter in file 0 41:9 -> 41:16, #23
+Counter in file 0 42:5 -> 45:6, #24
+Counter in file 0 47:5 -> 50:6, #25
+Counter in file 0 50:6 -> 50:7, (#24 + 0)
+Counter in file 0 52:8 -> 52:16, #26
+Counter in file 0 52:17 -> 54:6, #27
+Counter in file 0 54:6 -> 54:7, #28
+Counter in file 0 56:8 -> 56:15, #29
+Counter in file 0 56:16 -> 58:6, #30
+Counter in file 0 58:12 -> 60:6, #31
+Counter in file 0 60:6 -> 60:7, (#30 + 0)
+Counter in file 0 61:1 -> 61:2, #32
+Emitting segments for file: ../coverage/lazy_boolean.rs
+Combined regions:
+  7:9 -> 9:42 (count=1)
+  10:8 -> 10:15 (count=1)
+  10:16 -> 14:6 (count=1)
+  14:6 -> 14:7 (count=0)
+  16:9 -> 16:17 (count=1)
+  18:13 -> 18:18 (count=1)
+  20:13 -> 20:18 (count=0)
+  20:18 -> 20:19 (count=1)
+  23:9 -> 23:17 (count=1)
+  25:13 -> 25:18 (count=1)
+  27:13 -> 27:18 (count=1)
+  27:18 -> 27:19 (count=1)
+  29:9 -> 29:17 (count=1)
+  29:20 -> 29:25 (count=1)
+  29:29 -> 29:34 (count=1)
+  29:34 -> 29:35 (count=1)
+  30:9 -> 30:17 (count=1)
+  30:20 -> 30:25 (count=1)
+  30:29 -> 30:34 (count=0)
+  30:34 -> 30:35 (count=1)
+  33:9 -> 34:16 (count=1)
+  35:5 -> 38:6 (count=0)
+  38:6 -> 38:7 (count=1)
+  41:9 -> 41:16 (count=1)
+  42:5 -> 45:6 (count=1)
+  47:5 -> 50:6 (count=0)
+  50:6 -> 50:7 (count=1)
+  52:8 -> 52:16 (count=1)
+  52:17 -> 54:6 (count=0)
+  54:6 -> 54:7 (count=1)
+  56:8 -> 56:15 (count=1)
+  56:16 -> 58:6 (count=1)
+  58:12 -> 60:6 (count=0)
+  60:6 -> 60:7 (count=1)
+  61:1 -> 61:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:42 (count = 0), Skipped
+Segment at 10:8 (count = 1), RegionEntry
+Segment at 10:15 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 14:6 (count = 0), RegionEntry
+Segment at 14:7 (count = 0), Skipped
+Segment at 16:9 (count = 1), RegionEntry
+Segment at 16:17 (count = 0), Skipped
+Segment at 18:13 (count = 1), RegionEntry
+Segment at 18:18 (count = 0), Skipped
+Segment at 20:13 (count = 0), RegionEntry
+Segment at 20:18 (count = 1), RegionEntry
+Segment at 20:19 (count = 0), Skipped
+Segment at 23:9 (count = 1), RegionEntry
+Segment at 23:17 (count = 0), Skipped
+Segment at 25:13 (count = 1), RegionEntry
+Segment at 25:18 (count = 0), Skipped
+Segment at 27:13 (count = 1), RegionEntry
+Segment at 27:18 (count = 1), RegionEntry
+Segment at 27:19 (count = 0), Skipped
+Segment at 29:9 (count = 1), RegionEntry
+Segment at 29:17 (count = 0), Skipped
+Segment at 29:20 (count = 1), RegionEntry
+Segment at 29:25 (count = 0), Skipped
+Segment at 29:29 (count = 1), RegionEntry
+Segment at 29:34 (count = 1), RegionEntry
+Segment at 29:35 (count = 0), Skipped
+Segment at 30:9 (count = 1), RegionEntry
+Segment at 30:17 (count = 0), Skipped
+Segment at 30:20 (count = 1), RegionEntry
+Segment at 30:25 (count = 0), Skipped
+Segment at 30:29 (count = 0), RegionEntry
+Segment at 30:34 (count = 1), RegionEntry
+Segment at 30:35 (count = 0), Skipped
+Segment at 33:9 (count = 1), RegionEntry
+Segment at 34:16 (count = 0), Skipped
+Segment at 35:5 (count = 0), RegionEntry
+Segment at 38:6 (count = 1), RegionEntry
+Segment at 38:7 (count = 0), Skipped
+Segment at 41:9 (count = 1), RegionEntry
+Segment at 41:16 (count = 0), Skipped
+Segment at 42:5 (count = 1), RegionEntry
+Segment at 45:6 (count = 0), Skipped
+Segment at 47:5 (count = 0), RegionEntry
+Segment at 50:6 (count = 1), RegionEntry
+Segment at 50:7 (count = 0), Skipped
+Segment at 52:8 (count = 1), RegionEntry
+Segment at 52:16 (count = 0), Skipped
+Segment at 52:17 (count = 0), RegionEntry
+Segment at 54:6 (count = 1), RegionEntry
+Segment at 54:7 (count = 0), Skipped
+Segment at 56:8 (count = 1), RegionEntry
+Segment at 56:15 (count = 0), Skipped
+Segment at 56:16 (count = 1), RegionEntry
+Segment at 58:6 (count = 0), Skipped
+Segment at 58:12 (count = 0), RegionEntry
+Segment at 60:6 (count = 1), RegionEntry
+Segment at 60:7 (count = 0), Skipped
+Segment at 61:1 (count = 1), RegionEntry
+Segment at 61:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loop_break_value.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loop_break_value.txt
new file mode 100644
index 00000000000..df16c54617c
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loop_break_value.txt
@@ -0,0 +1,7 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/loop_break_value.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/loop_break_value 
+Counter in file 0 3:11 -> 13:2, #1
+Emitting segments for file: ../coverage/loop_break_value.rs
+Combined regions:
+  3:11 -> 13:2 (count=1)
+Segment at 3:11 (count = 1), RegionEntry
+Segment at 13:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt
new file mode 100644
index 00000000000..d6e4403268a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.loops_and_branches.txt
@@ -0,0 +1,39 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/loops_and_branches.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/loops_and_branches 
+Counter in file 0 10:12 -> 10:16, #1
+Counter in file 0 11:16 -> 11:21, #2
+Counter in file 0 14:14 -> 14:15, #6
+Counter in file 0 15:13 -> 15:31, #7
+Counter in file 0 15:31 -> 15:32, #8
+Counter in file 0 17:10 -> 17:11, #10
+Counter in file 0 18:9 -> 18:15, #11
+Counter in file 0 19:5 -> 19:6, #12
+Counter in file 0 19:5 -> 19:6, (#8 + 0)
+Counter in file 0 22:11 -> 25:2, #1
+Emitting segments for file: ../coverage/loops_and_branches.rs
+Combined regions:
+  10:12 -> 10:16 (count=1)
+  11:16 -> 11:21 (count=1)
+  14:14 -> 14:15 (count=1)
+  15:13 -> 15:31 (count=1)
+  15:31 -> 15:32 (count=0)
+  17:10 -> 17:11 (count=1)
+  18:9 -> 18:15 (count=1)
+  19:5 -> 19:6 (count=1)
+  22:11 -> 25:2 (count=1)
+Segment at 10:12 (count = 1), RegionEntry
+Segment at 10:16 (count = 0), Skipped
+Segment at 11:16 (count = 1), RegionEntry
+Segment at 11:21 (count = 0), Skipped
+Segment at 14:14 (count = 1), RegionEntry
+Segment at 14:15 (count = 0), Skipped
+Segment at 15:13 (count = 1), RegionEntry
+Segment at 15:31 (count = 0), RegionEntry
+Segment at 15:32 (count = 0), Skipped
+Segment at 17:10 (count = 1), RegionEntry
+Segment at 17:11 (count = 0), Skipped
+Segment at 18:9 (count = 1), RegionEntry
+Segment at 18:15 (count = 0), Skipped
+Segment at 19:5 (count = 1), RegionEntry
+Segment at 19:6 (count = 0), Skipped
+Segment at 22:11 (count = 1), RegionEntry
+Segment at 25:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt
new file mode 100644
index 00000000000..eec4aec79e6
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.nested_loops.txt
@@ -0,0 +1,76 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/nested_loops.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/nested_loops 
+Counter in file 0 2:9 -> 3:27, #1
+Counter in file 0 5:19 -> 5:32, #2
+Counter in file 0 6:13 -> 7:24, #3
+Counter in file 0 8:13 -> 8:14, #4
+Counter in file 0 8:18 -> 8:23, #5
+Counter in file 0 9:16 -> 9:22, (#4 + 0)
+Counter in file 0 10:17 -> 10:22, #6
+Counter in file 0 12:13 -> 12:19, #7
+Counter in file 0 13:13 -> 13:19, #8
+Counter in file 0 14:16 -> 14:22, (#8 + 0)
+Counter in file 0 15:17 -> 16:27, #9
+Counter in file 0 17:21 -> 17:33, #10
+Counter in file 0 19:21 -> 21:14, #11
+Counter in file 0 21:14 -> 21:15, #12
+Counter in file 0 22:10 -> 22:11, #13
+Counter in file 0 22:10 -> 22:11, (#3 + 0)
+Counter in file 0 23:9 -> 23:23, #14
+Counter in file 0 24:6 -> 24:7, #15
+Counter in file 0 24:6 -> 24:7, (#1 + 0)
+Counter in file 0 25:1 -> 25:2, #16
+Emitting segments for file: ../coverage/nested_loops.rs
+Combined regions:
+  2:9 -> 3:27 (count=1)
+  5:19 -> 5:32 (count=1)
+  6:13 -> 7:24 (count=1)
+  8:13 -> 8:14 (count=3)
+  8:18 -> 8:23 (count=3)
+  9:16 -> 9:22 (count=3)
+  10:17 -> 10:22 (count=0)
+  12:13 -> 12:19 (count=3)
+  13:13 -> 13:19 (count=3)
+  14:16 -> 14:22 (count=3)
+  15:17 -> 16:27 (count=1)
+  17:21 -> 17:33 (count=1)
+  19:21 -> 21:14 (count=0)
+  21:14 -> 21:15 (count=2)
+  22:10 -> 22:11 (count=3)
+  23:9 -> 23:23 (count=0)
+  24:6 -> 24:7 (count=1)
+  25:1 -> 25:2 (count=1)
+Segment at 2:9 (count = 1), RegionEntry
+Segment at 3:27 (count = 0), Skipped
+Segment at 5:19 (count = 1), RegionEntry
+Segment at 5:32 (count = 0), Skipped
+Segment at 6:13 (count = 1), RegionEntry
+Segment at 7:24 (count = 0), Skipped
+Segment at 8:13 (count = 3), RegionEntry
+Segment at 8:14 (count = 0), Skipped
+Segment at 8:18 (count = 3), RegionEntry
+Segment at 8:23 (count = 0), Skipped
+Segment at 9:16 (count = 3), RegionEntry
+Segment at 9:22 (count = 0), Skipped
+Segment at 10:17 (count = 0), RegionEntry
+Segment at 10:22 (count = 0), Skipped
+Segment at 12:13 (count = 3), RegionEntry
+Segment at 12:19 (count = 0), Skipped
+Segment at 13:13 (count = 3), RegionEntry
+Segment at 13:19 (count = 0), Skipped
+Segment at 14:16 (count = 3), RegionEntry
+Segment at 14:22 (count = 0), Skipped
+Segment at 15:17 (count = 1), RegionEntry
+Segment at 16:27 (count = 0), Skipped
+Segment at 17:21 (count = 1), RegionEntry
+Segment at 17:33 (count = 0), Skipped
+Segment at 19:21 (count = 0), RegionEntry
+Segment at 21:14 (count = 2), RegionEntry
+Segment at 21:15 (count = 0), Skipped
+Segment at 22:10 (count = 3), RegionEntry
+Segment at 22:11 (count = 0), Skipped
+Segment at 23:9 (count = 0), RegionEntry
+Segment at 23:23 (count = 0), Skipped
+Segment at 24:6 (count = 1), RegionEntry
+Segment at 24:7 (count = 0), Skipped
+Segment at 25:1 (count = 1), RegionEntry
+Segment at 25:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.partial_eq_counter_without_region.txt
new file mode 100644
index 00000000000..d2a68ab3202
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.partial_eq_counter_without_region.txt
@@ -0,0 +1,28 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/partial_eq_counter_without_region.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/partial_eq_counter_without_region 
+Counter in file 0 7:5 -> 7:6, #1
+Counter in file 0 21:11 -> 26:2, #1
+Counter in file 0 4:17 -> 4:22, #1
+Counter in file 0 13:9 -> 18:6, #1
+Counter in file 0 4:39 -> 4:40, #1
+Counter in file 0 4:48 -> 4:49, (#1 + 0)
+Counter in file 0 8:5 -> 8:17, #1
+Emitting segments for file: ../coverage/partial_eq_counter_without_region.rs
+Combined regions:
+  4:17 -> 4:22 (count=2)
+  4:39 -> 4:40 (count=1)
+  4:48 -> 4:49 (count=1)
+  7:5 -> 7:6 (count=1)
+  13:9 -> 18:6 (count=2)
+  21:11 -> 26:2 (count=1)
+Segment at 4:17 (count = 2), RegionEntry
+Segment at 4:22 (count = 0), Skipped
+Segment at 4:39 (count = 1), RegionEntry
+Segment at 4:40 (count = 0), Skipped
+Segment at 4:48 (count = 1), RegionEntry
+Segment at 4:49 (count = 0), Skipped
+Segment at 7:5 (count = 1), RegionEntry
+Segment at 7:6 (count = 0), Skipped
+Segment at 13:9 (count = 2), RegionEntry
+Segment at 18:6 (count = 0), Skipped
+Segment at 21:11 (count = 1), RegionEntry
+Segment at 26:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt
new file mode 100644
index 00000000000..d828e40ca3f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_loop.txt
@@ -0,0 +1,38 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/simple_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/simple_loop 
+Counter in file 0 7:9 -> 9:26, #1
+Counter in file 0 12:9 -> 12:16, (#1 + 0)
+Counter in file 0 13:5 -> 18:6, #2
+Counter in file 0 18:6 -> 18:7, #3
+Counter in file 0 23:13 -> 25:14, #4
+Counter in file 0 27:13 -> 27:18, #5
+Counter in file 0 30:9 -> 32:10, #6
+Counter in file 0 34:6 -> 34:7, #7
+Counter in file 0 35:1 -> 35:2, (#5 + 0)
+Emitting segments for file: ../coverage/simple_loop.rs
+Combined regions:
+  7:9 -> 9:26 (count=1)
+  12:9 -> 12:16 (count=1)
+  13:5 -> 18:6 (count=1)
+  18:6 -> 18:7 (count=0)
+  23:13 -> 25:14 (count=11)
+  27:13 -> 27:18 (count=1)
+  30:9 -> 32:10 (count=10)
+  34:6 -> 34:7 (count=1)
+  35:1 -> 35:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:26 (count = 0), Skipped
+Segment at 12:9 (count = 1), RegionEntry
+Segment at 12:16 (count = 0), Skipped
+Segment at 13:5 (count = 1), RegionEntry
+Segment at 18:6 (count = 0), RegionEntry
+Segment at 18:7 (count = 0), Skipped
+Segment at 23:13 (count = 11), RegionEntry
+Segment at 25:14 (count = 0), Skipped
+Segment at 27:13 (count = 1), RegionEntry
+Segment at 27:18 (count = 0), Skipped
+Segment at 30:9 (count = 10), RegionEntry
+Segment at 32:10 (count = 0), Skipped
+Segment at 34:6 (count = 1), RegionEntry
+Segment at 34:7 (count = 0), Skipped
+Segment at 35:1 (count = 1), RegionEntry
+Segment at 35:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt
new file mode 100644
index 00000000000..e7932e0be04
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.simple_match.txt
@@ -0,0 +1,58 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/simple_match.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/simple_match 
+Counter in file 0 7:9 -> 9:26, #1
+Counter in file 0 10:8 -> 10:15, (#1 + 0)
+Counter in file 0 10:16 -> 12:6, #2
+Counter in file 0 12:6 -> 12:7, #3
+Counter in file 0 15:9 -> 15:10, #4
+Counter in file 0 17:9 -> 17:13, #5
+Counter in file 0 22:13 -> 22:22, (#4 + 0)
+Counter in file 0 24:13 -> 24:14, #6
+Counter in file 0 26:17 -> 28:18, (#4 + 0)
+Counter in file 0 28:18 -> 28:19, #7
+Counter in file 0 30:13 -> 37:14, (#6 + 0)
+Counter in file 0 40:13 -> 40:15, #8
+Counter in file 0 42:6 -> 42:7, #9
+Counter in file 0 42:6 -> 42:7, #10
+Counter in file 0 43:1 -> 43:2, #11
+Emitting segments for file: ../coverage/simple_match.rs
+Combined regions:
+  7:9 -> 9:26 (count=1)
+  10:8 -> 10:15 (count=1)
+  10:16 -> 12:6 (count=1)
+  12:6 -> 12:7 (count=0)
+  15:9 -> 15:10 (count=2)
+  17:9 -> 17:13 (count=3)
+  22:13 -> 22:22 (count=2)
+  24:13 -> 24:14 (count=1)
+  26:17 -> 28:18 (count=2)
+  28:18 -> 28:19 (count=1)
+  30:13 -> 37:14 (count=1)
+  40:13 -> 40:15 (count=1)
+  42:6 -> 42:7 (count=3)
+  43:1 -> 43:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:26 (count = 0), Skipped
+Segment at 10:8 (count = 1), RegionEntry
+Segment at 10:15 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 12:6 (count = 0), RegionEntry
+Segment at 12:7 (count = 0), Skipped
+Segment at 15:9 (count = 2), RegionEntry
+Segment at 15:10 (count = 0), Skipped
+Segment at 17:9 (count = 3), RegionEntry
+Segment at 17:13 (count = 0), Skipped
+Segment at 22:13 (count = 2), RegionEntry
+Segment at 22:22 (count = 0), Skipped
+Segment at 24:13 (count = 1), RegionEntry
+Segment at 24:14 (count = 0), Skipped
+Segment at 26:17 (count = 2), RegionEntry
+Segment at 28:18 (count = 1), RegionEntry
+Segment at 28:19 (count = 0), Skipped
+Segment at 30:13 (count = 1), RegionEntry
+Segment at 37:14 (count = 0), Skipped
+Segment at 40:13 (count = 1), RegionEntry
+Segment at 40:15 (count = 0), Skipped
+Segment at 42:6 (count = 3), RegionEntry
+Segment at 42:7 (count = 0), Skipped
+Segment at 43:1 (count = 1), RegionEntry
+Segment at 43:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt
new file mode 100644
index 00000000000..a690874e3c0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.tight_infinite_loop.txt
@@ -0,0 +1,11 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/tight_infinite_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/tight_infinite_loop 
+Counter in file 0 2:8 -> 2:13, #1
+Counter in file 0 5:1 -> 5:2, #4
+Emitting segments for file: ../coverage/tight_infinite_loop.rs
+Combined regions:
+  2:8 -> 2:13 (count=1)
+  5:1 -> 5:2 (count=1)
+Segment at 2:8 (count = 1), RegionEntry
+Segment at 2:13 (count = 0), Skipped
+Segment at 5:1 (count = 1), RegionEntry
+Segment at 5:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt
new file mode 100644
index 00000000000..d510223417a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.try_error_result.txt
@@ -0,0 +1,72 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/try_error_result.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/try_error_result 
+Counter in file 0 13:9 -> 14:23, #1
+Counter in file 0 17:9 -> 17:10, #2
+Counter in file 0 19:9 -> 19:14, #3
+Counter in file 0 21:9 -> 25:26, #4
+Counter in file 0 27:13 -> 27:41, #5
+Counter in file 0 27:41 -> 27:42, #6
+Counter in file 0 31:13 -> 31:42, #7
+Counter in file 0 31:42 -> 31:43, #8
+Counter in file 0 32:10 -> 32:11, #9
+Counter in file 0 32:10 -> 32:11, #10
+Counter in file 0 33:6 -> 33:7, #11
+Counter in file 0 33:6 -> 33:7, (#1 + 0)
+Counter in file 0 34:5 -> 34:11, #12
+Counter in file 0 35:1 -> 35:2, #13
+Counter in file 0 35:1 -> 35:2, #14
+Counter in file 0 5:8 -> 5:20, #1
+Counter in file 0 6:9 -> 6:16, #2
+Counter in file 0 8:9 -> 8:15, #3
+Counter in file 0 9:6 -> 9:7, (#2 + 0)
+Counter in file 0 10:1 -> 10:2, #4
+Emitting segments for file: ../coverage/try_error_result.rs
+Combined regions:
+  5:8 -> 5:20 (count=6)
+  6:9 -> 6:16 (count=1)
+  8:9 -> 8:15 (count=5)
+  9:6 -> 9:7 (count=1)
+  10:1 -> 10:2 (count=6)
+  13:9 -> 14:23 (count=1)
+  17:9 -> 17:10 (count=6)
+  19:9 -> 19:14 (count=6)
+  21:9 -> 25:26 (count=6)
+  27:13 -> 27:41 (count=1)
+  27:41 -> 27:42 (count=1)
+  31:13 -> 31:42 (count=5)
+  31:42 -> 31:43 (count=0)
+  32:10 -> 32:11 (count=5)
+  33:6 -> 33:7 (count=6)
+  34:5 -> 34:11 (count=0)
+  35:1 -> 35:2 (count=2)
+Segment at 5:8 (count = 6), RegionEntry
+Segment at 5:20 (count = 0), Skipped
+Segment at 6:9 (count = 1), RegionEntry
+Segment at 6:16 (count = 0), Skipped
+Segment at 8:9 (count = 5), RegionEntry
+Segment at 8:15 (count = 0), Skipped
+Segment at 9:6 (count = 1), RegionEntry
+Segment at 9:7 (count = 0), Skipped
+Segment at 10:1 (count = 6), RegionEntry
+Segment at 10:2 (count = 0), Skipped
+Segment at 13:9 (count = 1), RegionEntry
+Segment at 14:23 (count = 0), Skipped
+Segment at 17:9 (count = 6), RegionEntry
+Segment at 17:10 (count = 0), Skipped
+Segment at 19:9 (count = 6), RegionEntry
+Segment at 19:14 (count = 0), Skipped
+Segment at 21:9 (count = 6), RegionEntry
+Segment at 25:26 (count = 0), Skipped
+Segment at 27:13 (count = 1), RegionEntry
+Segment at 27:41 (count = 1), RegionEntry
+Segment at 27:42 (count = 0), Skipped
+Segment at 31:13 (count = 5), RegionEntry
+Segment at 31:42 (count = 0), RegionEntry
+Segment at 31:43 (count = 0), Skipped
+Segment at 32:10 (count = 5), RegionEntry
+Segment at 32:11 (count = 0), Skipped
+Segment at 33:6 (count = 6), RegionEntry
+Segment at 33:7 (count = 0), Skipped
+Segment at 34:5 (count = 0), RegionEntry
+Segment at 34:11 (count = 0), Skipped
+Segment at 35:1 (count = 2), RegionEntry
+Segment at 35:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt
new file mode 100644
index 00000000000..0fb135b2cc9
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.various_conditions.txt
@@ -0,0 +1,240 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/various_conditions.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/various_conditions 
+Counter in file 0 4:9 -> 4:26, #1
+Counter in file 0 5:8 -> 5:12, (#1 + 0)
+Counter in file 0 5:13 -> 7:6, #2
+Counter in file 0 10:9 -> 10:10, #4
+Counter in file 0 10:16 -> 10:29, #5
+Counter in file 0 11:9 -> 12:10, #6
+Counter in file 0 13:15 -> 13:28, #7
+Counter in file 0 14:12 -> 14:25, #8
+Counter in file 0 14:29 -> 14:42, #9
+Counter in file 0 14:42 -> 14:43, #10
+Counter in file 0 14:42 -> 14:43, #11
+Counter in file 0 14:46 -> 14:60, #12
+Counter in file 0 14:60 -> 14:61, #13
+Counter in file 0 14:60 -> 14:61, #14
+Counter in file 0 14:61 -> 16:10, #15
+Counter in file 0 16:10 -> 16:11, #16
+Counter in file 0 17:9 -> 18:18, #17
+Counter in file 0 20:9 -> 20:15, #18
+Counter in file 0 23:9 -> 23:26, (#4 + 0)
+Counter in file 0 24:8 -> 24:12, (#4 + 0)
+Counter in file 0 24:13 -> 26:6, #19
+Counter in file 0 28:8 -> 28:21, #21
+Counter in file 0 29:9 -> 29:23, #22
+Counter in file 0 30:15 -> 30:28, #23
+Counter in file 0 31:12 -> 31:25, #24
+Counter in file 0 31:29 -> 31:42, #25
+Counter in file 0 31:42 -> 31:43, #26
+Counter in file 0 31:42 -> 31:43, #27
+Counter in file 0 31:46 -> 31:60, #28
+Counter in file 0 31:60 -> 31:61, #29
+Counter in file 0 31:60 -> 31:61, #30
+Counter in file 0 31:61 -> 33:10, #31
+Counter in file 0 33:10 -> 33:11, #32
+Counter in file 0 34:9 -> 34:23, #33
+Counter in file 0 36:9 -> 36:15, #34
+Counter in file 0 39:9 -> 39:26, #35
+Counter in file 0 40:8 -> 40:12, (#35 + 0)
+Counter in file 0 40:13 -> 42:6, #36
+Counter in file 0 44:9 -> 44:10, #38
+Counter in file 0 44:16 -> 44:29, #39
+Counter in file 0 45:9 -> 45:23, #40
+Counter in file 0 46:15 -> 46:28, #41
+Counter in file 0 47:12 -> 47:25, #42
+Counter in file 0 47:29 -> 47:42, #43
+Counter in file 0 47:42 -> 47:43, #44
+Counter in file 0 47:42 -> 47:43, #45
+Counter in file 0 47:46 -> 47:60, #46
+Counter in file 0 47:60 -> 47:61, #47
+Counter in file 0 47:60 -> 47:61, #48
+Counter in file 0 47:61 -> 49:10, #49
+Counter in file 0 49:10 -> 49:11, #50
+Counter in file 0 50:9 -> 50:23, #51
+Counter in file 0 52:13 -> 54:15, #52
+Counter in file 0 57:9 -> 57:10, #53
+Counter in file 0 57:16 -> 57:29, (#38 + 0)
+Counter in file 0 58:9 -> 58:23, #54
+Counter in file 0 59:15 -> 59:28, #55
+Counter in file 0 60:12 -> 60:25, #56
+Counter in file 0 60:29 -> 60:42, #57
+Counter in file 0 60:42 -> 60:43, #58
+Counter in file 0 60:42 -> 60:43, #59
+Counter in file 0 60:46 -> 60:60, #60
+Counter in file 0 60:60 -> 60:61, #61
+Counter in file 0 60:60 -> 60:61, #62
+Counter in file 0 60:61 -> 62:10, #63
+Counter in file 0 62:10 -> 62:11, #64
+Counter in file 0 63:9 -> 63:23, #65
+Counter in file 0 65:9 -> 65:15, #66
+Counter in file 0 67:1 -> 67:2, #67
+Counter in file 0 67:1 -> 67:2, #68
+Emitting segments for file: ../coverage/various_conditions.rs
+Combined regions:
+  4:9 -> 4:26 (count=1)
+  5:8 -> 5:12 (count=1)
+  5:13 -> 7:6 (count=1)
+  10:9 -> 10:10 (count=1)
+  10:16 -> 10:29 (count=1)
+  11:9 -> 12:10 (count=1)
+  13:15 -> 13:28 (count=0)
+  14:12 -> 14:25 (count=0)
+  14:29 -> 14:42 (count=0)
+  14:42 -> 14:43 (count=0)
+  14:46 -> 14:60 (count=0)
+  14:60 -> 14:61 (count=0)
+  14:61 -> 16:10 (count=0)
+  16:10 -> 16:11 (count=0)
+  17:9 -> 18:18 (count=0)
+  20:9 -> 20:15 (count=0)
+  23:9 -> 23:26 (count=1)
+  24:8 -> 24:12 (count=1)
+  24:13 -> 26:6 (count=1)
+  28:8 -> 28:21 (count=1)
+  29:9 -> 29:23 (count=1)
+  30:15 -> 30:28 (count=0)
+  31:12 -> 31:25 (count=0)
+  31:29 -> 31:42 (count=0)
+  31:42 -> 31:43 (count=0)
+  31:46 -> 31:60 (count=0)
+  31:60 -> 31:61 (count=0)
+  31:61 -> 33:10 (count=0)
+  33:10 -> 33:11 (count=0)
+  34:9 -> 34:23 (count=0)
+  36:9 -> 36:15 (count=0)
+  39:9 -> 39:26 (count=1)
+  40:8 -> 40:12 (count=1)
+  40:13 -> 42:6 (count=1)
+  44:9 -> 44:10 (count=0)
+  44:16 -> 44:29 (count=1)
+  45:9 -> 45:23 (count=0)
+  46:15 -> 46:28 (count=1)
+  47:12 -> 47:25 (count=0)
+  47:29 -> 47:42 (count=0)
+  47:42 -> 47:43 (count=0)
+  47:46 -> 47:60 (count=0)
+  47:60 -> 47:61 (count=0)
+  47:61 -> 49:10 (count=0)
+  49:10 -> 49:11 (count=0)
+  50:9 -> 50:23 (count=0)
+  52:13 -> 54:15 (count=1)
+  57:9 -> 57:10 (count=0)
+  57:16 -> 57:29 (count=0)
+  58:9 -> 58:23 (count=0)
+  59:15 -> 59:28 (count=0)
+  60:12 -> 60:25 (count=0)
+  60:29 -> 60:42 (count=0)
+  60:42 -> 60:43 (count=0)
+  60:46 -> 60:60 (count=0)
+  60:60 -> 60:61 (count=0)
+  60:61 -> 62:10 (count=0)
+  62:10 -> 62:11 (count=0)
+  63:9 -> 63:23 (count=0)
+  65:9 -> 65:15 (count=0)
+  67:1 -> 67:2 (count=2)
+Segment at 4:9 (count = 1), RegionEntry
+Segment at 4:26 (count = 0), Skipped
+Segment at 5:8 (count = 1), RegionEntry
+Segment at 5:12 (count = 0), Skipped
+Segment at 5:13 (count = 1), RegionEntry
+Segment at 7:6 (count = 0), Skipped
+Segment at 10:9 (count = 1), RegionEntry
+Segment at 10:10 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 10:29 (count = 0), Skipped
+Segment at 11:9 (count = 1), RegionEntry
+Segment at 12:10 (count = 0), Skipped
+Segment at 13:15 (count = 0), RegionEntry
+Segment at 13:28 (count = 0), Skipped
+Segment at 14:12 (count = 0), RegionEntry
+Segment at 14:25 (count = 0), Skipped
+Segment at 14:29 (count = 0), RegionEntry
+Segment at 14:42 (count = 0), RegionEntry
+Segment at 14:43 (count = 0), Skipped
+Segment at 14:46 (count = 0), RegionEntry
+Segment at 14:60 (count = 0), RegionEntry
+Segment at 14:61 (count = 0), RegionEntry
+Segment at 16:10 (count = 0), RegionEntry
+Segment at 16:11 (count = 0), Skipped
+Segment at 17:9 (count = 0), RegionEntry
+Segment at 18:18 (count = 0), Skipped
+Segment at 20:9 (count = 0), RegionEntry
+Segment at 20:15 (count = 0), Skipped
+Segment at 23:9 (count = 1), RegionEntry
+Segment at 23:26 (count = 0), Skipped
+Segment at 24:8 (count = 1), RegionEntry
+Segment at 24:12 (count = 0), Skipped
+Segment at 24:13 (count = 1), RegionEntry
+Segment at 26:6 (count = 0), Skipped
+Segment at 28:8 (count = 1), RegionEntry
+Segment at 28:21 (count = 0), Skipped
+Segment at 29:9 (count = 1), RegionEntry
+Segment at 29:23 (count = 0), Skipped
+Segment at 30:15 (count = 0), RegionEntry
+Segment at 30:28 (count = 0), Skipped
+Segment at 31:12 (count = 0), RegionEntry
+Segment at 31:25 (count = 0), Skipped
+Segment at 31:29 (count = 0), RegionEntry
+Segment at 31:42 (count = 0), RegionEntry
+Segment at 31:43 (count = 0), Skipped
+Segment at 31:46 (count = 0), RegionEntry
+Segment at 31:60 (count = 0), RegionEntry
+Segment at 31:61 (count = 0), RegionEntry
+Segment at 33:10 (count = 0), RegionEntry
+Segment at 33:11 (count = 0), Skipped
+Segment at 34:9 (count = 0), RegionEntry
+Segment at 34:23 (count = 0), Skipped
+Segment at 36:9 (count = 0), RegionEntry
+Segment at 36:15 (count = 0), Skipped
+Segment at 39:9 (count = 1), RegionEntry
+Segment at 39:26 (count = 0), Skipped
+Segment at 40:8 (count = 1), RegionEntry
+Segment at 40:12 (count = 0), Skipped
+Segment at 40:13 (count = 1), RegionEntry
+Segment at 42:6 (count = 0), Skipped
+Segment at 44:9 (count = 0), RegionEntry
+Segment at 44:10 (count = 0), Skipped
+Segment at 44:16 (count = 1), RegionEntry
+Segment at 44:29 (count = 0), Skipped
+Segment at 45:9 (count = 0), RegionEntry
+Segment at 45:23 (count = 0), Skipped
+Segment at 46:15 (count = 1), RegionEntry
+Segment at 46:28 (count = 0), Skipped
+Segment at 47:12 (count = 0), RegionEntry
+Segment at 47:25 (count = 0), Skipped
+Segment at 47:29 (count = 0), RegionEntry
+Segment at 47:42 (count = 0), RegionEntry
+Segment at 47:43 (count = 0), Skipped
+Segment at 47:46 (count = 0), RegionEntry
+Segment at 47:60 (count = 0), RegionEntry
+Segment at 47:61 (count = 0), RegionEntry
+Segment at 49:10 (count = 0), RegionEntry
+Segment at 49:11 (count = 0), Skipped
+Segment at 50:9 (count = 0), RegionEntry
+Segment at 50:23 (count = 0), Skipped
+Segment at 52:13 (count = 1), RegionEntry
+Segment at 54:15 (count = 0), Skipped
+Segment at 57:9 (count = 0), RegionEntry
+Segment at 57:10 (count = 0), Skipped
+Segment at 57:16 (count = 0), RegionEntry
+Segment at 57:29 (count = 0), Skipped
+Segment at 58:9 (count = 0), RegionEntry
+Segment at 58:23 (count = 0), Skipped
+Segment at 59:15 (count = 0), RegionEntry
+Segment at 59:28 (count = 0), Skipped
+Segment at 60:12 (count = 0), RegionEntry
+Segment at 60:25 (count = 0), Skipped
+Segment at 60:29 (count = 0), RegionEntry
+Segment at 60:42 (count = 0), RegionEntry
+Segment at 60:43 (count = 0), Skipped
+Segment at 60:46 (count = 0), RegionEntry
+Segment at 60:60 (count = 0), RegionEntry
+Segment at 60:61 (count = 0), RegionEntry
+Segment at 62:10 (count = 0), RegionEntry
+Segment at 62:11 (count = 0), Skipped
+Segment at 63:9 (count = 0), RegionEntry
+Segment at 63:23 (count = 0), Skipped
+Segment at 65:9 (count = 0), RegionEntry
+Segment at 65:15 (count = 0), Skipped
+Segment at 67:1 (count = 2), RegionEntry
+Segment at 67:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt
new file mode 100644
index 00000000000..52c809b5325
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while.txt
@@ -0,0 +1,22 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while 
+Counter in file 0 2:9 -> 2:16, #1
+Counter in file 0 3:11 -> 3:20, #2
+Counter in file 0 3:21 -> 4:6, #3
+Counter in file 0 4:6 -> 4:7, (#3 + 0)
+Counter in file 0 5:1 -> 5:2, #4
+Emitting segments for file: ../coverage/while.rs
+Combined regions:
+  2:9 -> 2:16 (count=1)
+  3:11 -> 3:20 (count=1)
+  3:21 -> 4:6 (count=0)
+  4:6 -> 4:7 (count=0)
+  5:1 -> 5:2 (count=1)
+Segment at 2:9 (count = 1), RegionEntry
+Segment at 2:16 (count = 0), Skipped
+Segment at 3:11 (count = 1), RegionEntry
+Segment at 3:20 (count = 0), Skipped
+Segment at 3:21 (count = 0), RegionEntry
+Segment at 4:6 (count = 0), RegionEntry
+Segment at 4:7 (count = 0), Skipped
+Segment at 5:1 (count = 1), RegionEntry
+Segment at 5:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt
new file mode 100644
index 00000000000..30d14f4f987
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage_counters.while_early_return.txt
@@ -0,0 +1,44 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while_early_return.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-base/coverage-reports-base/while_early_return 
+Counter in file 0 5:9 -> 5:27, #1
+Counter in file 0 7:9 -> 9:10, #2
+Counter in file 0 12:13 -> 14:14, #3
+Counter in file 0 18:21 -> 20:22, #4
+Counter in file 0 22:21 -> 22:27, #5
+Counter in file 0 26:21 -> 26:27, #6
+Counter in file 0 27:18 -> 27:19, (#5 + 0)
+Counter in file 0 30:9 -> 32:10, #7
+Counter in file 0 35:5 -> 35:11, #8
+Counter in file 0 36:1 -> 36:2, #9
+Counter in file 0 36:1 -> 36:2, #10
+Emitting segments for file: ../coverage/while_early_return.rs
+Combined regions:
+  5:9 -> 5:27 (count=1)
+  7:9 -> 9:10 (count=7)
+  12:13 -> 14:14 (count=7)
+  18:21 -> 20:22 (count=1)
+  22:21 -> 22:27 (count=0)
+  26:21 -> 26:27 (count=1)
+  27:18 -> 27:19 (count=0)
+  30:9 -> 32:10 (count=6)
+  35:5 -> 35:11 (count=0)
+  36:1 -> 36:2 (count=2)
+Segment at 5:9 (count = 1), RegionEntry
+Segment at 5:27 (count = 0), Skipped
+Segment at 7:9 (count = 7), RegionEntry
+Segment at 9:10 (count = 0), Skipped
+Segment at 12:13 (count = 7), RegionEntry
+Segment at 14:14 (count = 0), Skipped
+Segment at 18:21 (count = 1), RegionEntry
+Segment at 20:22 (count = 0), Skipped
+Segment at 22:21 (count = 0), RegionEntry
+Segment at 22:27 (count = 0), Skipped
+Segment at 26:21 (count = 1), RegionEntry
+Segment at 26:27 (count = 0), Skipped
+Segment at 27:18 (count = 0), RegionEntry
+Segment at 27:19 (count = 0), Skipped
+Segment at 30:9 (count = 6), RegionEntry
+Segment at 32:10 (count = 0), Skipped
+Segment at 35:5 (count = 0), RegionEntry
+Segment at 35:11 (count = 0), Skipped
+Segment at 36:1 (count = 2), RegionEntry
+Segment at 36:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json
index 8c6edae2803..bff55300b3c 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json
@@ -17,14 +17,14 @@
             },
             "lines": {
               "count": 91,
-              "covered": 75,
-              "percent": 82.41758241758241
+              "covered": 77,
+              "percent": 84.61538461538461
             },
             "regions": {
-              "count": 21,
-              "covered": 11,
-              "notcovered": 10,
-              "percent": 52.38095238095239
+              "count": 25,
+              "covered": 13,
+              "notcovered": 12,
+              "percent": 52
             }
           }
         }
@@ -42,14 +42,14 @@
         },
         "lines": {
           "count": 91,
-          "covered": 75,
-          "percent": 82.41758241758241
+          "covered": 77,
+          "percent": 84.61538461538461
         },
         "regions": {
-          "count": 21,
-          "covered": 11,
-          "notcovered": 10,
-          "percent": 52.38095238095239
+          "count": 25,
+          "covered": 13,
+          "notcovered": 12,
+          "percent": 52
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json
index bd2e2d56d4a..7a7e4c04f00 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json
@@ -21,8 +21,8 @@
               "percent": 100
             },
             "regions": {
-              "count": 5,
-              "covered": 5,
+              "count": 6,
+              "covered": 6,
               "notcovered": 0,
               "percent": 100
             }
@@ -46,8 +46,8 @@
           "percent": 100
         },
         "regions": {
-          "count": 5,
-          "covered": 5,
+          "count": 6,
+          "covered": 6,
           "notcovered": 0,
           "percent": 100
         }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json
index a50f4657e20..1025cd3de80 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json
@@ -21,8 +21,8 @@
               "percent": 100
             },
             "regions": {
-              "count": 6,
-              "covered": 6,
+              "count": 7,
+              "covered": 7,
               "notcovered": 0,
               "percent": 100
             }
@@ -46,8 +46,8 @@
           "percent": 100
         },
         "regions": {
-          "count": 6,
-          "covered": 6,
+          "count": 7,
+          "covered": 7,
           "notcovered": 0,
           "percent": 100
         }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json
index 2ff53ad33fa..84dcc251f3f 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json
@@ -21,10 +21,10 @@
               "percent": 100
             },
             "regions": {
-              "count": 4,
+              "count": 5,
               "covered": 4,
-              "notcovered": 0,
-              "percent": 100
+              "notcovered": 1,
+              "percent": 80
             }
           }
         }
@@ -46,10 +46,10 @@
           "percent": 100
         },
         "regions": {
-          "count": 4,
+          "count": 5,
           "covered": 4,
-          "notcovered": 0,
-          "percent": 100
+          "notcovered": 1,
+          "percent": 80
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json
index 36f81ceae19..2d2ad1dbe3f 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 28,
-              "covered": 19,
-              "percent": 67.85714285714286
+              "count": 29,
+              "covered": 21,
+              "percent": 72.41379310344827
             },
             "regions": {
-              "count": 7,
-              "covered": 5,
+              "count": 9,
+              "covered": 7,
               "notcovered": 2,
-              "percent": 71.42857142857143
+              "percent": 77.77777777777779
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 28,
-          "covered": 19,
-          "percent": 67.85714285714286
+          "count": 29,
+          "covered": 21,
+          "percent": 72.41379310344827
         },
         "regions": {
-          "count": 7,
-          "covered": 5,
+          "count": 9,
+          "covered": 7,
           "notcovered": 2,
-          "percent": 71.42857142857143
+          "percent": 77.77777777777779
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json
index a24e6a33a33..c178e7f9347 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json
@@ -21,10 +21,10 @@
               "percent": 100
             },
             "regions": {
-              "count": 13,
+              "count": 15,
               "covered": 13,
-              "notcovered": 0,
-              "percent": 100
+              "notcovered": 2,
+              "percent": 86.66666666666667
             }
           }
         }
@@ -46,10 +46,10 @@
           "percent": 100
         },
         "regions": {
-          "count": 13,
+          "count": 15,
           "covered": 13,
-          "notcovered": 0,
-          "percent": 100
+          "notcovered": 2,
+          "percent": 86.66666666666667
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json
index 585346dc32a..95a1dcd3b8e 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 21,
-              "covered": 19,
-              "percent": 90.47619047619048
+              "count": 40,
+              "covered": 32,
+              "percent": 80
             },
             "regions": {
-              "count": 16,
-              "covered": 14,
-              "notcovered": 2,
-              "percent": 87.5
+              "count": 39,
+              "covered": 28,
+              "notcovered": 11,
+              "percent": 71.7948717948718
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 21,
-          "covered": 19,
-          "percent": 90.47619047619048
+          "count": 40,
+          "covered": 32,
+          "percent": 80
         },
         "regions": {
-          "count": 16,
-          "covered": 14,
-          "notcovered": 2,
-          "percent": 87.5
+          "count": 39,
+          "covered": 28,
+          "notcovered": 11,
+          "percent": 71.7948717948718
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loops_and_branches.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loops_and_branches.json
new file mode 100644
index 00000000000..aec85cd0329
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loops_and_branches.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/loops_and_branches.rs",
+          "summary": {
+            "functions": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "lines": {
+              "count": 11,
+              "covered": 11,
+              "percent": 100
+            },
+            "regions": {
+              "count": 10,
+              "covered": 8,
+              "notcovered": 2,
+              "percent": 80
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "lines": {
+          "count": 11,
+          "covered": 11,
+          "percent": 100
+        },
+        "regions": {
+          "count": 10,
+          "covered": 8,
+          "notcovered": 2,
+          "percent": 80
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.nested_loops.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.nested_loops.json
new file mode 100644
index 00000000000..dbe4f9ca6fd
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.nested_loops.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/nested_loops.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 21,
+              "covered": 17,
+              "percent": 80.95238095238095
+            },
+            "regions": {
+              "count": 20,
+              "covered": 16,
+              "notcovered": 4,
+              "percent": 80
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 21,
+          "covered": 17,
+          "percent": 80.95238095238095
+        },
+        "regions": {
+          "count": 20,
+          "covered": 16,
+          "notcovered": 4,
+          "percent": 80
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.partial_eq_counter_without_region.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.partial_eq_counter_without_region.json
new file mode 100644
index 00000000000..779bfe9904c
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.partial_eq_counter_without_region.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/partial_eq_counter_without_region.rs",
+          "summary": {
+            "functions": {
+              "count": 5,
+              "covered": 5,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 8,
+              "covered": 5,
+              "percent": 62.5
+            },
+            "lines": {
+              "count": 15,
+              "covered": 15,
+              "percent": 100
+            },
+            "regions": {
+              "count": 6,
+              "covered": 6,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 5,
+          "covered": 5,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 8,
+          "covered": 5,
+          "percent": 62.5
+        },
+        "lines": {
+          "count": 15,
+          "covered": 15,
+          "percent": 100
+        },
+        "regions": {
+          "count": 6,
+          "covered": 6,
+          "notcovered": 0,
+          "percent": 100
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json
index 38bc96898ea..ada6bb062dd 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 18,
-              "covered": 18,
+              "count": 19,
+              "covered": 19,
               "percent": 100
             },
             "regions": {
-              "count": 7,
-              "covered": 7,
-              "notcovered": 0,
-              "percent": 100
+              "count": 9,
+              "covered": 8,
+              "notcovered": 1,
+              "percent": 88.88888888888889
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 18,
-          "covered": 18,
+          "count": 19,
+          "covered": 19,
           "percent": 100
         },
         "regions": {
-          "count": 7,
-          "covered": 7,
-          "notcovered": 0,
-          "percent": 100
+          "count": 9,
+          "covered": 8,
+          "notcovered": 1,
+          "percent": 88.88888888888889
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json
index f9d91d66f1d..63d1ae74c5f 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 26,
-              "covered": 26,
+              "count": 24,
+              "covered": 24,
               "percent": 100
             },
             "regions": {
-              "count": 9,
-              "covered": 9,
-              "notcovered": 0,
-              "percent": 100
+              "count": 15,
+              "covered": 14,
+              "notcovered": 1,
+              "percent": 93.33333333333333
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 26,
-          "covered": 26,
+          "count": 24,
+          "covered": 24,
           "percent": 100
         },
         "regions": {
-          "count": 9,
-          "covered": 9,
-          "notcovered": 0,
-          "percent": 100
+          "count": 15,
+          "covered": 14,
+          "notcovered": 1,
+          "percent": 93.33333333333333
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.tight_infinite_loop.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.tight_infinite_loop.json
new file mode 100644
index 00000000000..3fa6821cd1d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.tight_infinite_loop.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/tight_infinite_loop.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "regions": {
+              "count": 2,
+              "covered": 2,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "regions": {
+          "count": 2,
+          "covered": 2,
+          "notcovered": 0,
+          "percent": 100
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json
index e6ef2c1ab89..e845ee29fa4 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 16,
-              "covered": 15,
-              "percent": 93.75
+              "count": 20,
+              "covered": 19,
+              "percent": 95
             },
             "regions": {
-              "count": 13,
-              "covered": 12,
-              "notcovered": 1,
-              "percent": 92.3076923076923
+              "count": 20,
+              "covered": 17,
+              "notcovered": 3,
+              "percent": 85
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 16,
-          "covered": 15,
-          "percent": 93.75
+          "count": 20,
+          "covered": 19,
+          "percent": 95
         },
         "regions": {
-          "count": 13,
-          "covered": 12,
-          "notcovered": 1,
-          "percent": 92.3076923076923
+          "count": 20,
+          "covered": 17,
+          "notcovered": 3,
+          "percent": 85
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json
index 410821ea335..464bb614ea1 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json
@@ -21,10 +21,10 @@
               "percent": 46.93877551020408
             },
             "regions": {
-              "count": 51,
+              "count": 70,
               "covered": 19,
-              "notcovered": 32,
-              "percent": 37.254901960784316
+              "notcovered": 51,
+              "percent": 27.142857142857142
             }
           }
         }
@@ -46,10 +46,10 @@
           "percent": 46.93877551020408
         },
         "regions": {
-          "count": 51,
+          "count": 70,
           "covered": 19,
-          "notcovered": 32,
-          "percent": 37.254901960784316
+          "notcovered": 51,
+          "percent": 27.142857142857142
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while.json
new file mode 100644
index 00000000000..27862087ed5
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/while.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 4,
+              "covered": 3,
+              "percent": 75
+            },
+            "regions": {
+              "count": 5,
+              "covered": 3,
+              "notcovered": 2,
+              "percent": 60
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 4,
+          "covered": 3,
+          "percent": 75
+        },
+        "regions": {
+          "count": 5,
+          "covered": 3,
+          "notcovered": 2,
+          "percent": 60
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json
index 865b705fa20..555ac745d53 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json
@@ -17,14 +17,14 @@
             },
             "lines": {
               "count": 18,
-              "covered": 16,
-              "percent": 88.88888888888889
+              "covered": 15,
+              "percent": 83.33333333333334
             },
             "regions": {
-              "count": 9,
-              "covered": 7,
-              "notcovered": 2,
-              "percent": 77.77777777777779
+              "count": 11,
+              "covered": 8,
+              "notcovered": 3,
+              "percent": 72.72727272727273
             }
           }
         }
@@ -42,14 +42,14 @@
         },
         "lines": {
           "count": 18,
-          "covered": 16,
-          "percent": 88.88888888888889
+          "covered": 15,
+          "percent": 83.33333333333334
         },
         "regions": {
-          "count": 9,
-          "covered": 7,
-          "notcovered": 2,
-          "percent": 77.77777777777779
+          "count": 11,
+          "covered": 8,
+          "notcovered": 3,
+          "percent": 72.72727272727273
         }
       }
     }
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt
index 17054490e9b..aef26a62e25 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt
@@ -62,7 +62,7 @@
    62|      1|                let mut countdown = 0;
    63|      1|                if is_false {
    64|      0|                    countdown = 10;
-   65|      0|                }
+   65|      1|                }
    66|      1|                "alt string 3".to_owned()
    67|      1|            }
    68|      1|        )
@@ -77,7 +77,7 @@
    77|      1|        let mut countdown = 0;
    78|      1|        if is_false {
    79|      0|            countdown = 10;
-   80|      0|        }
+   80|      1|        }
    81|      1|        "alt string 4".to_owned()
    82|      1|    };
    83|      1|    println!(
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt
index 72aa020ca16..43592df1059 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt
@@ -24,7 +24,7 @@
    24|       |    let _ = Firework { strength: 1000 };
    25|       |
    26|       |    Ok(())
-   27|      1|}
+   27|      2|}
    28|       |
    29|       |// Expected program output:
    30|       |//   Exiting with error...
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt
index 86199d74763..11dc0aa65e2 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt
@@ -57,7 +57,7 @@
    35|       |    let _ = Firework { strength: 1000 };
    36|       |
    37|       |    Ok(())
-   38|      1|}
+   38|      2|}
    39|       |
    40|       |// Expected program output:
    41|       |//   Exiting with error...
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt
index bc2f9b108b2..85e6440ab37 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt
@@ -25,5 +25,6 @@
    25|      1|            10
    26|      1|        ;
    27|      1|    }
+                   ^0
    28|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt
index 5f899723e25..64cbc262521 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt
@@ -20,7 +20,7 @@
    20|      0|        countdown
    21|      0|        =
    22|      0|            100
-   23|       |    }
+   23|      1|    }
    24|       |
    25|       |    if
    26|      1|        is_true
@@ -36,6 +36,6 @@
    36|      0|        =
    37|      0|            100
    38|      0|        ;
-   39|      0|    }
+   39|      1|    }
    40|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt
index b13ca83d018..4a51f842a4b 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt
@@ -10,6 +10,7 @@
    10|      1|    if is_true {
    11|      1|        countdown = 10;
    12|      1|    }
+                   ^0
    13|       |
    14|       |    mod in_mod {
    15|       |        const IN_MOD_CONST: u32 = 1000;
@@ -48,6 +49,7 @@
    48|      1|    if is_true {
    49|      1|        in_func(countdown);
    50|      1|    }
+                   ^0
    51|       |
    52|      1|    let mut val = InStruct {
    53|      1|        in_struct_field: 101,
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt
index ded43697515..f01f69f2496 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt
@@ -12,12 +12,14 @@
    12|      1|        b = 10;
    13|      1|        c = 100;
    14|      1|    }
+                   ^0
    15|       |    let
    16|      1|        somebool
    17|       |        =
    18|      1|            a < b
    19|       |        ||
-   20|      0|            b < c
+   20|      1|            b < c
+                          ^0
    21|       |    ;
    22|       |    let
    23|      1|        somebool
@@ -26,19 +28,38 @@
    26|       |        ||
    27|      1|            b < c
    28|       |    ;
-   29|       |    let
-   30|      1|        somebool
-   31|       |        =
-   32|      1|            a < b
-   33|       |        &&
-   34|      1|            b < c
-   35|       |    ;
-   36|       |    let
-   37|      1|        somebool
-   38|       |        =
-   39|      1|            b < a
-   40|       |        &&
-   41|      0|            b < c
-   42|       |    ;
-   43|      1|}
+   29|      1|    let somebool = a < b && b < c;
+   30|      1|    let somebool = b < a && b < c;
+                                          ^0
+   31|       |
+   32|       |    if
+   33|      1|        !
+   34|      1|        is_true
+   35|      0|    {
+   36|      0|        a = 2
+   37|      0|        ;
+   38|      1|    }
+   39|       |
+   40|       |    if
+   41|      1|        is_true
+   42|      1|    {
+   43|      1|        b = 30
+   44|      1|        ;
+   45|      1|    }
+   46|       |    else
+   47|      0|    {
+   48|      0|        c = 400
+   49|      0|        ;
+   50|      1|    }
+   51|       |
+   52|      1|    if !is_true {
+   53|      0|        a = 2;
+   54|      1|    }
+   55|       |
+   56|      1|    if is_true {
+   57|      1|        b = 30;
+   58|      1|    } else {
+   59|      0|        c = 400;
+   60|      1|    }
+   61|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loops_and_branches.txt
new file mode 100644
index 00000000000..3a969a6b898
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loops_and_branches.txt
@@ -0,0 +1,38 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
+    4|       |// structure of this `fmt` function.
+    5|       |
+    6|       |struct DebugTest;
+    7|       |
+    8|       |impl std::fmt::Debug for DebugTest {
+    9|       |    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+   10|      1|        if true {
+   11|      1|            if false {
+   12|       |                while true {
+   13|       |                }
+   14|      1|            }
+   15|      1|            write!(f, "error")?;
+                                            ^0
+   16|       |        } else {
+   17|      1|        }
+   18|      1|        Ok(())
+   19|      1|    }
+   20|       |}
+   21|       |
+   22|      1|fn main() {
+   23|      1|    let debug_test = DebugTest;
+   24|      1|    println!("{:?}", debug_test);
+   25|      1|}
+   26|       |
+   27|       |/*
+   28|       |
+   29|       |This is the error message generated, before the issue was fixed:
+   30|       |
+   31|       |error: internal compiler error: compiler/rustc_mir/src/transform/coverage/mod.rs:374:42:
+   32|       |Error processing: DefId(0:6 ~ bug_incomplete_cov_graph_traversal_simplified[317d]::{impl#0}::fmt):
+   33|       |Error { message: "`TraverseCoverageGraphWithLoops` missed some `BasicCoverageBlock`s:
+   34|       |[bcb6, bcb7, bcb9]" }
+   35|       |
+   36|       |*/
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.nested_loops.txt
new file mode 100644
index 00000000000..e0545c76f78
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.nested_loops.txt
@@ -0,0 +1,26 @@
+    1|       |fn main() {
+    2|      1|    let is_true = std::env::args().len() == 1;
+    3|      1|    let mut countdown = 10;
+    4|       |
+    5|      1|    'outer: while countdown > 0 {
+    6|      1|        let mut a = 100;
+    7|      1|        let mut b = 100;
+    8|      3|        for _ in 0..50 {
+    9|      3|            if a < 30 {
+   10|      0|                break;
+   11|       |            }
+   12|      3|            a -= 5;
+   13|      3|            b -= 5;
+   14|      3|            if b < 90 {
+   15|      1|                a -= 10;
+   16|      1|                if is_true {
+   17|      1|                    break 'outer;
+   18|       |                } else {
+   19|      0|                    a -= 2;
+   20|      0|                }
+   21|      2|            }
+   22|      3|        }
+   23|      0|        countdown -= 1;
+   24|      1|    }
+   25|      1|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.partial_eq_counter_without_region.txt
new file mode 100644
index 00000000000..e7e4dfb5a86
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.partial_eq_counter_without_region.txt
@@ -0,0 +1,111 @@
+    1|       |// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
+    2|       |// structure of this test.
+    3|       |
+    4|      2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+                                                    ^1       ^1
+  ------------------
+  | Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::gt
+  ------------------
+  | Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::le
+  ------------------
+  | Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::ge
+  ------------------
+  | <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::lt:
+  |    4|      1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+  ------------------
+    5|       |pub struct Version {
+    6|       |    major: usize,
+    7|      1|    minor: usize,
+    8|       |    patch: usize,
+    9|       |}
+   10|       |
+   11|       |impl Version {
+   12|       |    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
+   13|      2|        Self {
+   14|      2|            major,
+   15|      2|            minor,
+   16|      2|            patch,
+   17|      2|        }
+   18|      2|    }
+   19|       |}
+   20|       |
+   21|      1|fn main() {
+   22|      1|    let version_3_2_1 = Version::new(3, 2, 1);
+   23|      1|    let version_3_3_0 = Version::new(3, 3, 0);
+   24|      1|
+   25|      1|    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0);
+   26|      1|}
+   27|       |
+   28|       |/*
+   29|       |
+   30|       |This test verifies a bug was fixed that otherwise generated this error:
+   31|       |
+   32|       |thread 'rustc' panicked at 'No counters provided the source_hash for function:
+   33|       |    Instance {
+   34|       |        def: Item(WithOptConstParam {
+   35|       |            did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp),
+   36|       |            const_param_did: None
+   37|       |        }),
+   38|       |        substs: []
+   39|       |    }'
+   40|       |The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage
+   41|       |without a code region associated with any `Counter`. Code regions were associated with at least
+   42|       |one expression, which is allowed, but the `function_source_hash` was only passed to the codegen
+   43|       |(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the
+   44|       |`function_source_hash` without a code region, if necessary.
+   45|       |
+   46|       |*/
+   47|       |
+   48|       |// FIXME(richkadel): It may be worth investigating why the coverage report for this test produces
+   49|       |// the following results:
+   50|       |
+   51|       |/*
+   52|       |
+   53|       |1. Why are their two counts below different characters (first and last) of `PartialOrd`, on line 17?
+   54|       |
+   55|       |2. Line 17 is counted twice, but the `::lt` instance shows a line count of 1? Is there a missing
+   56|       |   line count with a different instance? Or was it really only called once?
+   57|       |
+   58|       |3. Line 20 shows another line count (of 1) for a line within a `struct` declaration (on only one of
+   59|       |   its 3 fields). I doubt the specific field (`minor`) is relevant, but rather I suspect there's a
+   60|       |   problem computing the file position here, for some reason.
+   61|       |
+   62|       |<snip>
+   63|       |   16|       |
+   64|       |   17|      2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+   65|       |                                                    ^1       ^1
+   66|       |------------------
+   67|       ||Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::gt
+   68|       |------------------
+   69|       ||Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::le
+   70|       |------------------
+   71|       ||Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::ge
+   72|       |------------------
+   73|       ||<partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::lt:
+   74|       ||  17|      1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+   75|       |------------------
+   76|       |   18|       |pub struct Version {
+   77|       |   19|       |    major: usize,
+   78|       |   20|      1|    minor: usize,
+   79|       |   21|       |    patch: usize,
+   80|       |   22|       |}
+   81|       |   23|       |
+   82|       |   24|       |impl Version {
+   83|       |   25|       |    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
+   84|       |   26|      2|        Version {
+   85|       |   27|      2|            major,
+   86|       |   28|      2|            minor,
+   87|       |   29|      2|            patch,
+   88|       |   30|      2|        }
+   89|       |   31|      2|    }
+   90|       |   32|       |}
+   91|       |   33|       |
+   92|       |   34|      1|fn main() {
+   93|       |   35|      1|    let version_3_2_1 = Version::new(3, 2, 1);
+   94|       |   36|      1|    let version_3_3_0 = Version::new(3, 3, 0);
+   95|       |   37|      1|
+   96|       |   38|      1|    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version
+   97|       |_3_3_0);
+   98|       |   39|      1|}
+   99|       |*/
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt
index f1acb7c5459..064930dd75c 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt
@@ -16,6 +16,7 @@
    16|      1|            10
    17|      1|        ;
    18|      1|    }
+                   ^0
    19|       |
    20|       |    loop
    21|       |    {
@@ -31,6 +32,6 @@
    31|     10|        -=
    32|     10|        1
    33|       |        ;
-   34|       |    }
+   34|      1|    }
    35|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt
index e42f22cd047..1f7e71d3eb0 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt
@@ -10,22 +10,24 @@
    10|      1|    if is_true {
    11|      1|        countdown = 0;
    12|      1|    }
+                   ^0
    13|       |
-   14|      3|    for
-   15|      3|        _
+   14|       |    for
+   15|      2|        _
    16|       |    in
-   17|      1|        0..2
+   17|      3|        0..2
    18|       |    {
    19|       |        let z
    20|       |        ;
    21|       |        match
    22|      2|            countdown
-   23|      2|        {
-   24|      2|            x
-   25|      2|            if
+   23|       |        {
+   24|      1|            x
+   25|       |            if
    26|      2|                x
    27|      2|                    <
    28|      2|                1
+                               ^1
    29|       |            =>
    30|      1|            {
    31|      1|                z = countdown
@@ -39,6 +41,6 @@
    39|       |            =>
    40|      1|            {}
    41|       |        }
-   42|       |    }
+   42|      3|    }
    43|      1|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.tight_infinite_loop.txt
new file mode 100644
index 00000000000..e02eac03a6b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.tight_infinite_loop.txt
@@ -0,0 +1,6 @@
+    1|       |fn main() {
+    2|      1|    if false {
+    3|       |        loop {}
+    4|       |    }
+    5|      1|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt
index ae288d7d7a0..05d72d0de46 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt
@@ -6,22 +6,22 @@
     6|      1|        Err(())
     7|       |    } else {
     8|      5|        Ok(())
-    9|       |    }
+    9|      1|    }
    10|      6|}
    11|       |
    12|       |fn main() -> Result<(),()> {
    13|      1|    let mut
    14|      1|        countdown = 10
    15|       |    ;
-   16|      6|    for
+   16|       |    for
    17|      6|        _
    18|       |    in
-   19|      1|        0..10
+   19|      6|        0..10
    20|       |    {
    21|      6|        countdown
    22|      6|            -= 1
-   23|       |        ;
-   24|       |        if
+   23|      6|        ;
+   24|      6|        if
    25|      6|            countdown < 5
    26|       |        {
    27|      1|            call(/*return_error=*/ true)?;
@@ -29,8 +29,9 @@
    29|       |        else
    30|       |        {
    31|      5|            call(/*return_error=*/ false)?;
-   32|       |        }
-   33|       |    }
+                                                       ^0
+   32|      5|        }
+   33|      6|    }
    34|      0|    Ok(())
-   35|      1|}
+   35|      2|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt
index 173ff4aa4c4..e0efe75043d 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt
@@ -65,5 +65,5 @@
    64|       |    } else {
    65|      0|        return;
    66|       |    };
-   67|      1|}
+   67|      2|}
 
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while.txt
new file mode 100644
index 00000000000..194325b6b9e
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while.txt
@@ -0,0 +1,6 @@
+    1|       |fn main() {
+    2|      1|    let num = 9;
+    3|      1|    while num >= 10 {
+    4|      0|    }
+    5|      1|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt
index 7dce94f25f3..2e0c4022bed 100644
--- a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt
@@ -3,7 +3,7 @@
     3|       |
     4|       |fn main() -> Result<(),u8> {
     5|      1|    let mut countdown = 10;
-    6|      7|    while
+    6|       |    while
     7|      7|        countdown
     8|      7|            >
     9|      7|        0
@@ -24,7 +24,7 @@
    24|       |                else
    25|       |                {
    26|      1|                    Err(1)
-   27|       |                }
+   27|      0|                }
    28|       |                ;
    29|       |        }
    30|      6|        countdown
@@ -33,7 +33,7 @@
    33|       |        ;
    34|       |    }
    35|      0|    Ok(())
-   36|      1|}
+   36|      2|}
    37|       |
    38|       |// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and
    39|       |// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt
new file mode 100644
index 00000000000..39bf7bad9a1
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.closure.txt
@@ -0,0 +1,95 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/closure.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/closure 
+Counter in file 0 20:21 -> 20:38, #1
+Counter in file 0 21:20 -> 21:28, (#1 + 0)
+Counter in file 0 21:29 -> 23:18, #2
+Counter in file 0 23:18 -> 23:19, #3
+Counter in file 0 24:17 -> 25:14, #4
+Counter in file 0 3:11 -> 18:13, #1
+Counter in file 0 25:14 -> 33:9, (#1 + 0)
+Counter in file 0 40:6 -> 60:13, (#1 + 0)
+Counter in file 0 67:14 -> 75:9, (#1 + 0)
+Counter in file 0 82:6 -> 93:2, (#1 + 0)
+Counter in file 0 77:13 -> 77:30, #1
+Counter in file 0 78:12 -> 78:20, (#1 + 0)
+Counter in file 0 78:21 -> 80:10, #2
+Counter in file 0 80:10 -> 80:11, #3
+Counter in file 0 81:9 -> 82:6, #4
+Counter in file 0 62:21 -> 62:38, #1
+Counter in file 0 63:20 -> 63:28, (#1 + 0)
+Counter in file 0 63:29 -> 65:18, #2
+Counter in file 0 65:18 -> 65:19, #3
+Counter in file 0 66:17 -> 67:14, #4
+Counter in file 0 35:13 -> 35:30, #1
+Counter in file 0 36:12 -> 36:20, (#1 + 0)
+Counter in file 0 36:21 -> 38:10, #2
+Counter in file 0 38:10 -> 38:11, #3
+Counter in file 0 39:9 -> 40:6, #4
+Emitting segments for file: ../coverage/closure.rs
+Combined regions:
+  3:11 -> 18:13 (count=1)
+  20:21 -> 20:38 (count=0)
+  21:20 -> 21:28 (count=0)
+  21:29 -> 23:18 (count=0)
+  23:18 -> 23:19 (count=0)
+  24:17 -> 25:14 (count=0)
+  25:14 -> 33:9 (count=1)
+  35:13 -> 35:30 (count=0)
+  36:12 -> 36:20 (count=0)
+  36:21 -> 38:10 (count=0)
+  38:10 -> 38:11 (count=0)
+  39:9 -> 40:6 (count=0)
+  40:6 -> 60:13 (count=1)
+  62:21 -> 62:38 (count=1)
+  63:20 -> 63:28 (count=1)
+  63:29 -> 65:18 (count=0)
+  65:18 -> 65:19 (count=1)
+  66:17 -> 67:14 (count=1)
+  67:14 -> 75:9 (count=1)
+  77:13 -> 77:30 (count=1)
+  78:12 -> 78:20 (count=1)
+  78:21 -> 80:10 (count=0)
+  80:10 -> 80:11 (count=1)
+  81:9 -> 82:6 (count=1)
+  82:6 -> 93:2 (count=1)
+Segment at 3:11 (count = 1), RegionEntry
+Segment at 18:13 (count = 0), Skipped
+Segment at 20:21 (count = 0), RegionEntry
+Segment at 20:38 (count = 0), Skipped
+Segment at 21:20 (count = 0), RegionEntry
+Segment at 21:28 (count = 0), Skipped
+Segment at 21:29 (count = 0), RegionEntry
+Segment at 23:18 (count = 0), RegionEntry
+Segment at 23:19 (count = 0), Skipped
+Segment at 24:17 (count = 0), RegionEntry
+Segment at 25:14 (count = 1), RegionEntry
+Segment at 33:9 (count = 0), Skipped
+Segment at 35:13 (count = 0), RegionEntry
+Segment at 35:30 (count = 0), Skipped
+Segment at 36:12 (count = 0), RegionEntry
+Segment at 36:20 (count = 0), Skipped
+Segment at 36:21 (count = 0), RegionEntry
+Segment at 38:10 (count = 0), RegionEntry
+Segment at 38:11 (count = 0), Skipped
+Segment at 39:9 (count = 0), RegionEntry
+Segment at 40:6 (count = 1), RegionEntry
+Segment at 60:13 (count = 0), Skipped
+Segment at 62:21 (count = 1), RegionEntry
+Segment at 62:38 (count = 0), Skipped
+Segment at 63:20 (count = 1), RegionEntry
+Segment at 63:28 (count = 0), Skipped
+Segment at 63:29 (count = 0), RegionEntry
+Segment at 65:18 (count = 1), RegionEntry
+Segment at 65:19 (count = 0), Skipped
+Segment at 66:17 (count = 1), RegionEntry
+Segment at 67:14 (count = 1), RegionEntry
+Segment at 75:9 (count = 0), Skipped
+Segment at 77:13 (count = 1), RegionEntry
+Segment at 77:30 (count = 0), Skipped
+Segment at 78:12 (count = 1), RegionEntry
+Segment at 78:20 (count = 0), Skipped
+Segment at 78:21 (count = 0), RegionEntry
+Segment at 80:10 (count = 1), RegionEntry
+Segment at 80:11 (count = 0), Skipped
+Segment at 81:9 (count = 1), RegionEntry
+Segment at 82:6 (count = 1), RegionEntry
+Segment at 93:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt
new file mode 100644
index 00000000000..e416a84820a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.drop_trait.txt
@@ -0,0 +1,24 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/drop_trait.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/drop_trait 
+Counter in file 0 9:24 -> 11:6, #1
+Counter in file 0 15:9 -> 17:42, #1
+Counter in file 0 19:8 -> 19:12, (#1 + 0)
+Counter in file 0 20:9 -> 21:22, #2
+Counter in file 0 27:1 -> 27:2, #4
+Counter in file 0 27:1 -> 27:2, (#2 + 0)
+Emitting segments for file: ../coverage/drop_trait.rs
+Combined regions:
+  9:24 -> 11:6 (count=2)
+  15:9 -> 17:42 (count=1)
+  19:8 -> 19:12 (count=1)
+  20:9 -> 21:22 (count=1)
+  27:1 -> 27:2 (count=2)
+Segment at 9:24 (count = 2), RegionEntry
+Segment at 11:6 (count = 0), Skipped
+Segment at 15:9 (count = 1), RegionEntry
+Segment at 17:42 (count = 0), Skipped
+Segment at 19:8 (count = 1), RegionEntry
+Segment at 19:12 (count = 0), Skipped
+Segment at 20:9 (count = 1), RegionEntry
+Segment at 21:22 (count = 0), Skipped
+Segment at 27:1 (count = 2), RegionEntry
+Segment at 27:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt
new file mode 100644
index 00000000000..9e33b48fc29
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.generics.txt
@@ -0,0 +1,50 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/generics.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/generics 
+Counter in file 0 17:24 -> 19:6, #1
+Counter in file 0 17:24 -> 19:6, #1
+Counter in file 0 23:9 -> 28:28, #1
+Counter in file 0 30:8 -> 30:12, (#1 + 0)
+Counter in file 0 31:9 -> 32:22, #2
+Counter in file 0 38:1 -> 38:2, #4
+Counter in file 0 38:1 -> 38:2, (#2 + 0)
+Counter in file 0 10:49 -> 12:6, #1
+Counter in file 0 10:49 -> 12:6, #1
+Emitting segments for file: ../coverage/generics.rs
+Combined regions:
+  10:49 -> 12:6 (count=3)
+  17:24 -> 19:6 (count=2)
+  23:9 -> 28:28 (count=1)
+  30:8 -> 30:12 (count=1)
+  31:9 -> 32:22 (count=1)
+  38:1 -> 38:2 (count=2)
+Segment at 10:49 (count = 3), RegionEntry
+Segment at 12:6 (count = 0), Skipped
+Segment at 17:24 (count = 2), RegionEntry
+Segment at 19:6 (count = 0), Skipped
+Segment at 23:9 (count = 1), RegionEntry
+Segment at 28:28 (count = 0), Skipped
+Segment at 30:8 (count = 1), RegionEntry
+Segment at 30:12 (count = 0), Skipped
+Segment at 31:9 (count = 1), RegionEntry
+Segment at 32:22 (count = 0), Skipped
+Segment at 38:1 (count = 2), RegionEntry
+Segment at 38:2 (count = 0), Skipped
+Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworkdE12set_strengthB2_
+Combined regions:
+  10:49 -> 12:6 (count=2)
+Segment at 10:49 (count = 2), RegionEntry
+Segment at 12:6 (count = 0), Skipped
+Emitting segments for function: _RNvMCs4fqI2P2rA04_8genericsINtB2_8FireworklE12set_strengthB2_
+Combined regions:
+  10:49 -> 12:6 (count=1)
+Segment at 10:49 (count = 1), RegionEntry
+Segment at 12:6 (count = 0), Skipped
+Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworklENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_
+Combined regions:
+  17:24 -> 19:6 (count=1)
+Segment at 17:24 (count = 1), RegionEntry
+Segment at 19:6 (count = 0), Skipped
+Emitting segments for function: _RNvXs_Cs4fqI2P2rA04_8genericsINtB4_8FireworkdENtNtNtCs7f2nZg1zwMz_4core3ops4drop4Drop4dropB4_
+Combined regions:
+  17:24 -> 19:6 (count=1)
+Segment at 17:24 (count = 1), RegionEntry
+Segment at 19:6 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt
new file mode 100644
index 00000000000..325e6985e30
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if.txt
@@ -0,0 +1,22 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/if.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/if 
+Counter in file 0 8:5 -> 18:10, #1
+Counter in file 0 21:9 -> 21:16, (#1 + 0)
+Counter in file 0 22:5 -> 27:6, #2
+Counter in file 0 27:6 -> 27:7, #3
+Counter in file 0 28:1 -> 28:2, #4
+Emitting segments for file: ../coverage/if.rs
+Combined regions:
+  8:5 -> 18:10 (count=1)
+  21:9 -> 21:16 (count=1)
+  22:5 -> 27:6 (count=1)
+  27:6 -> 27:7 (count=0)
+  28:1 -> 28:2 (count=1)
+Segment at 8:5 (count = 1), RegionEntry
+Segment at 18:10 (count = 0), Skipped
+Segment at 21:9 (count = 1), RegionEntry
+Segment at 21:16 (count = 0), Skipped
+Segment at 22:5 (count = 1), RegionEntry
+Segment at 27:6 (count = 0), RegionEntry
+Segment at 27:7 (count = 0), Skipped
+Segment at 28:1 (count = 1), RegionEntry
+Segment at 28:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt
new file mode 100644
index 00000000000..a620bf8ae4a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.if_else.txt
@@ -0,0 +1,38 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/if_else.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/if_else 
+Counter in file 0 7:9 -> 11:16, #1
+Counter in file 0 12:5 -> 17:6, #2
+Counter in file 0 20:9 -> 22:16, #3
+Counter in file 0 23:6 -> 23:7, (#2 + 0)
+Counter in file 0 26:9 -> 26:16, #4
+Counter in file 0 27:5 -> 32:6, #5
+Counter in file 0 34:5 -> 39:6, #6
+Counter in file 0 39:6 -> 39:7, (#5 + 0)
+Counter in file 0 40:1 -> 40:2, #7
+Emitting segments for file: ../coverage/if_else.rs
+Combined regions:
+  7:9 -> 11:16 (count=1)
+  12:5 -> 17:6 (count=1)
+  20:9 -> 22:16 (count=0)
+  23:6 -> 23:7 (count=1)
+  26:9 -> 26:16 (count=1)
+  27:5 -> 32:6 (count=1)
+  34:5 -> 39:6 (count=0)
+  39:6 -> 39:7 (count=1)
+  40:1 -> 40:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 11:16 (count = 0), Skipped
+Segment at 12:5 (count = 1), RegionEntry
+Segment at 17:6 (count = 0), Skipped
+Segment at 20:9 (count = 0), RegionEntry
+Segment at 22:16 (count = 0), Skipped
+Segment at 23:6 (count = 1), RegionEntry
+Segment at 23:7 (count = 0), Skipped
+Segment at 26:9 (count = 1), RegionEntry
+Segment at 26:16 (count = 0), Skipped
+Segment at 27:5 (count = 1), RegionEntry
+Segment at 32:6 (count = 0), Skipped
+Segment at 34:5 (count = 0), RegionEntry
+Segment at 39:6 (count = 1), RegionEntry
+Segment at 39:7 (count = 0), Skipped
+Segment at 40:1 (count = 1), RegionEntry
+Segment at 40:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt
new file mode 100644
index 00000000000..ea6db9452a7
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.inner_items.txt
@@ -0,0 +1,61 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/inner_items.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/inner_items 
+Counter in file 0 19:13 -> 19:18, #1
+Counter in file 0 20:13 -> 20:14, #2
+Counter in file 0 20:17 -> 20:22, (#1 + 0)
+Counter in file 0 21:9 -> 22:6, (#2 + 0)
+Counter in file 0 7:9 -> 9:26, #1
+Counter in file 0 10:8 -> 10:15, (#1 + 0)
+Counter in file 0 10:16 -> 12:6, #2
+Counter in file 0 12:6 -> 12:7, #3
+Counter in file 0 48:8 -> 48:15, #4
+Counter in file 0 48:16 -> 50:6, #5
+Counter in file 0 50:6 -> 50:7, #6
+Counter in file 0 52:9 -> 57:2, #7
+Counter in file 0 33:42 -> 36:10, #1
+Counter in file 0 41:37 -> 41:41, #1
+Counter in file 0 42:13 -> 43:10, #2
+Emitting segments for file: ../coverage/inner_items.rs
+Combined regions:
+  7:9 -> 9:26 (count=1)
+  10:8 -> 10:15 (count=1)
+  10:16 -> 12:6 (count=1)
+  12:6 -> 12:7 (count=0)
+  19:13 -> 19:18 (count=3)
+  20:13 -> 20:14 (count=3)
+  20:17 -> 20:22 (count=3)
+  21:9 -> 22:6 (count=3)
+  33:42 -> 36:10 (count=1)
+  41:37 -> 41:41 (count=1)
+  42:13 -> 43:10 (count=1)
+  48:8 -> 48:15 (count=1)
+  48:16 -> 50:6 (count=1)
+  50:6 -> 50:7 (count=0)
+  52:9 -> 57:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:26 (count = 0), Skipped
+Segment at 10:8 (count = 1), RegionEntry
+Segment at 10:15 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 12:6 (count = 0), RegionEntry
+Segment at 12:7 (count = 0), Skipped
+Segment at 19:13 (count = 3), RegionEntry
+Segment at 19:18 (count = 0), Skipped
+Segment at 20:13 (count = 3), RegionEntry
+Segment at 20:14 (count = 0), Skipped
+Segment at 20:17 (count = 3), RegionEntry
+Segment at 20:22 (count = 0), Skipped
+Segment at 21:9 (count = 3), RegionEntry
+Segment at 22:6 (count = 0), Skipped
+Segment at 33:42 (count = 1), RegionEntry
+Segment at 36:10 (count = 0), Skipped
+Segment at 41:37 (count = 1), RegionEntry
+Segment at 41:41 (count = 0), Skipped
+Segment at 42:13 (count = 1), RegionEntry
+Segment at 43:10 (count = 0), Skipped
+Segment at 48:8 (count = 1), RegionEntry
+Segment at 48:15 (count = 0), Skipped
+Segment at 48:16 (count = 1), RegionEntry
+Segment at 50:6 (count = 0), RegionEntry
+Segment at 50:7 (count = 0), Skipped
+Segment at 52:9 (count = 1), RegionEntry
+Segment at 57:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt
new file mode 100644
index 00000000000..0f54f4904b0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.lazy_boolean.txt
@@ -0,0 +1,138 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/lazy_boolean.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/lazy_boolean 
+Counter in file 0 7:9 -> 9:42, #1
+Counter in file 0 10:8 -> 10:15, (#1 + 0)
+Counter in file 0 10:16 -> 14:6, #2
+Counter in file 0 14:6 -> 14:7, #3
+Counter in file 0 16:9 -> 16:17, #4
+Counter in file 0 18:13 -> 18:18, #5
+Counter in file 0 20:13 -> 20:18, #6
+Counter in file 0 20:18 -> 20:19, #7
+Counter in file 0 20:18 -> 20:19, #8
+Counter in file 0 23:9 -> 23:17, #9
+Counter in file 0 25:13 -> 25:18, (#4 + 0)
+Counter in file 0 27:13 -> 27:18, #10
+Counter in file 0 27:18 -> 27:19, #11
+Counter in file 0 27:18 -> 27:19, #12
+Counter in file 0 29:9 -> 29:17, #13
+Counter in file 0 29:20 -> 29:25, (#9 + 0)
+Counter in file 0 29:29 -> 29:34, #14
+Counter in file 0 29:34 -> 29:35, #15
+Counter in file 0 29:34 -> 29:35, #16
+Counter in file 0 30:9 -> 30:17, #17
+Counter in file 0 30:20 -> 30:25, (#13 + 0)
+Counter in file 0 30:29 -> 30:34, #18
+Counter in file 0 30:34 -> 30:35, #19
+Counter in file 0 30:34 -> 30:35, #20
+Counter in file 0 33:9 -> 34:16, (#17 + 0)
+Counter in file 0 35:5 -> 38:6, #21
+Counter in file 0 38:6 -> 38:7, #22
+Counter in file 0 41:9 -> 41:16, #23
+Counter in file 0 42:5 -> 45:6, #24
+Counter in file 0 47:5 -> 50:6, #25
+Counter in file 0 50:6 -> 50:7, (#24 + 0)
+Counter in file 0 52:8 -> 52:16, #26
+Counter in file 0 52:17 -> 54:6, #27
+Counter in file 0 54:6 -> 54:7, #28
+Counter in file 0 56:8 -> 56:15, #29
+Counter in file 0 56:16 -> 58:6, #30
+Counter in file 0 58:12 -> 60:6, #31
+Counter in file 0 60:6 -> 60:7, (#30 + 0)
+Counter in file 0 61:1 -> 61:2, #32
+Emitting segments for file: ../coverage/lazy_boolean.rs
+Combined regions:
+  7:9 -> 9:42 (count=1)
+  10:8 -> 10:15 (count=1)
+  10:16 -> 14:6 (count=1)
+  14:6 -> 14:7 (count=0)
+  16:9 -> 16:17 (count=1)
+  18:13 -> 18:18 (count=1)
+  20:13 -> 20:18 (count=0)
+  20:18 -> 20:19 (count=1)
+  23:9 -> 23:17 (count=1)
+  25:13 -> 25:18 (count=1)
+  27:13 -> 27:18 (count=1)
+  27:18 -> 27:19 (count=1)
+  29:9 -> 29:17 (count=1)
+  29:20 -> 29:25 (count=1)
+  29:29 -> 29:34 (count=1)
+  29:34 -> 29:35 (count=1)
+  30:9 -> 30:17 (count=1)
+  30:20 -> 30:25 (count=1)
+  30:29 -> 30:34 (count=0)
+  30:34 -> 30:35 (count=1)
+  33:9 -> 34:16 (count=1)
+  35:5 -> 38:6 (count=0)
+  38:6 -> 38:7 (count=1)
+  41:9 -> 41:16 (count=1)
+  42:5 -> 45:6 (count=1)
+  47:5 -> 50:6 (count=0)
+  50:6 -> 50:7 (count=1)
+  52:8 -> 52:16 (count=1)
+  52:17 -> 54:6 (count=0)
+  54:6 -> 54:7 (count=1)
+  56:8 -> 56:15 (count=1)
+  56:16 -> 58:6 (count=1)
+  58:12 -> 60:6 (count=0)
+  60:6 -> 60:7 (count=1)
+  61:1 -> 61:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:42 (count = 0), Skipped
+Segment at 10:8 (count = 1), RegionEntry
+Segment at 10:15 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 14:6 (count = 0), RegionEntry
+Segment at 14:7 (count = 0), Skipped
+Segment at 16:9 (count = 1), RegionEntry
+Segment at 16:17 (count = 0), Skipped
+Segment at 18:13 (count = 1), RegionEntry
+Segment at 18:18 (count = 0), Skipped
+Segment at 20:13 (count = 0), RegionEntry
+Segment at 20:18 (count = 1), RegionEntry
+Segment at 20:19 (count = 0), Skipped
+Segment at 23:9 (count = 1), RegionEntry
+Segment at 23:17 (count = 0), Skipped
+Segment at 25:13 (count = 1), RegionEntry
+Segment at 25:18 (count = 0), Skipped
+Segment at 27:13 (count = 1), RegionEntry
+Segment at 27:18 (count = 1), RegionEntry
+Segment at 27:19 (count = 0), Skipped
+Segment at 29:9 (count = 1), RegionEntry
+Segment at 29:17 (count = 0), Skipped
+Segment at 29:20 (count = 1), RegionEntry
+Segment at 29:25 (count = 0), Skipped
+Segment at 29:29 (count = 1), RegionEntry
+Segment at 29:34 (count = 1), RegionEntry
+Segment at 29:35 (count = 0), Skipped
+Segment at 30:9 (count = 1), RegionEntry
+Segment at 30:17 (count = 0), Skipped
+Segment at 30:20 (count = 1), RegionEntry
+Segment at 30:25 (count = 0), Skipped
+Segment at 30:29 (count = 0), RegionEntry
+Segment at 30:34 (count = 1), RegionEntry
+Segment at 30:35 (count = 0), Skipped
+Segment at 33:9 (count = 1), RegionEntry
+Segment at 34:16 (count = 0), Skipped
+Segment at 35:5 (count = 0), RegionEntry
+Segment at 38:6 (count = 1), RegionEntry
+Segment at 38:7 (count = 0), Skipped
+Segment at 41:9 (count = 1), RegionEntry
+Segment at 41:16 (count = 0), Skipped
+Segment at 42:5 (count = 1), RegionEntry
+Segment at 45:6 (count = 0), Skipped
+Segment at 47:5 (count = 0), RegionEntry
+Segment at 50:6 (count = 1), RegionEntry
+Segment at 50:7 (count = 0), Skipped
+Segment at 52:8 (count = 1), RegionEntry
+Segment at 52:16 (count = 0), Skipped
+Segment at 52:17 (count = 0), RegionEntry
+Segment at 54:6 (count = 1), RegionEntry
+Segment at 54:7 (count = 0), Skipped
+Segment at 56:8 (count = 1), RegionEntry
+Segment at 56:15 (count = 0), Skipped
+Segment at 56:16 (count = 1), RegionEntry
+Segment at 58:6 (count = 0), Skipped
+Segment at 58:12 (count = 0), RegionEntry
+Segment at 60:6 (count = 1), RegionEntry
+Segment at 60:7 (count = 0), Skipped
+Segment at 61:1 (count = 1), RegionEntry
+Segment at 61:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loop_break_value.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loop_break_value.txt
new file mode 100644
index 00000000000..3f5fc4a4401
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loop_break_value.txt
@@ -0,0 +1,7 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/loop_break_value.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/loop_break_value 
+Counter in file 0 3:11 -> 13:2, #1
+Emitting segments for file: ../coverage/loop_break_value.rs
+Combined regions:
+  3:11 -> 13:2 (count=1)
+Segment at 3:11 (count = 1), RegionEntry
+Segment at 13:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt
new file mode 100644
index 00000000000..ca3b1d61343
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.loops_and_branches.txt
@@ -0,0 +1,39 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/loops_and_branches.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/loops_and_branches 
+Counter in file 0 10:12 -> 10:16, #1
+Counter in file 0 11:16 -> 11:21, #2
+Counter in file 0 14:14 -> 14:15, #6
+Counter in file 0 15:13 -> 15:31, #7
+Counter in file 0 15:31 -> 15:32, #8
+Counter in file 0 17:10 -> 17:11, #10
+Counter in file 0 18:9 -> 18:15, #11
+Counter in file 0 19:5 -> 19:6, #12
+Counter in file 0 19:5 -> 19:6, (#8 + 0)
+Counter in file 0 22:11 -> 25:2, #1
+Emitting segments for file: ../coverage/loops_and_branches.rs
+Combined regions:
+  10:12 -> 10:16 (count=1)
+  11:16 -> 11:21 (count=1)
+  14:14 -> 14:15 (count=1)
+  15:13 -> 15:31 (count=1)
+  15:31 -> 15:32 (count=0)
+  17:10 -> 17:11 (count=1)
+  18:9 -> 18:15 (count=1)
+  19:5 -> 19:6 (count=1)
+  22:11 -> 25:2 (count=1)
+Segment at 10:12 (count = 1), RegionEntry
+Segment at 10:16 (count = 0), Skipped
+Segment at 11:16 (count = 1), RegionEntry
+Segment at 11:21 (count = 0), Skipped
+Segment at 14:14 (count = 1), RegionEntry
+Segment at 14:15 (count = 0), Skipped
+Segment at 15:13 (count = 1), RegionEntry
+Segment at 15:31 (count = 0), RegionEntry
+Segment at 15:32 (count = 0), Skipped
+Segment at 17:10 (count = 1), RegionEntry
+Segment at 17:11 (count = 0), Skipped
+Segment at 18:9 (count = 1), RegionEntry
+Segment at 18:15 (count = 0), Skipped
+Segment at 19:5 (count = 1), RegionEntry
+Segment at 19:6 (count = 0), Skipped
+Segment at 22:11 (count = 1), RegionEntry
+Segment at 25:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt
new file mode 100644
index 00000000000..9c9c46a0834
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.nested_loops.txt
@@ -0,0 +1,76 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/nested_loops.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/nested_loops 
+Counter in file 0 2:9 -> 3:27, #1
+Counter in file 0 5:19 -> 5:32, #2
+Counter in file 0 6:13 -> 7:24, #3
+Counter in file 0 8:13 -> 8:14, #4
+Counter in file 0 8:18 -> 8:23, #5
+Counter in file 0 9:16 -> 9:22, (#4 + 0)
+Counter in file 0 10:17 -> 10:22, #6
+Counter in file 0 12:13 -> 12:19, #7
+Counter in file 0 13:13 -> 13:19, #8
+Counter in file 0 14:16 -> 14:22, (#8 + 0)
+Counter in file 0 15:17 -> 16:27, #9
+Counter in file 0 17:21 -> 17:33, #10
+Counter in file 0 19:21 -> 21:14, #11
+Counter in file 0 21:14 -> 21:15, #12
+Counter in file 0 22:10 -> 22:11, #13
+Counter in file 0 22:10 -> 22:11, (#3 + 0)
+Counter in file 0 23:9 -> 23:23, #14
+Counter in file 0 24:6 -> 24:7, #15
+Counter in file 0 24:6 -> 24:7, (#1 + 0)
+Counter in file 0 25:1 -> 25:2, #16
+Emitting segments for file: ../coverage/nested_loops.rs
+Combined regions:
+  2:9 -> 3:27 (count=1)
+  5:19 -> 5:32 (count=1)
+  6:13 -> 7:24 (count=1)
+  8:13 -> 8:14 (count=3)
+  8:18 -> 8:23 (count=3)
+  9:16 -> 9:22 (count=3)
+  10:17 -> 10:22 (count=0)
+  12:13 -> 12:19 (count=3)
+  13:13 -> 13:19 (count=3)
+  14:16 -> 14:22 (count=3)
+  15:17 -> 16:27 (count=1)
+  17:21 -> 17:33 (count=1)
+  19:21 -> 21:14 (count=0)
+  21:14 -> 21:15 (count=2)
+  22:10 -> 22:11 (count=3)
+  23:9 -> 23:23 (count=0)
+  24:6 -> 24:7 (count=1)
+  25:1 -> 25:2 (count=1)
+Segment at 2:9 (count = 1), RegionEntry
+Segment at 3:27 (count = 0), Skipped
+Segment at 5:19 (count = 1), RegionEntry
+Segment at 5:32 (count = 0), Skipped
+Segment at 6:13 (count = 1), RegionEntry
+Segment at 7:24 (count = 0), Skipped
+Segment at 8:13 (count = 3), RegionEntry
+Segment at 8:14 (count = 0), Skipped
+Segment at 8:18 (count = 3), RegionEntry
+Segment at 8:23 (count = 0), Skipped
+Segment at 9:16 (count = 3), RegionEntry
+Segment at 9:22 (count = 0), Skipped
+Segment at 10:17 (count = 0), RegionEntry
+Segment at 10:22 (count = 0), Skipped
+Segment at 12:13 (count = 3), RegionEntry
+Segment at 12:19 (count = 0), Skipped
+Segment at 13:13 (count = 3), RegionEntry
+Segment at 13:19 (count = 0), Skipped
+Segment at 14:16 (count = 3), RegionEntry
+Segment at 14:22 (count = 0), Skipped
+Segment at 15:17 (count = 1), RegionEntry
+Segment at 16:27 (count = 0), Skipped
+Segment at 17:21 (count = 1), RegionEntry
+Segment at 17:33 (count = 0), Skipped
+Segment at 19:21 (count = 0), RegionEntry
+Segment at 21:14 (count = 2), RegionEntry
+Segment at 21:15 (count = 0), Skipped
+Segment at 22:10 (count = 3), RegionEntry
+Segment at 22:11 (count = 0), Skipped
+Segment at 23:9 (count = 0), RegionEntry
+Segment at 23:23 (count = 0), Skipped
+Segment at 24:6 (count = 1), RegionEntry
+Segment at 24:7 (count = 0), Skipped
+Segment at 25:1 (count = 1), RegionEntry
+Segment at 25:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt
new file mode 100644
index 00000000000..dbcaa57b4b2
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.partial_eq_counter_without_region.txt
@@ -0,0 +1,68 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/partial_eq_counter_without_region.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/partial_eq_counter_without_region 
+Counter in file 0 4:39 -> 4:49, #1
+Counter in file 0 4:39 -> 4:49, #2
+Counter in file 0 4:39 -> 4:49, #3
+Counter in file 0 4:39 -> 4:49, #4
+Counter in file 0 4:48 -> 4:49, #5
+Counter in file 0 8:5 -> 8:17, #1
+Counter in file 0 21:11 -> 26:2, #1
+Counter in file 0 4:39 -> 4:40, #1
+Counter in file 0 4:48 -> 4:49, (#1 + 0)
+Counter in file 0 7:5 -> 7:6, #1
+Counter in file 0 8:5 -> 8:17, #1
+Counter in file 0 4:39 -> 4:40, #1
+Counter in file 0 4:48 -> 4:49, (#1 + 0)
+Counter in file 0 4:24 -> 4:33, #1
+Counter in file 0 4:24 -> 4:33, #2
+Counter in file 0 4:24 -> 4:33, #3
+Counter in file 0 4:24 -> 4:33, #4
+Counter in file 0 4:32 -> 4:33, #5
+Counter in file 0 4:51 -> 4:54, #1
+Counter in file 0 4:51 -> 4:54, #2
+Counter in file 0 4:51 -> 4:54, #3
+Counter in file 0 4:51 -> 4:54, #4
+Counter in file 0 4:53 -> 4:54, #5
+Counter in file 0 13:9 -> 18:6, #1
+Counter in file 0 7:5 -> 7:6, #1
+Counter in file 0 4:39 -> 4:40, #1
+Counter in file 0 4:48 -> 4:49, (#1 + 0)
+Counter in file 0 7:5 -> 7:6, #1
+Counter in file 0 4:10 -> 4:15, #1
+Counter in file 0 4:35 -> 4:37, #1
+Counter in file 0 7:5 -> 7:6, #1
+Counter in file 0 8:5 -> 8:17, #1
+Counter in file 0 4:17 -> 4:22, #1
+Counter in file 0 8:5 -> 8:17, #1
+Counter in file 0 4:39 -> 4:40, #1
+Counter in file 0 4:48 -> 4:49, (#1 + 0)
+Counter in file 0 4:24 -> 4:33, #1
+Counter in file 0 4:24 -> 4:33, #2
+Counter in file 0 4:32 -> 4:33, #3
+Emitting segments for file: ../coverage/partial_eq_counter_without_region.rs
+Combined regions:
+  4:17 -> 4:22 (count=2)
+  4:39 -> 4:40 (count=1)
+  4:48 -> 4:49 (count=1)
+  7:5 -> 7:6 (count=1)
+  13:9 -> 18:6 (count=2)
+  21:11 -> 26:2 (count=1)
+Segment at 4:17 (count = 2), RegionEntry
+Segment at 4:22 (count = 0), Skipped
+Segment at 4:39 (count = 1), RegionEntry
+Segment at 4:40 (count = 0), Skipped
+Segment at 4:48 (count = 1), RegionEntry
+Segment at 4:49 (count = 0), Skipped
+Segment at 7:5 (count = 1), RegionEntry
+Segment at 7:6 (count = 0), Skipped
+Segment at 13:9 (count = 2), RegionEntry
+Segment at 18:6 (count = 0), Skipped
+Segment at 21:11 (count = 1), RegionEntry
+Segment at 26:2 (count = 0), Skipped
+Emitting segments for function: _RNvXs0_Cs4fqI2P2rA04_33partial_eq_counter_without_regionNtB5_7VersionNtNtCs7f2nZg1zwMz_4core3cmp10PartialOrd2ltB5_
+Combined regions:
+  4:39 -> 4:40 (count=1)
+  4:48 -> 4:49 (count=1)
+Segment at 4:39 (count = 1), RegionEntry
+Segment at 4:40 (count = 0), Skipped
+Segment at 4:48 (count = 1), RegionEntry
+Segment at 4:49 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt
new file mode 100644
index 00000000000..90e09099dcc
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_loop.txt
@@ -0,0 +1,38 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/simple_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/simple_loop 
+Counter in file 0 7:9 -> 9:26, #1
+Counter in file 0 12:9 -> 12:16, (#1 + 0)
+Counter in file 0 13:5 -> 18:6, #2
+Counter in file 0 18:6 -> 18:7, #3
+Counter in file 0 23:13 -> 25:14, #4
+Counter in file 0 27:13 -> 27:18, #5
+Counter in file 0 30:9 -> 32:10, #6
+Counter in file 0 34:6 -> 34:7, #7
+Counter in file 0 35:1 -> 35:2, (#5 + 0)
+Emitting segments for file: ../coverage/simple_loop.rs
+Combined regions:
+  7:9 -> 9:26 (count=1)
+  12:9 -> 12:16 (count=1)
+  13:5 -> 18:6 (count=1)
+  18:6 -> 18:7 (count=0)
+  23:13 -> 25:14 (count=11)
+  27:13 -> 27:18 (count=1)
+  30:9 -> 32:10 (count=10)
+  34:6 -> 34:7 (count=1)
+  35:1 -> 35:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:26 (count = 0), Skipped
+Segment at 12:9 (count = 1), RegionEntry
+Segment at 12:16 (count = 0), Skipped
+Segment at 13:5 (count = 1), RegionEntry
+Segment at 18:6 (count = 0), RegionEntry
+Segment at 18:7 (count = 0), Skipped
+Segment at 23:13 (count = 11), RegionEntry
+Segment at 25:14 (count = 0), Skipped
+Segment at 27:13 (count = 1), RegionEntry
+Segment at 27:18 (count = 0), Skipped
+Segment at 30:9 (count = 10), RegionEntry
+Segment at 32:10 (count = 0), Skipped
+Segment at 34:6 (count = 1), RegionEntry
+Segment at 34:7 (count = 0), Skipped
+Segment at 35:1 (count = 1), RegionEntry
+Segment at 35:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt
new file mode 100644
index 00000000000..39a986332cd
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.simple_match.txt
@@ -0,0 +1,58 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/simple_match.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/simple_match 
+Counter in file 0 7:9 -> 9:26, #1
+Counter in file 0 10:8 -> 10:15, (#1 + 0)
+Counter in file 0 10:16 -> 12:6, #2
+Counter in file 0 12:6 -> 12:7, #3
+Counter in file 0 15:9 -> 15:10, #4
+Counter in file 0 17:9 -> 17:13, #5
+Counter in file 0 22:13 -> 22:22, (#4 + 0)
+Counter in file 0 24:13 -> 24:14, #6
+Counter in file 0 26:17 -> 28:18, (#4 + 0)
+Counter in file 0 28:18 -> 28:19, #7
+Counter in file 0 30:13 -> 37:14, (#6 + 0)
+Counter in file 0 40:13 -> 40:15, #8
+Counter in file 0 42:6 -> 42:7, #9
+Counter in file 0 42:6 -> 42:7, #10
+Counter in file 0 43:1 -> 43:2, #11
+Emitting segments for file: ../coverage/simple_match.rs
+Combined regions:
+  7:9 -> 9:26 (count=1)
+  10:8 -> 10:15 (count=1)
+  10:16 -> 12:6 (count=1)
+  12:6 -> 12:7 (count=0)
+  15:9 -> 15:10 (count=2)
+  17:9 -> 17:13 (count=3)
+  22:13 -> 22:22 (count=2)
+  24:13 -> 24:14 (count=1)
+  26:17 -> 28:18 (count=2)
+  28:18 -> 28:19 (count=1)
+  30:13 -> 37:14 (count=1)
+  40:13 -> 40:15 (count=1)
+  42:6 -> 42:7 (count=3)
+  43:1 -> 43:2 (count=1)
+Segment at 7:9 (count = 1), RegionEntry
+Segment at 9:26 (count = 0), Skipped
+Segment at 10:8 (count = 1), RegionEntry
+Segment at 10:15 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 12:6 (count = 0), RegionEntry
+Segment at 12:7 (count = 0), Skipped
+Segment at 15:9 (count = 2), RegionEntry
+Segment at 15:10 (count = 0), Skipped
+Segment at 17:9 (count = 3), RegionEntry
+Segment at 17:13 (count = 0), Skipped
+Segment at 22:13 (count = 2), RegionEntry
+Segment at 22:22 (count = 0), Skipped
+Segment at 24:13 (count = 1), RegionEntry
+Segment at 24:14 (count = 0), Skipped
+Segment at 26:17 (count = 2), RegionEntry
+Segment at 28:18 (count = 1), RegionEntry
+Segment at 28:19 (count = 0), Skipped
+Segment at 30:13 (count = 1), RegionEntry
+Segment at 37:14 (count = 0), Skipped
+Segment at 40:13 (count = 1), RegionEntry
+Segment at 40:15 (count = 0), Skipped
+Segment at 42:6 (count = 3), RegionEntry
+Segment at 42:7 (count = 0), Skipped
+Segment at 43:1 (count = 1), RegionEntry
+Segment at 43:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt
new file mode 100644
index 00000000000..a0687815fb9
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.tight_infinite_loop.txt
@@ -0,0 +1,11 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/tight_infinite_loop.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/tight_infinite_loop 
+Counter in file 0 2:8 -> 2:13, #1
+Counter in file 0 5:1 -> 5:2, #4
+Emitting segments for file: ../coverage/tight_infinite_loop.rs
+Combined regions:
+  2:8 -> 2:13 (count=1)
+  5:1 -> 5:2 (count=1)
+Segment at 2:8 (count = 1), RegionEntry
+Segment at 2:13 (count = 0), Skipped
+Segment at 5:1 (count = 1), RegionEntry
+Segment at 5:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt
new file mode 100644
index 00000000000..10fc52354b9
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.try_error_result.txt
@@ -0,0 +1,72 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/try_error_result.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/try_error_result 
+Counter in file 0 13:9 -> 14:23, #1
+Counter in file 0 17:9 -> 17:10, #2
+Counter in file 0 19:9 -> 19:14, #3
+Counter in file 0 21:9 -> 25:26, #4
+Counter in file 0 27:13 -> 27:41, #5
+Counter in file 0 27:41 -> 27:42, #6
+Counter in file 0 31:13 -> 31:42, #7
+Counter in file 0 31:42 -> 31:43, #8
+Counter in file 0 32:10 -> 32:11, #9
+Counter in file 0 32:10 -> 32:11, #10
+Counter in file 0 33:6 -> 33:7, #11
+Counter in file 0 33:6 -> 33:7, (#1 + 0)
+Counter in file 0 34:5 -> 34:11, #12
+Counter in file 0 35:1 -> 35:2, #13
+Counter in file 0 35:1 -> 35:2, #14
+Counter in file 0 5:8 -> 5:20, #1
+Counter in file 0 6:9 -> 6:16, #2
+Counter in file 0 8:9 -> 8:15, #3
+Counter in file 0 9:6 -> 9:7, (#2 + 0)
+Counter in file 0 10:1 -> 10:2, #4
+Emitting segments for file: ../coverage/try_error_result.rs
+Combined regions:
+  5:8 -> 5:20 (count=6)
+  6:9 -> 6:16 (count=1)
+  8:9 -> 8:15 (count=5)
+  9:6 -> 9:7 (count=1)
+  10:1 -> 10:2 (count=6)
+  13:9 -> 14:23 (count=1)
+  17:9 -> 17:10 (count=6)
+  19:9 -> 19:14 (count=6)
+  21:9 -> 25:26 (count=6)
+  27:13 -> 27:41 (count=1)
+  27:41 -> 27:42 (count=1)
+  31:13 -> 31:42 (count=5)
+  31:42 -> 31:43 (count=0)
+  32:10 -> 32:11 (count=5)
+  33:6 -> 33:7 (count=6)
+  34:5 -> 34:11 (count=0)
+  35:1 -> 35:2 (count=2)
+Segment at 5:8 (count = 6), RegionEntry
+Segment at 5:20 (count = 0), Skipped
+Segment at 6:9 (count = 1), RegionEntry
+Segment at 6:16 (count = 0), Skipped
+Segment at 8:9 (count = 5), RegionEntry
+Segment at 8:15 (count = 0), Skipped
+Segment at 9:6 (count = 1), RegionEntry
+Segment at 9:7 (count = 0), Skipped
+Segment at 10:1 (count = 6), RegionEntry
+Segment at 10:2 (count = 0), Skipped
+Segment at 13:9 (count = 1), RegionEntry
+Segment at 14:23 (count = 0), Skipped
+Segment at 17:9 (count = 6), RegionEntry
+Segment at 17:10 (count = 0), Skipped
+Segment at 19:9 (count = 6), RegionEntry
+Segment at 19:14 (count = 0), Skipped
+Segment at 21:9 (count = 6), RegionEntry
+Segment at 25:26 (count = 0), Skipped
+Segment at 27:13 (count = 1), RegionEntry
+Segment at 27:41 (count = 1), RegionEntry
+Segment at 27:42 (count = 0), Skipped
+Segment at 31:13 (count = 5), RegionEntry
+Segment at 31:42 (count = 0), RegionEntry
+Segment at 31:43 (count = 0), Skipped
+Segment at 32:10 (count = 5), RegionEntry
+Segment at 32:11 (count = 0), Skipped
+Segment at 33:6 (count = 6), RegionEntry
+Segment at 33:7 (count = 0), Skipped
+Segment at 34:5 (count = 0), RegionEntry
+Segment at 34:11 (count = 0), Skipped
+Segment at 35:1 (count = 2), RegionEntry
+Segment at 35:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt
new file mode 100644
index 00000000000..567c8cd9b6d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.various_conditions.txt
@@ -0,0 +1,240 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/various_conditions.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/various_conditions 
+Counter in file 0 4:9 -> 4:26, #1
+Counter in file 0 5:8 -> 5:12, (#1 + 0)
+Counter in file 0 5:13 -> 7:6, #2
+Counter in file 0 10:9 -> 10:10, #4
+Counter in file 0 10:16 -> 10:29, #5
+Counter in file 0 11:9 -> 12:10, #6
+Counter in file 0 13:15 -> 13:28, #7
+Counter in file 0 14:12 -> 14:25, #8
+Counter in file 0 14:29 -> 14:42, #9
+Counter in file 0 14:42 -> 14:43, #10
+Counter in file 0 14:42 -> 14:43, #11
+Counter in file 0 14:46 -> 14:60, #12
+Counter in file 0 14:60 -> 14:61, #13
+Counter in file 0 14:60 -> 14:61, #14
+Counter in file 0 14:61 -> 16:10, #15
+Counter in file 0 16:10 -> 16:11, #16
+Counter in file 0 17:9 -> 18:18, #17
+Counter in file 0 20:9 -> 20:15, #18
+Counter in file 0 23:9 -> 23:26, (#4 + 0)
+Counter in file 0 24:8 -> 24:12, (#4 + 0)
+Counter in file 0 24:13 -> 26:6, #19
+Counter in file 0 28:8 -> 28:21, #21
+Counter in file 0 29:9 -> 29:23, #22
+Counter in file 0 30:15 -> 30:28, #23
+Counter in file 0 31:12 -> 31:25, #24
+Counter in file 0 31:29 -> 31:42, #25
+Counter in file 0 31:42 -> 31:43, #26
+Counter in file 0 31:42 -> 31:43, #27
+Counter in file 0 31:46 -> 31:60, #28
+Counter in file 0 31:60 -> 31:61, #29
+Counter in file 0 31:60 -> 31:61, #30
+Counter in file 0 31:61 -> 33:10, #31
+Counter in file 0 33:10 -> 33:11, #32
+Counter in file 0 34:9 -> 34:23, #33
+Counter in file 0 36:9 -> 36:15, #34
+Counter in file 0 39:9 -> 39:26, #35
+Counter in file 0 40:8 -> 40:12, (#35 + 0)
+Counter in file 0 40:13 -> 42:6, #36
+Counter in file 0 44:9 -> 44:10, #38
+Counter in file 0 44:16 -> 44:29, #39
+Counter in file 0 45:9 -> 45:23, #40
+Counter in file 0 46:15 -> 46:28, #41
+Counter in file 0 47:12 -> 47:25, #42
+Counter in file 0 47:29 -> 47:42, #43
+Counter in file 0 47:42 -> 47:43, #44
+Counter in file 0 47:42 -> 47:43, #45
+Counter in file 0 47:46 -> 47:60, #46
+Counter in file 0 47:60 -> 47:61, #47
+Counter in file 0 47:60 -> 47:61, #48
+Counter in file 0 47:61 -> 49:10, #49
+Counter in file 0 49:10 -> 49:11, #50
+Counter in file 0 50:9 -> 50:23, #51
+Counter in file 0 52:13 -> 54:15, #52
+Counter in file 0 57:9 -> 57:10, #53
+Counter in file 0 57:16 -> 57:29, (#38 + 0)
+Counter in file 0 58:9 -> 58:23, #54
+Counter in file 0 59:15 -> 59:28, #55
+Counter in file 0 60:12 -> 60:25, #56
+Counter in file 0 60:29 -> 60:42, #57
+Counter in file 0 60:42 -> 60:43, #58
+Counter in file 0 60:42 -> 60:43, #59
+Counter in file 0 60:46 -> 60:60, #60
+Counter in file 0 60:60 -> 60:61, #61
+Counter in file 0 60:60 -> 60:61, #62
+Counter in file 0 60:61 -> 62:10, #63
+Counter in file 0 62:10 -> 62:11, #64
+Counter in file 0 63:9 -> 63:23, #65
+Counter in file 0 65:9 -> 65:15, #66
+Counter in file 0 67:1 -> 67:2, #67
+Counter in file 0 67:1 -> 67:2, #68
+Emitting segments for file: ../coverage/various_conditions.rs
+Combined regions:
+  4:9 -> 4:26 (count=1)
+  5:8 -> 5:12 (count=1)
+  5:13 -> 7:6 (count=1)
+  10:9 -> 10:10 (count=1)
+  10:16 -> 10:29 (count=1)
+  11:9 -> 12:10 (count=1)
+  13:15 -> 13:28 (count=0)
+  14:12 -> 14:25 (count=0)
+  14:29 -> 14:42 (count=0)
+  14:42 -> 14:43 (count=0)
+  14:46 -> 14:60 (count=0)
+  14:60 -> 14:61 (count=0)
+  14:61 -> 16:10 (count=0)
+  16:10 -> 16:11 (count=0)
+  17:9 -> 18:18 (count=0)
+  20:9 -> 20:15 (count=0)
+  23:9 -> 23:26 (count=1)
+  24:8 -> 24:12 (count=1)
+  24:13 -> 26:6 (count=1)
+  28:8 -> 28:21 (count=1)
+  29:9 -> 29:23 (count=1)
+  30:15 -> 30:28 (count=0)
+  31:12 -> 31:25 (count=0)
+  31:29 -> 31:42 (count=0)
+  31:42 -> 31:43 (count=0)
+  31:46 -> 31:60 (count=0)
+  31:60 -> 31:61 (count=0)
+  31:61 -> 33:10 (count=0)
+  33:10 -> 33:11 (count=0)
+  34:9 -> 34:23 (count=0)
+  36:9 -> 36:15 (count=0)
+  39:9 -> 39:26 (count=1)
+  40:8 -> 40:12 (count=1)
+  40:13 -> 42:6 (count=1)
+  44:9 -> 44:10 (count=0)
+  44:16 -> 44:29 (count=1)
+  45:9 -> 45:23 (count=0)
+  46:15 -> 46:28 (count=1)
+  47:12 -> 47:25 (count=0)
+  47:29 -> 47:42 (count=0)
+  47:42 -> 47:43 (count=0)
+  47:46 -> 47:60 (count=0)
+  47:60 -> 47:61 (count=0)
+  47:61 -> 49:10 (count=0)
+  49:10 -> 49:11 (count=0)
+  50:9 -> 50:23 (count=0)
+  52:13 -> 54:15 (count=1)
+  57:9 -> 57:10 (count=0)
+  57:16 -> 57:29 (count=0)
+  58:9 -> 58:23 (count=0)
+  59:15 -> 59:28 (count=0)
+  60:12 -> 60:25 (count=0)
+  60:29 -> 60:42 (count=0)
+  60:42 -> 60:43 (count=0)
+  60:46 -> 60:60 (count=0)
+  60:60 -> 60:61 (count=0)
+  60:61 -> 62:10 (count=0)
+  62:10 -> 62:11 (count=0)
+  63:9 -> 63:23 (count=0)
+  65:9 -> 65:15 (count=0)
+  67:1 -> 67:2 (count=2)
+Segment at 4:9 (count = 1), RegionEntry
+Segment at 4:26 (count = 0), Skipped
+Segment at 5:8 (count = 1), RegionEntry
+Segment at 5:12 (count = 0), Skipped
+Segment at 5:13 (count = 1), RegionEntry
+Segment at 7:6 (count = 0), Skipped
+Segment at 10:9 (count = 1), RegionEntry
+Segment at 10:10 (count = 0), Skipped
+Segment at 10:16 (count = 1), RegionEntry
+Segment at 10:29 (count = 0), Skipped
+Segment at 11:9 (count = 1), RegionEntry
+Segment at 12:10 (count = 0), Skipped
+Segment at 13:15 (count = 0), RegionEntry
+Segment at 13:28 (count = 0), Skipped
+Segment at 14:12 (count = 0), RegionEntry
+Segment at 14:25 (count = 0), Skipped
+Segment at 14:29 (count = 0), RegionEntry
+Segment at 14:42 (count = 0), RegionEntry
+Segment at 14:43 (count = 0), Skipped
+Segment at 14:46 (count = 0), RegionEntry
+Segment at 14:60 (count = 0), RegionEntry
+Segment at 14:61 (count = 0), RegionEntry
+Segment at 16:10 (count = 0), RegionEntry
+Segment at 16:11 (count = 0), Skipped
+Segment at 17:9 (count = 0), RegionEntry
+Segment at 18:18 (count = 0), Skipped
+Segment at 20:9 (count = 0), RegionEntry
+Segment at 20:15 (count = 0), Skipped
+Segment at 23:9 (count = 1), RegionEntry
+Segment at 23:26 (count = 0), Skipped
+Segment at 24:8 (count = 1), RegionEntry
+Segment at 24:12 (count = 0), Skipped
+Segment at 24:13 (count = 1), RegionEntry
+Segment at 26:6 (count = 0), Skipped
+Segment at 28:8 (count = 1), RegionEntry
+Segment at 28:21 (count = 0), Skipped
+Segment at 29:9 (count = 1), RegionEntry
+Segment at 29:23 (count = 0), Skipped
+Segment at 30:15 (count = 0), RegionEntry
+Segment at 30:28 (count = 0), Skipped
+Segment at 31:12 (count = 0), RegionEntry
+Segment at 31:25 (count = 0), Skipped
+Segment at 31:29 (count = 0), RegionEntry
+Segment at 31:42 (count = 0), RegionEntry
+Segment at 31:43 (count = 0), Skipped
+Segment at 31:46 (count = 0), RegionEntry
+Segment at 31:60 (count = 0), RegionEntry
+Segment at 31:61 (count = 0), RegionEntry
+Segment at 33:10 (count = 0), RegionEntry
+Segment at 33:11 (count = 0), Skipped
+Segment at 34:9 (count = 0), RegionEntry
+Segment at 34:23 (count = 0), Skipped
+Segment at 36:9 (count = 0), RegionEntry
+Segment at 36:15 (count = 0), Skipped
+Segment at 39:9 (count = 1), RegionEntry
+Segment at 39:26 (count = 0), Skipped
+Segment at 40:8 (count = 1), RegionEntry
+Segment at 40:12 (count = 0), Skipped
+Segment at 40:13 (count = 1), RegionEntry
+Segment at 42:6 (count = 0), Skipped
+Segment at 44:9 (count = 0), RegionEntry
+Segment at 44:10 (count = 0), Skipped
+Segment at 44:16 (count = 1), RegionEntry
+Segment at 44:29 (count = 0), Skipped
+Segment at 45:9 (count = 0), RegionEntry
+Segment at 45:23 (count = 0), Skipped
+Segment at 46:15 (count = 1), RegionEntry
+Segment at 46:28 (count = 0), Skipped
+Segment at 47:12 (count = 0), RegionEntry
+Segment at 47:25 (count = 0), Skipped
+Segment at 47:29 (count = 0), RegionEntry
+Segment at 47:42 (count = 0), RegionEntry
+Segment at 47:43 (count = 0), Skipped
+Segment at 47:46 (count = 0), RegionEntry
+Segment at 47:60 (count = 0), RegionEntry
+Segment at 47:61 (count = 0), RegionEntry
+Segment at 49:10 (count = 0), RegionEntry
+Segment at 49:11 (count = 0), Skipped
+Segment at 50:9 (count = 0), RegionEntry
+Segment at 50:23 (count = 0), Skipped
+Segment at 52:13 (count = 1), RegionEntry
+Segment at 54:15 (count = 0), Skipped
+Segment at 57:9 (count = 0), RegionEntry
+Segment at 57:10 (count = 0), Skipped
+Segment at 57:16 (count = 0), RegionEntry
+Segment at 57:29 (count = 0), Skipped
+Segment at 58:9 (count = 0), RegionEntry
+Segment at 58:23 (count = 0), Skipped
+Segment at 59:15 (count = 0), RegionEntry
+Segment at 59:28 (count = 0), Skipped
+Segment at 60:12 (count = 0), RegionEntry
+Segment at 60:25 (count = 0), Skipped
+Segment at 60:29 (count = 0), RegionEntry
+Segment at 60:42 (count = 0), RegionEntry
+Segment at 60:43 (count = 0), Skipped
+Segment at 60:46 (count = 0), RegionEntry
+Segment at 60:60 (count = 0), RegionEntry
+Segment at 60:61 (count = 0), RegionEntry
+Segment at 62:10 (count = 0), RegionEntry
+Segment at 62:11 (count = 0), Skipped
+Segment at 63:9 (count = 0), RegionEntry
+Segment at 63:23 (count = 0), Skipped
+Segment at 65:9 (count = 0), RegionEntry
+Segment at 65:15 (count = 0), Skipped
+Segment at 67:1 (count = 2), RegionEntry
+Segment at 67:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt
new file mode 100644
index 00000000000..1aad1a3c83b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while.txt
@@ -0,0 +1,22 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while 
+Counter in file 0 2:9 -> 2:16, #1
+Counter in file 0 3:11 -> 3:20, #2
+Counter in file 0 3:21 -> 4:6, #3
+Counter in file 0 4:6 -> 4:7, (#3 + 0)
+Counter in file 0 5:1 -> 5:2, #4
+Emitting segments for file: ../coverage/while.rs
+Combined regions:
+  2:9 -> 2:16 (count=1)
+  3:11 -> 3:20 (count=1)
+  3:21 -> 4:6 (count=0)
+  4:6 -> 4:7 (count=0)
+  5:1 -> 5:2 (count=1)
+Segment at 2:9 (count = 1), RegionEntry
+Segment at 2:16 (count = 0), Skipped
+Segment at 3:11 (count = 1), RegionEntry
+Segment at 3:20 (count = 0), Skipped
+Segment at 3:21 (count = 0), RegionEntry
+Segment at 4:6 (count = 0), RegionEntry
+Segment at 4:7 (count = 0), Skipped
+Segment at 5:1 (count = 1), RegionEntry
+Segment at 5:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt
new file mode 100644
index 00000000000..7c24ea22d67
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage_counters.while_early_return.txt
@@ -0,0 +1,44 @@
+Args: /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/llvm/build/bin/llvm-cov show --debug --Xdemangler=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/stage0-tools-bin/rust-demangler --show-line-counts-or-regions --instr-profile=/usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while_early_return.profdata /usr/local/google/home/richkadel/rust/build/x86_64-unknown-linux-gnu/test/run-make-fulldeps/coverage-reports-deadcode/coverage-reports-deadcode/while_early_return 
+Counter in file 0 5:9 -> 5:27, #1
+Counter in file 0 7:9 -> 9:10, #2
+Counter in file 0 12:13 -> 14:14, #3
+Counter in file 0 18:21 -> 20:22, #4
+Counter in file 0 22:21 -> 22:27, #5
+Counter in file 0 26:21 -> 26:27, #6
+Counter in file 0 27:18 -> 27:19, (#5 + 0)
+Counter in file 0 30:9 -> 32:10, #7
+Counter in file 0 35:5 -> 35:11, #8
+Counter in file 0 36:1 -> 36:2, #9
+Counter in file 0 36:1 -> 36:2, #10
+Emitting segments for file: ../coverage/while_early_return.rs
+Combined regions:
+  5:9 -> 5:27 (count=1)
+  7:9 -> 9:10 (count=7)
+  12:13 -> 14:14 (count=7)
+  18:21 -> 20:22 (count=1)
+  22:21 -> 22:27 (count=0)
+  26:21 -> 26:27 (count=1)
+  27:18 -> 27:19 (count=0)
+  30:9 -> 32:10 (count=6)
+  35:5 -> 35:11 (count=0)
+  36:1 -> 36:2 (count=2)
+Segment at 5:9 (count = 1), RegionEntry
+Segment at 5:27 (count = 0), Skipped
+Segment at 7:9 (count = 7), RegionEntry
+Segment at 9:10 (count = 0), Skipped
+Segment at 12:13 (count = 7), RegionEntry
+Segment at 14:14 (count = 0), Skipped
+Segment at 18:21 (count = 1), RegionEntry
+Segment at 20:22 (count = 0), Skipped
+Segment at 22:21 (count = 0), RegionEntry
+Segment at 22:27 (count = 0), Skipped
+Segment at 26:21 (count = 1), RegionEntry
+Segment at 26:27 (count = 0), Skipped
+Segment at 27:18 (count = 0), RegionEntry
+Segment at 27:19 (count = 0), Skipped
+Segment at 30:9 (count = 6), RegionEntry
+Segment at 32:10 (count = 0), Skipped
+Segment at 35:5 (count = 0), RegionEntry
+Segment at 35:11 (count = 0), Skipped
+Segment at 36:1 (count = 2), RegionEntry
+Segment at 36:2 (count = 0), Skipped
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
index 43f75c574d0..0f076a93c09 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 35:13-35:26: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="36:12-36:20: @0[5]: _4 = (*((*_1).0: &amp;bool))
 36:12-36:20: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="37:13-37:27: @3[0]: _2 = const 10_i32
-36:21-38:10: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+36:21-38:10: @3[1]: _3 = const ()
+38:10-38:10: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="37:13-37:27: @3[0]: _2 = const 10_i32
-36:21-38:10: @3[1]: _3 = const ()">            countdown = 10;</span></span>
+36:21-38:10: @3[1]: _3 = const ()
+38:10-38:10: @3.Goto: goto -&gt; bb4">            countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="37:13-37:27: @3[0]: _2 = const 10_i32
-36:21-38:10: @3[1]: _3 = const ()">        }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
+36:21-38:10: @3[1]: _3 = const ()
+38:10-38:10: @3.Goto: goto -&gt; bb4">        }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="38:10-38:10: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
 39:9-39:23: @4[5]: _5 = &amp;(*_6)
 39:9-39:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 40:6-40:6: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 2".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
 39:9-39:23: @4[5]: _5 = &amp;(*_6)
 39:9-39:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 40:6-40:6: @5.Return: return">    }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
index 8f07ec5fcde..bc78a604e31 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 77:13-77:26: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="78:12-78:20: @0[5]: _4 = (*((*_1).0: &amp;bool))
 78:12-78:20: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="79:13-79:27: @3[0]: _2 = const 10_i32
-78:21-80:10: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+78:21-80:10: @3[1]: _3 = const ()
+80:10-80:10: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="79:13-79:27: @3[0]: _2 = const 10_i32
-78:21-80:10: @3[1]: _3 = const ()">            countdown = 10;</span></span>
+78:21-80:10: @3[1]: _3 = const ()
+80:10-80:10: @3.Goto: goto -&gt; bb4">            countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="79:13-79:27: @3[0]: _2 = const 10_i32
-78:21-80:10: @3[1]: _3 = const ()">        }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
+78:21-80:10: @3[1]: _3 = const ()
+80:10-80:10: @3.Goto: goto -&gt; bb4">        }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="80:10-80:10: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
 81:9-81:23: @4[5]: _5 = &amp;(*_6)
 81:9-81:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 82:6-82:6: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 4".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
 81:9-81:23: @4[5]: _5 = &amp;(*_6)
 81:9-81:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 82:6-82:6: @5.Return: return">    }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
index ca9031a1094..b0db2311730 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 20:21-20:34: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">                if </span><span><span class="code even" style="--layer: 1" title="21:20-21:28: @0[5]: _4 = (*(_1.0: &amp;bool))
 21:20-21:28: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="22:21-22:35: @3[0]: _2 = const 10_i32
-21:29-23:18: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+21:29-23:18: @3[1]: _3 = const ()
+23:18-23:18: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="22:21-22:35: @3[0]: _2 = const 10_i32
-21:29-23:18: @3[1]: _3 = const ()">                    countdown = 10;</span></span>
+21:29-23:18: @3[1]: _3 = const ()
+23:18-23:18: @3.Goto: goto -&gt; bb4">                    countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="22:21-22:35: @3[0]: _2 = const 10_i32
-21:29-23:18: @3[1]: _3 = const ()">                }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
+21:29-23:18: @3[1]: _3 = const ()
+23:18-23:18: @3.Goto: goto -&gt; bb4">                }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="23:18-23:18: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
 24:17-24:31: @4[5]: _5 = &amp;(*_6)
 24:17-24:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 25:14-25:14: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 1".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
 24:17-24:31: @4[5]: _5 = &amp;(*_6)
 24:17-24:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 25:14-25:14: @5.Return: return">            }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
index 820f8d9c6cf..ca07a8d3ce5 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 62:21-62:34: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">                if </span><span><span class="code even" style="--layer: 1" title="63:20-63:28: @0[5]: _4 = (*(_1.0: &amp;bool))
 63:20-63:28: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="64:21-64:35: @3[0]: _2 = const 10_i32
-63:29-65:18: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+63:29-65:18: @3[1]: _3 = const ()
+65:18-65:18: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="64:21-64:35: @3[0]: _2 = const 10_i32
-63:29-65:18: @3[1]: _3 = const ()">                    countdown = 10;</span></span>
+63:29-65:18: @3[1]: _3 = const ()
+65:18-65:18: @3.Goto: goto -&gt; bb4">                    countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="64:21-64:35: @3[0]: _2 = const 10_i32
-63:29-65:18: @3[1]: _3 = const ()">                }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
+63:29-65:18: @3[1]: _3 = const ()
+65:18-65:18: @3.Goto: goto -&gt; bb4">                }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="65:18-65:18: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
 66:17-66:31: @4[5]: _5 = &amp;(*_6)
 66:17-66:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 67:14-67:14: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 3".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
 66:17-66:31: @4[5]: _5 = &amp;(*_6)
 66:17-66:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 67:14-67:14: @5.Return: return">            }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
index 494e6f20ea7..325b6c64345 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
@@ -114,6 +114,6 @@
 <span class="line"><span class="code even" style="--layer: 1" title="24:13-24:40: @2[4]: _18 = Firework { strength: const 1000_i32 }
 26:8-26:10: @6[2]: _19 = ()
 26:5-26:11: @6[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _19)">    Ok(())<span class="annotation">⦉@2,6,7,8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="27:2-27:2: @11.Return: return"><span class="annotation">@11⦊</span>‸<span class="annotation">⦉@11</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="27:2-27:2: @10.Goto: goto -&gt; bb11"><span class="annotation">@1,3,4,5,9,10⦊</span>‸<span class="annotation">⦉@1,3,4,5,9,10</span></span></span><span><span class="code even" style="--layer: 1" title="27:2-27:2: @8.Goto: goto -&gt; bb11"><span class="annotation">@2,6,7,8⦊</span>‸<span class="annotation">⦉@2,6,7,8</span></span></span><span><span class="code odd" style="--layer: 1" title="27:2-27:2: @11.Return: return"><span class="annotation">@11⦊</span>‸<span class="annotation">⦉@11</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
index 6dc893d28ff..55d7e8bfbae 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
@@ -162,6 +162,6 @@
 <span class="line"><span class="code even" style="--layer: 1" title="35:13-35:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
 37:8-37:10: @9[2]: _25 = ()
 37:5-37:11: @9[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">    Ok(())<span class="annotation">⦉@5,9,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="38:2-38:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="38:2-38:2: @13.Goto: goto -&gt; bb14"><span class="annotation">@4,6,7,8,12,13⦊</span>‸<span class="annotation">⦉@4,6,7,8,12,13</span></span></span><span><span class="code even" style="--layer: 1" title="38:2-38:2: @11.Goto: goto -&gt; bb14"><span class="annotation">@5,9,10,11⦊</span>‸<span class="annotation">⦉@5,9,10,11</span></span></span><span><span class="code odd" style="--layer: 1" title="38:2-38:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
index 0379d900e94..0d4b940214e 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
@@ -146,17 +146,23 @@
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="21:9-21:16: @3[5]: _6 = _1
 21:9-21:16: @3[6]: FakeRead(ForMatchedPlace, _6)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">        countdown</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">        countdown</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">        =</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">        =</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">            10</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">            10</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">        ;</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">        ;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="28:2-28:2: @7.Return: return"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span></span></div>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="27:6-27:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="28:2-28:2: @7.Return: return"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
index b51c5c84c0d..094dacde986 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
@@ -128,36 +128,36 @@
 20:9-22:16: @5[1]: _6 = const ()">        =</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="20:9-22:16: @5[0]: _5 = const 100_i32
 20:9-22:16: @5[1]: _6 = const ()">            100<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="23:6-23:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>‸<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    if</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="26:9-26:16: @7[3]: _8 = _1
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="26:9-26:16: @7[3]: _8 = _1
 26:9-26:16: @7[4]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@7⦊</span>is_true<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()"><span class="annotation">@8,10⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">        countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">        =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">            10</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">        ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">    }<span class="annotation">⦉@8,10</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    else</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()"><span class="annotation">@9⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">        countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">        =</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">            100</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">        ;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
-34:5-39:6: @9[1]: _0 = const ()">    }<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+34:5-39:6: @9[1]: _0 = const ()">    }<span class="annotation">⦉@9</span></span></span><span><span class="code odd" style="--layer: 1" title="39:6-39:6: @10.Goto: goto -&gt; bb11"><span class="annotation">@8,10⦊</span>‸<span class="annotation">⦉@8,10</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="40:2-40:2: @11.Return: return"><span class="annotation">@11⦊</span>‸<span class="annotation">⦉@11</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
index 49639cc6884..7f1262a6abf 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
@@ -63,8 +63,7 @@
 <span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="19:17-19:18: @0[1]: _2 = const 1_u32
 19:13-19:14: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>b = 1<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code odd" style="--layer: 1" title="20:13-20:14: @1[3]: FakeRead(ForLet, _3)"><span class="annotation">@1,2,3,4⦊</span>c<span class="annotation">⦉@1,2,3,4</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code even" style="--layer: 1" title="20:17-20:18: @0[5]: _4 = _1
-20:21-20:22: @0[7]: _5 = _2
-20:17-20:22: @0[8]: _6 = CheckedAdd(_4, _5)"><span class="annotation">@0⦊</span>a + b<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
+20:21-20:22: @0[7]: _5 = _2"><span class="annotation">@0⦊</span>a + b<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="21:18-21:26: @1[9]: _23 = const in_func::promoted[0]
 21:18-21:26: @1[10]: _11 = &amp;(*_23)
 21:18-21:26: @1[11]: _10 = &amp;(*_11)
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
index a2cf86de278..c9e0fe31211 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
@@ -60,8 +60,7 @@
 </head>
 <body>
 <div class="code" style="counter-reset: line 39"><span class="line">        <span class="code" style="--layer: 0">fn trait_func(&amp;mut self, incr: u32) {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="41:37-41:41: @0[1]: _3 = _2
-41:13-41:41: @0[2]: _4 = CheckedAdd(((*_1).0: u32), _3)"><span class="annotation">@0⦊</span>self.in_struct_field += incr<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            self.in_struct_field += </span><span><span class="code even" style="--layer: 1" title="41:37-41:41: @0[1]: _3 = _2"><span class="annotation">@0⦊</span>incr<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="42:21-42:41: @1[4]: _6 = ((*_1).0: u32)
 42:13-42:42: @1.Call: _5 = in_func(move _6) -&gt; [return: bb2, unwind: bb3]
 43:10-43:10: @2.Return: return"><span class="annotation">@1,2⦊</span>in_func(self.in_struct_field);</span></span>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
index 56557b8ef95..ec3517ec9ed 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
@@ -86,11 +86,14 @@
 9:9-9:22: @3[3]: FakeRead(ForLet, _5)">    let mut countdown = 0<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="10:8-10:15: @3[6]: _7 = _1
 10:8-10:15: @3[7]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="11:9-11:23: @6[0]: _5 = const 10_u32
-10:16-12:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @6[0]: _5 = const 10_u32
-10:16-12:6: @6[1]: _6 = const ()">        countdown = 10;</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">        countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @6[0]: _5 = const 10_u32
-10:16-12:6: @6[1]: _6 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="12:6-12:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    mod in_mod {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        const IN_MOD_CONST: u32 = 1000;</span></span>
@@ -126,16 +129,19 @@
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    type InType = String;</span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="48:8-48:15: @7[4]: _9 = _1
-48:8-48:15: @7[5]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@7⦊</span>is_true<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="48:8-48:15: @7[4]: _9 = _1
+48:8-48:15: @7[5]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@7⦊</span>is_true<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
 49:9-49:27: @10.Call: _10 = in_func(move _11) -&gt; [return: bb11, unwind: bb15]
-48:16-50:6: @11[2]: _8 = const ()"><span class="annotation">@8,10,11⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
+48:16-50:6: @11[2]: _8 = const ()
+50:6-50:6: @11.Goto: goto -&gt; bb12"><span class="annotation">@8,10,11⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
 49:9-49:27: @10.Call: _10 = in_func(move _11) -&gt; [return: bb11, unwind: bb15]
-48:16-50:6: @11[2]: _8 = const ()">        in_func(countdown);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
+48:16-50:6: @11[2]: _8 = const ()
+50:6-50:6: @11.Goto: goto -&gt; bb12">        in_func(countdown);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
 49:9-49:27: @10.Call: _10 = in_func(move _11) -&gt; [return: bb11, unwind: bb15]
-48:16-50:6: @11[2]: _8 = const ()">    }<span class="annotation">⦉@8,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
+48:16-50:6: @11[2]: _8 = const ()
+50:6-50:6: @11.Goto: goto -&gt; bb12">    }<span class="annotation">⦉@8,10,11</span></span></span><span><span class="code odd" style="--layer: 1" title="50:6-50:6: @9.Goto: goto -&gt; bb12"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="52:19-54:6: @12[3]: _12 = InStruct { in_struct_field: const 101_u32 }
 52:9-52:16: @12[4]: FakeRead(ForLet, _12)
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
index defe743df60..636341055dc 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
@@ -63,27 +63,27 @@
 <span class="line"><span class="code" style="--layer: 0">    // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span>
 <span class="line"><span class="code" style="--layer: 0">    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span>
 <span class="line"><span class="code" style="--layer: 0">    // dependent conditions.</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb25]
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb41]
 7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb24]
+7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb40]
 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
 7:9-7:16: @2[3]: FakeRead(ForLet, _1)
 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32)
 9:10-9:15: @3[4]: _5 = (_8.0: i32)
 9:17-9:22: @3[6]: _6 = (_8.1: i32)
 9:24-9:29: @3[8]: _7 = (_8.2: i32)"><span class="annotation">@0,1,2,3⦊</span>is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb25]
+<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb41]
 7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb24]
+7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb40]
 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
 7:9-7:16: @2[3]: FakeRead(ForLet, _1)
 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32)
 9:10-9:15: @3[4]: _5 = (_8.0: i32)
 9:17-9:22: @3[6]: _6 = (_8.1: i32)
 9:24-9:29: @3[8]: _7 = (_8.2: i32)"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb25]
+<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb41]
 7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb24]
+7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb40]
 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
 7:9-7:16: @2[3]: FakeRead(ForLet, _1)
 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32)
@@ -94,67 +94,126 @@
 10:8-10:15: @3[13]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">        a = 1;</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">        a = 1;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">        b = 10;</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">        b = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">        c = 100;</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">        c = 100;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="14:6-14:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="16:9-16:17: @11[2]: FakeRead(ForLet, _11)"><span class="annotation">@11⦊</span>somebool<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="16:9-16:17: @11[2]: FakeRead(ForLet, _11)"><span class="annotation">@11⦊</span>somebool<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="18:13-18:14: @7[5]: _13 = _5
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="18:13-18:14: @7[5]: _13 = _5
 18:17-18:18: @7[7]: _14 = _6
 18:13-18:18: @7[8]: _12 = Lt(move _13, move _14)"><span class="annotation">@7⦊</span>a &lt; b<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ||</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="20:13-20:14: @10[2]: _16 = _6
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="20:13-20:14: @10[2]: _16 = _6
 20:17-20:18: @10[4]: _17 = _7
-20:13-20:18: @10[5]: _15 = Lt(move _16, move _17)"><span class="annotation">@10⦊</span>b &lt; c<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0"></span></span>
+20:13-20:18: @10[5]: _15 = Lt(move _16, move _17)"><span class="annotation">@10⦊</span>b &lt; c<span class="annotation">⦉@10</span></span></span><span><span class="code even" style="--layer: 1" title="20:18-20:18: @8.Goto: goto -&gt; bb11"><span class="annotation">@8⦊</span>‸<span class="annotation">⦉@8</span></span></span><span><span class="code odd" style="--layer: 1" title="20:18-20:18: @9.Goto: goto -&gt; bb11"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="23:9-23:17: @15[2]: FakeRead(ForLet, _18)"><span class="annotation">@15⦊</span>somebool<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="23:9-23:17: @15[2]: FakeRead(ForLet, _18)"><span class="annotation">@15⦊</span>somebool<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="25:13-25:14: @11[6]: _20 = _6
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="25:13-25:14: @11[6]: _20 = _6
 25:17-25:18: @11[8]: _21 = _5
 25:13-25:18: @11[9]: _19 = Lt(move _20, move _21)"><span class="annotation">@11⦊</span>b &lt; a<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ||</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="27:13-27:14: @14[2]: _23 = _6
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:14: @14[2]: _23 = _6
 27:17-27:18: @14[4]: _24 = _7
-27:13-27:18: @14[5]: _22 = Lt(move _23, move _24)"><span class="annotation">@14⦊</span>b &lt; c<span class="annotation">⦉@14</span></span></span><span class="code" style="--layer: 0"></span></span>
+27:13-27:18: @14[5]: _22 = Lt(move _23, move _24)"><span class="annotation">@14⦊</span>b &lt; c<span class="annotation">⦉@14</span></span></span><span><span class="code odd" style="--layer: 1" title="27:18-27:18: @12.Goto: goto -&gt; bb15"><span class="annotation">@12⦊</span>‸<span class="annotation">⦉@12</span></span></span><span><span class="code even" style="--layer: 1" title="27:18-27:18: @13.Goto: goto -&gt; bb15"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="30:9-30:17: @19[2]: FakeRead(ForLet, _25)"><span class="annotation">@19⦊</span>somebool<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="32:13-32:14: @15[6]: _27 = _5
-32:17-32:18: @15[8]: _28 = _6
-32:13-32:18: @15[9]: _26 = Lt(move _27, move _28)"><span class="annotation">@15⦊</span>a &lt; b<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        &amp;&amp;</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="34:13-34:14: @18[2]: _30 = _6
-34:17-34:18: @18[4]: _31 = _7
-34:13-34:18: @18[5]: _29 = Lt(move _30, move _31)"><span class="annotation">@18⦊</span>b &lt; c<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="37:9-37:17: @23[2]: FakeRead(ForLet, _32)"><span class="annotation">@23⦊</span>somebool<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="39:13-39:14: @19[6]: _34 = _6
-39:17-39:18: @19[8]: _35 = _5
-39:13-39:18: @19[9]: _33 = Lt(move _34, move _35)"><span class="annotation">@19⦊</span>b &lt; a<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        &amp;&amp;</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="41:13-41:14: @22[2]: _37 = _6
-41:17-41:18: @22[4]: _38 = _7
-41:13-41:18: @22[5]: _36 = Lt(move _37, move _38)"><span class="annotation">@22⦊</span>b &lt; c<span class="annotation">⦉@22</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="43:2-43:2: @23.Return: return"><span class="annotation">@23⦊</span>‸<span class="annotation">⦉@23</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="29:9-29:17: @19[2]: FakeRead(ForLet, _25)"><span class="annotation">@19⦊</span>somebool<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code even" style="--layer: 1" title="29:20-29:21: @15[6]: _27 = _5
+29:24-29:25: @15[8]: _28 = _6
+29:20-29:25: @15[9]: _26 = Lt(move _27, move _28)"><span class="annotation">@15⦊</span>a &lt; b<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"> &amp;&amp; </span><span><span class="code odd" style="--layer: 1" title="29:29-29:30: @18[2]: _30 = _6
+29:33-29:34: @18[4]: _31 = _7
+29:29-29:34: @18[5]: _29 = Lt(move _30, move _31)"><span class="annotation">@18⦊</span>b &lt; c<span class="annotation">⦉@18</span></span></span><span><span class="code even" style="--layer: 1" title="29:34-29:34: @16.Goto: goto -&gt; bb19"><span class="annotation">@16⦊</span>‸<span class="annotation">⦉@16</span></span></span><span><span class="code odd" style="--layer: 1" title="29:34-29:34: @17.Goto: goto -&gt; bb19"><span class="annotation">@17⦊</span>‸<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="30:9-30:17: @23[2]: FakeRead(ForLet, _32)"><span class="annotation">@23⦊</span>somebool<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code odd" style="--layer: 1" title="30:20-30:21: @19[6]: _34 = _6
+30:24-30:25: @19[8]: _35 = _5
+30:20-30:25: @19[9]: _33 = Lt(move _34, move _35)"><span class="annotation">@19⦊</span>b &lt; a<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"> &amp;&amp; </span><span><span class="code even" style="--layer: 1" title="30:29-30:30: @22[2]: _37 = _6
+30:33-30:34: @22[4]: _38 = _7
+30:29-30:34: @22[5]: _36 = Lt(move _37, move _38)"><span class="annotation">@22⦊</span>b &lt; c<span class="annotation">⦉@22</span></span></span><span><span class="code odd" style="--layer: 1" title="30:34-30:34: @20.Goto: goto -&gt; bb23"><span class="annotation">@20⦊</span>‸<span class="annotation">⦉@20</span></span></span><span><span class="code even" style="--layer: 1" title="30:34-30:34: @21.Goto: goto -&gt; bb23"><span class="annotation">@21⦊</span>‸<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="34:9-34:16: @23[6]: _41 = _1
+33:9-34:16: @23[7]: _40 = Not(move _41)
+33:9-34:16: @23[9]: FakeRead(ForMatchedPlace, _40)"><span class="annotation">@23⦊</span>!</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="34:9-34:16: @23[6]: _41 = _1
+33:9-34:16: @23[7]: _40 = Not(move _41)
+33:9-34:16: @23[9]: FakeRead(ForMatchedPlace, _40)">        is_true<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27"><span class="annotation">@24,26⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27">        a = 2</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27">        ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27">    }<span class="annotation">⦉@24,26</span></span></span><span><span class="code odd" style="--layer: 1" title="38:6-38:6: @25.Goto: goto -&gt; bb27"><span class="annotation">@25⦊</span>‸<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="41:9-41:16: @27[4]: _43 = _1
+41:9-41:16: @27[5]: FakeRead(ForMatchedPlace, _43)"><span class="annotation">@27⦊</span>is_true<span class="annotation">⦉@27</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()"><span class="annotation">@28,30⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()">        b = 30</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()">        ;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()">    }<span class="annotation">⦉@28,30</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    else</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()"><span class="annotation">@29⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()">        c = 400</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()">        ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()">    }<span class="annotation">⦉@29</span></span></span><span><span class="code odd" style="--layer: 1" title="50:6-50:6: @30.Goto: goto -&gt; bb31"><span class="annotation">@28,30⦊</span>‸<span class="annotation">⦉@28,30</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="52:9-52:16: @31[5]: _46 = _1
+52:8-52:16: @31[6]: _45 = Not(move _46)
+52:8-52:16: @31[8]: FakeRead(ForMatchedPlace, _45)"><span class="annotation">@31⦊</span>!is_true<span class="annotation">⦉@31</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="53:9-53:14: @34[0]: _5 = const 2_i32
+52:17-54:6: @34[1]: _44 = const ()
+54:6-54:6: @34.Goto: goto -&gt; bb35"><span class="annotation">@32,34⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="53:9-53:14: @34[0]: _5 = const 2_i32
+52:17-54:6: @34[1]: _44 = const ()
+54:6-54:6: @34.Goto: goto -&gt; bb35">        a = 2;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="53:9-53:14: @34[0]: _5 = const 2_i32
+52:17-54:6: @34[1]: _44 = const ()
+54:6-54:6: @34.Goto: goto -&gt; bb35">    }<span class="annotation">⦉@32,34</span></span></span><span><span class="code even" style="--layer: 1" title="54:6-54:6: @33.Goto: goto -&gt; bb35"><span class="annotation">@33⦊</span>‸<span class="annotation">⦉@33</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="56:8-56:15: @35[3]: _47 = _1
+56:8-56:15: @35[4]: FakeRead(ForMatchedPlace, _47)"><span class="annotation">@35⦊</span>is_true<span class="annotation">⦉@35</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="57:9-57:15: @38[0]: _6 = const 30_i32
+56:16-58:6: @38[1]: _0 = const ()"><span class="annotation">@36,38⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="57:9-57:15: @38[0]: _6 = const 30_i32
+56:16-58:6: @38[1]: _0 = const ()">        b = 30;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="57:9-57:15: @38[0]: _6 = const 30_i32
+56:16-58:6: @38[1]: _0 = const ()">    }<span class="annotation">⦉@36,38</span></span></span><span class="code" style="--layer: 0"> else </span><span><span class="code odd" style="--layer: 1" title="59:9-59:16: @37[0]: _7 = const 400_i32
+58:12-60:6: @37[1]: _0 = const ()"><span class="annotation">@37⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="59:9-59:16: @37[0]: _7 = const 400_i32
+58:12-60:6: @37[1]: _0 = const ()">        c = 400;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="59:9-59:16: @37[0]: _7 = const 400_i32
+58:12-60:6: @37[1]: _0 = const ()">    }<span class="annotation">⦉@37</span></span></span><span><span class="code even" style="--layer: 1" title="60:6-60:6: @38.Goto: goto -&gt; bb39"><span class="annotation">@36,38⦊</span>‸<span class="annotation">⦉@36,38</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="61:2-61:2: @39.Return: return"><span class="annotation">@39⦊</span>‸<span class="annotation">⦉@39</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..a876c85822f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,151 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>loops_and_branches.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 21"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return">    let debug_test = DebugTest;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return">    println!("{:?}", debug_test);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return">}<span class="annotation">⦉@0,1,2,3</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..1b9767506f2
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>loops_and_branches.{impl#0}-fmt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 8"><span class="line">    <span class="code" style="--layer: 0">fn fmt(&amp;self, f: &amp;mut std::fmt::Formatter) -&gt; std::fmt::Result {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="10:12-10:16: @0[2]: _4 = const true
+10:12-10:16: @0[3]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>true<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code odd" style="--layer: 1" title="11:16-11:21: @3[2]: _6 = const false
+11:16-11:21: @3[3]: FakeRead(ForMatchedPlace, _6)"><span class="annotation">@1,3⦊</span>false<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                while </span><span><span class="code even" style="--layer: 1" title="12:23-12:27: @7[1]: _8 = const true
+12:23-12:27: @7[2]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@6,7⦊</span>true<span class="annotation">⦉@6,7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="12:28-13:18: @10[0]: _7 = const ()
+13:18-13:18: @10.Goto: goto -&gt; bb6"><span class="annotation">@8,10⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="12:28-13:18: @10[0]: _7 = const ()
+13:18-13:18: @10.Goto: goto -&gt; bb6">                }<span class="annotation">⦉@8,10</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code even" style="--layer: 1" title="14:14-14:14: @9.Goto: goto -&gt; bb11"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span><span><span class="code odd" style="--layer: 1" title="14:14-14:14: @5.Goto: goto -&gt; bb11"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="15:20-15:21: @11[6]: _13 = &amp;mut (*_2)
+15:23-15:30: @11[11]: _32 = const &lt;DebugTest as Debug&gt;::fmt::promoted[1]
+15:23-15:30: @11[12]: _17 = &amp;(*_32)
+15:23-15:30: @11[13]: _16 = &amp;(*_17)
+15:23-15:30: @11[14]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
+15:13-15:31: @11[20]: _23 = ()
+15:13-15:31: @11[21]: FakeRead(ForMatchedPlace, _23)
+15:13-15:31: @11[22]: _31 = const &lt;DebugTest as Debug&gt;::fmt::promoted[0]
+15:13-15:31: @11[23]: _21 = &amp;(*_31)
+15:13-15:31: @11[24]: _20 = &amp;(*_21)
+15:13-15:31: @11[25]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+15:13-15:31: @11.Call: _14 = Arguments::new_v1(move _15, move _19) -&gt; [return: bb12, unwind: bb23]
+15:13-15:31: @12.Call: _12 = Formatter::write_fmt(move _13, move _14) -&gt; [return: bb13, unwind: bb23]"><span class="annotation">@11,12,13,14⦊</span>write!(f, "error")<span class="annotation">⦉@11,12,13,14</span></span></span><span><span class="code odd" style="--layer: 1" title="15:31-15:32: @18[1]: _25 = ((_11 as Err).0: std::fmt::Error)
+15:31-15:32: @18[4]: _28 = _25
+15:31-15:32: @18.Call: _27 = &lt;std::fmt::Error as From&lt;std::fmt::Error&gt;&gt;::from(move _28) -&gt; [return: bb19, unwind: bb23]"><span class="annotation">@16,18,19,20⦊</span>?<span class="annotation">⦉@16,18,19,20</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        } else </span><span><span class="code even" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()">        }<span class="annotation">⦉@2</span></span></span><span><span class="code odd" style="--layer: 1" title="17:10-17:10: @15.Goto: goto -&gt; bb21"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="18:12-18:14: @21[3]: _30 = ()
+18:9-18:15: @21[4]: _0 = std::result::Result::&lt;(), std::fmt::Error&gt;::Ok(move _30)"><span class="annotation">@21⦊</span>Ok(())<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="19:6-19:6: @20.Goto: goto -&gt; bb22"><span class="annotation">@16,18,19,20⦊</span>‸<span class="annotation">⦉@16,18,19,20</span></span></span><span><span class="code even" style="--layer: 1" title="19:6-19:6: @22.Return: return"><span class="annotation">@22⦊</span>‸<span class="annotation">⦉@22</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..042845b70cc
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>nested_loops.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 0"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb35]
+2:19-2:35: @1[0]: _3 = &amp;_4
+2:19-2:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb34]
+2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+2:9-2:16: @2[3]: FakeRead(ForLet, _1)
+3:25-3:27: @3[2]: _5 = const 10_i32
+3:9-3:22: @3[3]: FakeRead(ForLet, _5)"><span class="annotation">@0,1,2,3⦊</span>is_true = std::env::args().len() == 1;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb35]
+2:19-2:35: @1[0]: _3 = &amp;_4
+2:19-2:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb34]
+2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+2:9-2:16: @2[3]: FakeRead(ForLet, _1)
+3:25-3:27: @3[2]: _5 = const 10_i32
+3:9-3:22: @3[3]: FakeRead(ForLet, _5)">    let mut countdown = 10<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    'outer: while </span><span><span class="code odd" style="--layer: 1" title="5:19-5:28: @5[2]: _8 = _5
+5:19-5:32: @5[3]: _7 = Gt(move _8, const 0_i32)
+5:19-5:32: @5[5]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@4,5⦊</span>countdown &gt; 0<span class="annotation">⦉@4,5</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="6:21-6:24: @8[1]: _9 = const 100_i32
+6:13-6:18: @8[2]: FakeRead(ForLet, _9)
+7:21-7:24: @8[4]: _10 = const 100_i32
+7:13-7:18: @8[5]: FakeRead(ForLet, _10)"><span class="annotation">@6,8,9⦊</span>mut a = 100;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:21-6:24: @8[1]: _9 = const 100_i32
+6:13-6:18: @8[2]: FakeRead(ForLet, _9)
+7:21-7:24: @8[4]: _10 = const 100_i32
+7:13-7:18: @8[5]: FakeRead(ForLet, _10)">        let mut b = 100<span class="annotation">⦉@6,8,9</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        for </span><span><span class="code odd" style="--layer: 1" title="8:13-8:14: @16[1]: _21 = ((_17 as Some).0: i32)
+8:13-8:14: @16[3]: _22 = _21
+8:13-8:14: @16[4]: _15 = move _22
+8:13-8:14: @16[5]: _16 = const ()"><span class="annotation">@14,16⦊</span>_<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> in </span><span><span class="code even" style="--layer: 1" title="8:18-8:23: @11[5]: _19 = &amp;mut _14
+8:18-8:23: @11[6]: _18 = &amp;mut (*_19)
+8:18-8:23: @11.Call: _17 = &lt;std::ops::Range&lt;i32&gt; as Iterator&gt;::next(move _18) -&gt; [return: bb12, unwind: bb35]
+8:18-8:23: @12[1]: FakeRead(ForMatchedPlace, _17)"><span class="annotation">@10,11,12⦊</span>0..50<span class="annotation">⦉@10,11,12</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code odd" style="--layer: 1" title="9:16-9:17: @16[15]: _27 = _9
+9:16-9:22: @16[16]: _26 = Lt(move _27, const 30_i32)
+9:16-9:22: @16[18]: FakeRead(ForMatchedPlace, _26)"><span class="annotation">@14,16⦊</span>a &lt; 30<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="10:17-10:22: @19[0]: _11 = const ()"><span class="annotation">@17,19⦊</span>break<span class="annotation">⦉@17,19</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="12:13-12:19: @20[0]: _9 = move (_29.0: i32)"><span class="annotation">@20⦊</span>a -= 5<span class="annotation">⦉@20</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="13:13-13:19: @21[0]: _10 = move (_30.0: i32)"><span class="annotation">@21⦊</span>b -= 5<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code even" style="--layer: 1" title="14:16-14:17: @21[3]: _32 = _10
+14:16-14:22: @21[4]: _31 = Lt(move _32, const 90_i32)
+14:16-14:22: @21[6]: FakeRead(ForMatchedPlace, _31)"><span class="annotation">@21⦊</span>b &lt; 90<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="15:17-15:24: @25[0]: _9 = move (_33.0: i32)
+16:20-16:27: @25[2]: _34 = _1
+16:20-16:27: @25[3]: FakeRead(ForMatchedPlace, _34)"><span class="annotation">@25⦊</span>a -= 10;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="15:17-15:24: @25[0]: _9 = move (_33.0: i32)
+16:20-16:27: @25[2]: _34 = _1
+16:20-16:27: @25[3]: FakeRead(ForMatchedPlace, _34)">                if is_true<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    </span><span><span class="code even" style="--layer: 1" title="17:21-17:33: @28[0]: _0 = const ()"><span class="annotation">@26,28⦊</span>break 'outer<span class="annotation">⦉@26,28</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                } else {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    </span><span><span class="code odd" style="--layer: 1" title="19:21-19:27: @29[0]: _9 = move (_36.0: i32)
+21:14-21:14: @29.Goto: goto -&gt; bb30"><span class="annotation">@29⦊</span>a -= 2;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="19:21-19:27: @29[0]: _9 = move (_36.0: i32)
+21:14-21:14: @29.Goto: goto -&gt; bb30">                }</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="19:21-19:27: @29[0]: _9 = move (_36.0: i32)
+21:14-21:14: @29.Goto: goto -&gt; bb30">            }<span class="annotation">⦉@29</span></span></span><span><span class="code even" style="--layer: 1" title="21:14-21:14: @23.Goto: goto -&gt; bb30"><span class="annotation">@23⦊</span>‸<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span><span><span class="code odd" style="--layer: 1" title="22:10-22:10: @9.Goto: goto -&gt; bb10"><span class="annotation">@6,8,9⦊</span>‸<span class="annotation">⦉@6,8,9</span></span></span><span><span class="code even" style="--layer: 1" title="22:10-22:10: @30.Goto: goto -&gt; bb10"><span class="annotation">@30⦊</span>‸<span class="annotation">⦉@30</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="23:9-23:23: @32[0]: _5 = move (_37.0: i32)"><span class="annotation">@32⦊</span>countdown -= 1<span class="annotation">⦉@32</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="24:6-24:6: @3.Goto: goto -&gt; bb4"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span><span class="code odd" style="--layer: 1" title="24:6-24:6: @7.Goto: goto -&gt; bb33"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="25:2-25:2: @33.Return: return"><span class="annotation">@33⦊</span>‸<span class="annotation">⦉@33</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..3ebe51bc7ec
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,285 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 20"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">    let version_3_2_1 = Version::new(3, 2, 1);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">    let version_3_3_0 = Version::new(3, 3, 0);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">    println!("{:?} &lt; {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 &lt; version_3_3_0);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..ee6a5489f26
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html
@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#0}-new - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 11"><span class="line">    <span class="code" style="--layer: 0">pub fn new(major: usize, minor: usize, patch: usize) -&gt; Self {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return"><span class="annotation">@0⦊</span>Self {</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">            major,</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">            minor,</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">            patch,</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">        }</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">    }<span class="annotation">⦉@0</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..a39772288a3
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#1}-cmp - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                                  <span><span class="code even" style="--layer: 1" title="4:51-4:54: @14.Goto: goto -&gt; bb15"><span class="annotation">@14⦊</span></span></span><span class="code even" style="--layer: 2" title="4:51-4:54: @12[0]: _0 = Equal
+4:51-4:54: @12.Goto: goto -&gt; bb13"><span class="annotation">@11,12⦊</span></span><span class="code even" style="--layer: 3" title="4:51-4:54: @10[1]: _27 = _21
+4:51-4:54: @10[2]: _0 = _27
+4:51-4:54: @10.Goto: goto -&gt; bb13"><span class="annotation">@10⦊</span></span><span class="code even" style="--layer: 4" title="4:51-4:54: @13.Goto: goto -&gt; bb14"><span class="annotation">@13⦊</span>Ord<span class="annotation">⦉@13</span></span><span class="code even" style="--layer: 3" title="4:51-4:54: @10[1]: _27 = _21
+4:51-4:54: @10[2]: _0 = _27
+4:51-4:54: @10.Goto: goto -&gt; bb13"><span class="annotation">⦉@10</span></span><span class="code even" style="--layer: 2" title="4:51-4:54: @12[0]: _0 = Equal
+4:51-4:54: @12.Goto: goto -&gt; bb13"><span class="annotation">⦉@11,12</span></span><span><span class="code even" style="--layer: 1" title="4:51-4:54: @14.Goto: goto -&gt; bb15"><span class="annotation">⦉@14</span></span></span><span><span class="code odd" style="--layer: 1" title="4:54-4:54: @15.Return: return"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..671cbea0ff3
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Less
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..6da79c4b130
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-ge-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..5f5c31ce775
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-ge - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..fbdd0f7db42
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Less
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..736f2034333
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-gt-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..0fec7c9932f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-gt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..ff4eba10789
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Greater
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..ccc86a7f92f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-le-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..682b9112c4c
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-le - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..e018c96c24f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Greater
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..a10032059b5
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-lt-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..89dad0f9069
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-lt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..2c03e967eeb
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-partial_cmp - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @17.Goto: goto -&gt; bb18"><span class="annotation">@17⦊</span></span></span><span class="code even" style="--layer: 2" title="4:39-4:49: @15[1]: _30 = Equal
+4:39-4:49: @15[2]: _0 = Option::&lt;std::cmp::Ordering&gt;::Some(move _30)
+4:39-4:49: @15.Goto: goto -&gt; bb16"><span class="annotation">@14,15⦊</span></span><span class="code even" style="--layer: 3" title="4:39-4:49: @12[1]: _31 = _23
+4:39-4:49: @12[2]: _0 = _31
+4:39-4:49: @12.Goto: goto -&gt; bb16"><span class="annotation">@12⦊</span></span><span class="code even" style="--layer: 4" title="4:39-4:49: @16.Goto: goto -&gt; bb17"><span class="annotation">@16⦊</span>PartialOrd<span class="annotation">⦉@16</span></span><span class="code even" style="--layer: 3" title="4:39-4:49: @12[1]: _31 = _23
+4:39-4:49: @12[2]: _0 = _31
+4:39-4:49: @12.Goto: goto -&gt; bb16"><span class="annotation">⦉@12</span></span><span class="code even" style="--layer: 2" title="4:39-4:49: @15[1]: _30 = Equal
+4:39-4:49: @15[2]: _0 = Option::&lt;std::cmp::Ordering&gt;::Some(move _30)
+4:39-4:49: @15.Goto: goto -&gt; bb16"><span class="annotation">⦉@14,15</span></span><span><span class="code even" style="--layer: 1" title="4:39-4:49: @17.Goto: goto -&gt; bb18"><span class="annotation">⦉@17</span></span></span><span><span class="code odd" style="--layer: 1" title="4:49-4:49: @18.Return: return"><span class="annotation">@18⦊</span>‸<span class="annotation">⦉@18</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..49d73b3457b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html
@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                  <span><span class="code even" style="--layer: 1" title="4:35-4:37: @0[0]: _0 = const ()
+4:37-4:37: @0.Return: return"><span class="annotation">@0⦊</span>Eq<span class="annotation">⦉@0</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..bc34080f109
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#6}-eq - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                       <span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span></span></span><span class="code even" style="--layer: 2" title="4:24-4:33: @1[0]: _0 = const true
+4:24-4:33: @1.Goto: goto -&gt; bb4"><span class="annotation">@1⦊</span>PartialEq<span class="annotation">⦉@1</span></span><span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">⦉@2</span></span></span><span><span class="code odd" style="--layer: 1" title="4:33-4:33: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..376c8dd80d0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#6}-ne - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                       <span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span></span></span><span class="code even" style="--layer: 2" title="4:24-4:33: @5[0]: _9 = const true
+4:24-4:33: @5.Goto: goto -&gt; bb8"><span class="annotation">@5⦊</span></span><span class="code even" style="--layer: 3" title="4:24-4:33: @6[0]: _9 = const false
+4:24-4:33: @6.Goto: goto -&gt; bb8"><span class="annotation">@6⦊</span></span><span class="code even" style="--layer: 4" title="4:24-4:33: @1[0]: _0 = const true
+4:24-4:33: @1.Goto: goto -&gt; bb4"><span class="annotation">@1⦊</span>PartialEq<span class="annotation">⦉@1</span></span><span class="code even" style="--layer: 3" title="4:24-4:33: @6[0]: _9 = const false
+4:24-4:33: @6.Goto: goto -&gt; bb8"><span class="annotation">⦉@6</span></span><span class="code even" style="--layer: 2" title="4:24-4:33: @5[0]: _9 = const true
+4:24-4:33: @5.Goto: goto -&gt; bb8"><span class="annotation">⦉@5</span></span><span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">⦉@2</span></span></span><span><span class="code odd" style="--layer: 1" title="4:33-4:33: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..c3fed16a3b4
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#7}-fmt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                <span><span class="code even" style="--layer: 1" title="4:17-4:22: @0[0]: FakeRead(ForMatchedPlace, (*_1))
+4:17-4:22: @0[2]: _3 = &amp;((*_1).0: usize)
+4:17-4:22: @0[4]: _4 = &amp;((*_1).1: usize)
+4:17-4:22: @0[6]: _5 = &amp;((*_1).2: usize)
+4:17-4:22: @0[9]: _7 = &amp;mut (*_2)
+4:17-4:22: @0[12]: _9 = const &quot;Version&quot;
+4:17-4:22: @0[13]: _8 = &amp;(*_9)
+4:17-4:22: @0.Call: _6 = Formatter::debug_struct(move _7, move _8) -&gt; [return: bb1, unwind: bb6]
+4:17-4:22: @1[2]: FakeRead(ForLet, _6)
+4:17-4:22: @1[6]: _11 = &amp;mut _6
+4:17-4:22: @1[9]: _13 = const &quot;major&quot;
+4:17-4:22: @1[10]: _12 = &amp;(*_13)
+4:17-4:22: @1[15]: _17 = &amp;(*_3)
+4:17-4:22: @1[16]: _16 = &amp;_17
+4:17-4:22: @1[17]: _15 = &amp;(*_16)
+4:17-4:22: @1[18]: _14 = move _15 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
+4:17-4:22: @1.Call: _10 = DebugStruct::field(move _11, move _12, move _14) -&gt; [return: bb2, unwind: bb6]
+4:17-4:22: @2[9]: _19 = &amp;mut _6
+4:17-4:22: @2[12]: _21 = const &quot;minor&quot;
+4:17-4:22: @2[13]: _20 = &amp;(*_21)
+4:17-4:22: @2[18]: _25 = &amp;(*_4)
+4:17-4:22: @2[19]: _24 = &amp;_25
+4:17-4:22: @2[20]: _23 = &amp;(*_24)
+4:17-4:22: @2[21]: _22 = move _23 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
+4:17-4:22: @2.Call: _18 = DebugStruct::field(move _19, move _20, move _22) -&gt; [return: bb3, unwind: bb6]
+4:17-4:22: @3[9]: _27 = &amp;mut _6
+4:17-4:22: @3[12]: _29 = const &quot;patch&quot;
+4:17-4:22: @3[13]: _28 = &amp;(*_29)
+4:17-4:22: @3[18]: _33 = &amp;(*_5)
+4:17-4:22: @3[19]: _32 = &amp;_33
+4:17-4:22: @3[20]: _31 = &amp;(*_32)
+4:17-4:22: @3[21]: _30 = move _31 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
+4:17-4:22: @3.Call: _26 = DebugStruct::field(move _27, move _28, move _30) -&gt; [return: bb4, unwind: bb6]
+4:17-4:22: @4[8]: _34 = &amp;mut _6
+4:17-4:22: @4.Call: _0 = DebugStruct::finish(move _34) -&gt; [return: bb5, unwind: bb6]
+4:22-4:22: @5.Return: return"><span class="annotation">@0,1,2,3,4,5⦊</span>Debug<span class="annotation">⦉@0,1,2,3,4,5</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..6a4f11e0754
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#8}-clone - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">         <span><span class="code even" style="--layer: 1" title="4:10-4:15: @0[0]: FakeRead(ForMatchedPlace, (*_1))
+4:10-4:15: @0[2]: _2 = &amp;((*_1).0: usize)
+4:10-4:15: @0[4]: _3 = &amp;((*_1).1: usize)
+4:10-4:15: @0[6]: _4 = &amp;((*_1).2: usize)
+4:10-4:15: @0[10]: _7 = &amp;(*_2)
+4:10-4:15: @0[11]: _6 = &amp;(*_7)
+4:10-4:15: @0.Call: _5 = &lt;usize as Clone&gt;::clone(move _6) -&gt; [return: bb1, unwind: bb4]
+4:10-4:15: @1[4]: _10 = &amp;(*_3)
+4:10-4:15: @1[5]: _9 = &amp;(*_10)
+4:10-4:15: @1.Call: _8 = &lt;usize as Clone&gt;::clone(move _9) -&gt; [return: bb2, unwind: bb4]
+4:10-4:15: @2[4]: _13 = &amp;(*_4)
+4:10-4:15: @2[5]: _12 = &amp;(*_13)
+4:10-4:15: @2.Call: _11 = &lt;usize as Clone&gt;::clone(move _12) -&gt; [return: bb3, unwind: bb4]
+4:10-4:15: @3[1]: _0 = Version { major: move _5, minor: move _8, patch: move _11 }
+4:15-4:15: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>Clone<span class="annotation">⦉@0,1,2,3</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
index 4b21d3fc263..618f84513e9 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
@@ -89,39 +89,45 @@
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="12:9-12:16: @3[6]: _7 = _1
 12:9-12:16: @3[7]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">        countdown</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">        countdown</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">        =</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">        =</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">            10</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">            10</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">        ;</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">        ;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="18:6-18:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    loop</span></span>
 <span class="line"><span class="code" style="--layer: 0">    {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
 23:13-25:14: @9[4]: _10 = Eq(move _11, const 0_i32)
 23:13-25:14: @9[6]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@8,9⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
+<span class="line"><span class="code odd" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
 23:13-25:14: @9[4]: _10 = Eq(move _11, const 0_i32)
 23:13-25:14: @9[6]: FakeRead(ForMatchedPlace, _10)">                ==</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
+<span class="line"><span class="code odd" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
 23:13-25:14: @9[4]: _10 = Eq(move _11, const 0_i32)
 23:13-25:14: @9[6]: FakeRead(ForMatchedPlace, _10)">            0<span class="annotation">⦉@8,9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="27:13-27:18: @12[0]: _0 = const ()"><span class="annotation">@10,12⦊</span>break<span class="annotation">⦉@10,12</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:18: @12[0]: _0 = const ()"><span class="annotation">@10,12⦊</span>break<span class="annotation">⦉@10,12</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">            ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="30:9-32:10: @11[3]: _13 = CheckedSub(_5, const 1_i32)"><span class="annotation">@11⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @11[3]: _13 = CheckedSub(_5, const 1_i32)">        -=</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @11[3]: _13 = CheckedSub(_5, const 1_i32)">        1<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="30:9-32:10: @13[0]: _5 = move (_13.0: i32)"><span class="annotation">@13⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @13[0]: _5 = move (_13.0: i32)">        -=</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @13[0]: _5 = move (_13.0: i32)">        1<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="34:6-34:6: @7.Goto: goto -&gt; bb8"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="35:2-35:2: @12.Return: return"><span class="annotation">@10,12⦊</span>‸<span class="annotation">⦉@10,12</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
index 5ba770ef607..66885d0612b 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
@@ -86,51 +86,39 @@
 9:9-9:22: @3[3]: FakeRead(ForLet, _5)">    let mut countdown = 1<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="10:8-10:15: @3[6]: _7 = _1
 10:8-10:15: @3[7]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="11:9-11:22: @6[0]: _5 = const 0_i32
-10:16-12:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:22: @6[0]: _5 = const 0_i32
-10:16-12:6: @6[1]: _6 = const ()">        countdown = 0;</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">        countdown = 0;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:22: @6[0]: _5 = const 0_i32
-10:16-12:6: @6[1]: _6 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="12:6-12:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="15:9-15:10: @11[2]: _17 = discriminant(_14)"><span class="annotation">@9,10,11⦊</span>for</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="15:9-15:10: @11[2]: _17 = discriminant(_14)">        _<span class="annotation">⦉@9,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    for</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="15:9-15:10: @15[1]: _18 = ((_14 as Some).0: i32)
+15:9-15:10: @15[3]: _19 = _18
+15:9-15:10: @15[4]: _12 = move _19
+15:9-15:10: @15[5]: _13 = const ()"><span class="annotation">@13,15,17⦊</span>_<span class="annotation">⦉@13,15,17</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    in</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="17:9-17:13: @7[4]: _9 = std::ops::Range::&lt;i32&gt; { start: const 0_i32, end: const 2_i32 }
-17:9-17:13: @7.Call: _8 = &lt;std::ops::Range&lt;i32&gt; as IntoIterator&gt;::into_iter(move _9) -&gt; [return: bb8, unwind: bb22]
-17:9-17:13: @8[1]: FakeRead(ForMatchedPlace, _8)
-17:9-17:13: @8[3]: _10 = move _8"><span class="annotation">@7,8⦊</span>0..2<span class="annotation">⦉@7,8</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="17:9-17:13: @10[5]: _16 = &amp;mut _10
+17:9-17:13: @10[6]: _15 = &amp;mut (*_16)
+17:9-17:13: @10.Call: _14 = &lt;std::ops::Range&lt;i32&gt; as Iterator&gt;::next(move _15) -&gt; [return: bb11, unwind: bb22]
+17:9-17:13: @11[1]: FakeRead(ForMatchedPlace, _14)"><span class="annotation">@9,10,11⦊</span>0..2<span class="annotation">⦉@9,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        let z</span></span>
 <span class="line"><span class="code" style="--layer: 0">        ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        match</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)"><span class="annotation">@13,15,17⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">        {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">            x</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">            if</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                x</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)"><span class="annotation">@13,15,17⦊</span>countdown<span class="annotation">⦉@13,15,17</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="24:13-24:14: @18[3]: _23 = _5"><span class="annotation">@18⦊</span>x<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            if</span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="26:17-26:18: @17[4]: _26 = (*_24)
+26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)"><span class="annotation">@13,15,17⦊</span>x</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="26:17-26:18: @17[4]: _26 = (*_24)
 26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                    &lt;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                1<span class="annotation">⦉@13,15,17</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="26:17-26:18: @17[4]: _26 = (*_24)
+26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                1<span class="annotation">⦉@13,15,17</span></span></span><span><span class="code even" style="--layer: 1" title="28:18-28:18: @19.Goto: goto -&gt; bb16"><span class="annotation">@19⦊</span>‸<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">            =&gt;</span></span>
 <span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="31:21-31:30: @18[5]: _27 = _5
 31:17-31:30: @18[6]: _22 = move _27
@@ -184,7 +172,7 @@
 <span class="line"><span class="code" style="--layer: 0">            =&gt;</span></span>
 <span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="40:13-40:15: @16[0]: _21 = const ()"><span class="annotation">@16⦊</span>{}<span class="annotation">⦉@16</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="42:6-42:6: @8.Goto: goto -&gt; bb9"><span class="annotation">@7,8⦊</span>‸<span class="annotation">⦉@7,8</span></span></span><span><span class="code even" style="--layer: 1" title="42:6-42:6: @20.Goto: goto -&gt; bb9"><span class="annotation">@20⦊</span>‸<span class="annotation">⦉@20</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="43:2-43:2: @12.Return: return"><span class="annotation">@12⦊</span>‸<span class="annotation">⦉@12</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..db08315baa6
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>tight_infinite_loop.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 0"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="2:8-2:13: @0[1]: _1 = const false
+2:8-2:13: @0[2]: FakeRead(ForMatchedPlace, _1)"><span class="annotation">@0⦊</span>false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="3:9-3:16: @4.FalseUnwind: falseUnwind -&gt; [real: bb5, cleanup: bb6]
+3:14-3:16: @5[0]: _3 = const ()"><span class="annotation">@4,5⦊</span>loop {}<span class="annotation">⦉@4,5</span></span></span><span><span class="code even" style="--layer: 1" title="3:16-3:16: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>‸<span class="annotation">⦉@1,3</span></span></span><span><span class="code odd" style="--layer: 1" title="3:16-3:16: @5.Goto: goto -&gt; bb4"><span class="annotation">@4,5⦊</span>‸<span class="annotation">⦉@4,5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="5:2-5:2: @2.Return: return"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
index 9f993342340..8a0b1ae8dab 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
@@ -67,7 +67,7 @@
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="8:12-8:14: @2[1]: _4 = ()
 8:9-8:15: @2[2]: _0 = std::result::Result::&lt;(), ()&gt;::Ok(move _4)"><span class="annotation">@2⦊</span>Ok(())<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="10:2-10:2: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="9:6-9:6: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>‸<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="10:2-10:2: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
index 660c3031f35..428c6fadc27 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
@@ -65,37 +65,51 @@
 <span class="line"><span class="code even" style="--layer: 1" title="14:21-14:23: @0[1]: _1 = const 10_i32
 13:9-14:18: @0[2]: FakeRead(ForLet, _1)">        countdown = 10<span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="17:9-17:10: @4[2]: _12 = discriminant(_9)"><span class="annotation">@2,3,4⦊</span>for</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="17:9-17:10: @4[2]: _12 = discriminant(_9)">        _<span class="annotation">⦉@2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    for</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="17:9-17:10: @8[1]: _13 = ((_9 as Some).0: i32)
+17:9-17:10: @8[3]: _14 = _13
+17:9-17:10: @8[4]: _7 = move _14
+17:9-17:10: @8[5]: _8 = const ()"><span class="annotation">@6,8⦊</span>_<span class="annotation">⦉@6,8</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    in</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="19:9-19:14: @0[6]: _4 = std::ops::Range::&lt;i32&gt; { start: const 0_i32, end: const 10_i32 }
-19:9-19:14: @0.Call: _3 = &lt;std::ops::Range&lt;i32&gt; as IntoIterator&gt;::into_iter(move _4) -&gt; [return: bb1, unwind: bb32]
-19:9-19:14: @1[1]: FakeRead(ForMatchedPlace, _3)
-19:9-19:14: @1[3]: _5 = move _3"><span class="annotation">@0,1⦊</span>0..10<span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="19:9-19:14: @3[5]: _11 = &amp;mut _5
+19:9-19:14: @3[6]: _10 = &amp;mut (*_11)
+19:9-19:14: @3.Call: _9 = &lt;std::ops::Range&lt;i32&gt; as Iterator&gt;::next(move _10) -&gt; [return: bb4, unwind: bb32]
+19:9-19:14: @4[1]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@2,3,4⦊</span>0..10<span class="annotation">⦉@2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="21:9-22:17: @8[12]: _17 = CheckedSub(_1, const 1_i32)"><span class="annotation">@6,8⦊</span>countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @8[12]: _17 = CheckedSub(_1, const 1_i32)">            -= 1<span class="annotation">⦉@6,8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="25:13-25:22: @9[3]: _19 = _1
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
 25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
-25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)"><span class="annotation">@9⦊</span>countdown &lt; 5<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)"><span class="annotation">@9⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">            -= 1</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">        ;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">        if</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">            countdown &lt; 5<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="27:13-27:41: @12.Call: _22 = call(const true) -&gt; [return: bb13, unwind: bb32]
-27:13-27:42: @13.Call: _21 = &lt;std::result::Result&lt;(), ()&gt; as Try&gt;::into_result(move _22) -&gt; [return: bb14, unwind: bb32]
-27:13-27:42: @14[1]: FakeRead(ForMatchedPlace, _21)
-27:41-27:42: @14[2]: _23 = discriminant(_21)"><span class="annotation">@10,12,13,14⦊</span>call(/*return_error=*/ true)?<span class="annotation">⦉@10,12,13,14</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:41: @12.Call: _22 = call(const true) -&gt; [return: bb13, unwind: bb32]"><span class="annotation">@10,12,13,14⦊</span>call(/*return_error=*/ true)<span class="annotation">⦉@10,12,13,14</span></span></span><span><span class="code odd" style="--layer: 1" title="27:41-27:42: @18[1]: _24 = ((_21 as Err).0: ())
+27:41-27:42: @18[4]: _27 = _24
+27:41-27:42: @18.Call: _26 = &lt;() as From&lt;()&gt;&gt;::from(move _27) -&gt; [return: bb19, unwind: bb32]"><span class="annotation">@16,18,19,20⦊</span>?<span class="annotation">⦉@16,18,19,20</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
 <span class="line"><span class="code" style="--layer: 0">        else</span></span>
 <span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="31:13-31:42: @11.Call: _31 = call(const false) -&gt; [return: bb21, unwind: bb32]
-31:13-31:43: @21.Call: _30 = &lt;std::result::Result&lt;(), ()&gt; as Try&gt;::into_result(move _31) -&gt; [return: bb22, unwind: bb32]
-31:13-31:43: @22[1]: FakeRead(ForMatchedPlace, _30)
-31:42-31:43: @22[2]: _32 = discriminant(_30)"><span class="annotation">@11,21,22⦊</span>call(/*return_error=*/ false)?<span class="annotation">⦉@11,21,22</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="34:8-34:10: @5[9]: _38 = ()
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="31:13-31:42: @11.Call: _31 = call(const false) -&gt; [return: bb21, unwind: bb32]"><span class="annotation">@11,21,22⦊</span>call(/*return_error=*/ false)<span class="annotation">⦉@11,21,22</span></span></span><span><span class="code odd" style="--layer: 1" title="31:42-31:43: @26[1]: _33 = ((_30 as Err).0: ())
+31:42-31:43: @26[4]: _36 = _33
+31:42-31:43: @26.Call: _35 = &lt;() as From&lt;()&gt;&gt;::from(move _36) -&gt; [return: bb27, unwind: bb32]"><span class="annotation">@24,26,27,28⦊</span>?<span class="annotation">⦉@24,26,27,28</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span><span><span class="code even" style="--layer: 1" title="32:10-32:10: @15.Goto: goto -&gt; bb29"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span><span><span class="code odd" style="--layer: 1" title="32:10-32:10: @23.Goto: goto -&gt; bb29"><span class="annotation">@23⦊</span>‸<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="33:6-33:6: @1.Goto: goto -&gt; bb2"><span class="annotation">@0,1⦊</span>‸<span class="annotation">⦉@0,1</span></span></span><span><span class="code odd" style="--layer: 1" title="33:6-33:6: @29.Goto: goto -&gt; bb2"><span class="annotation">@29⦊</span>‸<span class="annotation">⦉@29</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="34:8-34:10: @5[9]: _38 = ()
 34:5-34:11: @5[10]: _0 = std::result::Result::&lt;(), ()&gt;::Ok(move _38)"><span class="annotation">@5⦊</span>Ok(())<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="35:2-35:2: @31.Return: return"><span class="annotation">@31⦊</span>‸<span class="annotation">⦉@31</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="35:2-35:2: @30.Goto: goto -&gt; bb31"><span class="annotation">@30⦊</span>‸<span class="annotation">⦉@30</span></span></span><span><span class="code even" style="--layer: 1" title="35:2-35:2: @31.Return: return"><span class="annotation">@31⦊</span>‸<span class="annotation">⦉@31</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
index 28f1d013c83..b9f6f4d7832 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
@@ -64,32 +64,42 @@
 4:9-4:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="5:8-5:12: @0[5]: _3 = const true
 5:8-5:12: @0[6]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@0⦊</span>true<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="6:9-6:23: @3[0]: _1 = const 10_u32
-5:13-7:6: @3[1]: _2 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+5:13-7:6: @3[1]: _2 = const ()
+7:6-7:6: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="6:9-6:23: @3[0]: _1 = const 10_u32
-5:13-7:6: @3[1]: _2 = const ()">        countdown = 10;</span></span>
+5:13-7:6: @3[1]: _2 = const ()
+7:6-7:6: @3.Goto: goto -&gt; bb4">        countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="6:9-6:23: @3[0]: _1 = const 10_u32
-5:13-7:6: @3[1]: _2 = const ()">    }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
+5:13-7:6: @3[1]: _2 = const ()
+7:6-7:6: @3.Goto: goto -&gt; bb4">    }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="7:6-7:6: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    const B: u32 = 100;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="10:9-10:10: @25[0]: FakeRead(ForLet, _4)"><span class="annotation">@25⦊</span>x<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code odd" style="--layer: 1" title="10:16-10:25: @4[5]: _6 = _1
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="10:9-10:10: @25[0]: FakeRead(ForLet, _4)"><span class="annotation">@25⦊</span>x<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="10:16-10:25: @4[5]: _6 = _1
 10:16-10:29: @4[6]: _5 = Gt(move _6, const 7_u32)
 10:16-10:29: @4[8]: FakeRead(ForMatchedPlace, _5)"><span class="annotation">@4⦊</span>countdown &gt; 7<span class="annotation">⦉@4</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="11:9-11:23: @7[0]: _7 = CheckedSub(_1, const 4_u32)"><span class="annotation">@5,7⦊</span>countdown -= 4<span class="annotation">⦉@5,7</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="12:9-12:10: @8[1]: _4 = const B"><span class="annotation">@8⦊</span>B<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="11:9-11:23: @8[0]: _1 = move (_7.0: u32)
+12:9-12:10: @8[1]: _4 = const B"><span class="annotation">@8⦊</span>countdown -= 4;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @8[0]: _1 = move (_7.0: u32)
+12:9-12:10: @8[1]: _4 = const B">        B<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="13:15-13:24: @6[2]: _9 = _1
 13:15-13:28: @6[3]: _8 = Gt(move _9, const 2_u32)
 13:15-13:28: @6[5]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@6⦊</span>countdown &gt; 2<span class="annotation">⦉@6</span></span></span><span class="code" style="--layer: 0"> {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="14:12-14:21: @11[5]: _14 = _1
 14:12-14:25: @11[6]: _13 = Lt(move _14, const 1_u32)"><span class="annotation">@9,11⦊</span>countdown &lt; 1<span class="annotation">⦉@9,11</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="14:29-14:38: @18[2]: _16 = _1
-14:29-14:42: @18[3]: _15 = Gt(move _16, const 5_u32)"><span class="annotation">@18⦊</span>countdown &gt; 5<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="14:46-14:55: @14[2]: _18 = _1
-14:46-14:60: @14[3]: _17 = Ne(move _18, const 9_u32)"><span class="annotation">@14⦊</span>countdown != 9<span class="annotation">⦉@14</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
-14:61-16:10: @22[1]: _10 = const ()"><span class="annotation">@20,22⦊</span>{</span></span>
+14:29-14:42: @18[3]: _15 = Gt(move _16, const 5_u32)"><span class="annotation">@18⦊</span>countdown &gt; 5<span class="annotation">⦉@18</span></span></span><span><span class="code odd" style="--layer: 1" title="14:42-14:42: @16.Goto: goto -&gt; bb19"><span class="annotation">@16⦊</span>‸<span class="annotation">⦉@16</span></span></span><span><span class="code even" style="--layer: 1" title="14:42-14:42: @17.Goto: goto -&gt; bb19"><span class="annotation">@17⦊</span>‸<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="14:46-14:55: @14[2]: _18 = _1
+14:46-14:60: @14[3]: _17 = Ne(move _18, const 9_u32)"><span class="annotation">@14⦊</span>countdown != 9<span class="annotation">⦉@14</span></span></span><span><span class="code even" style="--layer: 1" title="14:60-14:60: @12.Goto: goto -&gt; bb15"><span class="annotation">@12⦊</span>‸<span class="annotation">⦉@12</span></span></span><span><span class="code odd" style="--layer: 1" title="14:60-14:60: @13.Goto: goto -&gt; bb15"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
+14:61-16:10: @22[1]: _10 = const ()
+16:10-16:10: @22.Goto: goto -&gt; bb23"><span class="annotation">@20,22⦊</span>{</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
-14:61-16:10: @22[1]: _10 = const ()">            countdown = 0;</span></span>
+14:61-16:10: @22[1]: _10 = const ()
+16:10-16:10: @22.Goto: goto -&gt; bb23">            countdown = 0;</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
-14:61-16:10: @22[1]: _10 = const ()">        }<span class="annotation">⦉@20,22</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="17:9-17:23: @23[2]: _19 = CheckedSub(_1, const 5_u32)"><span class="annotation">@23⦊</span>countdown -= 5<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="18:9-18:18: @24[1]: _4 = _1"><span class="annotation">@24⦊</span>countdown<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0"></span></span>
+14:61-16:10: @22[1]: _10 = const ()
+16:10-16:10: @22.Goto: goto -&gt; bb23">        }<span class="annotation">⦉@20,22</span></span></span><span><span class="code odd" style="--layer: 1" title="16:10-16:10: @21.Goto: goto -&gt; bb23"><span class="annotation">@21⦊</span>‸<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="17:9-17:23: @24[0]: _1 = move (_19.0: u32)
+18:9-18:18: @24[1]: _4 = _1"><span class="annotation">@24⦊</span>countdown -= 5;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="17:9-17:23: @24[0]: _1 = move (_19.0: u32)
+18:9-18:18: @24[1]: _4 = _1">        countdown<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="20:9-20:15: @10[0]: _0 = const ()"><span class="annotation">@10⦊</span>return<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    };</span></span>
@@ -98,29 +108,35 @@
 23:9-23:22: @25[4]: FakeRead(ForLet, _21)"><span class="annotation">@25⦊</span>mut countdown = 0<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="24:8-24:12: @25[7]: _23 = const true
 24:8-24:12: @25[8]: FakeRead(ForMatchedPlace, _23)"><span class="annotation">@25⦊</span>true<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="25:9-25:23: @28[0]: _21 = const 10_i32
-24:13-26:6: @28[1]: _22 = const ()"><span class="annotation">@26,28⦊</span>{</span></span>
+24:13-26:6: @28[1]: _22 = const ()
+26:6-26:6: @28.Goto: goto -&gt; bb29"><span class="annotation">@26,28⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:23: @28[0]: _21 = const 10_i32
-24:13-26:6: @28[1]: _22 = const ()">        countdown = 10;</span></span>
+24:13-26:6: @28[1]: _22 = const ()
+26:6-26:6: @28.Goto: goto -&gt; bb29">        countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:23: @28[0]: _21 = const 10_i32
-24:13-26:6: @28[1]: _22 = const ()">    }<span class="annotation">⦉@26,28</span></span></span><span class="code" style="--layer: 0"></span></span>
+24:13-26:6: @28[1]: _22 = const ()
+26:6-26:6: @28.Goto: goto -&gt; bb29">    }<span class="annotation">⦉@26,28</span></span></span><span><span class="code even" style="--layer: 1" title="26:6-26:6: @27.Goto: goto -&gt; bb29"><span class="annotation">@27⦊</span>‸<span class="annotation">⦉@27</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="28:8-28:17: @29[5]: _26 = _21
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="28:8-28:17: @29[5]: _26 = _21
 28:8-28:21: @29[6]: _25 = Gt(move _26, const 7_i32)
 28:8-28:21: @29[8]: FakeRead(ForMatchedPlace, _25)"><span class="annotation">@29⦊</span>countdown &gt; 7<span class="annotation">⦉@29</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="29:9-29:23: @32[0]: _27 = CheckedSub(_21, const 4_i32)"><span class="annotation">@30,32⦊</span>countdown -= 4<span class="annotation">⦉@30,32</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="30:15-30:24: @31[2]: _29 = _21
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="29:9-29:23: @33[0]: _21 = move (_27.0: i32)"><span class="annotation">@33⦊</span>countdown -= 4<span class="annotation">⦉@33</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code odd" style="--layer: 1" title="30:15-30:24: @31[2]: _29 = _21
 30:15-30:28: @31[3]: _28 = Gt(move _29, const 2_i32)
 30:15-30:28: @31[5]: FakeRead(ForMatchedPlace, _28)"><span class="annotation">@31⦊</span>countdown &gt; 2<span class="annotation">⦉@31</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="31:12-31:21: @36[5]: _34 = _21
-31:12-31:25: @36[6]: _33 = Lt(move _34, const 1_i32)"><span class="annotation">@34,36⦊</span>countdown &lt; 1<span class="annotation">⦉@34,36</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="31:29-31:38: @43[2]: _36 = _21
-31:29-31:42: @43[3]: _35 = Gt(move _36, const 5_i32)"><span class="annotation">@43⦊</span>countdown &gt; 5<span class="annotation">⦉@43</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="31:46-31:55: @39[2]: _38 = _21
-31:46-31:60: @39[3]: _37 = Ne(move _38, const 9_i32)"><span class="annotation">@39⦊</span>countdown != 9<span class="annotation">⦉@39</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
-31:61-33:10: @47[1]: _30 = const ()"><span class="annotation">@45,47⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
-31:61-33:10: @47[1]: _30 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
-31:61-33:10: @47[1]: _30 = const ()">        }<span class="annotation">⦉@45,47</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="34:9-34:23: @48[2]: _39 = CheckedSub(_21, const 5_i32)"><span class="annotation">@48⦊</span>countdown -= 5<span class="annotation">⦉@48</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="31:12-31:21: @36[5]: _34 = _21
+31:12-31:25: @36[6]: _33 = Lt(move _34, const 1_i32)"><span class="annotation">@34,36⦊</span>countdown &lt; 1<span class="annotation">⦉@34,36</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="31:29-31:38: @43[2]: _36 = _21
+31:29-31:42: @43[3]: _35 = Gt(move _36, const 5_i32)"><span class="annotation">@43⦊</span>countdown &gt; 5<span class="annotation">⦉@43</span></span></span><span><span class="code even" style="--layer: 1" title="31:42-31:42: @41.Goto: goto -&gt; bb44"><span class="annotation">@41⦊</span>‸<span class="annotation">⦉@41</span></span></span><span><span class="code odd" style="--layer: 1" title="31:42-31:42: @42.Goto: goto -&gt; bb44"><span class="annotation">@42⦊</span>‸<span class="annotation">⦉@42</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="31:46-31:55: @39[2]: _38 = _21
+31:46-31:60: @39[3]: _37 = Ne(move _38, const 9_i32)"><span class="annotation">@39⦊</span>countdown != 9<span class="annotation">⦉@39</span></span></span><span><span class="code odd" style="--layer: 1" title="31:60-31:60: @37.Goto: goto -&gt; bb40"><span class="annotation">@37⦊</span>‸<span class="annotation">⦉@37</span></span></span><span><span class="code even" style="--layer: 1" title="31:60-31:60: @38.Goto: goto -&gt; bb40"><span class="annotation">@38⦊</span>‸<span class="annotation">⦉@38</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
+31:61-33:10: @47[1]: _30 = const ()
+33:10-33:10: @47.Goto: goto -&gt; bb48"><span class="annotation">@45,47⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
+31:61-33:10: @47[1]: _30 = const ()
+33:10-33:10: @47.Goto: goto -&gt; bb48">            countdown = 0;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
+31:61-33:10: @47[1]: _30 = const ()
+33:10-33:10: @47.Goto: goto -&gt; bb48">        }<span class="annotation">⦉@45,47</span></span></span><span><span class="code even" style="--layer: 1" title="33:10-33:10: @46.Goto: goto -&gt; bb48"><span class="annotation">@46⦊</span>‸<span class="annotation">⦉@46</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="34:9-34:23: @49[0]: _21 = move (_39.0: i32)"><span class="annotation">@49⦊</span>countdown -= 5<span class="annotation">⦉@49</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="36:9-36:15: @35[0]: _0 = const ()"><span class="annotation">@35⦊</span>return<span class="annotation">⦉@35</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    }</span></span>
@@ -129,29 +145,35 @@
 39:9-39:22: @50[4]: FakeRead(ForLet, _41)"><span class="annotation">@50⦊</span>mut countdown = 0<span class="annotation">⦉@50</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="40:8-40:12: @50[7]: _43 = const true
 40:8-40:12: @50[8]: FakeRead(ForMatchedPlace, _43)"><span class="annotation">@50⦊</span>true<span class="annotation">⦉@50</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="41:9-41:22: @53[0]: _41 = const 1_i32
-40:13-42:6: @53[1]: _42 = const ()"><span class="annotation">@51,53⦊</span>{</span></span>
+40:13-42:6: @53[1]: _42 = const ()
+42:6-42:6: @53.Goto: goto -&gt; bb54"><span class="annotation">@51,53⦊</span>{</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="41:9-41:22: @53[0]: _41 = const 1_i32
-40:13-42:6: @53[1]: _42 = const ()">        countdown = 1;</span></span>
+40:13-42:6: @53[1]: _42 = const ()
+42:6-42:6: @53.Goto: goto -&gt; bb54">        countdown = 1;</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="41:9-41:22: @53[0]: _41 = const 1_i32
-40:13-42:6: @53[1]: _42 = const ()">    }<span class="annotation">⦉@51,53</span></span></span><span class="code" style="--layer: 0"></span></span>
+40:13-42:6: @53[1]: _42 = const ()
+42:6-42:6: @53.Goto: goto -&gt; bb54">    }<span class="annotation">⦉@51,53</span></span></span><span><span class="code odd" style="--layer: 1" title="42:6-42:6: @52.Goto: goto -&gt; bb54"><span class="annotation">@52⦊</span>‸<span class="annotation">⦉@52</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="44:9-44:10: @77[0]: FakeRead(ForLet, _44)"><span class="annotation">@77⦊</span>z<span class="annotation">⦉@77</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="44:16-44:25: @54[5]: _46 = _41
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="44:9-44:10: @77[0]: FakeRead(ForLet, _44)"><span class="annotation">@77⦊</span>z<span class="annotation">⦉@77</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code odd" style="--layer: 1" title="44:16-44:25: @54[5]: _46 = _41
 44:16-44:29: @54[6]: _45 = Gt(move _46, const 7_i32)
 44:16-44:29: @54[8]: FakeRead(ForMatchedPlace, _45)"><span class="annotation">@54⦊</span>countdown &gt; 7<span class="annotation">⦉@54</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="45:9-45:23: @57[0]: _47 = CheckedSub(_41, const 4_i32)"><span class="annotation">@55,57⦊</span>countdown -= 4<span class="annotation">⦉@55,57</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="46:15-46:24: @56[2]: _49 = _41
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="45:9-45:23: @58[0]: _41 = move (_47.0: i32)"><span class="annotation">@58⦊</span>countdown -= 4<span class="annotation">⦉@58</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code odd" style="--layer: 1" title="46:15-46:24: @56[2]: _49 = _41
 46:15-46:28: @56[3]: _48 = Gt(move _49, const 2_i32)
 46:15-46:28: @56[5]: FakeRead(ForMatchedPlace, _48)"><span class="annotation">@56⦊</span>countdown &gt; 2<span class="annotation">⦉@56</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="47:12-47:21: @61[5]: _54 = _41
-47:12-47:25: @61[6]: _53 = Lt(move _54, const 1_i32)"><span class="annotation">@59,61⦊</span>countdown &lt; 1<span class="annotation">⦉@59,61</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="47:29-47:38: @68[2]: _56 = _41
-47:29-47:42: @68[3]: _55 = Gt(move _56, const 5_i32)"><span class="annotation">@68⦊</span>countdown &gt; 5<span class="annotation">⦉@68</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="47:46-47:55: @64[2]: _58 = _41
-47:46-47:60: @64[3]: _57 = Ne(move _58, const 9_i32)"><span class="annotation">@64⦊</span>countdown != 9<span class="annotation">⦉@64</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
-47:61-49:10: @72[1]: _50 = const ()"><span class="annotation">@70,72⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
-47:61-49:10: @72[1]: _50 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
-47:61-49:10: @72[1]: _50 = const ()">        }<span class="annotation">⦉@70,72</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="50:9-50:23: @73[2]: _59 = CheckedSub(_41, const 5_i32)"><span class="annotation">@73⦊</span>countdown -= 5<span class="annotation">⦉@73</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="47:12-47:21: @61[5]: _54 = _41
+47:12-47:25: @61[6]: _53 = Lt(move _54, const 1_i32)"><span class="annotation">@59,61⦊</span>countdown &lt; 1<span class="annotation">⦉@59,61</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="47:29-47:38: @68[2]: _56 = _41
+47:29-47:42: @68[3]: _55 = Gt(move _56, const 5_i32)"><span class="annotation">@68⦊</span>countdown &gt; 5<span class="annotation">⦉@68</span></span></span><span><span class="code even" style="--layer: 1" title="47:42-47:42: @66.Goto: goto -&gt; bb69"><span class="annotation">@66⦊</span>‸<span class="annotation">⦉@66</span></span></span><span><span class="code odd" style="--layer: 1" title="47:42-47:42: @67.Goto: goto -&gt; bb69"><span class="annotation">@67⦊</span>‸<span class="annotation">⦉@67</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="47:46-47:55: @64[2]: _58 = _41
+47:46-47:60: @64[3]: _57 = Ne(move _58, const 9_i32)"><span class="annotation">@64⦊</span>countdown != 9<span class="annotation">⦉@64</span></span></span><span><span class="code odd" style="--layer: 1" title="47:60-47:60: @62.Goto: goto -&gt; bb65"><span class="annotation">@62⦊</span>‸<span class="annotation">⦉@62</span></span></span><span><span class="code even" style="--layer: 1" title="47:60-47:60: @63.Goto: goto -&gt; bb65"><span class="annotation">@63⦊</span>‸<span class="annotation">⦉@63</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
+47:61-49:10: @72[1]: _50 = const ()
+49:10-49:10: @72.Goto: goto -&gt; bb73"><span class="annotation">@70,72⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
+47:61-49:10: @72[1]: _50 = const ()
+49:10-49:10: @72.Goto: goto -&gt; bb73">            countdown = 0;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
+47:61-49:10: @72[1]: _50 = const ()
+49:10-49:10: @72.Goto: goto -&gt; bb73">        }<span class="annotation">⦉@70,72</span></span></span><span><span class="code even" style="--layer: 1" title="49:10-49:10: @71.Goto: goto -&gt; bb73"><span class="annotation">@71⦊</span>‸<span class="annotation">⦉@71</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="50:9-50:23: @74[0]: _41 = move (_59.0: i32)"><span class="annotation">@74⦊</span>countdown -= 5<span class="annotation">⦉@74</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="52:35-52:44: @60[1]: _61 = _41
 52:13-52:32: @60[2]: FakeRead(ForLet, _61)
@@ -206,23 +228,26 @@
 <span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="57:9-57:10: @98[0]: FakeRead(ForLet, _74)"><span class="annotation">@98⦊</span>w<span class="annotation">⦉@98</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="57:16-57:25: @77[5]: _76 = _41
 57:16-57:29: @77[6]: _75 = Gt(move _76, const 7_i32)
 57:16-57:29: @77[8]: FakeRead(ForMatchedPlace, _75)"><span class="annotation">@77⦊</span>countdown &gt; 7<span class="annotation">⦉@77</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="58:9-58:23: @80[0]: _77 = CheckedSub(_41, const 4_i32)"><span class="annotation">@78,80⦊</span>countdown -= 4<span class="annotation">⦉@78,80</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="58:9-58:23: @81[0]: _41 = move (_77.0: i32)"><span class="annotation">@81⦊</span>countdown -= 4<span class="annotation">⦉@81</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="59:15-59:24: @79[2]: _79 = _41
 59:15-59:28: @79[3]: _78 = Gt(move _79, const 2_i32)
 59:15-59:28: @79[5]: FakeRead(ForMatchedPlace, _78)"><span class="annotation">@79⦊</span>countdown &gt; 2<span class="annotation">⦉@79</span></span></span><span class="code" style="--layer: 0"> {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="60:12-60:21: @84[5]: _84 = _41
 60:12-60:25: @84[6]: _83 = Lt(move _84, const 1_i32)"><span class="annotation">@82,84⦊</span>countdown &lt; 1<span class="annotation">⦉@82,84</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="60:29-60:38: @91[2]: _86 = _41
-60:29-60:42: @91[3]: _85 = Gt(move _86, const 5_i32)"><span class="annotation">@91⦊</span>countdown &gt; 5<span class="annotation">⦉@91</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="60:46-60:55: @87[2]: _88 = _41
-60:46-60:60: @87[3]: _87 = Ne(move _88, const 9_i32)"><span class="annotation">@87⦊</span>countdown != 9<span class="annotation">⦉@87</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
-60:61-62:10: @95[1]: _80 = const ()"><span class="annotation">@93,95⦊</span>{</span></span>
+60:29-60:42: @91[3]: _85 = Gt(move _86, const 5_i32)"><span class="annotation">@91⦊</span>countdown &gt; 5<span class="annotation">⦉@91</span></span></span><span><span class="code odd" style="--layer: 1" title="60:42-60:42: @89.Goto: goto -&gt; bb92"><span class="annotation">@89⦊</span>‸<span class="annotation">⦉@89</span></span></span><span><span class="code even" style="--layer: 1" title="60:42-60:42: @90.Goto: goto -&gt; bb92"><span class="annotation">@90⦊</span>‸<span class="annotation">⦉@90</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="60:46-60:55: @87[2]: _88 = _41
+60:46-60:60: @87[3]: _87 = Ne(move _88, const 9_i32)"><span class="annotation">@87⦊</span>countdown != 9<span class="annotation">⦉@87</span></span></span><span><span class="code even" style="--layer: 1" title="60:60-60:60: @85.Goto: goto -&gt; bb88"><span class="annotation">@85⦊</span>‸<span class="annotation">⦉@85</span></span></span><span><span class="code odd" style="--layer: 1" title="60:60-60:60: @86.Goto: goto -&gt; bb88"><span class="annotation">@86⦊</span>‸<span class="annotation">⦉@86</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
+60:61-62:10: @95[1]: _80 = const ()
+62:10-62:10: @95.Goto: goto -&gt; bb96"><span class="annotation">@93,95⦊</span>{</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
-60:61-62:10: @95[1]: _80 = const ()">            countdown = 0;</span></span>
+60:61-62:10: @95[1]: _80 = const ()
+62:10-62:10: @95.Goto: goto -&gt; bb96">            countdown = 0;</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
-60:61-62:10: @95[1]: _80 = const ()">        }<span class="annotation">⦉@93,95</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="63:9-63:23: @96[2]: _89 = CheckedSub(_41, const 5_i32)"><span class="annotation">@96⦊</span>countdown -= 5<span class="annotation">⦉@96</span></span></span><span class="code" style="--layer: 0">;</span></span>
+60:61-62:10: @95[1]: _80 = const ()
+62:10-62:10: @95.Goto: goto -&gt; bb96">        }<span class="annotation">⦉@93,95</span></span></span><span><span class="code odd" style="--layer: 1" title="62:10-62:10: @94.Goto: goto -&gt; bb96"><span class="annotation">@94⦊</span>‸<span class="annotation">⦉@94</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="63:9-63:23: @97[0]: _41 = move (_89.0: i32)"><span class="annotation">@97⦊</span>countdown -= 5<span class="annotation">⦉@97</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="65:9-65:15: @83[0]: _0 = const ()"><span class="annotation">@83⦊</span>return<span class="annotation">⦉@83</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="65:9-65:15: @83[0]: _0 = const ()"><span class="annotation">@83⦊</span>return<span class="annotation">⦉@83</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    };</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="67:2-67:2: @102.Return: return"><span class="annotation">@102⦊</span>‸<span class="annotation">⦉@102</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="67:2-67:2: @101.Goto: goto -&gt; bb102"><span class="annotation">@101⦊</span>‸<span class="annotation">⦉@101</span></span></span><span><span class="code odd" style="--layer: 1" title="67:2-67:2: @102.Return: return"><span class="annotation">@102⦊</span>‸<span class="annotation">⦉@102</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..5c49ec19707
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>while.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 0"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="2:15-2:16: @0[1]: _1 = const 9_i32
+2:9-2:12: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>num = 9<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    while </span><span><span class="code odd" style="--layer: 1" title="3:11-3:14: @2[2]: _4 = _1
+3:11-3:20: @2[3]: _3 = Ge(move _4, const 10_i32)
+3:11-3:20: @2[5]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@1,2⦊</span>num &gt;= 10<span class="annotation">⦉@1,2</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="3:21-4:6: @5[0]: _2 = const ()"><span class="annotation">@3,5⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="3:21-4:6: @5[0]: _2 = const ()">    }<span class="annotation">⦉@3,5</span></span></span><span><span class="code even" style="--layer: 1" title="4:6-4:6: @5.Goto: goto -&gt; bb1"><span class="annotation">@3,5⦊</span>‸<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="5:2-5:2: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
index b96789a9219..be674dc7d38 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
@@ -62,12 +62,10 @@
 <div class="code" style="counter-reset: line 3"><span class="line"><span class="code" style="--layer: 0">fn main() -&gt; Result&lt;(),u8&gt; {</span></span>
 <span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="5:25-5:27: @0[1]: _1 = const 10_i32
 5:9-5:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>mut countdown = 10<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
+<span class="line"><span class="code" style="--layer: 0">    while</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
 7:9-9:10: @2[3]: _4 = Gt(move _5, const 0_i32)
-7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>while</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
-7:9-9:10: @2[3]: _4 = Gt(move _5, const 0_i32)
-7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)">        countdown</span></span>
+7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>countdown</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
 7:9-9:10: @2[3]: _4 = Gt(move _5, const 0_i32)
 7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)">            &gt;</span></span>
@@ -104,16 +102,16 @@
 <span class="line"><span class="code" style="--layer: 0">                else</span></span>
 <span class="line"><span class="code" style="--layer: 0">                {</span></span>
 <span class="line"><span class="code" style="--layer: 0">                    </span><span><span class="code odd" style="--layer: 1" title="26:21-26:27: @10[0]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@10⦊</span>Err(1)<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                }</span></span>
+<span class="line"><span class="code" style="--layer: 0">                }</span><span><span class="code even" style="--layer: 1" title="27:18-27:18: @11.Goto: goto -&gt; bb13"><span class="annotation">@9,11⦊</span>‸<span class="annotation">⦉@9,11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">                ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)"><span class="annotation">@7⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)">            -=</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)">        1<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="30:9-32:10: @12[0]: _1 = move (_13.0: i32)"><span class="annotation">@12⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @12[0]: _1 = move (_13.0: i32)">            -=</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @12[0]: _1 = move (_13.0: i32)">        1<span class="annotation">⦉@12</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="35:8-35:10: @4[4]: _15 = ()
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="35:8-35:10: @4[4]: _15 = ()
 35:5-35:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _15)"><span class="annotation">@4⦊</span>Ok(())<span class="annotation">⦉@4</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="36:2-36:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="36:2-36:2: @13.Goto: goto -&gt; bb14"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span><span class="code even" style="--layer: 1" title="36:2-36:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
index 43f75c574d0..0f076a93c09 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 35:13-35:26: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="36:12-36:20: @0[5]: _4 = (*((*_1).0: &amp;bool))
 36:12-36:20: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="37:13-37:27: @3[0]: _2 = const 10_i32
-36:21-38:10: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+36:21-38:10: @3[1]: _3 = const ()
+38:10-38:10: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="37:13-37:27: @3[0]: _2 = const 10_i32
-36:21-38:10: @3[1]: _3 = const ()">            countdown = 10;</span></span>
+36:21-38:10: @3[1]: _3 = const ()
+38:10-38:10: @3.Goto: goto -&gt; bb4">            countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="37:13-37:27: @3[0]: _2 = const 10_i32
-36:21-38:10: @3[1]: _3 = const ()">        }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
+36:21-38:10: @3[1]: _3 = const ()
+38:10-38:10: @3.Goto: goto -&gt; bb4">        }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="38:10-38:10: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
 39:9-39:23: @4[5]: _5 = &amp;(*_6)
 39:9-39:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 40:6-40:6: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 2".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="39:9-39:23: @4[4]: _6 = const &quot;alt string 2&quot;
 39:9-39:23: @4[5]: _5 = &amp;(*_6)
 39:9-39:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 40:6-40:6: @5.Return: return">    }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
index 8f07ec5fcde..bc78a604e31 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 77:13-77:26: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="78:12-78:20: @0[5]: _4 = (*((*_1).0: &amp;bool))
 78:12-78:20: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="79:13-79:27: @3[0]: _2 = const 10_i32
-78:21-80:10: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+78:21-80:10: @3[1]: _3 = const ()
+80:10-80:10: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="79:13-79:27: @3[0]: _2 = const 10_i32
-78:21-80:10: @3[1]: _3 = const ()">            countdown = 10;</span></span>
+78:21-80:10: @3[1]: _3 = const ()
+80:10-80:10: @3.Goto: goto -&gt; bb4">            countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="79:13-79:27: @3[0]: _2 = const 10_i32
-78:21-80:10: @3[1]: _3 = const ()">        }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
+78:21-80:10: @3[1]: _3 = const ()
+80:10-80:10: @3.Goto: goto -&gt; bb4">        }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="80:10-80:10: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
 81:9-81:23: @4[5]: _5 = &amp;(*_6)
 81:9-81:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 82:6-82:6: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 4".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="81:9-81:23: @4[4]: _6 = const &quot;alt string 4&quot;
 81:9-81:23: @4[5]: _5 = &amp;(*_6)
 81:9-81:34: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 82:6-82:6: @5.Return: return">    }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
index ca9031a1094..b0db2311730 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 20:21-20:34: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">                if </span><span><span class="code even" style="--layer: 1" title="21:20-21:28: @0[5]: _4 = (*(_1.0: &amp;bool))
 21:20-21:28: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="22:21-22:35: @3[0]: _2 = const 10_i32
-21:29-23:18: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+21:29-23:18: @3[1]: _3 = const ()
+23:18-23:18: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="22:21-22:35: @3[0]: _2 = const 10_i32
-21:29-23:18: @3[1]: _3 = const ()">                    countdown = 10;</span></span>
+21:29-23:18: @3[1]: _3 = const ()
+23:18-23:18: @3.Goto: goto -&gt; bb4">                    countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="22:21-22:35: @3[0]: _2 = const 10_i32
-21:29-23:18: @3[1]: _3 = const ()">                }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
+21:29-23:18: @3[1]: _3 = const ()
+23:18-23:18: @3.Goto: goto -&gt; bb4">                }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="23:18-23:18: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
 24:17-24:31: @4[5]: _5 = &amp;(*_6)
 24:17-24:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 25:14-25:14: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 1".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="24:17-24:31: @4[4]: _6 = const &quot;alt string 1&quot;
 24:17-24:31: @4[5]: _5 = &amp;(*_6)
 24:17-24:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 25:14-25:14: @5.Return: return">            }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
index 820f8d9c6cf..ca07a8d3ce5 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
@@ -65,16 +65,19 @@
 62:21-62:34: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">                if </span><span><span class="code even" style="--layer: 1" title="63:20-63:28: @0[5]: _4 = (*(_1.0: &amp;bool))
 63:20-63:28: @0[6]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>is_false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="64:21-64:35: @3[0]: _2 = const 10_i32
-63:29-65:18: @3[1]: _3 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+63:29-65:18: @3[1]: _3 = const ()
+65:18-65:18: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="64:21-64:35: @3[0]: _2 = const 10_i32
-63:29-65:18: @3[1]: _3 = const ()">                    countdown = 10;</span></span>
+63:29-65:18: @3[1]: _3 = const ()
+65:18-65:18: @3.Goto: goto -&gt; bb4">                    countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="64:21-64:35: @3[0]: _2 = const 10_i32
-63:29-65:18: @3[1]: _3 = const ()">                }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
+63:29-65:18: @3[1]: _3 = const ()
+65:18-65:18: @3.Goto: goto -&gt; bb4">                }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="65:18-65:18: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
 66:17-66:31: @4[5]: _5 = &amp;(*_6)
 66:17-66:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 67:14-67:14: @5.Return: return"><span class="annotation">@4,5⦊</span>"alt string 3".to_owned()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
+<span class="line"><span class="code odd" style="--layer: 1" title="66:17-66:31: @4[4]: _6 = const &quot;alt string 3&quot;
 66:17-66:31: @4[5]: _5 = &amp;(*_6)
 66:17-66:42: @4.Call: _0 = &lt;str as ToOwned&gt;::to_owned(move _5) -&gt; [return: bb5, unwind: bb6]
 67:14-67:14: @5.Return: return">            }<span class="annotation">⦉@4,5</span></span></span></span></div>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
index 494e6f20ea7..325b6c64345 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
@@ -114,6 +114,6 @@
 <span class="line"><span class="code even" style="--layer: 1" title="24:13-24:40: @2[4]: _18 = Firework { strength: const 1000_i32 }
 26:8-26:10: @6[2]: _19 = ()
 26:5-26:11: @6[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _19)">    Ok(())<span class="annotation">⦉@2,6,7,8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="27:2-27:2: @11.Return: return"><span class="annotation">@11⦊</span>‸<span class="annotation">⦉@11</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="27:2-27:2: @10.Goto: goto -&gt; bb11"><span class="annotation">@1,3,4,5,9,10⦊</span>‸<span class="annotation">⦉@1,3,4,5,9,10</span></span></span><span><span class="code even" style="--layer: 1" title="27:2-27:2: @8.Goto: goto -&gt; bb11"><span class="annotation">@2,6,7,8⦊</span>‸<span class="annotation">⦉@2,6,7,8</span></span></span><span><span class="code odd" style="--layer: 1" title="27:2-27:2: @11.Return: return"><span class="annotation">@11⦊</span>‸<span class="annotation">⦉@11</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
index 6dc893d28ff..55d7e8bfbae 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
@@ -162,6 +162,6 @@
 <span class="line"><span class="code even" style="--layer: 1" title="35:13-35:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
 37:8-37:10: @9[2]: _25 = ()
 37:5-37:11: @9[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">    Ok(())<span class="annotation">⦉@5,9,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="38:2-38:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="38:2-38:2: @13.Goto: goto -&gt; bb14"><span class="annotation">@4,6,7,8,12,13⦊</span>‸<span class="annotation">⦉@4,6,7,8,12,13</span></span></span><span><span class="code even" style="--layer: 1" title="38:2-38:2: @11.Goto: goto -&gt; bb14"><span class="annotation">@5,9,10,11⦊</span>‸<span class="annotation">⦉@5,9,10,11</span></span></span><span><span class="code odd" style="--layer: 1" title="38:2-38:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
index 0379d900e94..0d4b940214e 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
@@ -146,17 +146,23 @@
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="21:9-21:16: @3[5]: _6 = _1
 21:9-21:16: @3[6]: FakeRead(ForMatchedPlace, _6)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">        countdown</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">        countdown</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">        =</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">        =</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">            10</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">            10</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">        ;</span></span>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">        ;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @6[0]: _5 = const 10_i32
-22:5-27:6: @6[1]: _0 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="28:2-28:2: @7.Return: return"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span></span></div>
+22:5-27:6: @6[1]: _0 = const ()
+27:6-27:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="27:6-27:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="28:2-28:2: @7.Return: return"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
index b51c5c84c0d..094dacde986 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
@@ -128,36 +128,36 @@
 20:9-22:16: @5[1]: _6 = const ()">        =</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="20:9-22:16: @5[0]: _5 = const 100_i32
 20:9-22:16: @5[1]: _6 = const ()">            100<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="23:6-23:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>‸<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    if</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="26:9-26:16: @7[3]: _8 = _1
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="26:9-26:16: @7[3]: _8 = _1
 26:9-26:16: @7[4]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@7⦊</span>is_true<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()"><span class="annotation">@8,10⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">        countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">        =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">            10</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">        ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
+<span class="line"><span class="code odd" style="--layer: 1" title="28:9-30:15: @10[0]: _5 = const 10_i32
 27:5-32:6: @10[1]: _0 = const ()">    }<span class="annotation">⦉@8,10</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    else</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()"><span class="annotation">@9⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">        countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">        =</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">            100</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
 34:5-39:6: @9[1]: _0 = const ()">        ;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
-34:5-39:6: @9[1]: _0 = const ()">    }<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="35:9-37:16: @9[0]: _5 = const 100_i32
+34:5-39:6: @9[1]: _0 = const ()">    }<span class="annotation">⦉@9</span></span></span><span><span class="code odd" style="--layer: 1" title="39:6-39:6: @10.Goto: goto -&gt; bb11"><span class="annotation">@8,10⦊</span>‸<span class="annotation">⦉@8,10</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="40:2-40:2: @11.Return: return"><span class="annotation">@11⦊</span>‸<span class="annotation">⦉@11</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
index 49639cc6884..7f1262a6abf 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
@@ -63,8 +63,7 @@
 <span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="19:17-19:18: @0[1]: _2 = const 1_u32
 19:13-19:14: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>b = 1<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code odd" style="--layer: 1" title="20:13-20:14: @1[3]: FakeRead(ForLet, _3)"><span class="annotation">@1,2,3,4⦊</span>c<span class="annotation">⦉@1,2,3,4</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code even" style="--layer: 1" title="20:17-20:18: @0[5]: _4 = _1
-20:21-20:22: @0[7]: _5 = _2
-20:17-20:22: @0[8]: _6 = CheckedAdd(_4, _5)"><span class="annotation">@0⦊</span>a + b<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
+20:21-20:22: @0[7]: _5 = _2"><span class="annotation">@0⦊</span>a + b<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="21:18-21:26: @1[9]: _23 = const in_func::promoted[0]
 21:18-21:26: @1[10]: _11 = &amp;(*_23)
 21:18-21:26: @1[11]: _10 = &amp;(*_11)
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
index a2cf86de278..c9e0fe31211 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
@@ -60,8 +60,7 @@
 </head>
 <body>
 <div class="code" style="counter-reset: line 39"><span class="line">        <span class="code" style="--layer: 0">fn trait_func(&amp;mut self, incr: u32) {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="41:37-41:41: @0[1]: _3 = _2
-41:13-41:41: @0[2]: _4 = CheckedAdd(((*_1).0: u32), _3)"><span class="annotation">@0⦊</span>self.in_struct_field += incr<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            self.in_struct_field += </span><span><span class="code even" style="--layer: 1" title="41:37-41:41: @0[1]: _3 = _2"><span class="annotation">@0⦊</span>incr<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="42:21-42:41: @1[4]: _6 = ((*_1).0: u32)
 42:13-42:42: @1.Call: _5 = in_func(move _6) -&gt; [return: bb2, unwind: bb3]
 43:10-43:10: @2.Return: return"><span class="annotation">@1,2⦊</span>in_func(self.in_struct_field);</span></span>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
index 56557b8ef95..ec3517ec9ed 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
@@ -86,11 +86,14 @@
 9:9-9:22: @3[3]: FakeRead(ForLet, _5)">    let mut countdown = 0<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="10:8-10:15: @3[6]: _7 = _1
 10:8-10:15: @3[7]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="11:9-11:23: @6[0]: _5 = const 10_u32
-10:16-12:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @6[0]: _5 = const 10_u32
-10:16-12:6: @6[1]: _6 = const ()">        countdown = 10;</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">        countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @6[0]: _5 = const 10_u32
-10:16-12:6: @6[1]: _6 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="12:6-12:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    mod in_mod {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        const IN_MOD_CONST: u32 = 1000;</span></span>
@@ -126,16 +129,19 @@
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    type InType = String;</span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="48:8-48:15: @7[4]: _9 = _1
-48:8-48:15: @7[5]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@7⦊</span>is_true<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="48:8-48:15: @7[4]: _9 = _1
+48:8-48:15: @7[5]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@7⦊</span>is_true<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
 49:9-49:27: @10.Call: _10 = in_func(move _11) -&gt; [return: bb11, unwind: bb15]
-48:16-50:6: @11[2]: _8 = const ()"><span class="annotation">@8,10,11⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
+48:16-50:6: @11[2]: _8 = const ()
+50:6-50:6: @11.Goto: goto -&gt; bb12"><span class="annotation">@8,10,11⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
 49:9-49:27: @10.Call: _10 = in_func(move _11) -&gt; [return: bb11, unwind: bb15]
-48:16-50:6: @11[2]: _8 = const ()">        in_func(countdown);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
+48:16-50:6: @11[2]: _8 = const ()
+50:6-50:6: @11.Goto: goto -&gt; bb12">        in_func(countdown);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @10[2]: _11 = _5
 49:9-49:27: @10.Call: _10 = in_func(move _11) -&gt; [return: bb11, unwind: bb15]
-48:16-50:6: @11[2]: _8 = const ()">    }<span class="annotation">⦉@8,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
+48:16-50:6: @11[2]: _8 = const ()
+50:6-50:6: @11.Goto: goto -&gt; bb12">    }<span class="annotation">⦉@8,10,11</span></span></span><span><span class="code odd" style="--layer: 1" title="50:6-50:6: @9.Goto: goto -&gt; bb12"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="52:19-54:6: @12[3]: _12 = InStruct { in_struct_field: const 101_u32 }
 52:9-52:16: @12[4]: FakeRead(ForLet, _12)
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
index defe743df60..636341055dc 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
@@ -63,27 +63,27 @@
 <span class="line"><span class="code" style="--layer: 0">    // Initialize test constants in a way that cannot be determined at compile time, to ensure</span></span>
 <span class="line"><span class="code" style="--layer: 0">    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</span></span>
 <span class="line"><span class="code" style="--layer: 0">    // dependent conditions.</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb25]
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb41]
 7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb24]
+7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb40]
 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
 7:9-7:16: @2[3]: FakeRead(ForLet, _1)
 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32)
 9:10-9:15: @3[4]: _5 = (_8.0: i32)
 9:17-9:22: @3[6]: _6 = (_8.1: i32)
 9:24-9:29: @3[8]: _7 = (_8.2: i32)"><span class="annotation">@0,1,2,3⦊</span>is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb25]
+<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb41]
 7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb24]
+7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb40]
 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
 7:9-7:16: @2[3]: FakeRead(ForLet, _1)
 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32)
 9:10-9:15: @3[4]: _5 = (_8.0: i32)
 9:17-9:22: @3[6]: _6 = (_8.1: i32)
 9:24-9:29: @3[8]: _7 = (_8.2: i32)"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb25]
+<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb41]
 7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb24]
+7:19-7:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb40]
 7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
 7:9-7:16: @2[3]: FakeRead(ForLet, _1)
 9:33-9:42: @3[2]: _8 = (const 0_i32, const 0_i32, const 0_i32)
@@ -94,67 +94,126 @@
 10:8-10:15: @3[13]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">        a = 1;</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">        a = 1;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">        b = 10;</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">        b = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">        c = 100;</span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">        c = 100;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @6[0]: _5 = const 1_i32
 12:9-12:15: @6[1]: _6 = const 10_i32
 13:9-13:16: @6[2]: _7 = const 100_i32
-10:16-14:6: @6[3]: _9 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+10:16-14:6: @6[3]: _9 = const ()
+14:6-14:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="14:6-14:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="16:9-16:17: @11[2]: FakeRead(ForLet, _11)"><span class="annotation">@11⦊</span>somebool<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="16:9-16:17: @11[2]: FakeRead(ForLet, _11)"><span class="annotation">@11⦊</span>somebool<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="18:13-18:14: @7[5]: _13 = _5
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="18:13-18:14: @7[5]: _13 = _5
 18:17-18:18: @7[7]: _14 = _6
 18:13-18:18: @7[8]: _12 = Lt(move _13, move _14)"><span class="annotation">@7⦊</span>a &lt; b<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ||</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="20:13-20:14: @10[2]: _16 = _6
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="20:13-20:14: @10[2]: _16 = _6
 20:17-20:18: @10[4]: _17 = _7
-20:13-20:18: @10[5]: _15 = Lt(move _16, move _17)"><span class="annotation">@10⦊</span>b &lt; c<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0"></span></span>
+20:13-20:18: @10[5]: _15 = Lt(move _16, move _17)"><span class="annotation">@10⦊</span>b &lt; c<span class="annotation">⦉@10</span></span></span><span><span class="code even" style="--layer: 1" title="20:18-20:18: @8.Goto: goto -&gt; bb11"><span class="annotation">@8⦊</span>‸<span class="annotation">⦉@8</span></span></span><span><span class="code odd" style="--layer: 1" title="20:18-20:18: @9.Goto: goto -&gt; bb11"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="23:9-23:17: @15[2]: FakeRead(ForLet, _18)"><span class="annotation">@15⦊</span>somebool<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="23:9-23:17: @15[2]: FakeRead(ForLet, _18)"><span class="annotation">@15⦊</span>somebool<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="25:13-25:14: @11[6]: _20 = _6
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="25:13-25:14: @11[6]: _20 = _6
 25:17-25:18: @11[8]: _21 = _5
 25:13-25:18: @11[9]: _19 = Lt(move _20, move _21)"><span class="annotation">@11⦊</span>b &lt; a<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ||</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="27:13-27:14: @14[2]: _23 = _6
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:14: @14[2]: _23 = _6
 27:17-27:18: @14[4]: _24 = _7
-27:13-27:18: @14[5]: _22 = Lt(move _23, move _24)"><span class="annotation">@14⦊</span>b &lt; c<span class="annotation">⦉@14</span></span></span><span class="code" style="--layer: 0"></span></span>
+27:13-27:18: @14[5]: _22 = Lt(move _23, move _24)"><span class="annotation">@14⦊</span>b &lt; c<span class="annotation">⦉@14</span></span></span><span><span class="code odd" style="--layer: 1" title="27:18-27:18: @12.Goto: goto -&gt; bb15"><span class="annotation">@12⦊</span>‸<span class="annotation">⦉@12</span></span></span><span><span class="code even" style="--layer: 1" title="27:18-27:18: @13.Goto: goto -&gt; bb15"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="30:9-30:17: @19[2]: FakeRead(ForLet, _25)"><span class="annotation">@19⦊</span>somebool<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="32:13-32:14: @15[6]: _27 = _5
-32:17-32:18: @15[8]: _28 = _6
-32:13-32:18: @15[9]: _26 = Lt(move _27, move _28)"><span class="annotation">@15⦊</span>a &lt; b<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        &amp;&amp;</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="34:13-34:14: @18[2]: _30 = _6
-34:17-34:18: @18[4]: _31 = _7
-34:13-34:18: @18[5]: _29 = Lt(move _30, move _31)"><span class="annotation">@18⦊</span>b &lt; c<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="37:9-37:17: @23[2]: FakeRead(ForLet, _32)"><span class="annotation">@23⦊</span>somebool<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="39:13-39:14: @19[6]: _34 = _6
-39:17-39:18: @19[8]: _35 = _5
-39:13-39:18: @19[9]: _33 = Lt(move _34, move _35)"><span class="annotation">@19⦊</span>b &lt; a<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        &amp;&amp;</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="41:13-41:14: @22[2]: _37 = _6
-41:17-41:18: @22[4]: _38 = _7
-41:13-41:18: @22[5]: _36 = Lt(move _37, move _38)"><span class="annotation">@22⦊</span>b &lt; c<span class="annotation">⦉@22</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="43:2-43:2: @23.Return: return"><span class="annotation">@23⦊</span>‸<span class="annotation">⦉@23</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="29:9-29:17: @19[2]: FakeRead(ForLet, _25)"><span class="annotation">@19⦊</span>somebool<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code even" style="--layer: 1" title="29:20-29:21: @15[6]: _27 = _5
+29:24-29:25: @15[8]: _28 = _6
+29:20-29:25: @15[9]: _26 = Lt(move _27, move _28)"><span class="annotation">@15⦊</span>a &lt; b<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"> &amp;&amp; </span><span><span class="code odd" style="--layer: 1" title="29:29-29:30: @18[2]: _30 = _6
+29:33-29:34: @18[4]: _31 = _7
+29:29-29:34: @18[5]: _29 = Lt(move _30, move _31)"><span class="annotation">@18⦊</span>b &lt; c<span class="annotation">⦉@18</span></span></span><span><span class="code even" style="--layer: 1" title="29:34-29:34: @16.Goto: goto -&gt; bb19"><span class="annotation">@16⦊</span>‸<span class="annotation">⦉@16</span></span></span><span><span class="code odd" style="--layer: 1" title="29:34-29:34: @17.Goto: goto -&gt; bb19"><span class="annotation">@17⦊</span>‸<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="30:9-30:17: @23[2]: FakeRead(ForLet, _32)"><span class="annotation">@23⦊</span>somebool<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code odd" style="--layer: 1" title="30:20-30:21: @19[6]: _34 = _6
+30:24-30:25: @19[8]: _35 = _5
+30:20-30:25: @19[9]: _33 = Lt(move _34, move _35)"><span class="annotation">@19⦊</span>b &lt; a<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"> &amp;&amp; </span><span><span class="code even" style="--layer: 1" title="30:29-30:30: @22[2]: _37 = _6
+30:33-30:34: @22[4]: _38 = _7
+30:29-30:34: @22[5]: _36 = Lt(move _37, move _38)"><span class="annotation">@22⦊</span>b &lt; c<span class="annotation">⦉@22</span></span></span><span><span class="code odd" style="--layer: 1" title="30:34-30:34: @20.Goto: goto -&gt; bb23"><span class="annotation">@20⦊</span>‸<span class="annotation">⦉@20</span></span></span><span><span class="code even" style="--layer: 1" title="30:34-30:34: @21.Goto: goto -&gt; bb23"><span class="annotation">@21⦊</span>‸<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="34:9-34:16: @23[6]: _41 = _1
+33:9-34:16: @23[7]: _40 = Not(move _41)
+33:9-34:16: @23[9]: FakeRead(ForMatchedPlace, _40)"><span class="annotation">@23⦊</span>!</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="34:9-34:16: @23[6]: _41 = _1
+33:9-34:16: @23[7]: _40 = Not(move _41)
+33:9-34:16: @23[9]: FakeRead(ForMatchedPlace, _40)">        is_true<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27"><span class="annotation">@24,26⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27">        a = 2</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27">        ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @26[0]: _5 = const 2_i32
+35:5-38:6: @26[1]: _39 = const ()
+38:6-38:6: @26.Goto: goto -&gt; bb27">    }<span class="annotation">⦉@24,26</span></span></span><span><span class="code odd" style="--layer: 1" title="38:6-38:6: @25.Goto: goto -&gt; bb27"><span class="annotation">@25⦊</span>‸<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="41:9-41:16: @27[4]: _43 = _1
+41:9-41:16: @27[5]: FakeRead(ForMatchedPlace, _43)"><span class="annotation">@27⦊</span>is_true<span class="annotation">⦉@27</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()"><span class="annotation">@28,30⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()">        b = 30</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()">        ;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @30[0]: _6 = const 30_i32
+42:5-45:6: @30[1]: _42 = const ()">    }<span class="annotation">⦉@28,30</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    else</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()"><span class="annotation">@29⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()">        c = 400</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()">        ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @29[0]: _7 = const 400_i32
+47:5-50:6: @29[1]: _42 = const ()">    }<span class="annotation">⦉@29</span></span></span><span><span class="code odd" style="--layer: 1" title="50:6-50:6: @30.Goto: goto -&gt; bb31"><span class="annotation">@28,30⦊</span>‸<span class="annotation">⦉@28,30</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="52:9-52:16: @31[5]: _46 = _1
+52:8-52:16: @31[6]: _45 = Not(move _46)
+52:8-52:16: @31[8]: FakeRead(ForMatchedPlace, _45)"><span class="annotation">@31⦊</span>!is_true<span class="annotation">⦉@31</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="53:9-53:14: @34[0]: _5 = const 2_i32
+52:17-54:6: @34[1]: _44 = const ()
+54:6-54:6: @34.Goto: goto -&gt; bb35"><span class="annotation">@32,34⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="53:9-53:14: @34[0]: _5 = const 2_i32
+52:17-54:6: @34[1]: _44 = const ()
+54:6-54:6: @34.Goto: goto -&gt; bb35">        a = 2;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="53:9-53:14: @34[0]: _5 = const 2_i32
+52:17-54:6: @34[1]: _44 = const ()
+54:6-54:6: @34.Goto: goto -&gt; bb35">    }<span class="annotation">⦉@32,34</span></span></span><span><span class="code even" style="--layer: 1" title="54:6-54:6: @33.Goto: goto -&gt; bb35"><span class="annotation">@33⦊</span>‸<span class="annotation">⦉@33</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="56:8-56:15: @35[3]: _47 = _1
+56:8-56:15: @35[4]: FakeRead(ForMatchedPlace, _47)"><span class="annotation">@35⦊</span>is_true<span class="annotation">⦉@35</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="57:9-57:15: @38[0]: _6 = const 30_i32
+56:16-58:6: @38[1]: _0 = const ()"><span class="annotation">@36,38⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="57:9-57:15: @38[0]: _6 = const 30_i32
+56:16-58:6: @38[1]: _0 = const ()">        b = 30;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="57:9-57:15: @38[0]: _6 = const 30_i32
+56:16-58:6: @38[1]: _0 = const ()">    }<span class="annotation">⦉@36,38</span></span></span><span class="code" style="--layer: 0"> else </span><span><span class="code odd" style="--layer: 1" title="59:9-59:16: @37[0]: _7 = const 400_i32
+58:12-60:6: @37[1]: _0 = const ()"><span class="annotation">@37⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="59:9-59:16: @37[0]: _7 = const 400_i32
+58:12-60:6: @37[1]: _0 = const ()">        c = 400;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="59:9-59:16: @37[0]: _7 = const 400_i32
+58:12-60:6: @37[1]: _0 = const ()">    }<span class="annotation">⦉@37</span></span></span><span><span class="code even" style="--layer: 1" title="60:6-60:6: @38.Goto: goto -&gt; bb39"><span class="annotation">@36,38⦊</span>‸<span class="annotation">⦉@36,38</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="61:2-61:2: @39.Return: return"><span class="annotation">@39⦊</span>‸<span class="annotation">⦉@39</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..a876c85822f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,151 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>loops_and_branches.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 21"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return">    let debug_test = DebugTest;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return">    println!("{:?}", debug_test);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
+23:9-23:19: @0[2]: FakeRead(ForLet, _1)
+24:14-24:20: @0[9]: _19 = const main::promoted[0]
+24:14-24:20: @0[10]: _7 = &amp;(*_19)
+24:14-24:20: @0[11]: _6 = &amp;(*_7)
+24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+24:22-24:32: @0[20]: _14 = &amp;_1
+24:5-24:34: @0[21]: _13 = (move _14,)
+24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
+24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
+24:5-24:34: @0[28]: _17 = &amp;(*_15)
+24:5-24:34: @0[30]: _18 = &lt;DebugTest as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+24:5-24:34: @0.Call: _16 = ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+24:5-24:34: @1[2]: _12 = [move _16]
+24:5-24:34: @1[5]: _11 = &amp;_12
+24:5-24:34: @1[6]: _10 = &amp;(*_11)
+24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+24:5-24:34: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+24:5-24:34: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+24:5-24:34: @3[6]: _2 = const ()
+22:11-25:2: @3[8]: _0 = const ()
+25:2-25:2: @3.Return: return">}<span class="annotation">⦉@0,1,2,3</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..1b9767506f2
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loops_and_branches/loops_and_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>loops_and_branches.{impl#0}-fmt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 8"><span class="line">    <span class="code" style="--layer: 0">fn fmt(&amp;self, f: &amp;mut std::fmt::Formatter) -&gt; std::fmt::Result {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="10:12-10:16: @0[2]: _4 = const true
+10:12-10:16: @0[3]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@0⦊</span>true<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code odd" style="--layer: 1" title="11:16-11:21: @3[2]: _6 = const false
+11:16-11:21: @3[3]: FakeRead(ForMatchedPlace, _6)"><span class="annotation">@1,3⦊</span>false<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                while </span><span><span class="code even" style="--layer: 1" title="12:23-12:27: @7[1]: _8 = const true
+12:23-12:27: @7[2]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@6,7⦊</span>true<span class="annotation">⦉@6,7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="12:28-13:18: @10[0]: _7 = const ()
+13:18-13:18: @10.Goto: goto -&gt; bb6"><span class="annotation">@8,10⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="12:28-13:18: @10[0]: _7 = const ()
+13:18-13:18: @10.Goto: goto -&gt; bb6">                }<span class="annotation">⦉@8,10</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code even" style="--layer: 1" title="14:14-14:14: @9.Goto: goto -&gt; bb11"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span><span><span class="code odd" style="--layer: 1" title="14:14-14:14: @5.Goto: goto -&gt; bb11"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="15:20-15:21: @11[6]: _13 = &amp;mut (*_2)
+15:23-15:30: @11[11]: _32 = const &lt;DebugTest as Debug&gt;::fmt::promoted[1]
+15:23-15:30: @11[12]: _17 = &amp;(*_32)
+15:23-15:30: @11[13]: _16 = &amp;(*_17)
+15:23-15:30: @11[14]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
+15:13-15:31: @11[20]: _23 = ()
+15:13-15:31: @11[21]: FakeRead(ForMatchedPlace, _23)
+15:13-15:31: @11[22]: _31 = const &lt;DebugTest as Debug&gt;::fmt::promoted[0]
+15:13-15:31: @11[23]: _21 = &amp;(*_31)
+15:13-15:31: @11[24]: _20 = &amp;(*_21)
+15:13-15:31: @11[25]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+15:13-15:31: @11.Call: _14 = Arguments::new_v1(move _15, move _19) -&gt; [return: bb12, unwind: bb23]
+15:13-15:31: @12.Call: _12 = Formatter::write_fmt(move _13, move _14) -&gt; [return: bb13, unwind: bb23]"><span class="annotation">@11,12,13,14⦊</span>write!(f, "error")<span class="annotation">⦉@11,12,13,14</span></span></span><span><span class="code odd" style="--layer: 1" title="15:31-15:32: @18[1]: _25 = ((_11 as Err).0: std::fmt::Error)
+15:31-15:32: @18[4]: _28 = _25
+15:31-15:32: @18.Call: _27 = &lt;std::fmt::Error as From&lt;std::fmt::Error&gt;&gt;::from(move _28) -&gt; [return: bb19, unwind: bb23]"><span class="annotation">@16,18,19,20⦊</span>?<span class="annotation">⦉@16,18,19,20</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        } else </span><span><span class="code even" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()">        }<span class="annotation">⦉@2</span></span></span><span><span class="code odd" style="--layer: 1" title="17:10-17:10: @15.Goto: goto -&gt; bb21"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="18:12-18:14: @21[3]: _30 = ()
+18:9-18:15: @21[4]: _0 = std::result::Result::&lt;(), std::fmt::Error&gt;::Ok(move _30)"><span class="annotation">@21⦊</span>Ok(())<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="19:6-19:6: @20.Goto: goto -&gt; bb22"><span class="annotation">@16,18,19,20⦊</span>‸<span class="annotation">⦉@16,18,19,20</span></span></span><span><span class="code even" style="--layer: 1" title="19:6-19:6: @22.Return: return"><span class="annotation">@22⦊</span>‸<span class="annotation">⦉@22</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..042845b70cc
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,125 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>nested_loops.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 0"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb35]
+2:19-2:35: @1[0]: _3 = &amp;_4
+2:19-2:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb34]
+2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+2:9-2:16: @2[3]: FakeRead(ForLet, _1)
+3:25-3:27: @3[2]: _5 = const 10_i32
+3:9-3:22: @3[3]: FakeRead(ForLet, _5)"><span class="annotation">@0,1,2,3⦊</span>is_true = std::env::args().len() == 1;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb35]
+2:19-2:35: @1[0]: _3 = &amp;_4
+2:19-2:41: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb34]
+2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+2:9-2:16: @2[3]: FakeRead(ForLet, _1)
+3:25-3:27: @3[2]: _5 = const 10_i32
+3:9-3:22: @3[3]: FakeRead(ForLet, _5)">    let mut countdown = 10<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    'outer: while </span><span><span class="code odd" style="--layer: 1" title="5:19-5:28: @5[2]: _8 = _5
+5:19-5:32: @5[3]: _7 = Gt(move _8, const 0_i32)
+5:19-5:32: @5[5]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@4,5⦊</span>countdown &gt; 0<span class="annotation">⦉@4,5</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="6:21-6:24: @8[1]: _9 = const 100_i32
+6:13-6:18: @8[2]: FakeRead(ForLet, _9)
+7:21-7:24: @8[4]: _10 = const 100_i32
+7:13-7:18: @8[5]: FakeRead(ForLet, _10)"><span class="annotation">@6,8,9⦊</span>mut a = 100;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:21-6:24: @8[1]: _9 = const 100_i32
+6:13-6:18: @8[2]: FakeRead(ForLet, _9)
+7:21-7:24: @8[4]: _10 = const 100_i32
+7:13-7:18: @8[5]: FakeRead(ForLet, _10)">        let mut b = 100<span class="annotation">⦉@6,8,9</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        for </span><span><span class="code odd" style="--layer: 1" title="8:13-8:14: @16[1]: _21 = ((_17 as Some).0: i32)
+8:13-8:14: @16[3]: _22 = _21
+8:13-8:14: @16[4]: _15 = move _22
+8:13-8:14: @16[5]: _16 = const ()"><span class="annotation">@14,16⦊</span>_<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> in </span><span><span class="code even" style="--layer: 1" title="8:18-8:23: @11[5]: _19 = &amp;mut _14
+8:18-8:23: @11[6]: _18 = &amp;mut (*_19)
+8:18-8:23: @11.Call: _17 = &lt;std::ops::Range&lt;i32&gt; as Iterator&gt;::next(move _18) -&gt; [return: bb12, unwind: bb35]
+8:18-8:23: @12[1]: FakeRead(ForMatchedPlace, _17)"><span class="annotation">@10,11,12⦊</span>0..50<span class="annotation">⦉@10,11,12</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code odd" style="--layer: 1" title="9:16-9:17: @16[15]: _27 = _9
+9:16-9:22: @16[16]: _26 = Lt(move _27, const 30_i32)
+9:16-9:22: @16[18]: FakeRead(ForMatchedPlace, _26)"><span class="annotation">@14,16⦊</span>a &lt; 30<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="10:17-10:22: @19[0]: _11 = const ()"><span class="annotation">@17,19⦊</span>break<span class="annotation">⦉@17,19</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="12:13-12:19: @20[0]: _9 = move (_29.0: i32)"><span class="annotation">@20⦊</span>a -= 5<span class="annotation">⦉@20</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="13:13-13:19: @21[0]: _10 = move (_30.0: i32)"><span class="annotation">@21⦊</span>b -= 5<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code even" style="--layer: 1" title="14:16-14:17: @21[3]: _32 = _10
+14:16-14:22: @21[4]: _31 = Lt(move _32, const 90_i32)
+14:16-14:22: @21[6]: FakeRead(ForMatchedPlace, _31)"><span class="annotation">@21⦊</span>b &lt; 90<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="15:17-15:24: @25[0]: _9 = move (_33.0: i32)
+16:20-16:27: @25[2]: _34 = _1
+16:20-16:27: @25[3]: FakeRead(ForMatchedPlace, _34)"><span class="annotation">@25⦊</span>a -= 10;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="15:17-15:24: @25[0]: _9 = move (_33.0: i32)
+16:20-16:27: @25[2]: _34 = _1
+16:20-16:27: @25[3]: FakeRead(ForMatchedPlace, _34)">                if is_true<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    </span><span><span class="code even" style="--layer: 1" title="17:21-17:33: @28[0]: _0 = const ()"><span class="annotation">@26,28⦊</span>break 'outer<span class="annotation">⦉@26,28</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                } else {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    </span><span><span class="code odd" style="--layer: 1" title="19:21-19:27: @29[0]: _9 = move (_36.0: i32)
+21:14-21:14: @29.Goto: goto -&gt; bb30"><span class="annotation">@29⦊</span>a -= 2;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="19:21-19:27: @29[0]: _9 = move (_36.0: i32)
+21:14-21:14: @29.Goto: goto -&gt; bb30">                }</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="19:21-19:27: @29[0]: _9 = move (_36.0: i32)
+21:14-21:14: @29.Goto: goto -&gt; bb30">            }<span class="annotation">⦉@29</span></span></span><span><span class="code even" style="--layer: 1" title="21:14-21:14: @23.Goto: goto -&gt; bb30"><span class="annotation">@23⦊</span>‸<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span><span><span class="code odd" style="--layer: 1" title="22:10-22:10: @9.Goto: goto -&gt; bb10"><span class="annotation">@6,8,9⦊</span>‸<span class="annotation">⦉@6,8,9</span></span></span><span><span class="code even" style="--layer: 1" title="22:10-22:10: @30.Goto: goto -&gt; bb10"><span class="annotation">@30⦊</span>‸<span class="annotation">⦉@30</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="23:9-23:23: @32[0]: _5 = move (_37.0: i32)"><span class="annotation">@32⦊</span>countdown -= 1<span class="annotation">⦉@32</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="24:6-24:6: @3.Goto: goto -&gt; bb4"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span><span class="code odd" style="--layer: 1" title="24:6-24:6: @7.Goto: goto -&gt; bb33"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="25:2-25:2: @33.Return: return"><span class="annotation">@33⦊</span>‸<span class="annotation">⦉@33</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..3ebe51bc7ec
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,285 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 20"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">    let version_3_2_1 = Version::new(3, 2, 1);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">    let version_3_3_0 = Version::new(3, 3, 0);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">    println!("{:?} &lt; {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 &lt; version_3_3_0);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
+22:9-22:22: @1[0]: FakeRead(ForLet, _1)
+23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
+23:9-23:22: @2[0]: FakeRead(ForLet, _2)
+25:14-25:32: @2[7]: _33 = const main::promoted[0]
+25:14-25:32: @2[8]: _8 = &amp;(*_33)
+25:14-25:32: @2[9]: _7 = &amp;(*_8)
+25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
+25:34-25:47: @2[18]: _15 = &amp;_1
+25:49-25:62: @2[20]: _16 = &amp;_2
+25:64-25:77: @2[24]: _19 = &amp;_1
+25:80-25:93: @2[26]: _20 = &amp;_2
+25:64-25:93: @2.Call: _18 = &lt;Version as PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
+25:64-25:93: @3[2]: _17 = &amp;_18
+25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
+25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
+25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
+25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
+25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
+25:5-25:95: @3[16]: _25 = &amp;(*_21)
+25:5-25:95: @3[18]: _26 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @3.Call: _24 = ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
+25:5-25:95: @4[4]: _28 = &amp;(*_22)
+25:5-25:95: @4[6]: _29 = &lt;Version as Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @4.Call: _27 = ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
+25:5-25:95: @5[4]: _31 = &amp;(*_23)
+25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+25:5-25:95: @5.Call: _30 = ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
+25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
+25:5-25:95: @6[9]: _12 = &amp;_13
+25:5-25:95: @6[10]: _11 = &amp;(*_12)
+25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+25:5-25:95: @6.Call: _5 = Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
+25:5-25:95: @7.Call: _4 = _print(move _5) -&gt; [return: bb8, unwind: bb9]
+25:5-25:95: @8[7]: _3 = const ()
+21:11-26:2: @8[9]: _0 = const ()
+26:2-26:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..ee6a5489f26
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#0}-new.-------.InstrumentCoverage.0.html
@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#0}-new - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 11"><span class="line">    <span class="code" style="--layer: 0">pub fn new(major: usize, minor: usize, patch: usize) -&gt; Self {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return"><span class="annotation">@0⦊</span>Self {</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">            major,</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">            minor,</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">            patch,</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">        }</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
+15:13-15:18: @0[3]: _5 = _2
+16:13-16:18: @0[5]: _6 = _3
+13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
+18:6-18:6: @0.Return: return">    }<span class="annotation">⦉@0</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..a39772288a3
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#1}-cmp.-------.InstrumentCoverage.0.html
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#1}-cmp - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                                  <span><span class="code even" style="--layer: 1" title="4:51-4:54: @14.Goto: goto -&gt; bb15"><span class="annotation">@14⦊</span></span></span><span class="code even" style="--layer: 2" title="4:51-4:54: @12[0]: _0 = Equal
+4:51-4:54: @12.Goto: goto -&gt; bb13"><span class="annotation">@11,12⦊</span></span><span class="code even" style="--layer: 3" title="4:51-4:54: @10[1]: _27 = _21
+4:51-4:54: @10[2]: _0 = _27
+4:51-4:54: @10.Goto: goto -&gt; bb13"><span class="annotation">@10⦊</span></span><span class="code even" style="--layer: 4" title="4:51-4:54: @13.Goto: goto -&gt; bb14"><span class="annotation">@13⦊</span>Ord<span class="annotation">⦉@13</span></span><span class="code even" style="--layer: 3" title="4:51-4:54: @10[1]: _27 = _21
+4:51-4:54: @10[2]: _0 = _27
+4:51-4:54: @10.Goto: goto -&gt; bb13"><span class="annotation">⦉@10</span></span><span class="code even" style="--layer: 2" title="4:51-4:54: @12[0]: _0 = Equal
+4:51-4:54: @12.Goto: goto -&gt; bb13"><span class="annotation">⦉@11,12</span></span><span><span class="code even" style="--layer: 1" title="4:51-4:54: @14.Goto: goto -&gt; bb15"><span class="annotation">⦉@14</span></span></span><span><span class="code odd" style="--layer: 1" title="4:54-4:54: @15.Return: return"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..671cbea0ff3
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-ge-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Less
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..6da79c4b130
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-ge-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..5f5c31ce775
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-ge.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-ge - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..fbdd0f7db42
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-gt-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Less
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..736f2034333
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-gt-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..0fec7c9932f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-gt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-gt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..ff4eba10789
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-le-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Greater
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..ccc86a7f92f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-le-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..682b9112c4c
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-le.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-le - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..e018c96c24f
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-lt-{closure#0}-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 6"><span class="line">    <span class="code" style="--layer: 0">minor: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="8:5-8:17: @0[3]: _4 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+8:5-8:17: @0[4]: _3 = &amp;(*_4)
+8:5-8:17: @0[7]: _6 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+8:5-8:17: @0[8]: _5 = &amp;(*_6)
+8:5-8:17: @0.Call: _2 = &lt;usize as PartialOrd&gt;::partial_cmp(move _3, move _5) -&gt; [return: bb1, unwind: bb3]
+8:5-8:17: @1[3]: _7 = Greater
+8:5-8:17: @1.Call: _0 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _2, move _7) -&gt; [return: bb2, unwind: bb3]
+8:5-8:17: @2.Return: return"><span class="annotation">@0,1,2⦊</span>patch: usize<span class="annotation">⦉@0,1,2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..a10032059b5
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-lt-{closure#0} - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 5"><span class="line">    <span class="code" style="--layer: 0">major: usize,</span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="7:5-7:17: @0[4]: _5 = &amp;(*(*(_1.0: &amp;&amp;usize)))
+7:5-7:17: @0[5]: _4 = &amp;(*_5)
+7:5-7:17: @0[8]: _7 = &amp;(*(*(_1.1: &amp;&amp;usize)))
+7:5-7:17: @0[9]: _6 = &amp;(*_7)
+7:5-7:17: @0.Call: _3 = &lt;usize as PartialOrd&gt;::partial_cmp(move _4, move _6) -&gt; [return: bb1, unwind: bb4]
+7:5-7:17: @1[3]: _8 = Equal
+7:5-7:17: @1.Call: _2 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _3, move _8) -&gt; [return: bb2, unwind: bb4]
+7:5-7:17: @2[4]: _10 = &amp;(*(_1.2: &amp;&amp;usize))
+7:5-7:17: @2[6]: _11 = &amp;(*(_1.3: &amp;&amp;usize))"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">minor: usize</span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..89dad0f9069
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-lt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-lt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @0[0]: FakeRead(ForMatchedPlace, (*_2))
+4:39-4:49: @0[2]: _3 = &amp;((*_2).0: usize)
+4:39-4:49: @0[4]: _4 = &amp;((*_2).1: usize)
+4:39-4:49: @0[6]: _5 = &amp;((*_2).2: usize)
+4:39-4:49: @0[7]: FakeRead(ForMatchedPlace, (*_1))
+4:39-4:49: @0[9]: _6 = &amp;((*_1).0: usize)
+4:39-4:49: @0[11]: _7 = &amp;((*_1).1: usize)
+4:39-4:49: @0[13]: _8 = &amp;((*_1).2: usize)
+4:39-4:49: @0[20]: _14 = &amp;(*_6)
+4:39-4:49: @0[21]: _13 = &amp;(*_14)
+4:39-4:49: @0[24]: _16 = &amp;(*_3)
+4:39-4:49: @0[25]: _15 = &amp;(*_16)
+4:39-4:49: @0.Call: _12 = &lt;usize as PartialOrd&gt;::partial_cmp(move _13, move _15) -&gt; [return: bb1, unwind: bb5]
+4:39-4:49: @1[3]: _17 = Equal
+4:39-4:49: @1.Call: _11 = Option::&lt;std::cmp::Ordering&gt;::unwrap_or(move _12, move _17) -&gt; [return: bb2, unwind: bb5]
+4:39-4:49: @2[4]: _19 = &amp;_7
+4:39-4:49: @2[6]: _20 = &amp;_4
+4:39-4:49: @2[8]: _21 = &amp;_8
+4:39-4:49: @2[10]: _22 = &amp;_5"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code even" style="--layer: 1" title="4:49-4:49: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>‸<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..2c03e967eeb
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#2}-partial_cmp - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1" title="4:39-4:49: @17.Goto: goto -&gt; bb18"><span class="annotation">@17⦊</span></span></span><span class="code even" style="--layer: 2" title="4:39-4:49: @15[1]: _30 = Equal
+4:39-4:49: @15[2]: _0 = Option::&lt;std::cmp::Ordering&gt;::Some(move _30)
+4:39-4:49: @15.Goto: goto -&gt; bb16"><span class="annotation">@14,15⦊</span></span><span class="code even" style="--layer: 3" title="4:39-4:49: @12[1]: _31 = _23
+4:39-4:49: @12[2]: _0 = _31
+4:39-4:49: @12.Goto: goto -&gt; bb16"><span class="annotation">@12⦊</span></span><span class="code even" style="--layer: 4" title="4:39-4:49: @16.Goto: goto -&gt; bb17"><span class="annotation">@16⦊</span>PartialOrd<span class="annotation">⦉@16</span></span><span class="code even" style="--layer: 3" title="4:39-4:49: @12[1]: _31 = _23
+4:39-4:49: @12[2]: _0 = _31
+4:39-4:49: @12.Goto: goto -&gt; bb16"><span class="annotation">⦉@12</span></span><span class="code even" style="--layer: 2" title="4:39-4:49: @15[1]: _30 = Equal
+4:39-4:49: @15[2]: _0 = Option::&lt;std::cmp::Ordering&gt;::Some(move _30)
+4:39-4:49: @15.Goto: goto -&gt; bb16"><span class="annotation">⦉@14,15</span></span><span><span class="code even" style="--layer: 1" title="4:39-4:49: @17.Goto: goto -&gt; bb18"><span class="annotation">⦉@17</span></span></span><span><span class="code odd" style="--layer: 1" title="4:49-4:49: @18.Return: return"><span class="annotation">@18⦊</span>‸<span class="annotation">⦉@18</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..49d73b3457b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html
@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#4}-assert_receiver_is_total_eq - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                                  <span><span class="code even" style="--layer: 1" title="4:35-4:37: @0[0]: _0 = const ()
+4:37-4:37: @0.Return: return"><span class="annotation">@0⦊</span>Eq<span class="annotation">⦉@0</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..bc34080f109
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-eq.-------.InstrumentCoverage.0.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#6}-eq - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                       <span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span></span></span><span class="code even" style="--layer: 2" title="4:24-4:33: @1[0]: _0 = const true
+4:24-4:33: @1.Goto: goto -&gt; bb4"><span class="annotation">@1⦊</span>PartialEq<span class="annotation">⦉@1</span></span><span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">⦉@2</span></span></span><span><span class="code odd" style="--layer: 1" title="4:33-4:33: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..376c8dd80d0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#6}-ne.-------.InstrumentCoverage.0.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#6}-ne - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                       <span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span></span></span><span class="code even" style="--layer: 2" title="4:24-4:33: @5[0]: _9 = const true
+4:24-4:33: @5.Goto: goto -&gt; bb8"><span class="annotation">@5⦊</span></span><span class="code even" style="--layer: 3" title="4:24-4:33: @6[0]: _9 = const false
+4:24-4:33: @6.Goto: goto -&gt; bb8"><span class="annotation">@6⦊</span></span><span class="code even" style="--layer: 4" title="4:24-4:33: @1[0]: _0 = const true
+4:24-4:33: @1.Goto: goto -&gt; bb4"><span class="annotation">@1⦊</span>PartialEq<span class="annotation">⦉@1</span></span><span class="code even" style="--layer: 3" title="4:24-4:33: @6[0]: _9 = const false
+4:24-4:33: @6.Goto: goto -&gt; bb8"><span class="annotation">⦉@6</span></span><span class="code even" style="--layer: 2" title="4:24-4:33: @5[0]: _9 = const true
+4:24-4:33: @5.Goto: goto -&gt; bb8"><span class="annotation">⦉@5</span></span><span><span class="code even" style="--layer: 1" title="4:24-4:33: @2[0]: _0 = const false
+4:24-4:33: @2.Goto: goto -&gt; bb4"><span class="annotation">⦉@2</span></span></span><span><span class="code odd" style="--layer: 1" title="4:33-4:33: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..c3fed16a3b4
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#7}-fmt.-------.InstrumentCoverage.0.html
@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#7}-fmt - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">                <span><span class="code even" style="--layer: 1" title="4:17-4:22: @0[0]: FakeRead(ForMatchedPlace, (*_1))
+4:17-4:22: @0[2]: _3 = &amp;((*_1).0: usize)
+4:17-4:22: @0[4]: _4 = &amp;((*_1).1: usize)
+4:17-4:22: @0[6]: _5 = &amp;((*_1).2: usize)
+4:17-4:22: @0[9]: _7 = &amp;mut (*_2)
+4:17-4:22: @0[12]: _9 = const &quot;Version&quot;
+4:17-4:22: @0[13]: _8 = &amp;(*_9)
+4:17-4:22: @0.Call: _6 = Formatter::debug_struct(move _7, move _8) -&gt; [return: bb1, unwind: bb6]
+4:17-4:22: @1[2]: FakeRead(ForLet, _6)
+4:17-4:22: @1[6]: _11 = &amp;mut _6
+4:17-4:22: @1[9]: _13 = const &quot;major&quot;
+4:17-4:22: @1[10]: _12 = &amp;(*_13)
+4:17-4:22: @1[15]: _17 = &amp;(*_3)
+4:17-4:22: @1[16]: _16 = &amp;_17
+4:17-4:22: @1[17]: _15 = &amp;(*_16)
+4:17-4:22: @1[18]: _14 = move _15 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
+4:17-4:22: @1.Call: _10 = DebugStruct::field(move _11, move _12, move _14) -&gt; [return: bb2, unwind: bb6]
+4:17-4:22: @2[9]: _19 = &amp;mut _6
+4:17-4:22: @2[12]: _21 = const &quot;minor&quot;
+4:17-4:22: @2[13]: _20 = &amp;(*_21)
+4:17-4:22: @2[18]: _25 = &amp;(*_4)
+4:17-4:22: @2[19]: _24 = &amp;_25
+4:17-4:22: @2[20]: _23 = &amp;(*_24)
+4:17-4:22: @2[21]: _22 = move _23 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
+4:17-4:22: @2.Call: _18 = DebugStruct::field(move _19, move _20, move _22) -&gt; [return: bb3, unwind: bb6]
+4:17-4:22: @3[9]: _27 = &amp;mut _6
+4:17-4:22: @3[12]: _29 = const &quot;patch&quot;
+4:17-4:22: @3[13]: _28 = &amp;(*_29)
+4:17-4:22: @3[18]: _33 = &amp;(*_5)
+4:17-4:22: @3[19]: _32 = &amp;_33
+4:17-4:22: @3[20]: _31 = &amp;(*_32)
+4:17-4:22: @3[21]: _30 = move _31 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
+4:17-4:22: @3.Call: _26 = DebugStruct::field(move _27, move _28, move _30) -&gt; [return: bb4, unwind: bb6]
+4:17-4:22: @4[8]: _34 = &amp;mut _6
+4:17-4:22: @4.Call: _0 = DebugStruct::finish(move _34) -&gt; [return: bb5, unwind: bb6]
+4:22-4:22: @5.Return: return"><span class="annotation">@0,1,2,3,4,5⦊</span>Debug<span class="annotation">⦉@0,1,2,3,4,5</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..6a4f11e0754
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.partial_eq_counter_without_region/partial_eq_counter_without_region.{impl#8}-clone.-------.InstrumentCoverage.0.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>partial_eq_counter_without_region.{impl#8}-clone - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 3"><span class="line">         <span><span class="code even" style="--layer: 1" title="4:10-4:15: @0[0]: FakeRead(ForMatchedPlace, (*_1))
+4:10-4:15: @0[2]: _2 = &amp;((*_1).0: usize)
+4:10-4:15: @0[4]: _3 = &amp;((*_1).1: usize)
+4:10-4:15: @0[6]: _4 = &amp;((*_1).2: usize)
+4:10-4:15: @0[10]: _7 = &amp;(*_2)
+4:10-4:15: @0[11]: _6 = &amp;(*_7)
+4:10-4:15: @0.Call: _5 = &lt;usize as Clone&gt;::clone(move _6) -&gt; [return: bb1, unwind: bb4]
+4:10-4:15: @1[4]: _10 = &amp;(*_3)
+4:10-4:15: @1[5]: _9 = &amp;(*_10)
+4:10-4:15: @1.Call: _8 = &lt;usize as Clone&gt;::clone(move _9) -&gt; [return: bb2, unwind: bb4]
+4:10-4:15: @2[4]: _13 = &amp;(*_4)
+4:10-4:15: @2[5]: _12 = &amp;(*_13)
+4:10-4:15: @2.Call: _11 = &lt;usize as Clone&gt;::clone(move _12) -&gt; [return: bb3, unwind: bb4]
+4:10-4:15: @3[1]: _0 = Version { major: move _5, minor: move _8, patch: move _11 }
+4:15-4:15: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>Clone<span class="annotation">⦉@0,1,2,3</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
index 4b21d3fc263..618f84513e9 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
@@ -89,39 +89,45 @@
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="12:9-12:16: @3[6]: _7 = _1
 12:9-12:16: @3[7]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">        countdown</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">        countdown</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">        =</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">        =</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">            10</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">            10</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">        ;</span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">        ;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @6[0]: _5 = const 10_i32
-13:5-18:6: @6[1]: _6 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+13:5-18:6: @6[1]: _6 = const ()
+18:6-18:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="18:6-18:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    loop</span></span>
 <span class="line"><span class="code" style="--layer: 0">    {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
 23:13-25:14: @9[4]: _10 = Eq(move _11, const 0_i32)
 23:13-25:14: @9[6]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@8,9⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
+<span class="line"><span class="code odd" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
 23:13-25:14: @9[4]: _10 = Eq(move _11, const 0_i32)
 23:13-25:14: @9[6]: FakeRead(ForMatchedPlace, _10)">                ==</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
+<span class="line"><span class="code odd" style="--layer: 1" title="23:13-23:22: @9[3]: _11 = _5
 23:13-25:14: @9[4]: _10 = Eq(move _11, const 0_i32)
 23:13-25:14: @9[6]: FakeRead(ForMatchedPlace, _10)">            0<span class="annotation">⦉@8,9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="27:13-27:18: @12[0]: _0 = const ()"><span class="annotation">@10,12⦊</span>break<span class="annotation">⦉@10,12</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:18: @12[0]: _0 = const ()"><span class="annotation">@10,12⦊</span>break<span class="annotation">⦉@10,12</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">            ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="30:9-32:10: @11[3]: _13 = CheckedSub(_5, const 1_i32)"><span class="annotation">@11⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @11[3]: _13 = CheckedSub(_5, const 1_i32)">        -=</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @11[3]: _13 = CheckedSub(_5, const 1_i32)">        1<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="30:9-32:10: @13[0]: _5 = move (_13.0: i32)"><span class="annotation">@13⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @13[0]: _5 = move (_13.0: i32)">        -=</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @13[0]: _5 = move (_13.0: i32)">        1<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="34:6-34:6: @7.Goto: goto -&gt; bb8"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="35:2-35:2: @12.Return: return"><span class="annotation">@10,12⦊</span>‸<span class="annotation">⦉@10,12</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
index 5ba770ef607..66885d0612b 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
@@ -86,51 +86,39 @@
 9:9-9:22: @3[3]: FakeRead(ForLet, _5)">    let mut countdown = 1<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="10:8-10:15: @3[6]: _7 = _1
 10:8-10:15: @3[7]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@0,1,2,3⦊</span>is_true<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="11:9-11:22: @6[0]: _5 = const 0_i32
-10:16-12:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7"><span class="annotation">@4,6⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:22: @6[0]: _5 = const 0_i32
-10:16-12:6: @6[1]: _6 = const ()">        countdown = 0;</span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">        countdown = 0;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:22: @6[0]: _5 = const 0_i32
-10:16-12:6: @6[1]: _6 = const ()">    }<span class="annotation">⦉@4,6</span></span></span><span class="code" style="--layer: 0"></span></span>
+10:16-12:6: @6[1]: _6 = const ()
+12:6-12:6: @6.Goto: goto -&gt; bb7">    }<span class="annotation">⦉@4,6</span></span></span><span><span class="code even" style="--layer: 1" title="12:6-12:6: @5.Goto: goto -&gt; bb7"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="15:9-15:10: @11[2]: _17 = discriminant(_14)"><span class="annotation">@9,10,11⦊</span>for</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="15:9-15:10: @11[2]: _17 = discriminant(_14)">        _<span class="annotation">⦉@9,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    for</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="15:9-15:10: @15[1]: _18 = ((_14 as Some).0: i32)
+15:9-15:10: @15[3]: _19 = _18
+15:9-15:10: @15[4]: _12 = move _19
+15:9-15:10: @15[5]: _13 = const ()"><span class="annotation">@13,15,17⦊</span>_<span class="annotation">⦉@13,15,17</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    in</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="17:9-17:13: @7[4]: _9 = std::ops::Range::&lt;i32&gt; { start: const 0_i32, end: const 2_i32 }
-17:9-17:13: @7.Call: _8 = &lt;std::ops::Range&lt;i32&gt; as IntoIterator&gt;::into_iter(move _9) -&gt; [return: bb8, unwind: bb22]
-17:9-17:13: @8[1]: FakeRead(ForMatchedPlace, _8)
-17:9-17:13: @8[3]: _10 = move _8"><span class="annotation">@7,8⦊</span>0..2<span class="annotation">⦉@7,8</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="17:9-17:13: @10[5]: _16 = &amp;mut _10
+17:9-17:13: @10[6]: _15 = &amp;mut (*_16)
+17:9-17:13: @10.Call: _14 = &lt;std::ops::Range&lt;i32&gt; as Iterator&gt;::next(move _15) -&gt; [return: bb11, unwind: bb22]
+17:9-17:13: @11[1]: FakeRead(ForMatchedPlace, _14)"><span class="annotation">@9,10,11⦊</span>0..2<span class="annotation">⦉@9,10,11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        let z</span></span>
 <span class="line"><span class="code" style="--layer: 0">        ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        match</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)"><span class="annotation">@13,15,17⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">        {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">            x</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">            if</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                x</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)"><span class="annotation">@13,15,17⦊</span>countdown<span class="annotation">⦉@13,15,17</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="24:13-24:14: @18[3]: _23 = _5"><span class="annotation">@18⦊</span>x<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">            if</span></span>
+<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="26:17-26:18: @17[4]: _26 = (*_24)
+26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)"><span class="annotation">@13,15,17⦊</span>x</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="26:17-26:18: @17[4]: _26 = (*_24)
 26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                    &lt;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:13-22:22: @15[13]: FakeRead(ForMatchedPlace, _5)
-24:13-24:14: @17[1]: _24 = &amp;_5
-26:17-26:18: @17[4]: _26 = (*_24)
-26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                1<span class="annotation">⦉@13,15,17</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="26:17-26:18: @17[4]: _26 = (*_24)
+26:17-28:18: @17[5]: _25 = Lt(move _26, const 1_i32)">                1<span class="annotation">⦉@13,15,17</span></span></span><span><span class="code even" style="--layer: 1" title="28:18-28:18: @19.Goto: goto -&gt; bb16"><span class="annotation">@19⦊</span>‸<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">            =&gt;</span></span>
 <span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="31:21-31:30: @18[5]: _27 = _5
 31:17-31:30: @18[6]: _22 = move _27
@@ -184,7 +172,7 @@
 <span class="line"><span class="code" style="--layer: 0">            =&gt;</span></span>
 <span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="40:13-40:15: @16[0]: _21 = const ()"><span class="annotation">@16⦊</span>{}<span class="annotation">⦉@16</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="42:6-42:6: @8.Goto: goto -&gt; bb9"><span class="annotation">@7,8⦊</span>‸<span class="annotation">⦉@7,8</span></span></span><span><span class="code even" style="--layer: 1" title="42:6-42:6: @20.Goto: goto -&gt; bb9"><span class="annotation">@20⦊</span>‸<span class="annotation">⦉@20</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="43:2-43:2: @12.Return: return"><span class="annotation">@12⦊</span>‸<span class="annotation">⦉@12</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..db08315baa6
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.tight_infinite_loop/tight_infinite_loop.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>tight_infinite_loop.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 0"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="2:8-2:13: @0[1]: _1 = const false
+2:8-2:13: @0[2]: FakeRead(ForMatchedPlace, _1)"><span class="annotation">@0⦊</span>false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="3:9-3:16: @4.FalseUnwind: falseUnwind -&gt; [real: bb5, cleanup: bb6]
+3:14-3:16: @5[0]: _3 = const ()"><span class="annotation">@4,5⦊</span>loop {}<span class="annotation">⦉@4,5</span></span></span><span><span class="code even" style="--layer: 1" title="3:16-3:16: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>‸<span class="annotation">⦉@1,3</span></span></span><span><span class="code odd" style="--layer: 1" title="3:16-3:16: @5.Goto: goto -&gt; bb4"><span class="annotation">@4,5⦊</span>‸<span class="annotation">⦉@4,5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="5:2-5:2: @2.Return: return"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
index 9f993342340..8a0b1ae8dab 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
@@ -67,7 +67,7 @@
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="8:12-8:14: @2[1]: _4 = ()
 8:9-8:15: @2[2]: _0 = std::result::Result::&lt;(), ()&gt;::Ok(move _4)"><span class="annotation">@2⦊</span>Ok(())<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="10:2-10:2: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code odd" style="--layer: 1" title="9:6-9:6: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>‸<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="10:2-10:2: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
index 660c3031f35..428c6fadc27 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
@@ -65,37 +65,51 @@
 <span class="line"><span class="code even" style="--layer: 1" title="14:21-14:23: @0[1]: _1 = const 10_i32
 13:9-14:18: @0[2]: FakeRead(ForLet, _1)">        countdown = 10<span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="17:9-17:10: @4[2]: _12 = discriminant(_9)"><span class="annotation">@2,3,4⦊</span>for</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="17:9-17:10: @4[2]: _12 = discriminant(_9)">        _<span class="annotation">⦉@2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    for</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="17:9-17:10: @8[1]: _13 = ((_9 as Some).0: i32)
+17:9-17:10: @8[3]: _14 = _13
+17:9-17:10: @8[4]: _7 = move _14
+17:9-17:10: @8[5]: _8 = const ()"><span class="annotation">@6,8⦊</span>_<span class="annotation">⦉@6,8</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    in</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="19:9-19:14: @0[6]: _4 = std::ops::Range::&lt;i32&gt; { start: const 0_i32, end: const 10_i32 }
-19:9-19:14: @0.Call: _3 = &lt;std::ops::Range&lt;i32&gt; as IntoIterator&gt;::into_iter(move _4) -&gt; [return: bb1, unwind: bb32]
-19:9-19:14: @1[1]: FakeRead(ForMatchedPlace, _3)
-19:9-19:14: @1[3]: _5 = move _3"><span class="annotation">@0,1⦊</span>0..10<span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="19:9-19:14: @3[5]: _11 = &amp;mut _5
+19:9-19:14: @3[6]: _10 = &amp;mut (*_11)
+19:9-19:14: @3.Call: _9 = &lt;std::ops::Range&lt;i32&gt; as Iterator&gt;::next(move _10) -&gt; [return: bb4, unwind: bb32]
+19:9-19:14: @4[1]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@2,3,4⦊</span>0..10<span class="annotation">⦉@2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="21:9-22:17: @8[12]: _17 = CheckedSub(_1, const 1_i32)"><span class="annotation">@6,8⦊</span>countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @8[12]: _17 = CheckedSub(_1, const 1_i32)">            -= 1<span class="annotation">⦉@6,8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        ;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="25:13-25:22: @9[3]: _19 = _1
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
 25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
-25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)"><span class="annotation">@9⦊</span>countdown &lt; 5<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)"><span class="annotation">@9⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">            -= 1</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">        ;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">        if</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="21:9-22:17: @9[0]: _1 = move (_17.0: i32)
+25:13-25:22: @9[3]: _19 = _1
+25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)
+25:13-25:26: @9[6]: FakeRead(ForMatchedPlace, _18)">            countdown &lt; 5<span class="annotation">⦉@9</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="27:13-27:41: @12.Call: _22 = call(const true) -&gt; [return: bb13, unwind: bb32]
-27:13-27:42: @13.Call: _21 = &lt;std::result::Result&lt;(), ()&gt; as Try&gt;::into_result(move _22) -&gt; [return: bb14, unwind: bb32]
-27:13-27:42: @14[1]: FakeRead(ForMatchedPlace, _21)
-27:41-27:42: @14[2]: _23 = discriminant(_21)"><span class="annotation">@10,12,13,14⦊</span>call(/*return_error=*/ true)?<span class="annotation">⦉@10,12,13,14</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:41: @12.Call: _22 = call(const true) -&gt; [return: bb13, unwind: bb32]"><span class="annotation">@10,12,13,14⦊</span>call(/*return_error=*/ true)<span class="annotation">⦉@10,12,13,14</span></span></span><span><span class="code odd" style="--layer: 1" title="27:41-27:42: @18[1]: _24 = ((_21 as Err).0: ())
+27:41-27:42: @18[4]: _27 = _24
+27:41-27:42: @18.Call: _26 = &lt;() as From&lt;()&gt;&gt;::from(move _27) -&gt; [return: bb19, unwind: bb32]"><span class="annotation">@16,18,19,20⦊</span>?<span class="annotation">⦉@16,18,19,20</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
 <span class="line"><span class="code" style="--layer: 0">        else</span></span>
 <span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="31:13-31:42: @11.Call: _31 = call(const false) -&gt; [return: bb21, unwind: bb32]
-31:13-31:43: @21.Call: _30 = &lt;std::result::Result&lt;(), ()&gt; as Try&gt;::into_result(move _31) -&gt; [return: bb22, unwind: bb32]
-31:13-31:43: @22[1]: FakeRead(ForMatchedPlace, _30)
-31:42-31:43: @22[2]: _32 = discriminant(_30)"><span class="annotation">@11,21,22⦊</span>call(/*return_error=*/ false)?<span class="annotation">⦉@11,21,22</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="34:8-34:10: @5[9]: _38 = ()
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="31:13-31:42: @11.Call: _31 = call(const false) -&gt; [return: bb21, unwind: bb32]"><span class="annotation">@11,21,22⦊</span>call(/*return_error=*/ false)<span class="annotation">⦉@11,21,22</span></span></span><span><span class="code odd" style="--layer: 1" title="31:42-31:43: @26[1]: _33 = ((_30 as Err).0: ())
+31:42-31:43: @26[4]: _36 = _33
+31:42-31:43: @26.Call: _35 = &lt;() as From&lt;()&gt;&gt;::from(move _36) -&gt; [return: bb27, unwind: bb32]"><span class="annotation">@24,26,27,28⦊</span>?<span class="annotation">⦉@24,26,27,28</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span><span><span class="code even" style="--layer: 1" title="32:10-32:10: @15.Goto: goto -&gt; bb29"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span><span><span class="code odd" style="--layer: 1" title="32:10-32:10: @23.Goto: goto -&gt; bb29"><span class="annotation">@23⦊</span>‸<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="33:6-33:6: @1.Goto: goto -&gt; bb2"><span class="annotation">@0,1⦊</span>‸<span class="annotation">⦉@0,1</span></span></span><span><span class="code odd" style="--layer: 1" title="33:6-33:6: @29.Goto: goto -&gt; bb2"><span class="annotation">@29⦊</span>‸<span class="annotation">⦉@29</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="34:8-34:10: @5[9]: _38 = ()
 34:5-34:11: @5[10]: _0 = std::result::Result::&lt;(), ()&gt;::Ok(move _38)"><span class="annotation">@5⦊</span>Ok(())<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="35:2-35:2: @31.Return: return"><span class="annotation">@31⦊</span>‸<span class="annotation">⦉@31</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="35:2-35:2: @30.Goto: goto -&gt; bb31"><span class="annotation">@30⦊</span>‸<span class="annotation">⦉@30</span></span></span><span><span class="code even" style="--layer: 1" title="35:2-35:2: @31.Return: return"><span class="annotation">@31⦊</span>‸<span class="annotation">⦉@31</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
index 28f1d013c83..b9f6f4d7832 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
@@ -64,32 +64,42 @@
 4:9-4:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>mut countdown = 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="5:8-5:12: @0[5]: _3 = const true
 5:8-5:12: @0[6]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@0⦊</span>true<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="6:9-6:23: @3[0]: _1 = const 10_u32
-5:13-7:6: @3[1]: _2 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
+5:13-7:6: @3[1]: _2 = const ()
+7:6-7:6: @3.Goto: goto -&gt; bb4"><span class="annotation">@1,3⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="6:9-6:23: @3[0]: _1 = const 10_u32
-5:13-7:6: @3[1]: _2 = const ()">        countdown = 10;</span></span>
+5:13-7:6: @3[1]: _2 = const ()
+7:6-7:6: @3.Goto: goto -&gt; bb4">        countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="6:9-6:23: @3[0]: _1 = const 10_u32
-5:13-7:6: @3[1]: _2 = const ()">    }<span class="annotation">⦉@1,3</span></span></span><span class="code" style="--layer: 0"></span></span>
+5:13-7:6: @3[1]: _2 = const ()
+7:6-7:6: @3.Goto: goto -&gt; bb4">    }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="7:6-7:6: @2.Goto: goto -&gt; bb4"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    const B: u32 = 100;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="10:9-10:10: @25[0]: FakeRead(ForLet, _4)"><span class="annotation">@25⦊</span>x<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code odd" style="--layer: 1" title="10:16-10:25: @4[5]: _6 = _1
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="10:9-10:10: @25[0]: FakeRead(ForLet, _4)"><span class="annotation">@25⦊</span>x<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="10:16-10:25: @4[5]: _6 = _1
 10:16-10:29: @4[6]: _5 = Gt(move _6, const 7_u32)
 10:16-10:29: @4[8]: FakeRead(ForMatchedPlace, _5)"><span class="annotation">@4⦊</span>countdown &gt; 7<span class="annotation">⦉@4</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="11:9-11:23: @7[0]: _7 = CheckedSub(_1, const 4_u32)"><span class="annotation">@5,7⦊</span>countdown -= 4<span class="annotation">⦉@5,7</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="12:9-12:10: @8[1]: _4 = const B"><span class="annotation">@8⦊</span>B<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="11:9-11:23: @8[0]: _1 = move (_7.0: u32)
+12:9-12:10: @8[1]: _4 = const B"><span class="annotation">@8⦊</span>countdown -= 4;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @8[0]: _1 = move (_7.0: u32)
+12:9-12:10: @8[1]: _4 = const B">        B<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="13:15-13:24: @6[2]: _9 = _1
 13:15-13:28: @6[3]: _8 = Gt(move _9, const 2_u32)
 13:15-13:28: @6[5]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@6⦊</span>countdown &gt; 2<span class="annotation">⦉@6</span></span></span><span class="code" style="--layer: 0"> {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="14:12-14:21: @11[5]: _14 = _1
 14:12-14:25: @11[6]: _13 = Lt(move _14, const 1_u32)"><span class="annotation">@9,11⦊</span>countdown &lt; 1<span class="annotation">⦉@9,11</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="14:29-14:38: @18[2]: _16 = _1
-14:29-14:42: @18[3]: _15 = Gt(move _16, const 5_u32)"><span class="annotation">@18⦊</span>countdown &gt; 5<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="14:46-14:55: @14[2]: _18 = _1
-14:46-14:60: @14[3]: _17 = Ne(move _18, const 9_u32)"><span class="annotation">@14⦊</span>countdown != 9<span class="annotation">⦉@14</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
-14:61-16:10: @22[1]: _10 = const ()"><span class="annotation">@20,22⦊</span>{</span></span>
+14:29-14:42: @18[3]: _15 = Gt(move _16, const 5_u32)"><span class="annotation">@18⦊</span>countdown &gt; 5<span class="annotation">⦉@18</span></span></span><span><span class="code odd" style="--layer: 1" title="14:42-14:42: @16.Goto: goto -&gt; bb19"><span class="annotation">@16⦊</span>‸<span class="annotation">⦉@16</span></span></span><span><span class="code even" style="--layer: 1" title="14:42-14:42: @17.Goto: goto -&gt; bb19"><span class="annotation">@17⦊</span>‸<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="14:46-14:55: @14[2]: _18 = _1
+14:46-14:60: @14[3]: _17 = Ne(move _18, const 9_u32)"><span class="annotation">@14⦊</span>countdown != 9<span class="annotation">⦉@14</span></span></span><span><span class="code even" style="--layer: 1" title="14:60-14:60: @12.Goto: goto -&gt; bb15"><span class="annotation">@12⦊</span>‸<span class="annotation">⦉@12</span></span></span><span><span class="code odd" style="--layer: 1" title="14:60-14:60: @13.Goto: goto -&gt; bb15"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
+14:61-16:10: @22[1]: _10 = const ()
+16:10-16:10: @22.Goto: goto -&gt; bb23"><span class="annotation">@20,22⦊</span>{</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
-14:61-16:10: @22[1]: _10 = const ()">            countdown = 0;</span></span>
+14:61-16:10: @22[1]: _10 = const ()
+16:10-16:10: @22.Goto: goto -&gt; bb23">            countdown = 0;</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="15:13-15:26: @22[0]: _1 = const 0_u32
-14:61-16:10: @22[1]: _10 = const ()">        }<span class="annotation">⦉@20,22</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="17:9-17:23: @23[2]: _19 = CheckedSub(_1, const 5_u32)"><span class="annotation">@23⦊</span>countdown -= 5<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="18:9-18:18: @24[1]: _4 = _1"><span class="annotation">@24⦊</span>countdown<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0"></span></span>
+14:61-16:10: @22[1]: _10 = const ()
+16:10-16:10: @22.Goto: goto -&gt; bb23">        }<span class="annotation">⦉@20,22</span></span></span><span><span class="code odd" style="--layer: 1" title="16:10-16:10: @21.Goto: goto -&gt; bb23"><span class="annotation">@21⦊</span>‸<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="17:9-17:23: @24[0]: _1 = move (_19.0: u32)
+18:9-18:18: @24[1]: _4 = _1"><span class="annotation">@24⦊</span>countdown -= 5;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="17:9-17:23: @24[0]: _1 = move (_19.0: u32)
+18:9-18:18: @24[1]: _4 = _1">        countdown<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="20:9-20:15: @10[0]: _0 = const ()"><span class="annotation">@10⦊</span>return<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    };</span></span>
@@ -98,29 +108,35 @@
 23:9-23:22: @25[4]: FakeRead(ForLet, _21)"><span class="annotation">@25⦊</span>mut countdown = 0<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="24:8-24:12: @25[7]: _23 = const true
 24:8-24:12: @25[8]: FakeRead(ForMatchedPlace, _23)"><span class="annotation">@25⦊</span>true<span class="annotation">⦉@25</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="25:9-25:23: @28[0]: _21 = const 10_i32
-24:13-26:6: @28[1]: _22 = const ()"><span class="annotation">@26,28⦊</span>{</span></span>
+24:13-26:6: @28[1]: _22 = const ()
+26:6-26:6: @28.Goto: goto -&gt; bb29"><span class="annotation">@26,28⦊</span>{</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:23: @28[0]: _21 = const 10_i32
-24:13-26:6: @28[1]: _22 = const ()">        countdown = 10;</span></span>
+24:13-26:6: @28[1]: _22 = const ()
+26:6-26:6: @28.Goto: goto -&gt; bb29">        countdown = 10;</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:23: @28[0]: _21 = const 10_i32
-24:13-26:6: @28[1]: _22 = const ()">    }<span class="annotation">⦉@26,28</span></span></span><span class="code" style="--layer: 0"></span></span>
+24:13-26:6: @28[1]: _22 = const ()
+26:6-26:6: @28.Goto: goto -&gt; bb29">    }<span class="annotation">⦉@26,28</span></span></span><span><span class="code even" style="--layer: 1" title="26:6-26:6: @27.Goto: goto -&gt; bb29"><span class="annotation">@27⦊</span>‸<span class="annotation">⦉@27</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="28:8-28:17: @29[5]: _26 = _21
+<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="28:8-28:17: @29[5]: _26 = _21
 28:8-28:21: @29[6]: _25 = Gt(move _26, const 7_i32)
 28:8-28:21: @29[8]: FakeRead(ForMatchedPlace, _25)"><span class="annotation">@29⦊</span>countdown &gt; 7<span class="annotation">⦉@29</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="29:9-29:23: @32[0]: _27 = CheckedSub(_21, const 4_i32)"><span class="annotation">@30,32⦊</span>countdown -= 4<span class="annotation">⦉@30,32</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="30:15-30:24: @31[2]: _29 = _21
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="29:9-29:23: @33[0]: _21 = move (_27.0: i32)"><span class="annotation">@33⦊</span>countdown -= 4<span class="annotation">⦉@33</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code odd" style="--layer: 1" title="30:15-30:24: @31[2]: _29 = _21
 30:15-30:28: @31[3]: _28 = Gt(move _29, const 2_i32)
 30:15-30:28: @31[5]: FakeRead(ForMatchedPlace, _28)"><span class="annotation">@31⦊</span>countdown &gt; 2<span class="annotation">⦉@31</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="31:12-31:21: @36[5]: _34 = _21
-31:12-31:25: @36[6]: _33 = Lt(move _34, const 1_i32)"><span class="annotation">@34,36⦊</span>countdown &lt; 1<span class="annotation">⦉@34,36</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="31:29-31:38: @43[2]: _36 = _21
-31:29-31:42: @43[3]: _35 = Gt(move _36, const 5_i32)"><span class="annotation">@43⦊</span>countdown &gt; 5<span class="annotation">⦉@43</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="31:46-31:55: @39[2]: _38 = _21
-31:46-31:60: @39[3]: _37 = Ne(move _38, const 9_i32)"><span class="annotation">@39⦊</span>countdown != 9<span class="annotation">⦉@39</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
-31:61-33:10: @47[1]: _30 = const ()"><span class="annotation">@45,47⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
-31:61-33:10: @47[1]: _30 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
-31:61-33:10: @47[1]: _30 = const ()">        }<span class="annotation">⦉@45,47</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="34:9-34:23: @48[2]: _39 = CheckedSub(_21, const 5_i32)"><span class="annotation">@48⦊</span>countdown -= 5<span class="annotation">⦉@48</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="31:12-31:21: @36[5]: _34 = _21
+31:12-31:25: @36[6]: _33 = Lt(move _34, const 1_i32)"><span class="annotation">@34,36⦊</span>countdown &lt; 1<span class="annotation">⦉@34,36</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="31:29-31:38: @43[2]: _36 = _21
+31:29-31:42: @43[3]: _35 = Gt(move _36, const 5_i32)"><span class="annotation">@43⦊</span>countdown &gt; 5<span class="annotation">⦉@43</span></span></span><span><span class="code even" style="--layer: 1" title="31:42-31:42: @41.Goto: goto -&gt; bb44"><span class="annotation">@41⦊</span>‸<span class="annotation">⦉@41</span></span></span><span><span class="code odd" style="--layer: 1" title="31:42-31:42: @42.Goto: goto -&gt; bb44"><span class="annotation">@42⦊</span>‸<span class="annotation">⦉@42</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="31:46-31:55: @39[2]: _38 = _21
+31:46-31:60: @39[3]: _37 = Ne(move _38, const 9_i32)"><span class="annotation">@39⦊</span>countdown != 9<span class="annotation">⦉@39</span></span></span><span><span class="code odd" style="--layer: 1" title="31:60-31:60: @37.Goto: goto -&gt; bb40"><span class="annotation">@37⦊</span>‸<span class="annotation">⦉@37</span></span></span><span><span class="code even" style="--layer: 1" title="31:60-31:60: @38.Goto: goto -&gt; bb40"><span class="annotation">@38⦊</span>‸<span class="annotation">⦉@38</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
+31:61-33:10: @47[1]: _30 = const ()
+33:10-33:10: @47.Goto: goto -&gt; bb48"><span class="annotation">@45,47⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
+31:61-33:10: @47[1]: _30 = const ()
+33:10-33:10: @47.Goto: goto -&gt; bb48">            countdown = 0;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="32:13-32:26: @47[0]: _21 = const 0_i32
+31:61-33:10: @47[1]: _30 = const ()
+33:10-33:10: @47.Goto: goto -&gt; bb48">        }<span class="annotation">⦉@45,47</span></span></span><span><span class="code even" style="--layer: 1" title="33:10-33:10: @46.Goto: goto -&gt; bb48"><span class="annotation">@46⦊</span>‸<span class="annotation">⦉@46</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="34:9-34:23: @49[0]: _21 = move (_39.0: i32)"><span class="annotation">@49⦊</span>countdown -= 5<span class="annotation">⦉@49</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="36:9-36:15: @35[0]: _0 = const ()"><span class="annotation">@35⦊</span>return<span class="annotation">⦉@35</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    }</span></span>
@@ -129,29 +145,35 @@
 39:9-39:22: @50[4]: FakeRead(ForLet, _41)"><span class="annotation">@50⦊</span>mut countdown = 0<span class="annotation">⦉@50</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="40:8-40:12: @50[7]: _43 = const true
 40:8-40:12: @50[8]: FakeRead(ForMatchedPlace, _43)"><span class="annotation">@50⦊</span>true<span class="annotation">⦉@50</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="41:9-41:22: @53[0]: _41 = const 1_i32
-40:13-42:6: @53[1]: _42 = const ()"><span class="annotation">@51,53⦊</span>{</span></span>
+40:13-42:6: @53[1]: _42 = const ()
+42:6-42:6: @53.Goto: goto -&gt; bb54"><span class="annotation">@51,53⦊</span>{</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="41:9-41:22: @53[0]: _41 = const 1_i32
-40:13-42:6: @53[1]: _42 = const ()">        countdown = 1;</span></span>
+40:13-42:6: @53[1]: _42 = const ()
+42:6-42:6: @53.Goto: goto -&gt; bb54">        countdown = 1;</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="41:9-41:22: @53[0]: _41 = const 1_i32
-40:13-42:6: @53[1]: _42 = const ()">    }<span class="annotation">⦉@51,53</span></span></span><span class="code" style="--layer: 0"></span></span>
+40:13-42:6: @53[1]: _42 = const ()
+42:6-42:6: @53.Goto: goto -&gt; bb54">    }<span class="annotation">⦉@51,53</span></span></span><span><span class="code odd" style="--layer: 1" title="42:6-42:6: @52.Goto: goto -&gt; bb54"><span class="annotation">@52⦊</span>‸<span class="annotation">⦉@52</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="44:9-44:10: @77[0]: FakeRead(ForLet, _44)"><span class="annotation">@77⦊</span>z<span class="annotation">⦉@77</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="44:16-44:25: @54[5]: _46 = _41
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="44:9-44:10: @77[0]: FakeRead(ForLet, _44)"><span class="annotation">@77⦊</span>z<span class="annotation">⦉@77</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code odd" style="--layer: 1" title="44:16-44:25: @54[5]: _46 = _41
 44:16-44:29: @54[6]: _45 = Gt(move _46, const 7_i32)
 44:16-44:29: @54[8]: FakeRead(ForMatchedPlace, _45)"><span class="annotation">@54⦊</span>countdown &gt; 7<span class="annotation">⦉@54</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="45:9-45:23: @57[0]: _47 = CheckedSub(_41, const 4_i32)"><span class="annotation">@55,57⦊</span>countdown -= 4<span class="annotation">⦉@55,57</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="46:15-46:24: @56[2]: _49 = _41
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="45:9-45:23: @58[0]: _41 = move (_47.0: i32)"><span class="annotation">@58⦊</span>countdown -= 4<span class="annotation">⦉@58</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code odd" style="--layer: 1" title="46:15-46:24: @56[2]: _49 = _41
 46:15-46:28: @56[3]: _48 = Gt(move _49, const 2_i32)
 46:15-46:28: @56[5]: FakeRead(ForMatchedPlace, _48)"><span class="annotation">@56⦊</span>countdown &gt; 2<span class="annotation">⦉@56</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="47:12-47:21: @61[5]: _54 = _41
-47:12-47:25: @61[6]: _53 = Lt(move _54, const 1_i32)"><span class="annotation">@59,61⦊</span>countdown &lt; 1<span class="annotation">⦉@59,61</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="47:29-47:38: @68[2]: _56 = _41
-47:29-47:42: @68[3]: _55 = Gt(move _56, const 5_i32)"><span class="annotation">@68⦊</span>countdown &gt; 5<span class="annotation">⦉@68</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="47:46-47:55: @64[2]: _58 = _41
-47:46-47:60: @64[3]: _57 = Ne(move _58, const 9_i32)"><span class="annotation">@64⦊</span>countdown != 9<span class="annotation">⦉@64</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
-47:61-49:10: @72[1]: _50 = const ()"><span class="annotation">@70,72⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
-47:61-49:10: @72[1]: _50 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
-47:61-49:10: @72[1]: _50 = const ()">        }<span class="annotation">⦉@70,72</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="50:9-50:23: @73[2]: _59 = CheckedSub(_41, const 5_i32)"><span class="annotation">@73⦊</span>countdown -= 5<span class="annotation">⦉@73</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="47:12-47:21: @61[5]: _54 = _41
+47:12-47:25: @61[6]: _53 = Lt(move _54, const 1_i32)"><span class="annotation">@59,61⦊</span>countdown &lt; 1<span class="annotation">⦉@59,61</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="47:29-47:38: @68[2]: _56 = _41
+47:29-47:42: @68[3]: _55 = Gt(move _56, const 5_i32)"><span class="annotation">@68⦊</span>countdown &gt; 5<span class="annotation">⦉@68</span></span></span><span><span class="code even" style="--layer: 1" title="47:42-47:42: @66.Goto: goto -&gt; bb69"><span class="annotation">@66⦊</span>‸<span class="annotation">⦉@66</span></span></span><span><span class="code odd" style="--layer: 1" title="47:42-47:42: @67.Goto: goto -&gt; bb69"><span class="annotation">@67⦊</span>‸<span class="annotation">⦉@67</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="47:46-47:55: @64[2]: _58 = _41
+47:46-47:60: @64[3]: _57 = Ne(move _58, const 9_i32)"><span class="annotation">@64⦊</span>countdown != 9<span class="annotation">⦉@64</span></span></span><span><span class="code odd" style="--layer: 1" title="47:60-47:60: @62.Goto: goto -&gt; bb65"><span class="annotation">@62⦊</span>‸<span class="annotation">⦉@62</span></span></span><span><span class="code even" style="--layer: 1" title="47:60-47:60: @63.Goto: goto -&gt; bb65"><span class="annotation">@63⦊</span>‸<span class="annotation">⦉@63</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
+47:61-49:10: @72[1]: _50 = const ()
+49:10-49:10: @72.Goto: goto -&gt; bb73"><span class="annotation">@70,72⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
+47:61-49:10: @72[1]: _50 = const ()
+49:10-49:10: @72.Goto: goto -&gt; bb73">            countdown = 0;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="48:13-48:26: @72[0]: _41 = const 0_i32
+47:61-49:10: @72[1]: _50 = const ()
+49:10-49:10: @72.Goto: goto -&gt; bb73">        }<span class="annotation">⦉@70,72</span></span></span><span><span class="code even" style="--layer: 1" title="49:10-49:10: @71.Goto: goto -&gt; bb73"><span class="annotation">@71⦊</span>‸<span class="annotation">⦉@71</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="50:9-50:23: @74[0]: _41 = move (_59.0: i32)"><span class="annotation">@74⦊</span>countdown -= 5<span class="annotation">⦉@74</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="52:35-52:44: @60[1]: _61 = _41
 52:13-52:32: @60[2]: FakeRead(ForLet, _61)
@@ -206,23 +228,26 @@
 <span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="57:9-57:10: @98[0]: FakeRead(ForLet, _74)"><span class="annotation">@98⦊</span>w<span class="annotation">⦉@98</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="57:16-57:25: @77[5]: _76 = _41
 57:16-57:29: @77[6]: _75 = Gt(move _76, const 7_i32)
 57:16-57:29: @77[8]: FakeRead(ForMatchedPlace, _75)"><span class="annotation">@77⦊</span>countdown &gt; 7<span class="annotation">⦉@77</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="58:9-58:23: @80[0]: _77 = CheckedSub(_41, const 4_i32)"><span class="annotation">@78,80⦊</span>countdown -= 4<span class="annotation">⦉@78,80</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="58:9-58:23: @81[0]: _41 = move (_77.0: i32)"><span class="annotation">@81⦊</span>countdown -= 4<span class="annotation">⦉@81</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else if </span><span><span class="code even" style="--layer: 1" title="59:15-59:24: @79[2]: _79 = _41
 59:15-59:28: @79[3]: _78 = Gt(move _79, const 2_i32)
 59:15-59:28: @79[5]: FakeRead(ForMatchedPlace, _78)"><span class="annotation">@79⦊</span>countdown &gt; 2<span class="annotation">⦉@79</span></span></span><span class="code" style="--layer: 0"> {</span></span>
 <span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="60:12-60:21: @84[5]: _84 = _41
 60:12-60:25: @84[6]: _83 = Lt(move _84, const 1_i32)"><span class="annotation">@82,84⦊</span>countdown &lt; 1<span class="annotation">⦉@82,84</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="60:29-60:38: @91[2]: _86 = _41
-60:29-60:42: @91[3]: _85 = Gt(move _86, const 5_i32)"><span class="annotation">@91⦊</span>countdown &gt; 5<span class="annotation">⦉@91</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="60:46-60:55: @87[2]: _88 = _41
-60:46-60:60: @87[3]: _87 = Ne(move _88, const 9_i32)"><span class="annotation">@87⦊</span>countdown != 9<span class="annotation">⦉@87</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
-60:61-62:10: @95[1]: _80 = const ()"><span class="annotation">@93,95⦊</span>{</span></span>
+60:29-60:42: @91[3]: _85 = Gt(move _86, const 5_i32)"><span class="annotation">@91⦊</span>countdown &gt; 5<span class="annotation">⦉@91</span></span></span><span><span class="code odd" style="--layer: 1" title="60:42-60:42: @89.Goto: goto -&gt; bb92"><span class="annotation">@89⦊</span>‸<span class="annotation">⦉@89</span></span></span><span><span class="code even" style="--layer: 1" title="60:42-60:42: @90.Goto: goto -&gt; bb92"><span class="annotation">@90⦊</span>‸<span class="annotation">⦉@90</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="60:46-60:55: @87[2]: _88 = _41
+60:46-60:60: @87[3]: _87 = Ne(move _88, const 9_i32)"><span class="annotation">@87⦊</span>countdown != 9<span class="annotation">⦉@87</span></span></span><span><span class="code even" style="--layer: 1" title="60:60-60:60: @85.Goto: goto -&gt; bb88"><span class="annotation">@85⦊</span>‸<span class="annotation">⦉@85</span></span></span><span><span class="code odd" style="--layer: 1" title="60:60-60:60: @86.Goto: goto -&gt; bb88"><span class="annotation">@86⦊</span>‸<span class="annotation">⦉@86</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
+60:61-62:10: @95[1]: _80 = const ()
+62:10-62:10: @95.Goto: goto -&gt; bb96"><span class="annotation">@93,95⦊</span>{</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
-60:61-62:10: @95[1]: _80 = const ()">            countdown = 0;</span></span>
+60:61-62:10: @95[1]: _80 = const ()
+62:10-62:10: @95.Goto: goto -&gt; bb96">            countdown = 0;</span></span>
 <span class="line"><span class="code even" style="--layer: 1" title="61:13-61:26: @95[0]: _41 = const 0_i32
-60:61-62:10: @95[1]: _80 = const ()">        }<span class="annotation">⦉@93,95</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="63:9-63:23: @96[2]: _89 = CheckedSub(_41, const 5_i32)"><span class="annotation">@96⦊</span>countdown -= 5<span class="annotation">⦉@96</span></span></span><span class="code" style="--layer: 0">;</span></span>
+60:61-62:10: @95[1]: _80 = const ()
+62:10-62:10: @95.Goto: goto -&gt; bb96">        }<span class="annotation">⦉@93,95</span></span></span><span><span class="code odd" style="--layer: 1" title="62:10-62:10: @94.Goto: goto -&gt; bb96"><span class="annotation">@94⦊</span>‸<span class="annotation">⦉@94</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="63:9-63:23: @97[0]: _41 = move (_89.0: i32)"><span class="annotation">@97⦊</span>countdown -= 5<span class="annotation">⦉@97</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="65:9-65:15: @83[0]: _0 = const ()"><span class="annotation">@83⦊</span>return<span class="annotation">⦉@83</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="65:9-65:15: @83[0]: _0 = const ()"><span class="annotation">@83⦊</span>return<span class="annotation">⦉@83</span></span></span><span class="code" style="--layer: 0">;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    };</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="67:2-67:2: @102.Return: return"><span class="annotation">@102⦊</span>‸<span class="annotation">⦉@102</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="67:2-67:2: @101.Goto: goto -&gt; bb102"><span class="annotation">@101⦊</span>‸<span class="annotation">⦉@101</span></span></span><span><span class="code odd" style="--layer: 1" title="67:2-67:2: @102.Return: return"><span class="annotation">@102⦊</span>‸<span class="annotation">⦉@102</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..5c49ec19707
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>while.main - Coverage Spans</title>
+<style>
+    .line {
+        counter-increment: line;
+    }
+    .line:before {
+        content: counter(line) ": ";
+        font-family: Menlo, Monaco, monospace;
+        font-style: italic;
+        width: 3.8em;
+        display: inline-block;
+        text-align: right;
+        filter: opacity(50%);
+        -webkit-user-select: none;
+    }
+    .code {
+        color: #dddddd;
+        background-color: #222222;
+        font-family: Menlo, Monaco, monospace;
+        line-height: 1.4em;
+        border-bottom: 2px solid #222222;
+        white-space: pre;
+        display: inline-block;
+    }
+    .odd {
+        background-color: #55bbff;
+        color: #223311;
+    }
+    .even {
+        background-color: #ee7756;
+        color: #551133;
+    }
+    .code {
+        --index: calc(var(--layer) - 1);
+        padding-top: calc(var(--index) * 0.15em);
+        filter:
+            hue-rotate(calc(var(--index) * 25deg))
+            saturate(calc(100% - (var(--index) * 2%)))
+            brightness(calc(100% - (var(--index) * 1.5%)));
+    }
+    .annotation {
+        color: #4444ff;
+        font-family: monospace;
+        font-style: italic;
+        display: none;
+        -webkit-user-select: none;
+    }
+    body:active .annotation {
+        /* requires holding mouse down anywhere on the page */
+        display: inline-block;
+    }
+    span:hover .annotation {
+        /* requires hover over a span ONLY on its first line */
+        display: inline-block;
+    }
+</style>
+</head>
+<body>
+<div class="code" style="counter-reset: line 0"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="2:15-2:16: @0[1]: _1 = const 9_i32
+2:9-2:12: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>num = 9<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
+<span class="line"><span class="code" style="--layer: 0">    while </span><span><span class="code odd" style="--layer: 1" title="3:11-3:14: @2[2]: _4 = _1
+3:11-3:20: @2[3]: _3 = Ge(move _4, const 10_i32)
+3:11-3:20: @2[5]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@1,2⦊</span>num &gt;= 10<span class="annotation">⦉@1,2</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="3:21-4:6: @5[0]: _2 = const ()"><span class="annotation">@3,5⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="3:21-4:6: @5[0]: _2 = const ()">    }<span class="annotation">⦉@3,5</span></span></span><span><span class="code even" style="--layer: 1" title="4:6-4:6: @5.Goto: goto -&gt; bb1"><span class="annotation">@3,5⦊</span>‸<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="5:2-5:2: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
index b96789a9219..be674dc7d38 100644
--- a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
@@ -62,12 +62,10 @@
 <div class="code" style="counter-reset: line 3"><span class="line"><span class="code" style="--layer: 0">fn main() -&gt; Result&lt;(),u8&gt; {</span></span>
 <span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="5:25-5:27: @0[1]: _1 = const 10_i32
 5:9-5:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>mut countdown = 10<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
+<span class="line"><span class="code" style="--layer: 0">    while</span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
 7:9-9:10: @2[3]: _4 = Gt(move _5, const 0_i32)
-7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>while</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
-7:9-9:10: @2[3]: _4 = Gt(move _5, const 0_i32)
-7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)">        countdown</span></span>
+7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>countdown</span></span>
 <span class="line"><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
 7:9-9:10: @2[3]: _4 = Gt(move _5, const 0_i32)
 7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)">            &gt;</span></span>
@@ -104,16 +102,16 @@
 <span class="line"><span class="code" style="--layer: 0">                else</span></span>
 <span class="line"><span class="code" style="--layer: 0">                {</span></span>
 <span class="line"><span class="code" style="--layer: 0">                    </span><span><span class="code odd" style="--layer: 1" title="26:21-26:27: @10[0]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@10⦊</span>Err(1)<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                }</span></span>
+<span class="line"><span class="code" style="--layer: 0">                }</span><span><span class="code even" style="--layer: 1" title="27:18-27:18: @11.Goto: goto -&gt; bb13"><span class="annotation">@9,11⦊</span>‸<span class="annotation">⦉@9,11</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">                ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)"><span class="annotation">@7⦊</span>countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)">            -=</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)">        1<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="30:9-32:10: @12[0]: _1 = move (_13.0: i32)"><span class="annotation">@12⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @12[0]: _1 = move (_13.0: i32)">            -=</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="30:9-32:10: @12[0]: _1 = move (_13.0: i32)">        1<span class="annotation">⦉@12</span></span></span><span class="code" style="--layer: 0"></span></span>
 <span class="line"><span class="code" style="--layer: 0">        ;</span></span>
 <span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="35:8-35:10: @4[4]: _15 = ()
+<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="35:8-35:10: @4[4]: _15 = ()
 35:5-35:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _15)"><span class="annotation">@4⦊</span>Ok(())<span class="annotation">⦉@4</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="36:2-36:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
+<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="36:2-36:2: @13.Goto: goto -&gt; bb14"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span><span class="code even" style="--layer: 1" title="36:2-36:2: @14.Return: return"><span class="annotation">@14⦊</span>‸<span class="annotation">⦉@14</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/coverage/lazy_boolean.rs b/src/test/run-make-fulldeps/coverage/lazy_boolean.rs
index 1d83eb30dea..bb6219e851c 100644
--- a/src/test/run-make-fulldeps/coverage/lazy_boolean.rs
+++ b/src/test/run-make-fulldeps/coverage/lazy_boolean.rs
@@ -26,18 +26,36 @@ fn main() {
         ||
             b < c
     ;
-    let
-        somebool
-        =
-            a < b
-        &&
-            b < c
-    ;
-    let
-        somebool
-        =
-            b < a
-        &&
-            b < c
-    ;
+    let somebool = a < b && b < c;
+    let somebool = b < a && b < c;
+
+    if
+        !
+        is_true
+    {
+        a = 2
+        ;
+    }
+
+    if
+        is_true
+    {
+        b = 30
+        ;
+    }
+    else
+    {
+        c = 400
+        ;
+    }
+
+    if !is_true {
+        a = 2;
+    }
+
+    if is_true {
+        b = 30;
+    } else {
+        c = 400;
+    }
 }
diff --git a/src/test/run-make-fulldeps/coverage/loops_and_branches.rs b/src/test/run-make-fulldeps/coverage/loops_and_branches.rs
new file mode 100644
index 00000000000..a9df7e0fab7
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/loops_and_branches.rs
@@ -0,0 +1,36 @@
+#![allow(unused_assignments)]
+
+// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
+// structure of this `fmt` function.
+
+struct DebugTest;
+
+impl std::fmt::Debug for DebugTest {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        if true {
+            if false {
+                while true {
+                }
+            }
+            write!(f, "error")?;
+        } else {
+        }
+        Ok(())
+    }
+}
+
+fn main() {
+    let debug_test = DebugTest;
+    println!("{:?}", debug_test);
+}
+
+/*
+
+This is the error message generated, before the issue was fixed:
+
+error: internal compiler error: compiler/rustc_mir/src/transform/coverage/mod.rs:374:42:
+Error processing: DefId(0:6 ~ bug_incomplete_cov_graph_traversal_simplified[317d]::{impl#0}::fmt):
+Error { message: "`TraverseCoverageGraphWithLoops` missed some `BasicCoverageBlock`s:
+[bcb6, bcb7, bcb9]" }
+
+*/
diff --git a/src/test/run-make-fulldeps/coverage/nested_loops.rs b/src/test/run-make-fulldeps/coverage/nested_loops.rs
new file mode 100644
index 00000000000..4c7c7842796
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/nested_loops.rs
@@ -0,0 +1,25 @@
+fn main() {
+    let is_true = std::env::args().len() == 1;
+    let mut countdown = 10;
+
+    'outer: while countdown > 0 {
+        let mut a = 100;
+        let mut b = 100;
+        for _ in 0..50 {
+            if a < 30 {
+                break;
+            }
+            a -= 5;
+            b -= 5;
+            if b < 90 {
+                a -= 10;
+                if is_true {
+                    break 'outer;
+                } else {
+                    a -= 2;
+                }
+            }
+        }
+        countdown -= 1;
+    }
+}
diff --git a/src/test/run-make-fulldeps/coverage/partial_eq_counter_without_region.rs b/src/test/run-make-fulldeps/coverage/partial_eq_counter_without_region.rs
new file mode 100644
index 00000000000..334fb3364cc
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/partial_eq_counter_without_region.rs
@@ -0,0 +1,99 @@
+// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
+// structure of this test.
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Version {
+    major: usize,
+    minor: usize,
+    patch: usize,
+}
+
+impl Version {
+    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
+        Self {
+            major,
+            minor,
+            patch,
+        }
+    }
+}
+
+fn main() {
+    let version_3_2_1 = Version::new(3, 2, 1);
+    let version_3_3_0 = Version::new(3, 3, 0);
+
+    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0);
+}
+
+/*
+
+This test verifies a bug was fixed that otherwise generated this error:
+
+thread 'rustc' panicked at 'No counters provided the source_hash for function:
+    Instance {
+        def: Item(WithOptConstParam {
+            did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp),
+            const_param_did: None
+        }),
+        substs: []
+    }'
+The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage
+without a code region associated with any `Counter`. Code regions were associated with at least
+one expression, which is allowed, but the `function_source_hash` was only passed to the codegen
+(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the
+`function_source_hash` without a code region, if necessary.
+
+*/
+
+// FIXME(richkadel): It may be worth investigating why the coverage report for this test produces
+// the following results:
+
+/*
+
+1. Why are their two counts below different characters (first and last) of `PartialOrd`, on line 17?
+
+2. Line 17 is counted twice, but the `::lt` instance shows a line count of 1? Is there a missing
+   line count with a different instance? Or was it really only called once?
+
+3. Line 20 shows another line count (of 1) for a line within a `struct` declaration (on only one of
+   its 3 fields). I doubt the specific field (`minor`) is relevant, but rather I suspect there's a
+   problem computing the file position here, for some reason.
+
+<snip>
+   16|       |
+   17|      2|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+                                                    ^1       ^1
+------------------
+|Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::gt
+------------------
+|Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::le
+------------------
+|Unexecuted instantiation: <partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::ge
+------------------
+|<partial_eq_counter_without_region::Version as core::cmp::PartialOrd>::lt:
+|  17|      1|#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+------------------
+   18|       |pub struct Version {
+   19|       |    major: usize,
+   20|      1|    minor: usize,
+   21|       |    patch: usize,
+   22|       |}
+   23|       |
+   24|       |impl Version {
+   25|       |    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
+   26|      2|        Version {
+   27|      2|            major,
+   28|      2|            minor,
+   29|      2|            patch,
+   30|      2|        }
+   31|      2|    }
+   32|       |}
+   33|       |
+   34|      1|fn main() {
+   35|      1|    let version_3_2_1 = Version::new(3, 2, 1);
+   36|      1|    let version_3_3_0 = Version::new(3, 3, 0);
+   37|      1|
+   38|      1|    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version
+_3_3_0);
+   39|      1|}
+*/
diff --git a/src/test/run-make-fulldeps/coverage/tight_infinite_loop.rs b/src/test/run-make-fulldeps/coverage/tight_infinite_loop.rs
new file mode 100644
index 00000000000..cef99027aaa
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/tight_infinite_loop.rs
@@ -0,0 +1,5 @@
+fn main() {
+    if false {
+        loop {}
+    }
+}
diff --git a/src/test/run-make-fulldeps/coverage/while.rs b/src/test/run-make-fulldeps/coverage/while.rs
new file mode 100644
index 00000000000..781b90b3566
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/while.rs
@@ -0,0 +1,5 @@
+fn main() {
+    let num = 9;
+    while num >= 10 {
+    }
+}