Auto merge of #77080 - richkadel:llvm-coverage-counters-2, r=tmandry

Working branch-level code coverage

Add a generalized implementation for computing branch-level coverage spans.

This iteration resolves some of the challenges I had identified a few weeks ago.

I've tried to implement a solution that is general enough to work for a lot of different graphs/patterns. It's encouraging to see the results on fairly large and complex crates seem to meet my expectations. This may be a "functionally complete" implementation.

Except for bug fixes or edge cases I haven't run into yet, the next and essentially final step, I think, is to replace some Counters with CounterExpressions (where their counter values can be computed by adding or subtracting other counters/expressions).

Examples of branch-level coverage support enabled in this PR:

* https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/expected_show_coverage.coverage_of_drop_trait.txt
* https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/expected_show_coverage.coverage_of_if.txt
* https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/expected_show_coverage.coverage_of_if_else.txt
* https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/expected_show_coverage.coverage_of_simple_loop.txt
* https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/expected_show_coverage.coverage_of_simple_match.txt
* ... _and others in the same directory_

Examples of coverage analysis results (MIR spanview files) used to inject counters in the right `BasicBlocks`:

* https://htmlpreview.github.io/?https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_drop_trait/coverage_of_drop_trait.main.-------.InstrumentCoverage.0.html
* https://htmlpreview.github.io/?https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_if/coverage_of_if.main.-------.InstrumentCoverage.0.html
* https://htmlpreview.github.io/?https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_if_else/coverage_of_if_else.main.-------.InstrumentCoverage.0.html
* https://htmlpreview.github.io/?https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_simple_loop/coverage_of_simple_loop.main.-------.InstrumentCoverage.0.html
* https://htmlpreview.github.io/?https://github.com/richkadel/rust/blob/llvm-coverage-counters-2/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_simple_match/coverage_of_simple_match.main.-------.InstrumentCoverage.0.html
* ... _and others in the same directory_

Here is some sample coverage output after compiling a few real-world crates with the new branch-level coverage features:

<img width="801" alt="Screen Shot 2020-09-25 at 1 03 11 PM" src="https://user-images.githubusercontent.com/3827298/94316848-fd882c00-ff39-11ea-9cff-0402d3abd1e7.png">
<img width="721" alt="Screen Shot 2020-09-25 at 1 00 36 PM" src="https://user-images.githubusercontent.com/3827298/94316886-11cc2900-ff3a-11ea-9d03-80b26c8a5173.png">
<img width="889" alt="Screen Shot 2020-09-25 at 12 54 57 PM" src="https://user-images.githubusercontent.com/3827298/94316900-18f33700-ff3a-11ea-8a80-58f67d84b8de.png">

r? `@tmandry`
FYI: `@wesleywiser`

151 files changed, 19001 insertions, 1878 deletions

diff --git a/Cargo.lock b/Cargo.lock
index fd27f053638..d216b09c66a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2938,8 +2938,9 @@ dependencies = [
 
 [[package]]
 name = "rust-demangler"
-version = "0.0.0"
+version = "0.0.1"
 dependencies = [
+ "regex",
  "rustc-demangle",
 ]
 
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
index ec6c177614d..0098555a373 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
@@ -126,6 +126,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,);
             mapping_regions.push(CounterMappingRegion::code_region(
                 counter,
                 current_file_id,
diff --git a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
index 814e43c5fa5..d8bde8ee705 100644
--- a/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
+++ b/compiler/rustc_codegen_ssa/src/coverageinfo/map.rs
@@ -143,7 +143,9 @@ impl FunctionCoverage {
         let id_to_counter =
             |new_indexes: &IndexVec<InjectedExpressionIndex, MappedExpressionIndex>,
              id: ExpressionOperandId| {
-                if id.index() < self.counters.len() {
+                if id == ExpressionOperandId::ZERO {
+                    Some(Counter::zero())
+                } else if id.index() < self.counters.len() {
                     let index = CounterValueReference::from(id.index());
                     self.counters
                         .get(index)
@@ -179,14 +181,19 @@ impl FunctionCoverage {
                 // been assigned a `new_index`.
                 let mapped_expression_index =
                     MappedExpressionIndex::from(counter_expressions.len());
-                counter_expressions.push(CounterExpression::new(
+                let expression = CounterExpression::new(
                     lhs_counter,
                     match op {
                         Op::Add => ExprKind::Add,
                         Op::Subtract => ExprKind::Subtract,
                     },
                     rhs_counter,
-                ));
+                );
+                debug!(
+                    "Adding expression {:?} = {:?} at {:?}",
+                    mapped_expression_index, expression, region
+                );
+                counter_expressions.push(expression);
                 new_indexes[original_index] = mapped_expression_index;
                 expression_regions.push((Counter::expression(mapped_expression_index), region));
             }
diff --git a/compiler/rustc_data_structures/src/graph/dominators/mod.rs b/compiler/rustc_data_structures/src/graph/dominators/mod.rs
index 438a0d0c6ff..1cfbce2355e 100644
--- a/compiler/rustc_data_structures/src/graph/dominators/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/dominators/mod.rs
@@ -9,6 +9,7 @@ use super::iterate::reverse_post_order;
 use super::ControlFlowGraph;
 use rustc_index::vec::{Idx, IndexVec};
 use std::borrow::BorrowMut;
+use std::cmp::Ordering;
 
 #[cfg(test)]
 mod tests;
@@ -108,6 +109,14 @@ impl<Node: Idx> Dominators<Node> {
         // FIXME -- could be optimized by using post-order-rank
         self.dominators(node).any(|n| n == dom)
     }
+
+    /// Provide deterministic ordering of nodes such that, if any two nodes have a dominator
+    /// relationship, the dominator will always precede the dominated. (The relative ordering
+    /// of two unrelated nodes will also be consistent, but otherwise the order has no
+    /// meaning.) This method cannot be used to determine if either Node dominates the other.
+    pub fn rank_partial_cmp(&self, lhs: Node, rhs: Node) -> Option<Ordering> {
+        self.post_order_rank[lhs].partial_cmp(&self.post_order_rank[rhs])
+    }
 }
 
 pub struct Iter<'dom, Node: Idx> {
diff --git a/compiler/rustc_middle/src/mir/coverage/mod.rs b/compiler/rustc_middle/src/mir/coverage/mod.rs
index ce311c2ee52..0421eabc2dc 100644
--- a/compiler/rustc_middle/src/mir/coverage/mod.rs
+++ b/compiler/rustc_middle/src/mir/coverage/mod.rs
@@ -14,6 +14,20 @@ rustc_index::newtype_index! {
     }
 }
 
+impl ExpressionOperandId {
+    /// An expression operand for a "zero counter", as described in the following references:
+    ///
+    /// * https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#counter
+    /// * https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#tag
+    /// * https://github.com/rust-lang/llvm-project/blob/llvmorg-8.0.0/llvm/docs/CoverageMappingFormat.rst#counter-expressions
+    ///
+    /// This operand can be used to count two or more separate code regions with a single counter,
+    /// if they run sequentially with no branches, by injecting the `Counter` in a `BasicBlock` for
+    /// one of the code regions, and inserting `CounterExpression`s ("add ZERO to the counter") in
+    /// the coverage map for the other code regions.
+    pub const ZERO: Self = Self::from_u32(0);
+}
+
 rustc_index::newtype_index! {
     pub struct CounterValueReference {
         derive [HashStable]
@@ -22,6 +36,11 @@ rustc_index::newtype_index! {
     }
 }
 
+impl CounterValueReference {
+    // Counters start at 1 to reserve 0 for ExpressionOperandId::ZERO.
+    pub const START: Self = Self::from_u32(1);
+}
+
 rustc_index::newtype_index! {
     pub struct InjectedExpressionIndex {
         derive [HashStable]
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index a008bd5f75f..c1f8d22c2c6 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -752,7 +752,7 @@ macro_rules! make_mir_visitor {
             }
 
             fn super_coverage(&mut self,
-                              _kind: & $($mutability)? Coverage,
+                              _coverage: & $($mutability)? Coverage,
                               _location: Location) {
             }
 
diff --git a/compiler/rustc_mir/src/transform/instrument_coverage.rs b/compiler/rustc_mir/src/transform/instrument_coverage.rs
index 388fb90651c..babe10a0f14 100644
--- a/compiler/rustc_mir/src/transform/instrument_coverage.rs
+++ b/compiler/rustc_mir/src/transform/instrument_coverage.rs
@@ -1,26 +1,34 @@
 use crate::transform::MirPass;
 use crate::util::pretty;
-use crate::util::spanview::{
-    source_range_no_file, statement_kind_name, terminator_kind_name, write_spanview_document,
-    SpanViewable, TOOLTIP_INDENT,
-};
+use crate::util::spanview::{self, SpanViewable};
 
 use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::graph::dominators::Dominators;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_data_structures::sync::Lrc;
 use rustc_index::bit_set::BitSet;
+use rustc_index::vec::IndexVec;
 use rustc_middle::hir;
+use rustc_middle::hir::map::blocks::FnLikeNode;
 use rustc_middle::ich::StableHashingContext;
 use rustc_middle::mir;
 use rustc_middle::mir::coverage::*;
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{
-    BasicBlock, BasicBlockData, Coverage, CoverageInfo, Location, Statement, StatementKind,
-    TerminatorKind,
+    AggregateKind, BasicBlock, BasicBlockData, Coverage, CoverageInfo, FakeReadCause, Location,
+    Rvalue, SourceInfo, Statement, StatementKind, Terminator, TerminatorKind,
 };
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::DefId;
-use rustc_span::{FileName, Pos, RealFileName, Span, Symbol};
+use rustc_span::source_map::original_sp;
+use rustc_span::{
+    BytePos, CharPos, FileName, Pos, RealFileName, SourceFile, Span, Symbol, SyntaxContext,
+};
+
+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
@@ -33,6 +41,21 @@ pub(crate) fn provide(providers: &mut Providers) {
     providers.coverageinfo = |tcx, def_id| coverageinfo_from_mir(tcx, def_id);
 }
 
+/// The `num_counters` argument to `llvm.instrprof.increment` is the max counter_id + 1, or in
+/// other words, the number of counter value references injected into the MIR (plus 1 for the
+/// reserved `ZERO` counter, which uses counter ID `0` when included in an expression). Injected
+/// counters have a counter ID from `1..num_counters-1`.
+///
+/// `num_expressions` is the number of counter expressions added to the MIR body.
+///
+/// Both `num_counters` and `num_expressions` are used to initialize new vectors, during backend
+/// code generate, to lookup counters and expressions by simple u32 indexes.
+///
+/// MIR optimization may split and duplicate some BasicBlock sequences, or optimize out some code
+/// including injected counters. (It is OK if some counters are optimized out, but those counters
+/// 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.
 struct CoverageVisitor {
     info: CoverageInfo,
 }
@@ -57,15 +80,6 @@ impl Visitor<'_> for CoverageVisitor {
 fn coverageinfo_from_mir<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> CoverageInfo {
     let mir_body = tcx.optimized_mir(def_id);
 
-    // The `num_counters` argument to `llvm.instrprof.increment` is the number of injected
-    // counters, with each counter having a counter ID from `0..num_counters-1`. MIR optimization
-    // may split and duplicate some BasicBlock sequences. Simply counting the calls may not
-    // work; but computing the num_counters by adding `1` to the highest counter_id (for a given
-    // instrumented function) is valid.
-    //
-    // `num_expressions` is the number of counter expressions added to the MIR body. Both
-    // `num_counters` and `num_expressions` are used to initialize new vectors, during backend
-    // code generate, to lookup counters and expressions by simple u32 indexes.
     let mut coverage_visitor =
         CoverageVisitor { info: CoverageInfo { num_counters: 0, num_expressions: 0 } };
 
@@ -77,25 +91,399 @@ impl<'tcx> MirPass<'tcx> for InstrumentCoverage {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, mir_body: &mut mir::Body<'tcx>) {
         // 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_none() {
-            Instrumentor::new(&self.name(), tcx, mir_body).inject_counters();
+        if mir_body.source.promoted.is_some() {
+            trace!(
+                "InstrumentCoverage skipped for {:?} (already promoted for Miri evaluation)",
+                mir_body.source.def_id()
+            );
+            return;
         }
+
+        let hir_id = tcx.hir().local_def_id_to_hir_id(mir_body.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
+        if !is_fn_like {
+            trace!(
+                "InstrumentCoverage skipped for {:?} (not an FnLikeNode)",
+                mir_body.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());
+        Instrumentor::new(&self.name(), tcx, mir_body).inject_counters();
+        trace!("InstrumentCoverage starting for {:?}", mir_body.source.def_id());
     }
 }
 
-#[derive(Clone)]
-struct CoverageRegion {
-    pub span: Span,
+/// A BasicCoverageBlock (BCB) represents the maximal-length sequence of CFG (MIR) BasicBlocks
+/// without conditional branches.
+///
+/// The BCB allows coverage analysis to be performed on a simplified projection of the underlying
+/// MIR CFG, without altering the original CFG. Note that running the MIR `SimplifyCfg` transform,
+/// is not sufficient, and therefore not necessary, since the BCB-based CFG projection is a more
+/// aggressive simplification. For example:
+///
+///   * The BCB CFG projection ignores (trims) branches not relevant to coverage, such as unwind-
+///     related code that is injected by the Rust compiler but has no physical source code to
+///     count. This also means a BasicBlock with a `Call` terminator can be merged into its
+///     primary successor target block, in the same BCB.
+///   * Some BasicBlock terminators support Rust-specific concerns--like borrow-checking--that are
+///     not relevant to coverage analysis. `FalseUnwind`, for example, can be treated the same as
+///     a `Goto`, and merged with its successor into the same BCB.
+///
+/// Each BCB with at least one computed `CoverageSpan` will have no more than one `Counter`.
+/// In some cases, a BCB's execution count can be computed by `CounterExpression`. Additional
+/// disjoint `CoverageSpan`s in a BCB can also be counted by `CounterExpression` (by adding `ZERO`
+/// to the BCB's primary counter or expression).
+///
+/// Dominator/dominated relationships (which are fundamental to the coverage analysis algorithm)
+/// between two BCBs can be computed using the `mir::Body` `dominators()` with any `BasicBlock`
+/// member of each BCB. (For consistency, BCB's use the first `BasicBlock`, also referred to as the
+/// `bcb_leader_bb`.)
+///
+/// The BCB CFG projection is critical to simplifying the coverage analysis by ensuring graph
+/// path-based queries (`is_dominated_by()`, `predecessors`, `successors`, etc.) have branch
+/// (control flow) significance.
+#[derive(Debug, Clone)]
+struct BasicCoverageBlock {
     pub blocks: Vec<BasicBlock>,
 }
 
+impl BasicCoverageBlock {
+    pub fn leader_bb(&self) -> BasicBlock {
+        self.blocks[0]
+    }
+
+    pub fn id(&self) -> String {
+        format!(
+            "@{}",
+            self.blocks
+                .iter()
+                .map(|bb| bb.index().to_string())
+                .collect::<Vec<_>>()
+                .join(ID_SEPARATOR)
+        )
+    }
+}
+
+struct BasicCoverageBlocks {
+    vec: IndexVec<BasicBlock, Option<BasicCoverageBlock>>,
+}
+
+impl BasicCoverageBlocks {
+    pub fn from_mir(mir_body: &mir::Body<'tcx>) -> Self {
+        let mut basic_coverage_blocks =
+            BasicCoverageBlocks { vec: IndexVec::from_elem_n(None, mir_body.basic_blocks().len()) };
+        basic_coverage_blocks.extract_from_mir(mir_body);
+        basic_coverage_blocks
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &BasicCoverageBlock> {
+        self.vec.iter().filter_map(|option| option.as_ref())
+    }
+
+    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 mut successors = term_kind.successors();
+            match &term_kind {
+                // SwitchInt successors are never unwind, and all of them should be traversed.
+
+                // NOTE: TerminatorKind::FalseEdge targets from SwitchInt don't appear to be
+                // helpful in identifying unreachable code. I did test the theory, but the following
+                // changes were not beneficial. (I assumed that replacing some constants with
+                // non-deterministic variables might effect which blocks were targeted by a
+                // `FalseEdge` `imaginary_target`. It did not.)
+                //
+                // Also note that, if there is a way to identify BasicBlocks that are part of the
+                // MIR CFG, but not actually reachable, here are some other things to consider:
+                //
+                // Injecting unreachable code regions will probably require computing the set
+                // difference between the basic blocks found without filtering out unreachable
+                // blocks, and the basic blocks found with the filter; then computing the
+                // `CoverageSpans` without the filter; and then injecting `Counter`s or
+                // `CounterExpression`s for blocks that are not unreachable, or injecting
+                // `Unreachable` code regions otherwise. This seems straightforward, but not
+                // trivial.
+                //
+                // Alternatively, we might instead want to leave the unreachable blocks in
+                // (bypass the filter here), and inject the counters. This will result in counter
+                // values of zero (0) for unreachable code (and, notably, the code will be displayed
+                // with a red background by `llvm-cov show`).
+                //
+                // TerminatorKind::SwitchInt { .. } => {
+                //     let some_imaginary_target = successors.clone().find_map(|&successor| {
+                //         let term = mir_body.basic_blocks()[successor].terminator();
+                //         if let TerminatorKind::FalseEdge { imaginary_target, .. } = term.kind {
+                //             if mir_body.predecessors()[imaginary_target].len() == 1 {
+                //                 return Some(imaginary_target);
+                //             }
+                //         }
+                //         None
+                //     });
+                //     if let Some(imaginary_target) = some_imaginary_target {
+                //         box successors.filter(move |&&successor| successor != imaginary_target)
+                //     } else {
+                //         box successors
+                //     }
+                // }
+                //
+                // Note this also required changing the closure signature for the
+                // `ShortCurcuitPreorder` to:
+                //
+                // F: Fn(&'tcx TerminatorKind<'tcx>) -> Box<dyn Iterator<Item = &BasicBlock> + 'a>,
+                TerminatorKind::SwitchInt { .. } => successors,
+
+                // For all other kinds, return only the first successor, if any, and ignore unwinds
+                _ => successors.next().into_iter().chain(&[]),
+            }
+        });
+
+        // Walk the CFG using a Preorder traversal, which starts from `START_BLOCK` and follows
+        // each block terminator's `successors()`. Coverage spans must map to actual source code,
+        // so compiler generated blocks and paths can be ignored. To that end the CFG traversal
+        // intentionally omits unwind paths.
+        let mut blocks = Vec::new();
+        for (bb, data) in cfg_without_unwind {
+            if let Some(last) = blocks.last() {
+                let predecessors = &mir_body.predecessors()[bb];
+                if predecessors.len() > 1 || !predecessors.contains(last) {
+                    // The `bb` has more than one _incoming_ edge, and should start its own
+                    // `BasicCoverageBlock`. (Note, the `blocks` vector does not yet include `bb`;
+                    // it contains a sequence of one or more sequential blocks with no intermediate
+                    // branches in or out. Save these as a new `BasicCoverageBlock` before starting
+                    // the new one.)
+                    self.add_basic_coverage_block(blocks.split_off(0));
+                    debug!(
+                        "  because {}",
+                        if predecessors.len() > 1 {
+                            "predecessors.len() > 1".to_owned()
+                        } else {
+                            format!("bb {} is not in precessors: {:?}", bb.index(), predecessors)
+                        }
+                    );
+                }
+            }
+            blocks.push(bb);
+
+            let term = data.terminator();
+
+            match term.kind {
+                TerminatorKind::Return { .. }
+                | TerminatorKind::Abort
+                | TerminatorKind::Assert { .. }
+                | TerminatorKind::Yield { .. }
+                | TerminatorKind::SwitchInt { .. } => {
+                    // The `bb` has more than one _outgoing_ edge, or exits the function. Save the
+                    // current sequence of `blocks` gathered to this point, as a new
+                    // `BasicCoverageBlock`.
+                    self.add_basic_coverage_block(blocks.split_off(0));
+                    debug!("  because term.kind = {:?}", term.kind);
+                    // Note that this condition is based on `TerminatorKind`, even though it
+                    // theoretically boils down to `successors().len() != 1`; that is, either zero
+                    // (e.g., `Return`, `Abort`) or multiple successors (e.g., `SwitchInt`), but
+                    // since the Coverage graph (the BCB CFG projection) ignores things like unwind
+                    // branches (which exist in the `Terminator`s `successors()` list) checking the
+                    // number of successors won't work.
+                }
+                TerminatorKind::Goto { .. }
+                | TerminatorKind::Resume
+                | TerminatorKind::Unreachable
+                | TerminatorKind::Drop { .. }
+                | TerminatorKind::DropAndReplace { .. }
+                | TerminatorKind::Call { .. }
+                | TerminatorKind::GeneratorDrop
+                | TerminatorKind::FalseEdge { .. }
+                | TerminatorKind::FalseUnwind { .. }
+                | TerminatorKind::InlineAsm { .. } => {}
+            }
+        }
+
+        if !blocks.is_empty() {
+            // process any remaining blocks into a final `BasicCoverageBlock`
+            self.add_basic_coverage_block(blocks.split_off(0));
+            debug!("  because the end of the CFG was reached while traversing");
+        }
+    }
+
+    fn add_basic_coverage_block(&mut self, blocks: Vec<BasicBlock>) {
+        let leader_bb = blocks[0];
+        let bcb = BasicCoverageBlock { blocks };
+        debug!("adding BCB: {:?}", bcb);
+        self.vec[leader_bb] = Some(bcb);
+    }
+}
+
+impl std::ops::Index<BasicBlock> for BasicCoverageBlocks {
+    type Output = BasicCoverageBlock;
+
+    fn index(&self, index: BasicBlock) -> &Self::Output {
+        self.vec[index].as_ref().expect("is_some if BasicBlock is a BasicCoverageBlock leader")
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+enum CoverageStatement {
+    Statement(BasicBlock, Span, usize),
+    Terminator(BasicBlock, Span),
+}
+
+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];
+                format!(
+                    "{}: @{}[{}]: {:?}",
+                    spanview::source_range_no_file(tcx, &span),
+                    bb.index(),
+                    stmt_index,
+                    stmt
+                )
+            }
+            Self::Terminator(bb, span) => {
+                let term = mir_body.basic_blocks()[bb].terminator();
+                format!(
+                    "{}: @{}.{}: {:?}",
+                    spanview::source_range_no_file(tcx, &span),
+                    bb.index(),
+                    term_type(&term.kind),
+                    term.kind
+                )
+            }
+        }
+    }
+
+    pub fn span(&self) -> &Span {
+        match self {
+            Self::Statement(_, span, _) | Self::Terminator(_, span) => span,
+        }
+    }
+}
+
+fn term_type(kind: &TerminatorKind<'tcx>) -> &'static str {
+    match kind {
+        TerminatorKind::Goto { .. } => "Goto",
+        TerminatorKind::SwitchInt { .. } => "SwitchInt",
+        TerminatorKind::Resume => "Resume",
+        TerminatorKind::Abort => "Abort",
+        TerminatorKind::Return => "Return",
+        TerminatorKind::Unreachable => "Unreachable",
+        TerminatorKind::Drop { .. } => "Drop",
+        TerminatorKind::DropAndReplace { .. } => "DropAndReplace",
+        TerminatorKind::Call { .. } => "Call",
+        TerminatorKind::Assert { .. } => "Assert",
+        TerminatorKind::Yield { .. } => "Yield",
+        TerminatorKind::GeneratorDrop => "GeneratorDrop",
+        TerminatorKind::FalseEdge { .. } => "FalseEdge",
+        TerminatorKind::FalseUnwind { .. } => "FalseUnwind",
+        TerminatorKind::InlineAsm { .. } => "InlineAsm",
+    }
+}
+
+/// A BCB is deconstructed into one or more `Span`s. Each `Span` maps to a `CoverageSpan` that
+/// references the originating BCB and one or more MIR `Statement`s and/or `Terminator`s.
+/// Initially, the `Span`s come from the `Statement`s and `Terminator`s, but subsequent
+/// transforms can combine adjacent `Span`s and `CoverageSpan` from the same BCB, merging the
+/// `CoverageStatement` vectors, and the `Span`s to cover the extent of the combined `Span`s.
+///
+/// Note: A `CoverageStatement` merged into another CoverageSpan may come from a `BasicBlock` that
+/// is not part of the `CoverageSpan` bcb if the statement was included because it's `Span` matches
+/// or is subsumed by the `Span` associated with this `CoverageSpan`, and it's `BasicBlock`
+/// `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,
+}
+
+impl CoverageSpan {
+    pub fn for_statement(
+        statement: &Statement<'tcx>,
+        span: Span,
+        bcb: &BasicCoverageBlock,
+        bb: BasicBlock,
+        stmt_index: usize,
+    ) -> Self {
+        let is_closure = match statement.kind {
+            StatementKind::Assign(box (
+                _,
+                Rvalue::Aggregate(box AggregateKind::Closure(_, _), _),
+            )) => true,
+            _ => false,
+        };
+
+        Self {
+            span,
+            bcb_leader_bb: bcb.leader_bb(),
+            coverage_statements: vec![CoverageStatement::Statement(bb, span, stmt_index)],
+            is_closure,
+        }
+    }
+
+    pub fn for_terminator(span: Span, bcb: &'a BasicCoverageBlock, bb: BasicBlock) -> Self {
+        Self {
+            span,
+            bcb_leader_bb: bcb.leader_bb(),
+            coverage_statements: vec![CoverageStatement::Terminator(bb, span)],
+            is_closure: false,
+        }
+    }
+
+    pub fn merge_from(&mut self, mut other: CoverageSpan) {
+        debug_assert!(self.is_mergeable(&other));
+        self.span = self.span.to(other.span);
+        if other.is_closure {
+            self.is_closure = true;
+        }
+        self.coverage_statements.append(&mut other.coverage_statements);
+    }
+
+    pub fn cutoff_statements_at(&mut self, cutoff_pos: BytePos) {
+        self.coverage_statements.retain(|covstmt| covstmt.span().hi() <= cutoff_pos);
+        if let Some(highest_covstmt) =
+            self.coverage_statements.iter().max_by_key(|covstmt| covstmt.span().hi())
+        {
+            self.span = self.span.with_hi(highest_covstmt.span().hi());
+        }
+    }
+
+    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)
+    }
+
+    pub fn is_mergeable(&self, other: &Self) -> bool {
+        self.is_in_same_bcb(other) && !(self.is_closure || other.is_closure)
+    }
+
+    pub fn is_in_same_bcb(&self, other: &Self) -> bool {
+        self.bcb_leader_bb == other.bcb_leader_bb
+    }
+}
+
 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>,
-    num_counters: u32,
+    next_counter_id: u32,
     num_expressions: u32,
 }
 
@@ -107,17 +495,19 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
             tcx,
             mir_body,
             hir_body,
+            dominators: None,
+            basic_coverage_blocks: None,
             function_source_hash: None,
-            num_counters: 0,
+            next_counter_id: CounterValueReference::START.as_u32(),
             num_expressions: 0,
         }
     }
 
-    /// Counter IDs start from zero and go up.
+    /// Counter IDs start from one and go up.
     fn next_counter(&mut self) -> CounterValueReference {
-        assert!(self.num_counters < u32::MAX - self.num_expressions);
-        let next = self.num_counters;
-        self.num_counters += 1;
+        assert!(self.next_counter_id < u32::MAX - self.num_expressions);
+        let next = self.next_counter_id;
+        self.next_counter_id += 1;
         CounterValueReference::from(next)
     }
 
@@ -125,12 +515,22 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
     /// (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.num_counters < u32::MAX - self.num_expressions);
+        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 dominators(&self) -> &Dominators<BasicBlock> {
+        self.dominators.as_ref().expect("dominators must be initialized before calling")
+    }
+
+    fn basic_coverage_blocks(&self) -> &BasicCoverageBlocks {
+        self.basic_coverage_blocks
+            .as_ref()
+            .expect("basic_coverage_blocks must be initialized before calling")
+    }
+
     fn function_source_hash(&mut self) -> u64 {
         match self.function_source_hash {
             Some(hash) => hash,
@@ -144,86 +544,61 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
 
     fn inject_counters(&mut self) {
         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.hir_body.value.span;
-        debug!(
-            "instrumenting {:?}, span: {}",
-            def_id,
-            tcx.sess.source_map().span_to_string(body_span)
-        );
-
-        if !tcx.sess.opts.debugging_opts.experimental_coverage {
-            // Coverage at the function level should be accurate. This is the default implementation
-            // if `-Z experimental-coverage` is *NOT* enabled.
-            let block = rustc_middle::mir::START_BLOCK;
-            let counter = self.make_counter();
-            self.inject_statement(counter, body_span, block);
-            return;
-        }
-        // FIXME(richkadel): else if `-Z experimental-coverage` *IS* enabled: Efforts are still in
-        // progress to identify the correct code region spans and associated counters to generate
-        // accurate Rust coverage reports.
-
-        let block_span = |data: &BasicBlockData<'tcx>| {
-            // The default span will be the `Terminator` span; but until we have a smarter solution,
-            // the coverage region also incorporates at least the statements in this BasicBlock as
-            // well. Extend the span to encompass all, if possible.
-            // FIXME(richkadel): Assuming the terminator's span is already known to be contained in `body_span`.
-            let mut span = data.terminator().source_info.span;
-            // FIXME(richkadel): It's looking unlikely that we should compute a span from MIR
-            // spans, but if we do keep something like this logic, we will need a smarter way
-            // to combine `Statement`s and/or `Terminator`s with `Span`s from different
-            // files.
-            for statement_span in data.statements.iter().map(|statement| statement.source_info.span)
-            {
-                // Only combine Spans from the function's body_span.
-                if body_span.contains(statement_span) {
-                    span = span.to(statement_span);
-                }
-            }
-            span
+        let body_span = self.body_span();
+        let source_file = source_map.lookup_source_file(body_span.lo());
+        let file_name = match &source_file.name {
+            FileName::Real(RealFileName::Named(path)) => Symbol::intern(&path.to_string_lossy()),
+            _ => bug!(
+                "source_file.name should be a RealFileName, but it was: {:?}",
+                source_file.name
+            ),
         };
 
-        // Traverse the CFG but ignore anything following an `unwind`
-        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
-                TerminatorKind::SwitchInt { .. } => successors,
-                // For all other kinds, return only the first successor, if any, and ignore unwinds
-                _ => successors.next().into_iter().chain(&[]),
-            }
-        });
+        debug!("instrumenting {:?}, span: {}", def_id, source_map.span_to_string(body_span));
 
-        let mut coverage_regions = Vec::with_capacity(cfg_without_unwind.size_hint().0);
-        for (bb, data) in cfg_without_unwind {
-            if !body_span.contains(data.terminator().source_info.span) {
-                continue;
-            }
+        self.dominators.replace(mir_body.dominators());
+        self.basic_coverage_blocks.replace(BasicCoverageBlocks::from_mir(mir_body));
 
-            // FIXME(richkadel): Regions will soon contain multiple blocks.
-            let mut blocks = Vec::new();
-            blocks.push(bb);
-            let span = block_span(data);
-            coverage_regions.push(CoverageRegion { span, blocks });
-        }
+        let coverage_spans = self.coverage_spans();
 
         let span_viewables = if pretty::dump_enabled(tcx, self.pass_name, def_id) {
-            Some(self.span_viewables(&coverage_regions))
+            Some(self.span_viewables(&coverage_spans))
         } else {
             None
         };
 
-        // Inject counters for the selected spans
-        for CoverageRegion { span, blocks } in coverage_regions {
-            debug!(
-                "Injecting counter at: {:?}:\n{}\n==========",
-                span,
-                tcx.sess.source_map().span_to_snippet(span).expect("Error getting source for span"),
-            );
-            let counter = self.make_counter();
-            self.inject_statement(counter, span, blocks[0]);
+        // 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());
+        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);
+                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);
+            } else {
+                let counter = self.make_counter();
+                debug!(
+                    "Injecting counter {:?} at: {:?}:\n{}\n==========",
+                    counter,
+                    span,
+                    source_map.span_to_snippet(span).expect("Error getting source for span"),
+                );
+                let counter_operand = counter.as_operand_id();
+                bb_counters[bb] = Some(counter_operand);
+                self.inject_statement(file_name, &source_file, counter, span, bb);
+            }
         }
 
         if let Some(span_viewables) = span_viewables {
@@ -236,36 +611,12 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
                 self.mir_body.source,
             )
             .expect("Unexpected error creating MIR spanview HTML file");
-            write_spanview_document(tcx, def_id, span_viewables, &mut 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");
         }
-
-        // FIXME(richkadel): Some regions will be counted by "counter expression". Counter
-        // expressions are supported, but are not yet generated. When they are, remove this `fake_use`
-        // block.
-        let fake_use = false;
-        if fake_use {
-            let add = false;
-            let fake_counter = CoverageKind::Counter {
-                function_source_hash: self.function_source_hash(),
-                id: CounterValueReference::from_u32(1),
-            };
-            let fake_expression = CoverageKind::Expression {
-                id: InjectedExpressionIndex::from(u32::MAX - 1),
-                lhs: ExpressionOperandId::from_u32(1),
-                op: Op::Add,
-                rhs: ExpressionOperandId::from_u32(2),
-            };
-
-            let lhs = fake_counter.as_operand_id();
-            let op = if add { Op::Add } else { Op::Subtract };
-            let rhs = fake_expression.as_operand_id();
-
-            let block = rustc_middle::mir::START_BLOCK;
-
-            let expression = self.make_expression(lhs, op, rhs);
-            self.inject_statement(expression, body_span, block);
-        }
     }
 
     fn make_counter(&mut self) -> CoverageKind {
@@ -284,8 +635,15 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         CoverageKind::Expression { id: self.next_expression(), lhs, op, rhs }
     }
 
-    fn inject_statement(&mut self, coverage_kind: CoverageKind, span: Span, block: BasicBlock) {
-        let code_region = make_code_region(self.tcx, &span);
+    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];
@@ -297,112 +655,548 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
         data.statements.push(statement);
     }
 
-    /// Converts the computed `CoverageRegion`s into `SpanViewable`s.
-    fn span_viewables(&self, coverage_regions: &Vec<CoverageRegion>) -> Vec<SpanViewable> {
+    /// 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_region in coverage_regions {
-            span_viewables.push(SpanViewable {
-                span: coverage_region.span,
-                id: format!("{}", coverage_region.blocks[0].index()),
-                tooltip: self.make_tooltip_text(coverage_region),
+        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
     }
 
-    /// A custom tooltip renderer used in a spanview HTML+CSS document used for coverage analysis.
-    fn make_tooltip_text(&self, coverage_region: &CoverageRegion) -> String {
-        const INCLUDE_COVERAGE_STATEMENTS: bool = false;
-        let tcx = self.tcx;
-        let source_map = tcx.sess.source_map();
-        let mut text = Vec::new();
-        for (i, &bb) in coverage_region.blocks.iter().enumerate() {
-            if i > 0 {
-                text.push("\n".to_owned());
+    #[inline(always)]
+    fn bcb_from_coverage_span(&self, coverage_span: &CoverageSpan) -> &BasicCoverageBlock {
+        &self.basic_coverage_blocks()[coverage_span.bcb_leader_bb]
+    }
+
+    #[inline(always)]
+    fn body_span(&self) -> Span {
+        self.hir_body.value.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()
+    }
+
+    /// Generate a minimal set of `CoverageSpan`s, each representing a contiguous code region to be
+    /// counted.
+    ///
+    /// The basic steps are:
+    ///
+    /// 1. Extract an initial set of spans from the `Statement`s and `Terminator`s of each
+    ///    `BasicCoverageBlock`.
+    /// 2. Sort the spans by span.lo() (starting position). Spans that start at the same position
+    ///    are sorted with longer spans before shorter spans; and equal spans are sorted
+    ///    (deterministically) based on "dominator" relationship (if any).
+    /// 3. Traverse the spans in sorted order to identify spans that can be dropped (for instance,
+    ///    if another span or spans are already counting the same code region), or should be merged
+    ///    into a broader combined span (because it represents a contiguous, non-branching, and
+    ///    uninterrupted region of source code).
+    ///
+    ///    Closures are exposed in their enclosing functions as `Assign` `Rvalue`s, and since
+    ///    closures have their own MIR, their `Span` in their enclosing function should be left
+    ///    "uncovered".
+    ///
+    /// 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) {
+                initial_spans.push(coverage_span);
             }
-            text.push(format!("{:?}: {}:", bb, &source_map.span_to_string(coverage_region.span)));
-            let data = &self.mir_body.basic_blocks()[bb];
-            for statement in &data.statements {
-                let statement_string = match statement.kind {
-                    StatementKind::Coverage(box ref coverage) => match coverage.kind {
-                        CoverageKind::Counter { id, .. } => {
-                            if !INCLUDE_COVERAGE_STATEMENTS {
-                                continue;
-                            }
-                            format!("increment counter #{}", id.index())
-                        }
-                        CoverageKind::Expression { id, lhs, op, rhs } => {
-                            if !INCLUDE_COVERAGE_STATEMENTS {
-                                continue;
-                            }
-                            format!(
-                                "expression #{} = {} {} {}",
-                                id.index(),
-                                lhs.index(),
-                                if op == Op::Add { "+" } else { "-" },
-                                rhs.index()
-                            )
-                        }
-                        CoverageKind::Unreachable => {
-                            if !INCLUDE_COVERAGE_STATEMENTS {
-                                continue;
-                            }
-                            String::from("unreachable")
-                        }
-                    },
-                    _ => format!("{:?}", statement),
-                };
-                let source_range = source_range_no_file(tcx, &statement.source_info.span);
-                text.push(format!(
-                    "\n{}{}: {}: {}",
-                    TOOLTIP_INDENT,
-                    source_range,
-                    statement_kind_name(statement),
-                    statement_string
-                ));
+        }
+
+        if initial_spans.is_empty() {
+            // This can happen if, for example, the function is unreachable (contains only a
+            // `BasicBlock`(s) with an `Unreachable` terminator).
+            return initial_spans;
+        }
+
+        initial_spans.sort_unstable_by(|a, b| {
+            if a.span.lo() == b.span.lo() {
+                if a.span.hi() == b.span.hi() {
+                    if a.is_in_same_bcb(b) {
+                        Some(Ordering::Equal)
+                    } else {
+                        // Sort equal spans by dominator relationship, in reverse order (so
+                        // 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)
+                    }
+                } 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.
+                    b.span.hi().partial_cmp(&a.span.hi())
+                }
+            } else {
+                a.span.lo().partial_cmp(&b.span.lo())
             }
-            let term = data.terminator();
-            let source_range = source_range_no_file(tcx, &term.source_info.span);
-            text.push(format!(
-                "\n{}{}: {}: {:?}",
-                TOOLTIP_INDENT,
-                source_range,
-                terminator_kind_name(term),
-                term.kind
-            ));
+            .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(),
+        }
+    }
+
+    /// Iterate through the sorted `CoverageSpan`s, and return the refined list of merged and
+    /// de-duplicated `CoverageSpan`s.
+    fn to_refined_spans(mut self) -> Vec<CoverageSpan> {
+        while self.next_coverage_span() {
+            if self.curr().is_mergeable(self.prev()) {
+                debug!("  same bcb (and neither is a closure), merge with prev={:?}", self.prev());
+                let prev = self.take_prev();
+                self.curr_mut().merge_from(prev);
+            // Note that curr.span may now differ from curr_original_span
+            } else if self.prev_ends_before_curr() {
+                debug!(
+                    "  different bcbs and disjoint spans, so keep curr for next iter, and add \
+                    prev={:?}",
+                    self.prev()
+                );
+                let prev = self.take_prev();
+                self.add_refined_span(prev);
+            } else if self.prev().is_closure {
+                // drop any equal or overlapping span (`curr`) and keep `prev` to test again in the
+                // next iter
+                debug!(
+                    "  curr overlaps a closure (prev). Drop curr and keep prev for next iter. \
+                    prev={:?}",
+                    self.prev()
+                );
+                self.discard_curr();
+            } else if self.curr().is_closure {
+                self.carve_out_span_for_closure();
+            } else if self.prev_original_span == self.curr().span {
+                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() {
+            debug!("    ...adding at least one pending dup={:?}", dup);
+            self.add_refined_span(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()
+    }
+
+    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).
+    fn to_refined_spans_without_closures(mut self) -> Vec<CoverageSpan> {
+        self.refined_spans.retain(|covspan| !covspan.is_closure);
+        self.refined_spans
+    }
+
+    fn curr(&self) -> &CoverageSpan {
+        self.some_curr
+            .as_ref()
+            .unwrap_or_else(|| bug!("invalid attempt to unwrap a None some_curr"))
+    }
+
+    fn curr_mut(&mut self) -> &mut CoverageSpan {
+        self.some_curr
+            .as_mut()
+            .unwrap_or_else(|| bug!("invalid attempt to unwrap a None some_curr"))
+    }
+
+    fn prev(&self) -> &CoverageSpan {
+        self.some_prev
+            .as_ref()
+            .unwrap_or_else(|| bug!("invalid attempt to unwrap a None some_prev"))
+    }
+
+    fn prev_mut(&mut self) -> &mut CoverageSpan {
+        self.some_prev
+            .as_mut()
+            .unwrap_or_else(|| bug!("invalid attempt to unwrap a None some_prev"))
+    }
+
+    fn take_prev(&mut self) -> CoverageSpan {
+        self.some_prev.take().unwrap_or_else(|| bug!("invalid attempt to unwrap a None some_prev"))
+    }
+
+    /// 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()`)
+    /// 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) {
+        if let Some(dup) = self.pending_dups.last() {
+            if dup.span != self.prev().span {
+                debug!(
+                    "    SAME spans, but pending_dups are NOT THE SAME, so BCBs matched on \
+                    previous iteration, or prev started a new disjoint span"
+                );
+                if dup.span.hi() <= self.curr().span.lo() {
+                    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);
+                    }
+                } else {
+                    self.pending_dups.clear();
+                }
+            }
+        }
+    }
+
+    /// Advance `prev` to `curr` (if any), and `curr` to the next `CoverageSpan` in sorted order.
+    fn next_coverage_span(&mut self) -> bool {
+        if let Some(curr) = self.some_curr.take() {
+            self.some_prev = Some(curr);
+            self.prev_original_span = self.curr_original_span;
+        }
+        while let Some(curr) = self.sorted_spans_iter.next() {
+            debug!("FOR curr={:?}", curr);
+            if self.prev_starts_after_next(&curr) {
+                debug!(
+                    "  prev.span starts after curr.span, so curr will be dropped (skipping past \
+                    closure?); prev={:?}",
+                    self.prev()
+                );
+            } else {
+                // Save a copy of the original span for `curr` in case the `CoverageSpan` is changed
+                // by `self.curr_mut().merge_from(prev)`.
+                self.curr_original_span = curr.span;
+                self.some_curr.replace(curr);
+                self.check_pending_dups();
+                return true;
+            }
+        }
+        false
+    }
+
+    /// If called, then the next call to `next_coverage_span()` will *not* update `prev` with the
+    /// `curr` coverage span.
+    fn discard_curr(&mut self) {
+        self.some_curr = None;
+    }
+
+    /// Returns true if the curr span should be skipped because prev has already advanced beyond the
+    /// end of curr. This can only happen if a prior iteration updated `prev` to skip past a region
+    /// of code, such as skipping past a closure.
+    fn prev_starts_after_next(&self, next_curr: &CoverageSpan) -> bool {
+        self.prev().span.lo() > next_curr.span.lo()
+    }
+
+    /// Returns true if the curr span starts past the end of the prev span, which means they don't
+    /// overlap, so we now know the prev can be added to the refined coverage spans.
+    fn prev_ends_before_curr(&self) -> bool {
+        self.prev().span.hi() <= self.curr().span.lo()
+    }
+
+    /// If `prev`s span extends left of the closure (`curr`), carve out the closure's
+    /// span from `prev`'s span. (The closure's coverage counters will be injected when
+    /// processing the closure's own MIR.) Add the portion of the span to the left of the
+    /// closure; and if the span extends to the right of the closure, update `prev` to
+    /// that portion of the span. For any `pending_dups`, repeat the same process.
+    fn carve_out_span_for_closure(&mut self) {
+        let curr_span = self.curr().span;
+        let left_cutoff = curr_span.lo();
+        let right_cutoff = curr_span.hi();
+        let has_pre_closure_span = self.prev().span.lo() < right_cutoff;
+        let has_post_closure_span = self.prev().span.hi() > right_cutoff;
+        let mut pending_dups = self.pending_dups.split_off(0);
+        if has_pre_closure_span {
+            let mut pre_closure = self.prev().clone();
+            pre_closure.span = pre_closure.span.with_hi(left_cutoff);
+            debug!("  prev overlaps a closure. Adding span for pre_closure={:?}", pre_closure);
+            if !pending_dups.is_empty() {
+                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.add_refined_span(pre_closure);
+        }
+        if has_post_closure_span {
+            // Update prev.span to start after the closure (and discard curr)
+            self.prev_mut().span = self.prev().span.with_lo(right_cutoff);
+            self.prev_original_span = self.prev().span;
+            for dup in pending_dups.iter_mut() {
+                dup.span = dup.span.with_lo(right_cutoff);
+            }
+            self.pending_dups.append(&mut pending_dups);
+            self.discard_curr(); // since self.prev() was already updated
+        } else {
+            pending_dups.clear();
+        }
+    }
+
+    /// 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`.
+            debug!(
+                "  different bcbs but SAME spans, and prev dominates curr. Drop curr and \
+                keep prev for next iter. prev={:?}",
+                self.prev()
+            );
+            self.discard_curr();
+        } 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
+            // well; but if `curr` is added to refined_spans, the `pending_dups` will also be added.
+            debug!(
+                "  different bcbs but SAME spans, and neither dominates, so keep curr for \
+                next iter, and, pending upcoming spans (unless overlapping) add prev={:?}",
+                self.prev()
+            );
+            let prev = self.take_prev();
+            self.pending_dups.push(prev);
+        }
+    }
+
+    /// `curr` overlaps `prev`. If `prev`s span extends left of `curr`s span, keep _only_
+    /// statements that end before `curr.lo()` (if any), and add the portion of the
+    /// combined span for those statements. Any other statements have overlapping spans
+    /// that can be ignored because `curr` and/or other upcoming statements/spans inside
+    /// the overlap area will produce their own counters. This disambiguation process
+    /// avoids injecting multiple counters for overlapping spans, and the potential for
+    /// double-counting.
+    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={:?}",
+            self.prev()
+        );
+        if self.pending_dups.is_empty() {
+            let curr_span = self.curr().span;
+            self.prev_mut().cutoff_statements_at(curr_span.lo());
+            if self.prev().coverage_statements.is_empty() {
+                debug!("  ... no non-overlapping statements to add");
+            } else {
+                debug!("  ... adding modified prev={:?}", self.prev());
+                let prev = self.take_prev();
+                self.add_refined_span(prev);
+            }
+        } else {
+            // with `pending_dups`, `prev` cannot have any statements that don't overlap
+            self.pending_dups.clear();
         }
-        text.join("")
     }
 }
 
+fn filtered_statement_span(statement: &'a Statement<'tcx>, body_span: Span) -> Option<Span> {
+    match statement.kind {
+        // These statements have spans that are often outside the scope of the executed source code
+        // for their parent `BasicBlock`.
+        StatementKind::StorageLive(_)
+        | StatementKind::StorageDead(_)
+        // Coverage should not be encountered, but don't inject coverage coverage
+        | StatementKind::Coverage(_)
+        // Ignore `Nop`s
+        | StatementKind::Nop => None,
+
+        // FIXME(richkadel): Look into a possible issue assigning the span to a
+        // FakeReadCause::ForGuardBinding, in this example:
+        //     match somenum {
+        //         x if x < 1 => { ... }
+        //     }...
+        // The BasicBlock within the match arm code included one of these statements, but the span
+        // for it covered the `1` in this source. The actual statements have nothing to do with that
+        // source span:
+        //     FakeRead(ForGuardBinding, _4);
+        // where `_4` is:
+        //     _4 = &_1; (at the span for the first `x`)
+        // and `_1` is the `Place` for `somenum`.
+        //
+        // The arm code BasicBlock already has its own assignment for `x` itself, `_3 = 1`, and I've
+        // decided it's reasonable for that span (even though outside the arm code) to be part of
+        // the counted coverage of the arm code execution, but I can't justify including the literal
+        // `1` in the arm code. I'm pretty sure that, if the `FakeRead(ForGuardBinding)` has a
+        // purpose in codegen, it's probably in the right BasicBlock, but if so, the `Statement`s
+        // `source_info.span` can't be right.
+        //
+        // Consider correcting the span assignment, assuming there is a better solution, and see if
+        // the following pattern can be removed here:
+        StatementKind::FakeRead(cause, _) if cause == FakeReadCause::ForGuardBinding => None,
+
+        // Retain spans from all other statements
+        StatementKind::FakeRead(_, _) // Not including `ForGuardBinding`
+        | StatementKind::Assign(_)
+        | StatementKind::SetDiscriminant { .. }
+        | StatementKind::LlvmInlineAsm(_)
+        | StatementKind::Retag(_, _)
+        | StatementKind::AscribeUserType(_, _) => {
+            Some(source_info_span(&statement.source_info, body_span))
+        }
+    }
+}
+
+fn filtered_terminator_span(terminator: &'a Terminator<'tcx>, body_span: Span) -> Option<Span> {
+    match terminator.kind {
+        // These terminators have spans that don't positively contribute to computing a reasonable
+        // span of actually executed source code. (For example, SwitchInt terminators extracted from
+        // 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::Assert { .. }
+        | TerminatorKind::Drop { .. }
+        | TerminatorKind::DropAndReplace { .. }
+        | TerminatorKind::SwitchInt { .. }
+        | TerminatorKind::Goto { .. }
+        // For `FalseEdge`, only the `real` branch is taken, so it is similar to a `Goto`.
+        | TerminatorKind::FalseEdge { .. } => None,
+
+        // Retain spans from all other terminators
+        TerminatorKind::Resume
+        | TerminatorKind::Abort
+        | TerminatorKind::Return
+        | TerminatorKind::Call { .. }
+        | TerminatorKind::Yield { .. }
+        | TerminatorKind::GeneratorDrop
+        | TerminatorKind::FalseUnwind { .. }
+        | TerminatorKind::InlineAsm { .. } => {
+            Some(source_info_span(&terminator.source_info, 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());
+    if body_span.contains(span) { span } else { body_span }
+}
+
 /// Convert the Span into its file name, start line and column, and end line and column
-fn make_code_region<'tcx>(tcx: TyCtxt<'tcx>, span: &Span) -> CodeRegion {
-    let source_map = tcx.sess.source_map();
-    let start = source_map.lookup_char_pos(span.lo());
-    let end = if span.hi() == span.lo() {
-        start.clone()
+fn make_code_region(file_name: Symbol, source_file: &Lrc<SourceFile>, 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 {
+            start_col = CharPos(char_pos - 1);
+        } else {
+            end_col = CharPos(char_pos + 1);
+        }
+        (end_line, end_col)
     } else {
-        let end = source_map.lookup_char_pos(span.hi());
-        debug_assert_eq!(
-            start.file.name,
-            end.file.name,
-            "Region start ({:?} -> {:?}) and end ({:?} -> {:?}) don't come from the same source file!",
-            span.lo(),
-            start,
-            span.hi(),
-            end
-        );
-        end
+        source_file.lookup_file_pos(span.hi())
     };
-    match &start.file.name {
-        FileName::Real(RealFileName::Named(path)) => CodeRegion {
-            file_name: Symbol::intern(&path.to_string_lossy()),
-            start_line: start.line as u32,
-            start_col: start.col.to_u32() + 1,
-            end_line: end.line as u32,
-            end_col: end.col.to_u32() + 1,
-        },
-        _ => bug!("start.file.name should be a RealFileName, but it was: {:?}", start.file.name),
+    CodeRegion {
+        file_name,
+        start_line: start_line as u32,
+        start_col: start_col.to_u32() + 1,
+        end_line: end_line as u32,
+        end_col: end_col.to_u32() + 1,
     }
 }
 
diff --git a/compiler/rustc_mir/src/util/pretty.rs b/compiler/rustc_mir/src/util/pretty.rs
index c00c3b740ed..81bb1342104 100644
--- a/compiler/rustc_mir/src/util/pretty.rs
+++ b/compiler/rustc_mir/src/util/pretty.rs
@@ -150,26 +150,25 @@ fn dump_matched_mir_node<'tcx, F>(
 
     if let Some(spanview) = tcx.sess.opts.debugging_opts.dump_mir_spanview {
         let _: io::Result<()> = try {
-            let mut file =
-                create_dump_file(tcx, "html", pass_num, pass_name, disambiguator, body.source)?;
+            let file_basename =
+                dump_file_basename(tcx, pass_num, pass_name, disambiguator, body.source);
+            let mut file = create_dump_file_with_basename(tcx, &file_basename, "html")?;
             if body.source.def_id().is_local() {
-                write_mir_fn_spanview(tcx, body, spanview, &mut file)?;
+                write_mir_fn_spanview(tcx, body, spanview, &file_basename, &mut file)?;
             }
         };
     }
 }
 
-/// Returns the path to the filename where we should dump a given MIR.
-/// Also used by other bits of code (e.g., NLL inference) that dump
-/// graphviz data or other things.
-fn dump_path(
+/// Returns the file basename portion (without extension) of a filename path
+/// where we should dump a MIR representation output files.
+fn dump_file_basename(
     tcx: TyCtxt<'_>,
-    extension: &str,
     pass_num: Option<&dyn Display>,
     pass_name: &str,
     disambiguator: &dyn Display,
     source: MirSource<'tcx>,
-) -> PathBuf {
+) -> String {
     let promotion_id = match source.promoted {
         Some(id) => format!("-{:?}", id),
         None => String::new(),
@@ -184,9 +183,6 @@ fn dump_path(
         }
     };
 
-    let mut file_path = PathBuf::new();
-    file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
-
     let crate_name = tcx.crate_name(source.def_id().krate);
     let item_name = tcx.def_path(source.def_id()).to_filename_friendly_no_crate();
     // All drop shims have the same DefId, so we have to add the type
@@ -206,23 +202,46 @@ fn dump_path(
         _ => String::new(),
     };
 
-    let file_name = format!(
-        "{}.{}{}{}{}.{}.{}.{}",
-        crate_name,
-        item_name,
-        shim_disambiguator,
-        promotion_id,
-        pass_num,
-        pass_name,
-        disambiguator,
-        extension,
-    );
+    format!(
+        "{}.{}{}{}{}.{}.{}",
+        crate_name, item_name, shim_disambiguator, promotion_id, pass_num, pass_name, disambiguator,
+    )
+}
+
+/// Returns the path to the filename where we should dump a given MIR.
+/// Also used by other bits of code (e.g., NLL inference) that dump
+/// graphviz data or other things.
+fn dump_path(tcx: TyCtxt<'_>, basename: &str, extension: &str) -> PathBuf {
+    let mut file_path = PathBuf::new();
+    file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
+
+    let file_name = format!("{}.{}", basename, extension,);
 
     file_path.push(&file_name);
 
     file_path
 }
 
+/// Attempts to open the MIR dump file with the given name and extension.
+fn create_dump_file_with_basename(
+    tcx: TyCtxt<'_>,
+    file_basename: &str,
+    extension: &str,
+) -> io::Result<io::BufWriter<fs::File>> {
+    let file_path = dump_path(tcx, file_basename, extension);
+    if let Some(parent) = file_path.parent() {
+        fs::create_dir_all(parent).map_err(|e| {
+            io::Error::new(
+                e.kind(),
+                format!("IO error creating MIR dump directory: {:?}; {}", parent, e),
+            )
+        })?;
+    }
+    Ok(io::BufWriter::new(fs::File::create(&file_path).map_err(|e| {
+        io::Error::new(e.kind(), format!("IO error creating MIR dump file: {:?}; {}", file_path, e))
+    })?))
+}
+
 /// Attempts to open a file where we should dump a given MIR or other
 /// bit of MIR-related data. Used by `mir-dump`, but also by other
 /// bits of code (e.g., NLL inference) that dump graphviz data or
@@ -235,11 +254,11 @@ pub(crate) fn create_dump_file(
     disambiguator: &dyn Display,
     source: MirSource<'tcx>,
 ) -> io::Result<io::BufWriter<fs::File>> {
-    let file_path = dump_path(tcx, extension, pass_num, pass_name, disambiguator, source);
-    if let Some(parent) = file_path.parent() {
-        fs::create_dir_all(parent)?;
-    }
-    Ok(io::BufWriter::new(fs::File::create(&file_path)?))
+    create_dump_file_with_basename(
+        tcx,
+        &dump_file_basename(tcx, pass_num, pass_name, disambiguator, source),
+        extension,
+    )
 }
 
 /// Write out a human-readable textual representation for the given MIR.
diff --git a/compiler/rustc_mir/src/util/spanview.rs b/compiler/rustc_mir/src/util/spanview.rs
index fdc724178b6..d3ef8c64565 100644
--- a/compiler/rustc_mir/src/util/spanview.rs
+++ b/compiler/rustc_mir/src/util/spanview.rs
@@ -16,9 +16,13 @@ const ANNOTATION_RIGHT_BRACKET: char = '\u{2989}'; // Unicode `Z NOTATION LEFT B
 const NEW_LINE_SPAN: &str = "</span>\n<span class=\"line\">";
 const HEADER: &str = r#"<!DOCTYPE html>
 <html>
-<head>
-    <title>coverage_of_if_else - Code Regions</title>
-    <style>
+<head>"#;
+const START_BODY: &str = r#"</head>
+<body>"#;
+const FOOTER: &str = r#"</body>
+</html>"#;
+
+const STYLE_SECTION: &str = r#"<style>
     .line {
         counter-increment: line;
     }
@@ -72,16 +76,12 @@ const HEADER: &str = r#"<!DOCTYPE html>
         /* requires hover over a span ONLY on its first line */
         display: inline-block;
     }
-    </style>
-</head>
-<body>"#;
-
-const FOOTER: &str = r#"
-</body>
-</html>"#;
+</style>"#;
 
 /// Metadata to highlight the span of a MIR BasicBlock, Statement, or Terminator.
+#[derive(Clone, Debug)]
 pub struct SpanViewable {
+    pub bb: BasicBlock,
     pub span: Span,
     pub id: String,
     pub tooltip: String,
@@ -92,6 +92,7 @@ pub fn write_mir_fn_spanview<'tcx, W>(
     tcx: TyCtxt<'tcx>,
     body: &Body<'tcx>,
     spanview: MirSpanview,
+    title: &str,
     w: &mut W,
 ) -> io::Result<()>
 where
@@ -126,16 +127,17 @@ where
             }
         }
     }
-    write_spanview_document(tcx, def_id, span_viewables, w)?;
+    write_document(tcx, def_id, span_viewables, title, w)?;
     Ok(())
 }
 
 /// Generate a spanview HTML+CSS document for the given local function `def_id`, and a pre-generated
 /// list `SpanViewable`s.
-pub fn write_spanview_document<'tcx, W>(
+pub fn write_document<'tcx, W>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
     mut span_viewables: Vec<SpanViewable>,
+    title: &str,
     w: &mut W,
 ) -> io::Result<()>
 where
@@ -153,6 +155,9 @@ where
         source_map.span_to_snippet(fn_span).expect("function should have printable source")
     );
     writeln!(w, "{}", HEADER)?;
+    writeln!(w, "<title>{}</title>", title)?;
+    writeln!(w, "{}", STYLE_SECTION)?;
+    writeln!(w, "{}", START_BODY)?;
     write!(
         w,
         r#"<div class="code" style="counter-reset: line {}"><span class="line">{}"#,
@@ -182,6 +187,7 @@ where
             end_pos.to_usize(),
             ordered_viewables.len()
         );
+        let curr_id = &ordered_viewables[0].id;
         let (next_from_pos, next_ordered_viewables) = write_next_viewable_with_overlaps(
             tcx,
             from_pos,
@@ -204,13 +210,17 @@ where
         from_pos = next_from_pos;
         if next_ordered_viewables.len() != ordered_viewables.len() {
             ordered_viewables = next_ordered_viewables;
-            alt = !alt;
+            if let Some(next_ordered_viewable) = ordered_viewables.first() {
+                if &next_ordered_viewable.id != curr_id {
+                    alt = !alt;
+                }
+            }
         }
     }
     if from_pos < end_pos {
         write_coverage_gap(tcx, from_pos, end_pos, w)?;
     }
-    write!(w, r#"</span></div>"#)?;
+    writeln!(w, r#"</span></div>"#)?;
     writeln!(w, "{}", FOOTER)?;
     Ok(())
 }
@@ -273,7 +283,7 @@ fn statement_span_viewable<'tcx>(
     }
     let id = format!("{}[{}]", bb.index(), i);
     let tooltip = tooltip(tcx, &id, span, vec![statement.clone()], &None);
-    Some(SpanViewable { span, id, tooltip })
+    Some(SpanViewable { bb, span, id, tooltip })
 }
 
 fn terminator_span_viewable<'tcx>(
@@ -289,7 +299,7 @@ fn terminator_span_viewable<'tcx>(
     }
     let id = format!("{}:{}", bb.index(), terminator_kind_name(term));
     let tooltip = tooltip(tcx, &id, span, vec![], &data.terminator);
-    Some(SpanViewable { span, id, tooltip })
+    Some(SpanViewable { bb, span, id, tooltip })
 }
 
 fn block_span_viewable<'tcx>(
@@ -304,7 +314,7 @@ fn block_span_viewable<'tcx>(
     }
     let id = format!("{}", bb.index());
     let tooltip = tooltip(tcx, &id, span, data.statements.clone(), &data.terminator);
-    Some(SpanViewable { span, id, tooltip })
+    Some(SpanViewable { bb, span, id, tooltip })
 }
 
 fn compute_block_span<'tcx>(data: &BasicBlockData<'tcx>, body_span: Span) -> Span {
@@ -456,6 +466,7 @@ where
             remaining_viewables.len()
         );
         // Write the overlaps (and the overlaps' overlaps, if any) up to `to_pos`.
+        let curr_id = &remaining_viewables[0].id;
         let (next_from_pos, next_remaining_viewables) = write_next_viewable_with_overlaps(
             tcx,
             from_pos,
@@ -480,7 +491,11 @@ where
         from_pos = next_from_pos;
         if next_remaining_viewables.len() != remaining_viewables.len() {
             remaining_viewables = next_remaining_viewables;
-            subalt = !subalt;
+            if let Some(next_ordered_viewable) = remaining_viewables.first() {
+                if &next_ordered_viewable.id != curr_id {
+                    subalt = !subalt;
+                }
+            }
         }
     }
     if from_pos <= viewable.span.hi() {
@@ -649,8 +664,12 @@ fn fn_span<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Span {
         tcx.hir().local_def_id_to_hir_id(def_id.as_local().expect("expected DefId is local"));
     let fn_decl_span = tcx.hir().span(hir_id);
     let body_span = hir_body(tcx, def_id).value.span;
-    debug_assert_eq!(fn_decl_span.ctxt(), body_span.ctxt());
-    fn_decl_span.to(body_span)
+    if fn_decl_span.ctxt() == body_span.ctxt() {
+        fn_decl_span.to(body_span)
+    } else {
+        // This probably occurs for functions defined via macros
+        body_span
+    }
 }
 
 fn hir_body<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx rustc_hir::Body<'tcx> {
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index ab96b0333f4..231e315a22f 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -1756,10 +1756,6 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         );
     }
 
-    if debugging_opts.experimental_coverage {
-        debugging_opts.instrument_coverage = true;
-    }
-
     if debugging_opts.instrument_coverage {
         if cg.profile_generate.enabled() || cg.profile_use.is_some() {
             early_error(
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index b705ab6d931..a106007c274 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -895,11 +895,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
         all statements)."),
     emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
         "emit a section containing stack size metadata (default: no)"),
-    experimental_coverage: bool = (false, parse_bool, [TRACKED],
-        "enable and extend the `-Z instrument-coverage` function-level coverage \
-        feature, adding additional experimental (likely inaccurate) counters and \
-        code regions (used by `rustc` compiler developers to test new coverage \
-        counter placements) (default: no)"),
     fewer_names: bool = (false, parse_bool, [TRACKED],
         "reduce memory use by retaining fewer names within compilation artifacts (LLVM-IR) \
         (default: no)"),
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 96a6956a40c..e7cb8cb6e88 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -60,6 +60,8 @@ use md5::Md5;
 use sha1::Digest;
 use sha1::Sha1;
 
+use tracing::debug;
+
 #[cfg(test)]
 mod tests;
 
@@ -1462,6 +1464,88 @@ impl SourceFile {
 
         BytePos::from_u32(pos.0 - self.start_pos.0 + diff)
     }
+
+    /// Converts an absolute `BytePos` to a `CharPos` relative to the `SourceFile`.
+    pub fn bytepos_to_file_charpos(&self, bpos: BytePos) -> CharPos {
+        // The number of extra bytes due to multibyte chars in the `SourceFile`.
+        let mut total_extra_bytes = 0;
+
+        for mbc in self.multibyte_chars.iter() {
+            debug!("{}-byte char at {:?}", mbc.bytes, mbc.pos);
+            if mbc.pos < bpos {
+                // Every character is at least one byte, so we only
+                // count the actual extra bytes.
+                total_extra_bytes += mbc.bytes as u32 - 1;
+                // We should never see a byte position in the middle of a
+                // character.
+                assert!(bpos.to_u32() >= mbc.pos.to_u32() + mbc.bytes as u32);
+            } else {
+                break;
+            }
+        }
+
+        assert!(self.start_pos.to_u32() + total_extra_bytes <= bpos.to_u32());
+        CharPos(bpos.to_usize() - self.start_pos.to_usize() - total_extra_bytes as usize)
+    }
+
+    /// Looks up the file's (1-based) line number and (0-based `CharPos`) column offset, for a
+    /// given `BytePos`.
+    pub fn lookup_file_pos(&self, pos: BytePos) -> (usize, CharPos) {
+        let chpos = self.bytepos_to_file_charpos(pos);
+        match self.lookup_line(pos) {
+            Some(a) => {
+                let line = a + 1; // Line numbers start at 1
+                let linebpos = self.lines[a];
+                let linechpos = self.bytepos_to_file_charpos(linebpos);
+                let col = chpos - linechpos;
+                debug!("byte pos {:?} is on the line at byte pos {:?}", pos, linebpos);
+                debug!("char pos {:?} is on the line at char pos {:?}", chpos, linechpos);
+                debug!("byte is on line: {}", line);
+                assert!(chpos >= linechpos);
+                (line, col)
+            }
+            None => (0, chpos),
+        }
+    }
+
+    /// Looks up the file's (1-based) line number, (0-based `CharPos`) column offset, and (0-based)
+    /// column offset when displayed, for a given `BytePos`.
+    pub fn lookup_file_pos_with_col_display(&self, pos: BytePos) -> (usize, CharPos, usize) {
+        let (line, col_or_chpos) = self.lookup_file_pos(pos);
+        if line > 0 {
+            let col = col_or_chpos;
+            let linebpos = self.lines[line - 1];
+            let col_display = {
+                let start_width_idx = self
+                    .non_narrow_chars
+                    .binary_search_by_key(&linebpos, |x| x.pos())
+                    .unwrap_or_else(|x| x);
+                let end_width_idx = self
+                    .non_narrow_chars
+                    .binary_search_by_key(&pos, |x| x.pos())
+                    .unwrap_or_else(|x| x);
+                let special_chars = end_width_idx - start_width_idx;
+                let non_narrow: usize = self.non_narrow_chars[start_width_idx..end_width_idx]
+                    .iter()
+                    .map(|x| x.width())
+                    .sum();
+                col.0 - special_chars + non_narrow
+            };
+            (line, col, col_display)
+        } else {
+            let chpos = col_or_chpos;
+            let col_display = {
+                let end_width_idx = self
+                    .non_narrow_chars
+                    .binary_search_by_key(&pos, |x| x.pos())
+                    .unwrap_or_else(|x| x);
+                let non_narrow: usize =
+                    self.non_narrow_chars[0..end_width_idx].iter().map(|x| x.width()).sum();
+                chpos.0 - end_width_idx + non_narrow
+            };
+            (0, chpos, col_display)
+        }
+    }
 }
 
 /// Normalizes the source code and records the normalizations.
diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs
index 37596b8ef6f..fdb031fd9b3 100644
--- a/compiler/rustc_span/src/source_map.rs
+++ b/compiler/rustc_span/src/source_map.rs
@@ -428,58 +428,22 @@ impl SourceMap {
         }
     }
 
+    /// Return the SourceFile that contains the given `BytePos`
+    pub fn lookup_source_file(&self, pos: BytePos) -> Lrc<SourceFile> {
+        let idx = self.lookup_source_file_idx(pos);
+        (*self.files.borrow().source_files)[idx].clone()
+    }
+
     /// Looks up source information about a `BytePos`.
     pub fn lookup_char_pos(&self, pos: BytePos) -> Loc {
-        let chpos = self.bytepos_to_file_charpos(pos);
-        match self.lookup_line(pos) {
-            Ok(SourceFileAndLine { sf: f, line: a }) => {
-                let line = a + 1; // Line numbers start at 1
-                let linebpos = f.lines[a];
-                let linechpos = self.bytepos_to_file_charpos(linebpos);
-                let col = chpos - linechpos;
-
-                let col_display = {
-                    let start_width_idx = f
-                        .non_narrow_chars
-                        .binary_search_by_key(&linebpos, |x| x.pos())
-                        .unwrap_or_else(|x| x);
-                    let end_width_idx = f
-                        .non_narrow_chars
-                        .binary_search_by_key(&pos, |x| x.pos())
-                        .unwrap_or_else(|x| x);
-                    let special_chars = end_width_idx - start_width_idx;
-                    let non_narrow: usize = f.non_narrow_chars[start_width_idx..end_width_idx]
-                        .iter()
-                        .map(|x| x.width())
-                        .sum();
-                    col.0 - special_chars + non_narrow
-                };
-                debug!("byte pos {:?} is on the line at byte pos {:?}", pos, linebpos);
-                debug!("char pos {:?} is on the line at char pos {:?}", chpos, linechpos);
-                debug!("byte is on line: {}", line);
-                assert!(chpos >= linechpos);
-                Loc { file: f, line, col, col_display }
-            }
-            Err(f) => {
-                let col_display = {
-                    let end_width_idx = f
-                        .non_narrow_chars
-                        .binary_search_by_key(&pos, |x| x.pos())
-                        .unwrap_or_else(|x| x);
-                    let non_narrow: usize =
-                        f.non_narrow_chars[0..end_width_idx].iter().map(|x| x.width()).sum();
-                    chpos.0 - end_width_idx + non_narrow
-                };
-                Loc { file: f, line: 0, col: chpos, col_display }
-            }
-        }
+        let sf = self.lookup_source_file(pos);
+        let (line, col, col_display) = sf.lookup_file_pos_with_col_display(pos);
+        Loc { file: sf, line, col, col_display }
     }
 
     // If the corresponding `SourceFile` is empty, does not return a line number.
     pub fn lookup_line(&self, pos: BytePos) -> Result<SourceFileAndLine, Lrc<SourceFile>> {
-        let idx = self.lookup_source_file_idx(pos);
-
-        let f = (*self.files.borrow().source_files)[idx].clone();
+        let f = self.lookup_source_file(pos);
 
         match f.lookup_line(pos) {
             Some(line) => Ok(SourceFileAndLine { sf: f, line }),
@@ -934,27 +898,8 @@ impl SourceMap {
     /// Converts an absolute `BytePos` to a `CharPos` relative to the `SourceFile`.
     pub fn bytepos_to_file_charpos(&self, bpos: BytePos) -> CharPos {
         let idx = self.lookup_source_file_idx(bpos);
-        let map = &(*self.files.borrow().source_files)[idx];
-
-        // The number of extra bytes due to multibyte chars in the `SourceFile`.
-        let mut total_extra_bytes = 0;
-
-        for mbc in map.multibyte_chars.iter() {
-            debug!("{}-byte char at {:?}", mbc.bytes, mbc.pos);
-            if mbc.pos < bpos {
-                // Every character is at least one byte, so we only
-                // count the actual extra bytes.
-                total_extra_bytes += mbc.bytes as u32 - 1;
-                // We should never see a byte position in the middle of a
-                // character.
-                assert!(bpos.to_u32() >= mbc.pos.to_u32() + mbc.bytes as u32);
-            } else {
-                break;
-            }
-        }
-
-        assert!(map.start_pos.to_u32() + total_extra_bytes <= bpos.to_u32());
-        CharPos(bpos.to_usize() - map.start_pos.to_usize() - total_extra_bytes as usize)
+        let sf = &(*self.files.borrow().source_files)[idx];
+        sf.bytepos_to_file_charpos(bpos)
     }
 
     // Returns the index of the `SourceFile` (in `self.files`) that contains `pos`.
diff --git a/src/test/mir-opt/graphviz.main.mir_map.0.dot b/src/test/mir-opt/graphviz.main.mir_map.0.dot
index df4f11f0f21..8d1da7f1b96 100644
--- a/src/test/mir-opt/graphviz.main.mir_map.0.dot
+++ b/src/test/mir-opt/graphviz.main.mir_map.0.dot
@@ -3,8 +3,5 @@ digraph Mir_0_3 {
     node [fontname="Courier, monospace"];
     edge [fontname="Courier, monospace"];
     label=<fn main() -&gt; ()<br align="left"/>>;
-    bb0__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">0</td></tr><tr><td align="left" balign="left">_0 = const ()<br/></td></tr><tr><td align="left">goto</td></tr></table>>];
-    bb1__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">1</td></tr><tr><td align="left">resume</td></tr></table>>];
-    bb2__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">2</td></tr><tr><td align="left">return</td></tr></table>>];
-    bb0__0_3 -> bb2__0_3 [label=""];
+    bb0__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">0</td></tr><tr><td align="left" balign="left">_0 = const ()<br/></td></tr><tr><td align="left">return</td></tr></table>>];
 }
diff --git a/src/test/mir-opt/graphviz.main.mir_map.0.dot.mir b/src/test/mir-opt/graphviz.main.mir_map.0.dot.mir
deleted file mode 100644
index 8d1da7f1b96..00000000000
--- a/src/test/mir-opt/graphviz.main.mir_map.0.dot.mir
+++ /dev/null
@@ -1,7 +0,0 @@
-digraph Mir_0_3 {
-    graph [fontname="Courier, monospace"];
-    node [fontname="Courier, monospace"];
-    edge [fontname="Courier, monospace"];
-    label=<fn main() -&gt; ()<br align="left"/>>;
-    bb0__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">0</td></tr><tr><td align="left" balign="left">_0 = const ()<br/></td></tr><tr><td align="left">return</td></tr></table>>];
-}
diff --git a/src/test/mir-opt/instrument_coverage.bar.InstrumentCoverage.diff b/src/test/mir-opt/instrument_coverage.bar.InstrumentCoverage.diff
index 5b2572655cc..5048359e5c6 100644
--- a/src/test/mir-opt/instrument_coverage.bar.InstrumentCoverage.diff
+++ b/src/test/mir-opt/instrument_coverage.bar.InstrumentCoverage.diff
@@ -6,7 +6,7 @@
   
       bb0: {
           _0 = const true;                 // scope 0 at /the/src/instrument_coverage.rs:20:5: 20:9
-+         Coverage::Counter(0) for /the/src/instrument_coverage.rs:19:18 - 21:2; // scope 0 at /the/src/instrument_coverage.rs:21:2: 21:2
++         Coverage::Counter(1) for /the/src/instrument_coverage.rs:20:5 - 21:2; // scope 0 at /the/src/instrument_coverage.rs:21:2: 21:2
           return;                          // scope 0 at /the/src/instrument_coverage.rs:21:2: 21:2
       }
   }
diff --git a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
index 800754542d9..598727e677c 100644
--- a/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
+++ b/src/test/mir-opt/instrument_coverage.main.InstrumentCoverage.diff
@@ -8,7 +8,7 @@
       let mut _3: !;                       // in scope 0 at /the/src/instrument_coverage.rs:12:18: 14:10
   
       bb0: {
-+         Coverage::Counter(0) for /the/src/instrument_coverage.rs:10:11 - 16:2; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6
++         Coverage::Counter(1) for /the/src/instrument_coverage.rs:12:12 - 12:17; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6
           falseUnwind -> [real: bb1, cleanup: bb6]; // scope 0 at /the/src/instrument_coverage.rs:11:5: 15:6
       }
   
@@ -26,6 +26,7 @@
       }
   
       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
           falseEdge -> [real: bb5, imaginary: bb4]; // scope 0 at /the/src/instrument_coverage.rs:12:9: 14:10
       }
   
diff --git a/src/test/mir-opt/spanview_block.main.mir_map.0.html b/src/test/mir-opt/spanview_block.main.mir_map.0.html
index 8f6b1307971..8e5268043e7 100644
--- a/src/test/mir-opt/spanview_block.main.mir_map.0.html
+++ b/src/test/mir-opt/spanview_block.main.mir_map.0.html
@@ -1,8 +1,8 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>coverage_of_if_else - Code Regions</title>
-    <style>
+<title>spanview_block.main.mir_map.0</title>
+<style>
     .line {
         counter-increment: line;
     }
@@ -56,12 +56,11 @@
         /* requires hover over a span ONLY on its first line */
         display: inline-block;
     }
-    </style>
+</style>
 </head>
 <body>
 <div class="code" style="counter-reset: line 4"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="0: $DIR/spanview-block.rs:5:11: 5:13:
     5:11-5:13: Assign: _0 = const ()
-    5:13-5:13: Goto: goto -&gt; bb2"><span class="annotation">0⦊</span>{}<span class="annotation">⦉0</span></span></span><span><span class="code odd" style="--layer: 1" title="2: $DIR/spanview-block.rs:5:13: 5:13:
-    5:13-5:13: Return: return"><span class="annotation">2⦊</span>‸<span class="annotation">⦉2</span></span></span></span></div>
+    5:13-5:13: Return: return"><span class="annotation">0⦊</span>{}<span class="annotation">⦉0</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/mir-opt/spanview_statement.main.mir_map.0.html b/src/test/mir-opt/spanview_statement.main.mir_map.0.html
index 072d22473a9..abbff2270b7 100644
--- a/src/test/mir-opt/spanview_statement.main.mir_map.0.html
+++ b/src/test/mir-opt/spanview_statement.main.mir_map.0.html
@@ -1,8 +1,8 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>coverage_of_if_else - Code Regions</title>
-    <style>
+<title>spanview_statement.main.mir_map.0</title>
+<style>
     .line {
         counter-increment: line;
     }
@@ -56,12 +56,11 @@
         /* requires hover over a span ONLY on its first line */
         display: inline-block;
     }
-    </style>
+</style>
 </head>
 <body>
 <div class="code" style="counter-reset: line 4"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="0[0]: $DIR/spanview-statement.rs:5:11: 5:13:
-    5:11-5:13: Assign: _0 = const ()"><span class="annotation">0[0]⦊</span>{}<span class="annotation">⦉0[0]</span></span></span><span><span class="code odd" style="--layer: 1" title="0:Goto: $DIR/spanview-statement.rs:5:13: 5:13:
-    5:13-5:13: Goto: goto -&gt; bb2"><span class="annotation">0:Goto⦊</span>‸<span class="annotation">⦉0:Goto</span></span></span><span><span class="code even" style="--layer: 1" title="2:Return: $DIR/spanview-statement.rs:5:13: 5:13:
-    5:13-5:13: Return: return"><span class="annotation">2:Return⦊</span>‸<span class="annotation">⦉2:Return</span></span></span></span></div>
+    5:11-5:13: Assign: _0 = const ()"><span class="annotation">0[0]⦊</span>{}<span class="annotation">⦉0[0]</span></span></span><span><span class="code odd" style="--layer: 1" title="0:Return: $DIR/spanview-statement.rs:5:13: 5:13:
+    5:13-5:13: Return: return"><span class="annotation">0:Return⦊</span>‸<span class="annotation">⦉0:Return</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/mir-opt/spanview_terminator.main.mir_map.0.html b/src/test/mir-opt/spanview_terminator.main.mir_map.0.html
index e023f0f8aea..55fafd90b0a 100644
--- a/src/test/mir-opt/spanview_terminator.main.mir_map.0.html
+++ b/src/test/mir-opt/spanview_terminator.main.mir_map.0.html
@@ -1,8 +1,8 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>coverage_of_if_else - Code Regions</title>
-    <style>
+<title>spanview_terminator.main.mir_map.0</title>
+<style>
     .line {
         counter-increment: line;
     }
@@ -56,11 +56,10 @@
         /* requires hover over a span ONLY on its first line */
         display: inline-block;
     }
-    </style>
+</style>
 </head>
 <body>
-<div class="code" style="counter-reset: line 4"><span class="line"><span class="code" style="--layer: 0">fn main() {}</span><span><span class="code even" style="--layer: 1" title="0:Goto: $DIR/spanview-terminator.rs:5:13: 5:13:
-    5:13-5:13: Goto: goto -&gt; bb2"><span class="annotation">0:Goto⦊</span>‸<span class="annotation">⦉0:Goto</span></span></span><span><span class="code odd" style="--layer: 1" title="2:Return: $DIR/spanview-terminator.rs:5:13: 5:13:
-    5:13-5:13: Return: return"><span class="annotation">2:Return⦊</span>‸<span class="annotation">⦉2:Return</span></span></span></span></div>
+<div class="code" style="counter-reset: line 4"><span class="line"><span class="code" style="--layer: 0">fn main() {}</span><span><span class="code even" style="--layer: 1" title="0:Return: $DIR/spanview-terminator.rs:5:13: 5:13:
+    5:13-5:13: Return: return"><span class="annotation">0:Return⦊</span>‸<span class="annotation">⦉0:Return</span></span></span></span></div>
 </body>
 </html>
diff --git a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-base/Makefile b/src/test/run-make-fulldeps/coverage-llvmir-base/Makefile
index f623248ab57..e84642922d9 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-base/Makefile
+++ b/src/test/run-make-fulldeps/coverage-llvmir-base/Makefile
@@ -2,11 +2,11 @@
 
 # ISSUE(76038): When targeting MSVC, Rust binaries built with both `-Z instrument-coverage` and
 # `-C link-dead-code` typically crash (with a seg-fault) or at best generate an empty `*.profraw`.
-# See ../instrument-coverage/coverage_tools.mk for more information.
+# See ../coverage/coverage_tools.mk for more information.
 
--include ../instrument-coverage/coverage_tools.mk
+-include ../coverage/coverage_tools.mk
 
-BASEDIR=../instrument-coverage-llvm-ir-base
+BASEDIR=../coverage-llvmir-base
 
 ifeq ($(UNAME),Darwin)
 	INSTR_PROF_DATA_SUFFIX=,regular,live_support
diff --git a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-base/filecheck.testprog.txt b/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt
index 0a3c4aedd55..0a3c4aedd55 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-base/filecheck.testprog.txt
+++ b/src/test/run-make-fulldeps/coverage-llvmir-base/filecheck.testprog.txt
diff --git a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-base/testprog.rs b/src/test/run-make-fulldeps/coverage-llvmir-base/testprog.rs
index 358c25677ae..358c25677ae 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-base/testprog.rs
+++ b/src/test/run-make-fulldeps/coverage-llvmir-base/testprog.rs
diff --git a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-link-dead-code/Makefile b/src/test/run-make-fulldeps/coverage-llvmir-deadcode/Makefile
index ba2126a6b3f..30c7c0fbb51 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-llvm-ir-link-dead-code/Makefile
+++ b/src/test/run-make-fulldeps/coverage-llvmir-deadcode/Makefile
@@ -4,8 +4,8 @@
 # LINK_DEAD_CODE requires ignore-msvc due to Issue #76038
 LINK_DEAD_CODE=yes
 
--include ../instrument-coverage-llvm-ir-base/Makefile
+-include ../coverage-llvmir-base/Makefile
 
 # ISSUE(76038): When targeting MSVC, Rust binaries built with both `-Z instrument-coverage` and
 # `-C link-dead-code` typically crash (with a seg-fault) or at best generate an empty `*.profraw`.
-# See ../instrument-coverage/coverage_tools.mk for more information.
\ No newline at end of file
+# See ../coverage/coverage_tools.mk for more information.
diff --git a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/Makefile b/src/test/run-make-fulldeps/coverage-reports-base/Makefile
index cb081fb641b..880d7fdb1b0 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/Makefile
+++ b/src/test/run-make-fulldeps/coverage-reports-base/Makefile
@@ -6,12 +6,12 @@
 
 # ISSUE(76038): When targeting MSVC, Rust binaries built with both `-Z instrument-coverage` and
 # `-C link-dead-code` typically crash (with a seg-fault) or at best generate an empty `*.profraw`.
-# See ../instrument-coverage/coverage_tools.mk for more information.
+# See ../coverage/coverage_tools.mk for more information.
 
--include ../instrument-coverage/coverage_tools.mk
+-include ../coverage/coverage_tools.mk
 
-BASEDIR=../instrument-coverage-cov-reports-base
-SOURCEDIR=../instrument-coverage
+BASEDIR=../coverage-reports-base
+SOURCEDIR=../coverage
 
 all: $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs))
 
@@ -20,25 +20,29 @@ all: $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs))
 clear_expected_if_blessed:
 ifdef RUSTC_BLESS_TEST
 	rm -f expected_export_coverage.*.json
-	rm -f typical_show_coverage.*.txt
+	rm -f expected_show_coverage.*.txt
 endif
 
 -include clear_expected_if_blessed
 
 %: $(SOURCEDIR)/%.rs
-	# Compile the test program with "experimental" coverage instrumentation and generate relevant MIR.
-	#
-	# FIXME(richkadel):  `-Zexperimental-coverage` to `-Zinstrument-coverage` once we are
-	# satisfied with the branch-level instrumentation.
+	# Compile the test program with coverage instrumentation and generate relevant MIR.
 	$(RUSTC) $(SOURCEDIR)/$@.rs \
-			-Zexperimental-coverage \
+			-Zinstrument-coverage \
 			-Clink-dead-code=$(LINK_DEAD_CODE)
 
 	# Run it in order to generate some profiling data,
 	# with `LLVM_PROFILE_FILE=<profdata_file>` environment variable set to
 	# output the coverage stats for this run.
 	LLVM_PROFILE_FILE="$(TMPDIR)"/$@.profraw \
-			$(call RUN,$@)
+			$(call RUN,$@) || \
+			( \
+				status=$$?; \
+				grep -q "^\/\/ expect-exit-status-$$status" $(SOURCEDIR)/$@.rs || \
+				( >&2 echo "program exited with an unexpected exit status: $$status"; \
+					false \
+				) \
+			)
 
 	# Postprocess the profiling data so it can be used by the llvm-cov tool
 	"$(LLVM_BIN_DIR)"/llvm-profdata merge --sparse \
@@ -57,11 +61,20 @@ endif
 		> "$(TMPDIR)"/actual_show_coverage.$@.txt
 
 ifdef RUSTC_BLESS_TEST
-	cp "$(TMPDIR)"/actual_show_coverage.$@.txt typical_show_coverage.$@.txt
+	cp "$(TMPDIR)"/actual_show_coverage.$@.txt expected_show_coverage.$@.txt
 else
 	# Compare the show coverage output (`--bless` refreshes `typical` files)
-	$(DIFF) typical_show_coverage.$@.txt "$(TMPDIR)"/actual_show_coverage.$@.txt || \
-		>&2 echo 'diff failed for `llvm-cov show` on $@ (might not be an error)'
+	# Note `llvm-cov show` output for some programs can vary, but can be ignored
+	# by inserting `// ignore-llvm-cov-show-diffs` at the top of the source file.
+
+	$(DIFF) expected_show_coverage.$@.txt "$(TMPDIR)"/actual_show_coverage.$@.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
new file mode 100644
index 00000000000..8c6edae2803
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.closure.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/closure.rs",
+          "summary": {
+            "functions": {
+              "count": 5,
+              "covered": 3,
+              "percent": 60
+            },
+            "instantiations": {
+              "count": 5,
+              "covered": 3,
+              "percent": 60
+            },
+            "lines": {
+              "count": 91,
+              "covered": 75,
+              "percent": 82.41758241758241
+            },
+            "regions": {
+              "count": 21,
+              "covered": 11,
+              "notcovered": 10,
+              "percent": 52.38095238095239
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 5,
+          "covered": 3,
+          "percent": 60
+        },
+        "instantiations": {
+          "count": 5,
+          "covered": 3,
+          "percent": 60
+        },
+        "lines": {
+          "count": 91,
+          "covered": 75,
+          "percent": 82.41758241758241
+        },
+        "regions": {
+          "count": 21,
+          "covered": 11,
+          "notcovered": 10,
+          "percent": 52.38095238095239
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
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
new file mode 100644
index 00000000000..bd2e2d56d4a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.drop_trait.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/drop_trait.rs",
+          "summary": {
+            "functions": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "lines": {
+              "count": 10,
+              "covered": 10,
+              "percent": 100
+            },
+            "regions": {
+              "count": 5,
+              "covered": 5,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "lines": {
+          "count": 10,
+          "covered": 10,
+          "percent": 100
+        },
+        "regions": {
+          "count": 5,
+          "covered": 5,
+          "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.generics.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json
new file mode 100644
index 00000000000..a50f4657e20
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.generics.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/generics.rs",
+          "summary": {
+            "functions": {
+              "count": 3,
+              "covered": 3,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 5,
+              "covered": 5,
+              "percent": 100
+            },
+            "lines": {
+              "count": 16,
+              "covered": 16,
+              "percent": 100
+            },
+            "regions": {
+              "count": 6,
+              "covered": 6,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 3,
+          "covered": 3,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 5,
+          "covered": 5,
+          "percent": 100
+        },
+        "lines": {
+          "count": 16,
+          "covered": 16,
+          "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.if.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json
new file mode 100644
index 00000000000..2ff53ad33fa
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/if.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 19,
+              "covered": 19,
+              "percent": 100
+            },
+            "regions": {
+              "count": 4,
+              "covered": 4,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 19,
+          "covered": 19,
+          "percent": 100
+        },
+        "regions": {
+          "count": 4,
+          "covered": 4,
+          "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.if_else.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json
new file mode 100644
index 00000000000..36f81ceae19
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.if_else.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/if_else.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 28,
+              "covered": 19,
+              "percent": 67.85714285714286
+            },
+            "regions": {
+              "count": 7,
+              "covered": 5,
+              "notcovered": 2,
+              "percent": 71.42857142857143
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 28,
+          "covered": 19,
+          "percent": 67.85714285714286
+        },
+        "regions": {
+          "count": 7,
+          "covered": 5,
+          "notcovered": 2,
+          "percent": 71.42857142857143
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
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
new file mode 100644
index 00000000000..a24e6a33a33
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.inner_items.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/inner_items.rs",
+          "summary": {
+            "functions": {
+              "count": 4,
+              "covered": 4,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 4,
+              "covered": 4,
+              "percent": 100
+            },
+            "lines": {
+              "count": 26,
+              "covered": 26,
+              "percent": 100
+            },
+            "regions": {
+              "count": 13,
+              "covered": 13,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 4,
+          "covered": 4,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 4,
+          "covered": 4,
+          "percent": 100
+        },
+        "lines": {
+          "count": 26,
+          "covered": 26,
+          "percent": 100
+        },
+        "regions": {
+          "count": 13,
+          "covered": 13,
+          "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.lazy_boolean.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json
new file mode 100644
index 00000000000..585346dc32a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.lazy_boolean.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/lazy_boolean.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 21,
+              "covered": 19,
+              "percent": 90.47619047619048
+            },
+            "regions": {
+              "count": 16,
+              "covered": 14,
+              "notcovered": 2,
+              "percent": 87.5
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 21,
+          "covered": 19,
+          "percent": 90.47619047619048
+        },
+        "regions": {
+          "count": 16,
+          "covered": 14,
+          "notcovered": 2,
+          "percent": 87.5
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loop_break_value.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loop_break_value.json
new file mode 100644
index 00000000000..6cb1465c818
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.loop_break_value.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/loop_break_value.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 11,
+              "covered": 11,
+              "percent": 100
+            },
+            "regions": {
+              "count": 1,
+              "covered": 1,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 11,
+          "covered": 11,
+          "percent": 100
+        },
+        "regions": {
+          "count": 1,
+          "covered": 1,
+          "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
new file mode 100644
index 00000000000..38bc96898ea
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_loop.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/simple_loop.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 18,
+              "covered": 18,
+              "percent": 100
+            },
+            "regions": {
+              "count": 7,
+              "covered": 7,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 18,
+          "covered": 18,
+          "percent": 100
+        },
+        "regions": {
+          "count": 7,
+          "covered": 7,
+          "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_match.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json
new file mode 100644
index 00000000000..f9d91d66f1d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.simple_match.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/simple_match.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 26,
+              "covered": 26,
+              "percent": 100
+            },
+            "regions": {
+              "count": 9,
+              "covered": 9,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 26,
+          "covered": 26,
+          "percent": 100
+        },
+        "regions": {
+          "count": 9,
+          "covered": 9,
+          "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
new file mode 100644
index 00000000000..e6ef2c1ab89
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.try_error_result.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/try_error_result.rs",
+          "summary": {
+            "functions": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "lines": {
+              "count": 16,
+              "covered": 15,
+              "percent": 93.75
+            },
+            "regions": {
+              "count": 13,
+              "covered": 12,
+              "notcovered": 1,
+              "percent": 92.3076923076923
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "lines": {
+          "count": 16,
+          "covered": 15,
+          "percent": 93.75
+        },
+        "regions": {
+          "count": 13,
+          "covered": 12,
+          "notcovered": 1,
+          "percent": 92.3076923076923
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/expected_export_coverage.coverage_of_if_else.json b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json
index 051250d90a2..410821ea335 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/expected_export_coverage.coverage_of_if_else.json
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.various_conditions.json
@@ -3,7 +3,7 @@
     {
       "files": [
         {
-          "filename": "../instrument-coverage/coverage_of_if_else.rs",
+          "filename": "../coverage/various_conditions.rs",
           "summary": {
             "functions": {
               "count": 1,
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 40,
-              "covered": 19,
-              "percent": 47.5
+              "count": 49,
+              "covered": 23,
+              "percent": 46.93877551020408
             },
             "regions": {
-              "count": 71,
-              "covered": 23,
-              "notcovered": 48,
-              "percent": 32.3943661971831
+              "count": 51,
+              "covered": 19,
+              "notcovered": 32,
+              "percent": 37.254901960784316
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 40,
-          "covered": 19,
-          "percent": 47.5
+          "count": 49,
+          "covered": 23,
+          "percent": 46.93877551020408
         },
         "regions": {
-          "count": 71,
-          "covered": 23,
-          "notcovered": 48,
-          "percent": 32.3943661971831
+          "count": 51,
+          "covered": 19,
+          "notcovered": 32,
+          "percent": 37.254901960784316
         }
       }
     }
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
new file mode 100644
index 00000000000..865b705fa20
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_export_coverage.while_early_return.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/while_early_return.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 18,
+              "covered": 16,
+              "percent": 88.88888888888889
+            },
+            "regions": {
+              "count": 9,
+              "covered": 7,
+              "notcovered": 2,
+              "percent": 77.77777777777779
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 18,
+          "covered": 16,
+          "percent": 88.88888888888889
+        },
+        "regions": {
+          "count": 9,
+          "covered": 7,
+          "notcovered": 2,
+          "percent": 77.77777777777779
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
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
new file mode 100644
index 00000000000..17054490e9b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.closure.txt
@@ -0,0 +1,94 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|      1|fn main() {
+    4|      1|    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|      1|    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|      1|    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|    let is_false = ! is_true;
+    9|      1|
+   10|      1|    let mut some_string = Some(String::from("the string content"));
+   11|      1|    println!(
+   12|      1|        "The string or alt: {}"
+   13|      1|        ,
+   14|      1|        some_string
+   15|      1|            .
+   16|      1|            unwrap_or_else
+   17|      1|        (
+   18|      1|            ||
+   19|       |            {
+   20|      0|                let mut countdown = 0;
+   21|      0|                if is_false {
+   22|      0|                    countdown = 10;
+   23|      0|                }
+   24|      0|                "alt string 1".to_owned()
+   25|      1|            }
+   26|      1|        )
+   27|      1|    );
+   28|      1|
+   29|      1|    some_string = Some(String::from("the string content"));
+   30|      1|    let
+   31|      1|        a
+   32|      1|    =
+   33|      1|        ||
+   34|       |    {
+   35|      0|        let mut countdown = 0;
+   36|      0|        if is_false {
+   37|      0|            countdown = 10;
+   38|      0|        }
+   39|      0|        "alt string 2".to_owned()
+   40|      1|    };
+   41|      1|    println!(
+   42|      1|        "The string or alt: {}"
+   43|      1|        ,
+   44|      1|        some_string
+   45|      1|            .
+   46|      1|            unwrap_or_else
+   47|      1|        (
+   48|      1|            a
+   49|      1|        )
+   50|      1|    );
+   51|      1|
+   52|      1|    some_string = None;
+   53|      1|    println!(
+   54|      1|        "The string or alt: {}"
+   55|      1|        ,
+   56|      1|        some_string
+   57|      1|            .
+   58|      1|            unwrap_or_else
+   59|      1|        (
+   60|      1|            ||
+   61|       |            {
+   62|      1|                let mut countdown = 0;
+   63|      1|                if is_false {
+   64|      0|                    countdown = 10;
+   65|      0|                }
+   66|      1|                "alt string 3".to_owned()
+   67|      1|            }
+   68|      1|        )
+   69|      1|    );
+   70|      1|
+   71|      1|    some_string = None;
+   72|      1|    let
+   73|      1|        a
+   74|      1|    =
+   75|      1|        ||
+   76|       |    {
+   77|      1|        let mut countdown = 0;
+   78|      1|        if is_false {
+   79|      0|            countdown = 10;
+   80|      0|        }
+   81|      1|        "alt string 4".to_owned()
+   82|      1|    };
+   83|      1|    println!(
+   84|      1|        "The string or alt: {}"
+   85|      1|        ,
+   86|      1|        some_string
+   87|      1|            .
+   88|      1|            unwrap_or_else
+   89|      1|        (
+   90|      1|            a
+   91|      1|        )
+   92|      1|    );
+   93|      1|}
+
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
new file mode 100644
index 00000000000..72aa020ca16
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.drop_trait.txt
@@ -0,0 +1,34 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |struct Firework {
+    5|       |    strength: i32,
+    6|       |}
+    7|       |
+    8|       |impl Drop for Firework {
+    9|      2|    fn drop(&mut self) {
+   10|      2|        println!("BOOM times {}!!!", self.strength);
+   11|      2|    }
+   12|       |}
+   13|       |
+   14|       |fn main() -> Result<(),u8> {
+   15|      1|    let _firecracker = Firework { strength: 1 };
+   16|      1|
+   17|      1|    let _tnt = Firework { strength: 100 };
+   18|       |
+   19|      1|    if true {
+   20|      1|        println!("Exiting with error...");
+   21|      1|        return Err(1);
+   22|       |    }
+   23|       |
+   24|       |    let _ = Firework { strength: 1000 };
+   25|       |
+   26|       |    Ok(())
+   27|      1|}
+   28|       |
+   29|       |// Expected program output:
+   30|       |//   Exiting with error...
+   31|       |//   BOOM times 100!!!
+   32|       |//   BOOM times 1!!!
+   33|       |//   Error: 1
+
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
new file mode 100644
index 00000000000..86199d74763
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.generics.txt
@@ -0,0 +1,67 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |struct Firework<T> where T: Copy + std::fmt::Display {
+    5|       |    strength: T,
+    6|       |}
+    7|       |
+    8|       |impl<T> Firework<T> where T: Copy + std::fmt::Display {
+    9|       |    #[inline(always)]
+   10|      3|    fn set_strength(&mut self, new_strength: T) {
+   11|      3|        self.strength = new_strength;
+   12|      3|    }
+  ------------------
+  | <generics::Firework<f64>>::set_strength:
+  |   10|      2|    fn set_strength(&mut self, new_strength: T) {
+  |   11|      2|        self.strength = new_strength;
+  |   12|      2|    }
+  ------------------
+  | <generics::Firework<i32>>::set_strength:
+  |   10|      1|    fn set_strength(&mut self, new_strength: T) {
+  |   11|      1|        self.strength = new_strength;
+  |   12|      1|    }
+  ------------------
+   13|       |}
+   14|       |
+   15|       |impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display {
+   16|       |    #[inline(always)]
+   17|      2|    fn drop(&mut self) {
+   18|      2|        println!("BOOM times {}!!!", self.strength);
+   19|      2|    }
+  ------------------
+  | <generics::Firework<i32> as core::ops::drop::Drop>::drop:
+  |   17|      1|    fn drop(&mut self) {
+  |   18|      1|        println!("BOOM times {}!!!", self.strength);
+  |   19|      1|    }
+  ------------------
+  | <generics::Firework<f64> as core::ops::drop::Drop>::drop:
+  |   17|      1|    fn drop(&mut self) {
+  |   18|      1|        println!("BOOM times {}!!!", self.strength);
+  |   19|      1|    }
+  ------------------
+   20|       |}
+   21|       |
+   22|       |fn main() -> Result<(),u8> {
+   23|      1|    let mut firecracker = Firework { strength: 1 };
+   24|      1|    firecracker.set_strength(2);
+   25|      1|
+   26|      1|    let mut tnt = Firework { strength: 100.1 };
+   27|      1|    tnt.set_strength(200.1);
+   28|      1|    tnt.set_strength(300.3);
+   29|       |
+   30|      1|    if true {
+   31|      1|        println!("Exiting with error...");
+   32|      1|        return Err(1);
+   33|       |    }
+   34|       |
+   35|       |    let _ = Firework { strength: 1000 };
+   36|       |
+   37|       |    Ok(())
+   38|      1|}
+   39|       |
+   40|       |// Expected program output:
+   41|       |//   Exiting with error...
+   42|       |//   BOOM times 100!!!
+   43|       |//   BOOM times 1!!!
+   44|       |//   Error: 1
+
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
new file mode 100644
index 00000000000..bc2f9b108b2
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if.txt
@@ -0,0 +1,29 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|       |    let
+    8|      1|    is_true
+    9|      1|    =
+   10|      1|        std::env::args().len()
+   11|      1|    ==
+   12|      1|        1
+   13|      1|    ;
+   14|      1|    let
+   15|      1|        mut
+   16|      1|    countdown
+   17|      1|    =
+   18|      1|        0
+   19|       |    ;
+   20|       |    if
+   21|      1|        is_true
+   22|      1|    {
+   23|      1|        countdown
+   24|      1|        =
+   25|      1|            10
+   26|      1|        ;
+   27|      1|    }
+   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
new file mode 100644
index 00000000000..5f899723e25
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.if_else.txt
@@ -0,0 +1,41 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 0;
+   10|      1|    if
+   11|      1|        is_true
+   12|      1|    {
+   13|      1|        countdown
+   14|      1|        =
+   15|      1|            10
+   16|      1|        ;
+   17|      1|    }
+   18|       |    else // Note coverage region difference without semicolon
+   19|       |    {
+   20|      0|        countdown
+   21|      0|        =
+   22|      0|            100
+   23|       |    }
+   24|       |
+   25|       |    if
+   26|      1|        is_true
+   27|      1|    {
+   28|      1|        countdown
+   29|      1|        =
+   30|      1|            10
+   31|      1|        ;
+   32|      1|    }
+   33|       |    else
+   34|      0|    {
+   35|      0|        countdown
+   36|      0|        =
+   37|      0|            100
+   38|      0|        ;
+   39|      0|    }
+   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
new file mode 100644
index 00000000000..b13ca83d018
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.inner_items.txt
@@ -0,0 +1,58 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 0;
+   10|      1|    if is_true {
+   11|      1|        countdown = 10;
+   12|      1|    }
+   13|       |
+   14|       |    mod in_mod {
+   15|       |        const IN_MOD_CONST: u32 = 1000;
+   16|       |    }
+   17|       |
+   18|       |    fn in_func(a: u32) {
+   19|      3|        let b = 1;
+   20|      3|        let c = a + b;
+   21|      3|        println!("c = {}", c)
+   22|      3|    }
+   23|       |
+   24|       |    struct InStruct {
+   25|       |        in_struct_field: u32,
+   26|       |    }
+   27|       |
+   28|       |    const IN_CONST: u32 = 1234;
+   29|       |
+   30|       |    trait InTrait {
+   31|       |        fn trait_func(&mut self, incr: u32);
+   32|       |
+   33|      1|        fn default_trait_func(&mut self) {
+   34|      1|            in_func(IN_CONST);
+   35|      1|            self.trait_func(IN_CONST);
+   36|      1|        }
+   37|       |    }
+   38|       |
+   39|       |    impl InTrait for InStruct {
+   40|       |        fn trait_func(&mut self, incr: u32) {
+   41|      1|            self.in_struct_field += incr;
+   42|      1|            in_func(self.in_struct_field);
+   43|      1|        }
+   44|       |    }
+   45|       |
+   46|       |    type InType = String;
+   47|       |
+   48|      1|    if is_true {
+   49|      1|        in_func(countdown);
+   50|      1|    }
+   51|       |
+   52|      1|    let mut val = InStruct {
+   53|      1|        in_struct_field: 101,
+   54|      1|    };
+   55|      1|
+   56|      1|    val.default_trait_func();
+   57|      1|}
+
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
new file mode 100644
index 00000000000..ded43697515
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.lazy_boolean.txt
@@ -0,0 +1,44 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let (mut a, mut b, mut c) = (0, 0, 0);
+   10|      1|    if is_true {
+   11|      1|        a = 1;
+   12|      1|        b = 10;
+   13|      1|        c = 100;
+   14|      1|    }
+   15|       |    let
+   16|      1|        somebool
+   17|       |        =
+   18|      1|            a < b
+   19|       |        ||
+   20|      0|            b < c
+   21|       |    ;
+   22|       |    let
+   23|      1|        somebool
+   24|       |        =
+   25|      1|            b < a
+   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|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loop_break_value.txt b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loop_break_value.txt
new file mode 100644
index 00000000000..b0d668c6d76
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.loop_break_value.txt
@@ -0,0 +1,14 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|      1|fn main() {
+    4|      1|    let result
+    5|      1|        =
+    6|      1|            loop
+    7|      1|        {
+    8|      1|            break
+    9|      1|            10
+   10|      1|            ;
+   11|      1|        }
+   12|      1|    ;
+   13|      1|}
+
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
new file mode 100644
index 00000000000..f1acb7c5459
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_loop.txt
@@ -0,0 +1,36 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 0;
+   10|       |
+   11|       |    if
+   12|      1|        is_true
+   13|      1|    {
+   14|      1|        countdown
+   15|      1|        =
+   16|      1|            10
+   17|      1|        ;
+   18|      1|    }
+   19|       |
+   20|       |    loop
+   21|       |    {
+   22|       |        if
+   23|     11|            countdown
+   24|     11|                ==
+   25|     11|            0
+   26|       |        {
+   27|      1|            break
+   28|       |            ;
+   29|       |        }
+   30|     10|        countdown
+   31|     10|        -=
+   32|     10|        1
+   33|       |        ;
+   34|       |    }
+   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
new file mode 100644
index 00000000000..e42f22cd047
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.simple_match.txt
@@ -0,0 +1,44 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 1;
+   10|      1|    if is_true {
+   11|      1|        countdown = 0;
+   12|      1|    }
+   13|       |
+   14|      3|    for
+   15|      3|        _
+   16|       |    in
+   17|      1|        0..2
+   18|       |    {
+   19|       |        let z
+   20|       |        ;
+   21|       |        match
+   22|      2|            countdown
+   23|      2|        {
+   24|      2|            x
+   25|      2|            if
+   26|      2|                x
+   27|      2|                    <
+   28|      2|                1
+   29|       |            =>
+   30|      1|            {
+   31|      1|                z = countdown
+   32|      1|                ;
+   33|      1|                let y = countdown
+   34|      1|                ;
+   35|      1|                countdown = 10
+   36|      1|                ;
+   37|      1|            }
+   38|       |            _
+   39|       |            =>
+   40|      1|            {}
+   41|       |        }
+   42|       |    }
+   43|      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
new file mode 100644
index 00000000000..ae288d7d7a0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.try_error_result.txt
@@ -0,0 +1,36 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |fn call(return_error: bool) -> Result<(),()> {
+    5|      6|    if return_error {
+    6|      1|        Err(())
+    7|       |    } else {
+    8|      5|        Ok(())
+    9|       |    }
+   10|      6|}
+   11|       |
+   12|       |fn main() -> Result<(),()> {
+   13|      1|    let mut
+   14|      1|        countdown = 10
+   15|       |    ;
+   16|      6|    for
+   17|      6|        _
+   18|       |    in
+   19|      1|        0..10
+   20|       |    {
+   21|      6|        countdown
+   22|      6|            -= 1
+   23|       |        ;
+   24|       |        if
+   25|      6|            countdown < 5
+   26|       |        {
+   27|      1|            call(/*return_error=*/ true)?;
+   28|       |        }
+   29|       |        else
+   30|       |        {
+   31|      5|            call(/*return_error=*/ false)?;
+   32|       |        }
+   33|       |    }
+   34|      0|    Ok(())
+   35|      1|}
+
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
new file mode 100644
index 00000000000..173ff4aa4c4
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.various_conditions.txt
@@ -0,0 +1,69 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|      1|    let mut countdown = 0;
+    5|      1|    if true {
+    6|      1|        countdown = 10;
+    7|      1|    }
+    8|       |
+    9|       |    const B: u32 = 100;
+   10|      1|    let x = if countdown > 7 {
+   11|      1|        countdown -= 4;
+   12|      1|        B
+   13|      0|    } else if countdown > 2 {
+   14|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   15|      0|            countdown = 0;
+   16|      0|        }
+   17|      0|        countdown -= 5;
+   18|      0|        countdown
+   19|       |    } else {
+   20|      0|        return;
+   21|       |    };
+   22|       |
+   23|      1|    let mut countdown = 0;
+   24|      1|    if true {
+   25|      1|        countdown = 10;
+   26|      1|    }
+   27|       |
+   28|      1|    if countdown > 7 {
+   29|      1|        countdown -= 4;
+   30|      0|    } else if countdown > 2 {
+   31|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   32|      0|            countdown = 0;
+   33|      0|        }
+   34|      0|        countdown -= 5;
+   35|       |    } else {
+   36|      0|        return;
+   37|       |    }
+   38|       |
+   39|      1|    let mut countdown = 0;
+   40|      1|    if true {
+   41|      1|        countdown = 1;
+   42|      1|    }
+   43|       |
+   44|      1|    let z = if countdown > 7 {
+                      ^0
+   45|      0|        countdown -= 4;
+   46|      1|    } else if countdown > 2 {
+   47|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   48|      0|            countdown = 0;
+   49|      0|        }
+   50|      0|        countdown -= 5;
+   51|       |    } else {
+   52|      1|        let should_be_reachable = countdown;
+   53|      1|        println!("reached");
+   54|      1|        return;
+   55|       |    };
+   56|       |
+   57|      0|    let w = if countdown > 7 {
+   58|      0|        countdown -= 4;
+   59|      0|    } else if countdown > 2 {
+   60|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   61|      0|            countdown = 0;
+   62|      0|        }
+   63|      0|        countdown -= 5;
+   64|       |    } else {
+   65|      0|        return;
+   66|       |    };
+   67|      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
new file mode 100644
index 00000000000..7dce94f25f3
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-base/expected_show_coverage.while_early_return.txt
@@ -0,0 +1,48 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |fn main() -> Result<(),u8> {
+    5|      1|    let mut countdown = 10;
+    6|      7|    while
+    7|      7|        countdown
+    8|      7|            >
+    9|      7|        0
+   10|       |    {
+   11|       |        if
+   12|      7|            countdown
+   13|      7|                <
+   14|      7|            5
+   15|       |        {
+   16|       |            return
+   17|       |                if
+   18|      1|                    countdown
+   19|      1|                        >
+   20|      1|                    8
+   21|       |                {
+   22|      0|                    Ok(())
+   23|       |                }
+   24|       |                else
+   25|       |                {
+   26|      1|                    Err(1)
+   27|       |                }
+   28|       |                ;
+   29|       |        }
+   30|      6|        countdown
+   31|      6|            -=
+   32|      6|        1
+   33|       |        ;
+   34|       |    }
+   35|      0|    Ok(())
+   36|      1|}
+   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
+   40|       |// and MacOS. But on Windows (MSVC, at least), the call to `std::process::exit()` exits the program
+   41|       |// without saving the InstrProf coverage counters. The use of `std::process:exit()` is not critical
+   42|       |// to the coverage test for early returns, but this is a limitation that should be fixed.
+   43|       |//
+   44|       |// FIXME(richkadel): Consider creating a new tests for coverage when calling `std::process::exit()`,
+   45|       |// move the `ISSUE` comment to that test, and implement a new test directive that supports skipping
+   46|       |// coverage tests when targeting specific platforms (at least skipping Windows, or MSVC if the
+   47|       |// problem exists on MSVC only).
+
diff --git a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/prettify_json.py b/src/test/run-make-fulldeps/coverage-reports-base/prettify_json.py
index ed9279841f7..ed9279841f7 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/prettify_json.py
+++ b/src/test/run-make-fulldeps/coverage-reports-base/prettify_json.py
diff --git a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-link-dead-code/Makefile b/src/test/run-make-fulldeps/coverage-reports-deadcode/Makefile
index ab826d07e05..b6a9acbf18b 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-link-dead-code/Makefile
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/Makefile
@@ -8,8 +8,8 @@
 # LINK_DEAD_CODE requires ignore-msvc due to Issue #76038
 LINK_DEAD_CODE=yes
 
--include ../instrument-coverage-cov-reports-base/Makefile
+-include ../coverage-reports-base/Makefile
 
 # ISSUE(76038): When targeting MSVC, Rust binaries built with both `-Z instrument-coverage` and
 # `-C link-dead-code` typically crash (with a seg-fault) or at best generate an empty `*.profraw`.
-# See ../instrument-coverage/coverage_tools.mk for more information.
+# See ../coverage/coverage_tools.mk for more information.
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
new file mode 100644
index 00000000000..8c6edae2803
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.closure.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/closure.rs",
+          "summary": {
+            "functions": {
+              "count": 5,
+              "covered": 3,
+              "percent": 60
+            },
+            "instantiations": {
+              "count": 5,
+              "covered": 3,
+              "percent": 60
+            },
+            "lines": {
+              "count": 91,
+              "covered": 75,
+              "percent": 82.41758241758241
+            },
+            "regions": {
+              "count": 21,
+              "covered": 11,
+              "notcovered": 10,
+              "percent": 52.38095238095239
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 5,
+          "covered": 3,
+          "percent": 60
+        },
+        "instantiations": {
+          "count": 5,
+          "covered": 3,
+          "percent": 60
+        },
+        "lines": {
+          "count": 91,
+          "covered": 75,
+          "percent": 82.41758241758241
+        },
+        "regions": {
+          "count": 21,
+          "covered": 11,
+          "notcovered": 10,
+          "percent": 52.38095238095239
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
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
new file mode 100644
index 00000000000..bd2e2d56d4a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.drop_trait.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/drop_trait.rs",
+          "summary": {
+            "functions": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "lines": {
+              "count": 10,
+              "covered": 10,
+              "percent": 100
+            },
+            "regions": {
+              "count": 5,
+              "covered": 5,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "lines": {
+          "count": 10,
+          "covered": 10,
+          "percent": 100
+        },
+        "regions": {
+          "count": 5,
+          "covered": 5,
+          "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.generics.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json
new file mode 100644
index 00000000000..a50f4657e20
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.generics.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/generics.rs",
+          "summary": {
+            "functions": {
+              "count": 3,
+              "covered": 3,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 5,
+              "covered": 5,
+              "percent": 100
+            },
+            "lines": {
+              "count": 16,
+              "covered": 16,
+              "percent": 100
+            },
+            "regions": {
+              "count": 6,
+              "covered": 6,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 3,
+          "covered": 3,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 5,
+          "covered": 5,
+          "percent": 100
+        },
+        "lines": {
+          "count": 16,
+          "covered": 16,
+          "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.if.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json
new file mode 100644
index 00000000000..2ff53ad33fa
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/if.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 19,
+              "covered": 19,
+              "percent": 100
+            },
+            "regions": {
+              "count": 4,
+              "covered": 4,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 19,
+          "covered": 19,
+          "percent": 100
+        },
+        "regions": {
+          "count": 4,
+          "covered": 4,
+          "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.if_else.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json
new file mode 100644
index 00000000000..36f81ceae19
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.if_else.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/if_else.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 28,
+              "covered": 19,
+              "percent": 67.85714285714286
+            },
+            "regions": {
+              "count": 7,
+              "covered": 5,
+              "notcovered": 2,
+              "percent": 71.42857142857143
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 28,
+          "covered": 19,
+          "percent": 67.85714285714286
+        },
+        "regions": {
+          "count": 7,
+          "covered": 5,
+          "notcovered": 2,
+          "percent": 71.42857142857143
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
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
new file mode 100644
index 00000000000..a24e6a33a33
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.inner_items.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/inner_items.rs",
+          "summary": {
+            "functions": {
+              "count": 4,
+              "covered": 4,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 4,
+              "covered": 4,
+              "percent": 100
+            },
+            "lines": {
+              "count": 26,
+              "covered": 26,
+              "percent": 100
+            },
+            "regions": {
+              "count": 13,
+              "covered": 13,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 4,
+          "covered": 4,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 4,
+          "covered": 4,
+          "percent": 100
+        },
+        "lines": {
+          "count": 26,
+          "covered": 26,
+          "percent": 100
+        },
+        "regions": {
+          "count": 13,
+          "covered": 13,
+          "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.lazy_boolean.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json
new file mode 100644
index 00000000000..585346dc32a
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.lazy_boolean.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/lazy_boolean.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 21,
+              "covered": 19,
+              "percent": 90.47619047619048
+            },
+            "regions": {
+              "count": 16,
+              "covered": 14,
+              "notcovered": 2,
+              "percent": 87.5
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 21,
+          "covered": 19,
+          "percent": 90.47619047619048
+        },
+        "regions": {
+          "count": 16,
+          "covered": 14,
+          "notcovered": 2,
+          "percent": 87.5
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loop_break_value.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loop_break_value.json
new file mode 100644
index 00000000000..6cb1465c818
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.loop_break_value.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/loop_break_value.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 11,
+              "covered": 11,
+              "percent": 100
+            },
+            "regions": {
+              "count": 1,
+              "covered": 1,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 11,
+          "covered": 11,
+          "percent": 100
+        },
+        "regions": {
+          "count": 1,
+          "covered": 1,
+          "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
new file mode 100644
index 00000000000..38bc96898ea
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_loop.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/simple_loop.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 18,
+              "covered": 18,
+              "percent": 100
+            },
+            "regions": {
+              "count": 7,
+              "covered": 7,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 18,
+          "covered": 18,
+          "percent": 100
+        },
+        "regions": {
+          "count": 7,
+          "covered": 7,
+          "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_match.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json
new file mode 100644
index 00000000000..f9d91d66f1d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.simple_match.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/simple_match.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 26,
+              "covered": 26,
+              "percent": 100
+            },
+            "regions": {
+              "count": 9,
+              "covered": 9,
+              "notcovered": 0,
+              "percent": 100
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 26,
+          "covered": 26,
+          "percent": 100
+        },
+        "regions": {
+          "count": 9,
+          "covered": 9,
+          "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
new file mode 100644
index 00000000000..e6ef2c1ab89
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.try_error_result.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/try_error_result.rs",
+          "summary": {
+            "functions": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 2,
+              "covered": 2,
+              "percent": 100
+            },
+            "lines": {
+              "count": 16,
+              "covered": 15,
+              "percent": 93.75
+            },
+            "regions": {
+              "count": 13,
+              "covered": 12,
+              "notcovered": 1,
+              "percent": 92.3076923076923
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 2,
+          "covered": 2,
+          "percent": 100
+        },
+        "lines": {
+          "count": 16,
+          "covered": 15,
+          "percent": 93.75
+        },
+        "regions": {
+          "count": 13,
+          "covered": 12,
+          "notcovered": 1,
+          "percent": 92.3076923076923
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
diff --git a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-link-dead-code/expected_export_coverage.coverage_of_if_else.json b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json
index 051250d90a2..410821ea335 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-link-dead-code/expected_export_coverage.coverage_of_if_else.json
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.various_conditions.json
@@ -3,7 +3,7 @@
     {
       "files": [
         {
-          "filename": "../instrument-coverage/coverage_of_if_else.rs",
+          "filename": "../coverage/various_conditions.rs",
           "summary": {
             "functions": {
               "count": 1,
@@ -16,15 +16,15 @@
               "percent": 100
             },
             "lines": {
-              "count": 40,
-              "covered": 19,
-              "percent": 47.5
+              "count": 49,
+              "covered": 23,
+              "percent": 46.93877551020408
             },
             "regions": {
-              "count": 71,
-              "covered": 23,
-              "notcovered": 48,
-              "percent": 32.3943661971831
+              "count": 51,
+              "covered": 19,
+              "notcovered": 32,
+              "percent": 37.254901960784316
             }
           }
         }
@@ -41,15 +41,15 @@
           "percent": 100
         },
         "lines": {
-          "count": 40,
-          "covered": 19,
-          "percent": 47.5
+          "count": 49,
+          "covered": 23,
+          "percent": 46.93877551020408
         },
         "regions": {
-          "count": 71,
-          "covered": 23,
-          "notcovered": 48,
-          "percent": 32.3943661971831
+          "count": 51,
+          "covered": 19,
+          "notcovered": 32,
+          "percent": 37.254901960784316
         }
       }
     }
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
new file mode 100644
index 00000000000..865b705fa20
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_export_coverage.while_early_return.json
@@ -0,0 +1,59 @@
+{
+  "data": [
+    {
+      "files": [
+        {
+          "filename": "../coverage/while_early_return.rs",
+          "summary": {
+            "functions": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "instantiations": {
+              "count": 1,
+              "covered": 1,
+              "percent": 100
+            },
+            "lines": {
+              "count": 18,
+              "covered": 16,
+              "percent": 88.88888888888889
+            },
+            "regions": {
+              "count": 9,
+              "covered": 7,
+              "notcovered": 2,
+              "percent": 77.77777777777779
+            }
+          }
+        }
+      ],
+      "totals": {
+        "functions": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "instantiations": {
+          "count": 1,
+          "covered": 1,
+          "percent": 100
+        },
+        "lines": {
+          "count": 18,
+          "covered": 16,
+          "percent": 88.88888888888889
+        },
+        "regions": {
+          "count": 9,
+          "covered": 7,
+          "notcovered": 2,
+          "percent": 77.77777777777779
+        }
+      }
+    }
+  ],
+  "type": "llvm.coverage.json.export",
+  "version": "2.0.1"
+}
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
new file mode 100644
index 00000000000..17054490e9b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.closure.txt
@@ -0,0 +1,94 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|      1|fn main() {
+    4|      1|    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|      1|    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|      1|    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|    let is_false = ! is_true;
+    9|      1|
+   10|      1|    let mut some_string = Some(String::from("the string content"));
+   11|      1|    println!(
+   12|      1|        "The string or alt: {}"
+   13|      1|        ,
+   14|      1|        some_string
+   15|      1|            .
+   16|      1|            unwrap_or_else
+   17|      1|        (
+   18|      1|            ||
+   19|       |            {
+   20|      0|                let mut countdown = 0;
+   21|      0|                if is_false {
+   22|      0|                    countdown = 10;
+   23|      0|                }
+   24|      0|                "alt string 1".to_owned()
+   25|      1|            }
+   26|      1|        )
+   27|      1|    );
+   28|      1|
+   29|      1|    some_string = Some(String::from("the string content"));
+   30|      1|    let
+   31|      1|        a
+   32|      1|    =
+   33|      1|        ||
+   34|       |    {
+   35|      0|        let mut countdown = 0;
+   36|      0|        if is_false {
+   37|      0|            countdown = 10;
+   38|      0|        }
+   39|      0|        "alt string 2".to_owned()
+   40|      1|    };
+   41|      1|    println!(
+   42|      1|        "The string or alt: {}"
+   43|      1|        ,
+   44|      1|        some_string
+   45|      1|            .
+   46|      1|            unwrap_or_else
+   47|      1|        (
+   48|      1|            a
+   49|      1|        )
+   50|      1|    );
+   51|      1|
+   52|      1|    some_string = None;
+   53|      1|    println!(
+   54|      1|        "The string or alt: {}"
+   55|      1|        ,
+   56|      1|        some_string
+   57|      1|            .
+   58|      1|            unwrap_or_else
+   59|      1|        (
+   60|      1|            ||
+   61|       |            {
+   62|      1|                let mut countdown = 0;
+   63|      1|                if is_false {
+   64|      0|                    countdown = 10;
+   65|      0|                }
+   66|      1|                "alt string 3".to_owned()
+   67|      1|            }
+   68|      1|        )
+   69|      1|    );
+   70|      1|
+   71|      1|    some_string = None;
+   72|      1|    let
+   73|      1|        a
+   74|      1|    =
+   75|      1|        ||
+   76|       |    {
+   77|      1|        let mut countdown = 0;
+   78|      1|        if is_false {
+   79|      0|            countdown = 10;
+   80|      0|        }
+   81|      1|        "alt string 4".to_owned()
+   82|      1|    };
+   83|      1|    println!(
+   84|      1|        "The string or alt: {}"
+   85|      1|        ,
+   86|      1|        some_string
+   87|      1|            .
+   88|      1|            unwrap_or_else
+   89|      1|        (
+   90|      1|            a
+   91|      1|        )
+   92|      1|    );
+   93|      1|}
+
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
new file mode 100644
index 00000000000..72aa020ca16
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.drop_trait.txt
@@ -0,0 +1,34 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |struct Firework {
+    5|       |    strength: i32,
+    6|       |}
+    7|       |
+    8|       |impl Drop for Firework {
+    9|      2|    fn drop(&mut self) {
+   10|      2|        println!("BOOM times {}!!!", self.strength);
+   11|      2|    }
+   12|       |}
+   13|       |
+   14|       |fn main() -> Result<(),u8> {
+   15|      1|    let _firecracker = Firework { strength: 1 };
+   16|      1|
+   17|      1|    let _tnt = Firework { strength: 100 };
+   18|       |
+   19|      1|    if true {
+   20|      1|        println!("Exiting with error...");
+   21|      1|        return Err(1);
+   22|       |    }
+   23|       |
+   24|       |    let _ = Firework { strength: 1000 };
+   25|       |
+   26|       |    Ok(())
+   27|      1|}
+   28|       |
+   29|       |// Expected program output:
+   30|       |//   Exiting with error...
+   31|       |//   BOOM times 100!!!
+   32|       |//   BOOM times 1!!!
+   33|       |//   Error: 1
+
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
new file mode 100644
index 00000000000..86199d74763
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.generics.txt
@@ -0,0 +1,67 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |struct Firework<T> where T: Copy + std::fmt::Display {
+    5|       |    strength: T,
+    6|       |}
+    7|       |
+    8|       |impl<T> Firework<T> where T: Copy + std::fmt::Display {
+    9|       |    #[inline(always)]
+   10|      3|    fn set_strength(&mut self, new_strength: T) {
+   11|      3|        self.strength = new_strength;
+   12|      3|    }
+  ------------------
+  | <generics::Firework<f64>>::set_strength:
+  |   10|      2|    fn set_strength(&mut self, new_strength: T) {
+  |   11|      2|        self.strength = new_strength;
+  |   12|      2|    }
+  ------------------
+  | <generics::Firework<i32>>::set_strength:
+  |   10|      1|    fn set_strength(&mut self, new_strength: T) {
+  |   11|      1|        self.strength = new_strength;
+  |   12|      1|    }
+  ------------------
+   13|       |}
+   14|       |
+   15|       |impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display {
+   16|       |    #[inline(always)]
+   17|      2|    fn drop(&mut self) {
+   18|      2|        println!("BOOM times {}!!!", self.strength);
+   19|      2|    }
+  ------------------
+  | <generics::Firework<i32> as core::ops::drop::Drop>::drop:
+  |   17|      1|    fn drop(&mut self) {
+  |   18|      1|        println!("BOOM times {}!!!", self.strength);
+  |   19|      1|    }
+  ------------------
+  | <generics::Firework<f64> as core::ops::drop::Drop>::drop:
+  |   17|      1|    fn drop(&mut self) {
+  |   18|      1|        println!("BOOM times {}!!!", self.strength);
+  |   19|      1|    }
+  ------------------
+   20|       |}
+   21|       |
+   22|       |fn main() -> Result<(),u8> {
+   23|      1|    let mut firecracker = Firework { strength: 1 };
+   24|      1|    firecracker.set_strength(2);
+   25|      1|
+   26|      1|    let mut tnt = Firework { strength: 100.1 };
+   27|      1|    tnt.set_strength(200.1);
+   28|      1|    tnt.set_strength(300.3);
+   29|       |
+   30|      1|    if true {
+   31|      1|        println!("Exiting with error...");
+   32|      1|        return Err(1);
+   33|       |    }
+   34|       |
+   35|       |    let _ = Firework { strength: 1000 };
+   36|       |
+   37|       |    Ok(())
+   38|      1|}
+   39|       |
+   40|       |// Expected program output:
+   41|       |//   Exiting with error...
+   42|       |//   BOOM times 100!!!
+   43|       |//   BOOM times 1!!!
+   44|       |//   Error: 1
+
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
new file mode 100644
index 00000000000..bc2f9b108b2
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if.txt
@@ -0,0 +1,29 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|       |    let
+    8|      1|    is_true
+    9|      1|    =
+   10|      1|        std::env::args().len()
+   11|      1|    ==
+   12|      1|        1
+   13|      1|    ;
+   14|      1|    let
+   15|      1|        mut
+   16|      1|    countdown
+   17|      1|    =
+   18|      1|        0
+   19|       |    ;
+   20|       |    if
+   21|      1|        is_true
+   22|      1|    {
+   23|      1|        countdown
+   24|      1|        =
+   25|      1|            10
+   26|      1|        ;
+   27|      1|    }
+   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
new file mode 100644
index 00000000000..5f899723e25
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.if_else.txt
@@ -0,0 +1,41 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 0;
+   10|      1|    if
+   11|      1|        is_true
+   12|      1|    {
+   13|      1|        countdown
+   14|      1|        =
+   15|      1|            10
+   16|      1|        ;
+   17|      1|    }
+   18|       |    else // Note coverage region difference without semicolon
+   19|       |    {
+   20|      0|        countdown
+   21|      0|        =
+   22|      0|            100
+   23|       |    }
+   24|       |
+   25|       |    if
+   26|      1|        is_true
+   27|      1|    {
+   28|      1|        countdown
+   29|      1|        =
+   30|      1|            10
+   31|      1|        ;
+   32|      1|    }
+   33|       |    else
+   34|      0|    {
+   35|      0|        countdown
+   36|      0|        =
+   37|      0|            100
+   38|      0|        ;
+   39|      0|    }
+   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
new file mode 100644
index 00000000000..b13ca83d018
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.inner_items.txt
@@ -0,0 +1,58 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 0;
+   10|      1|    if is_true {
+   11|      1|        countdown = 10;
+   12|      1|    }
+   13|       |
+   14|       |    mod in_mod {
+   15|       |        const IN_MOD_CONST: u32 = 1000;
+   16|       |    }
+   17|       |
+   18|       |    fn in_func(a: u32) {
+   19|      3|        let b = 1;
+   20|      3|        let c = a + b;
+   21|      3|        println!("c = {}", c)
+   22|      3|    }
+   23|       |
+   24|       |    struct InStruct {
+   25|       |        in_struct_field: u32,
+   26|       |    }
+   27|       |
+   28|       |    const IN_CONST: u32 = 1234;
+   29|       |
+   30|       |    trait InTrait {
+   31|       |        fn trait_func(&mut self, incr: u32);
+   32|       |
+   33|      1|        fn default_trait_func(&mut self) {
+   34|      1|            in_func(IN_CONST);
+   35|      1|            self.trait_func(IN_CONST);
+   36|      1|        }
+   37|       |    }
+   38|       |
+   39|       |    impl InTrait for InStruct {
+   40|       |        fn trait_func(&mut self, incr: u32) {
+   41|      1|            self.in_struct_field += incr;
+   42|      1|            in_func(self.in_struct_field);
+   43|      1|        }
+   44|       |    }
+   45|       |
+   46|       |    type InType = String;
+   47|       |
+   48|      1|    if is_true {
+   49|      1|        in_func(countdown);
+   50|      1|    }
+   51|       |
+   52|      1|    let mut val = InStruct {
+   53|      1|        in_struct_field: 101,
+   54|      1|    };
+   55|      1|
+   56|      1|    val.default_trait_func();
+   57|      1|}
+
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
new file mode 100644
index 00000000000..ded43697515
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.lazy_boolean.txt
@@ -0,0 +1,44 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let (mut a, mut b, mut c) = (0, 0, 0);
+   10|      1|    if is_true {
+   11|      1|        a = 1;
+   12|      1|        b = 10;
+   13|      1|        c = 100;
+   14|      1|    }
+   15|       |    let
+   16|      1|        somebool
+   17|       |        =
+   18|      1|            a < b
+   19|       |        ||
+   20|      0|            b < c
+   21|       |    ;
+   22|       |    let
+   23|      1|        somebool
+   24|       |        =
+   25|      1|            b < a
+   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|}
+
diff --git a/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loop_break_value.txt b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loop_break_value.txt
new file mode 100644
index 00000000000..b0d668c6d76
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.loop_break_value.txt
@@ -0,0 +1,14 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|      1|fn main() {
+    4|      1|    let result
+    5|      1|        =
+    6|      1|            loop
+    7|      1|        {
+    8|      1|            break
+    9|      1|            10
+   10|      1|            ;
+   11|      1|        }
+   12|      1|    ;
+   13|      1|}
+
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
new file mode 100644
index 00000000000..f1acb7c5459
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_loop.txt
@@ -0,0 +1,36 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 0;
+   10|       |
+   11|       |    if
+   12|      1|        is_true
+   13|      1|    {
+   14|      1|        countdown
+   15|      1|        =
+   16|      1|            10
+   17|      1|        ;
+   18|      1|    }
+   19|       |
+   20|       |    loop
+   21|       |    {
+   22|       |        if
+   23|     11|            countdown
+   24|     11|                ==
+   25|     11|            0
+   26|       |        {
+   27|      1|            break
+   28|       |            ;
+   29|       |        }
+   30|     10|        countdown
+   31|     10|        -=
+   32|     10|        1
+   33|       |        ;
+   34|       |    }
+   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
new file mode 100644
index 00000000000..e42f22cd047
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.simple_match.txt
@@ -0,0 +1,44 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |
+    3|       |fn main() {
+    4|       |    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    5|       |    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    6|       |    // dependent conditions.
+    7|      1|    let is_true = std::env::args().len() == 1;
+    8|      1|
+    9|      1|    let mut countdown = 1;
+   10|      1|    if is_true {
+   11|      1|        countdown = 0;
+   12|      1|    }
+   13|       |
+   14|      3|    for
+   15|      3|        _
+   16|       |    in
+   17|      1|        0..2
+   18|       |    {
+   19|       |        let z
+   20|       |        ;
+   21|       |        match
+   22|      2|            countdown
+   23|      2|        {
+   24|      2|            x
+   25|      2|            if
+   26|      2|                x
+   27|      2|                    <
+   28|      2|                1
+   29|       |            =>
+   30|      1|            {
+   31|      1|                z = countdown
+   32|      1|                ;
+   33|      1|                let y = countdown
+   34|      1|                ;
+   35|      1|                countdown = 10
+   36|      1|                ;
+   37|      1|            }
+   38|       |            _
+   39|       |            =>
+   40|      1|            {}
+   41|       |        }
+   42|       |    }
+   43|      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
new file mode 100644
index 00000000000..ae288d7d7a0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.try_error_result.txt
@@ -0,0 +1,36 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |fn call(return_error: bool) -> Result<(),()> {
+    5|      6|    if return_error {
+    6|      1|        Err(())
+    7|       |    } else {
+    8|      5|        Ok(())
+    9|       |    }
+   10|      6|}
+   11|       |
+   12|       |fn main() -> Result<(),()> {
+   13|      1|    let mut
+   14|      1|        countdown = 10
+   15|       |    ;
+   16|      6|    for
+   17|      6|        _
+   18|       |    in
+   19|      1|        0..10
+   20|       |    {
+   21|      6|        countdown
+   22|      6|            -= 1
+   23|       |        ;
+   24|       |        if
+   25|      6|            countdown < 5
+   26|       |        {
+   27|      1|            call(/*return_error=*/ true)?;
+   28|       |        }
+   29|       |        else
+   30|       |        {
+   31|      5|            call(/*return_error=*/ false)?;
+   32|       |        }
+   33|       |    }
+   34|      0|    Ok(())
+   35|      1|}
+
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
new file mode 100644
index 00000000000..173ff4aa4c4
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.various_conditions.txt
@@ -0,0 +1,69 @@
+    1|       |#![allow(unused_assignments, unused_variables)]
+    2|       |
+    3|       |fn main() {
+    4|      1|    let mut countdown = 0;
+    5|      1|    if true {
+    6|      1|        countdown = 10;
+    7|      1|    }
+    8|       |
+    9|       |    const B: u32 = 100;
+   10|      1|    let x = if countdown > 7 {
+   11|      1|        countdown -= 4;
+   12|      1|        B
+   13|      0|    } else if countdown > 2 {
+   14|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   15|      0|            countdown = 0;
+   16|      0|        }
+   17|      0|        countdown -= 5;
+   18|      0|        countdown
+   19|       |    } else {
+   20|      0|        return;
+   21|       |    };
+   22|       |
+   23|      1|    let mut countdown = 0;
+   24|      1|    if true {
+   25|      1|        countdown = 10;
+   26|      1|    }
+   27|       |
+   28|      1|    if countdown > 7 {
+   29|      1|        countdown -= 4;
+   30|      0|    } else if countdown > 2 {
+   31|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   32|      0|            countdown = 0;
+   33|      0|        }
+   34|      0|        countdown -= 5;
+   35|       |    } else {
+   36|      0|        return;
+   37|       |    }
+   38|       |
+   39|      1|    let mut countdown = 0;
+   40|      1|    if true {
+   41|      1|        countdown = 1;
+   42|      1|    }
+   43|       |
+   44|      1|    let z = if countdown > 7 {
+                      ^0
+   45|      0|        countdown -= 4;
+   46|      1|    } else if countdown > 2 {
+   47|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   48|      0|            countdown = 0;
+   49|      0|        }
+   50|      0|        countdown -= 5;
+   51|       |    } else {
+   52|      1|        let should_be_reachable = countdown;
+   53|      1|        println!("reached");
+   54|      1|        return;
+   55|       |    };
+   56|       |
+   57|      0|    let w = if countdown > 7 {
+   58|      0|        countdown -= 4;
+   59|      0|    } else if countdown > 2 {
+   60|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
+   61|      0|            countdown = 0;
+   62|      0|        }
+   63|      0|        countdown -= 5;
+   64|       |    } else {
+   65|      0|        return;
+   66|       |    };
+   67|      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
new file mode 100644
index 00000000000..7dce94f25f3
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-reports-deadcode/expected_show_coverage.while_early_return.txt
@@ -0,0 +1,48 @@
+    1|       |#![allow(unused_assignments)]
+    2|       |// expect-exit-status-1
+    3|       |
+    4|       |fn main() -> Result<(),u8> {
+    5|      1|    let mut countdown = 10;
+    6|      7|    while
+    7|      7|        countdown
+    8|      7|            >
+    9|      7|        0
+   10|       |    {
+   11|       |        if
+   12|      7|            countdown
+   13|      7|                <
+   14|      7|            5
+   15|       |        {
+   16|       |            return
+   17|       |                if
+   18|      1|                    countdown
+   19|      1|                        >
+   20|      1|                    8
+   21|       |                {
+   22|      0|                    Ok(())
+   23|       |                }
+   24|       |                else
+   25|       |                {
+   26|      1|                    Err(1)
+   27|       |                }
+   28|       |                ;
+   29|       |        }
+   30|      6|        countdown
+   31|      6|            -=
+   32|      6|        1
+   33|       |        ;
+   34|       |    }
+   35|      0|    Ok(())
+   36|      1|}
+   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
+   40|       |// and MacOS. But on Windows (MSVC, at least), the call to `std::process::exit()` exits the program
+   41|       |// without saving the InstrProf coverage counters. The use of `std::process:exit()` is not critical
+   42|       |// to the coverage test for early returns, but this is a limitation that should be fixed.
+   43|       |//
+   44|       |// FIXME(richkadel): Consider creating a new tests for coverage when calling `std::process::exit()`,
+   45|       |// move the `ISSUE` comment to that test, and implement a new test directive that supports skipping
+   46|       |// coverage tests when targeting specific platforms (at least skipping Windows, or MSVC if the
+   47|       |// problem exists on MSVC only).
+
diff --git a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/Makefile b/src/test/run-make-fulldeps/coverage-spanview-base/Makefile
index 5cd425979ea..fa2f4ec394e 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/Makefile
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/Makefile
@@ -2,11 +2,11 @@
 
 # ISSUE(76038): When targeting MSVC, Rust binaries built with both `-Z instrument-coverage` and
 # `-C link-dead-code` typically crash (with a seg-fault) or at best generate an empty `*.profraw`.
-# See ../instrument-coverage/coverage_tools.mk for more information.
+# See ../coverage/coverage_tools.mk for more information.
 
--include ../instrument-coverage/coverage_tools.mk
+-include ../coverage/coverage_tools.mk
 
-SOURCEDIR=../instrument-coverage
+SOURCEDIR=../coverage
 
 all: $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs))
 
@@ -20,12 +20,9 @@ endif
 -include clear_expected_if_blessed
 
 %: $(SOURCEDIR)/%.rs
-	# Compile the test program with "experimental" coverage instrumentation and generate relevant MIR.
-	#
-	# FIXME(richkadel): `-Zexperimental-coverage` to `-Zinstrument-coverage` once we are
-	# satisfied with the branch-level instrumentation.
+	# Compile the test program with coverage instrumentation and generate relevant MIR.
 	$(RUSTC) $(SOURCEDIR)/$@.rs \
-			-Zexperimental-coverage \
+			-Zinstrument-coverage \
 			-Clink-dead-code=$(LINK_DEAD_CODE) \
 			-Zdump-mir=InstrumentCoverage \
 			-Zdump-mir-dir="$(TMPDIR)"/mir_dump.$@
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
new file mode 100644
index 00000000000..43f75c574d0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{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 32"><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">        let </span><span><span class="code even" style="--layer: 1" title="35:29-35:30: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
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
new file mode 100644
index 00000000000..8f07ec5fcde
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{closure#1} - 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 74"><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">        let </span><span><span class="code even" style="--layer: 1" title="77:29-77:30: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
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
new file mode 100644
index 00000000000..ca9031a1094
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{closure#2} - 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 17"><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">                let </span><span><span class="code even" style="--layer: 1" title="20:37-20:38: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
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
new file mode 100644
index 00000000000..820f8d9c6cf
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{closure#3} - 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 59"><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">                let </span><span><span class="code even" style="--layer: 1" title="62:37-62:38: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..f70576ca24e
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,4505 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span>{</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    // Initialize test constants in a way that cannot be determined at compile time, to ensure</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    // dependent conditions.</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    let 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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    let is_false = ! is_true;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    let mut some_string = Some(String::from("the string content"));</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                }</span></span>
+<span class="line"><span class="code" style="--layer: 0">                "alt string 1".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    some_string = Some(String::from("the string content"));</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    let</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">        a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    =</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">        <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span></span>
+<span class="line"><span class="code" style="--layer: 0">        "alt string 2".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span>;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    some_string = None;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                }</span></span>
+<span class="line"><span class="code" style="--layer: 0">                "alt string 3".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    some_string = None;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    let</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">        a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    =</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">        <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span></span>
+<span class="line"><span class="code" style="--layer: 0">        "alt string 4".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span>;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">            a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</span></span></span></span></div>
+</body>
+</html>
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
new file mode 100644
index 00000000000..494e6f20ea7
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>drop_trait.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 13"><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="15:24-15:48: @0[1]: _1 = Firework { strength: const 1_i32 }
+15:9-15:21: @0[2]: FakeRead(ForLet, _1)
+17:16-17:42: @0[4]: _2 = Firework { strength: const 100_i32 }
+17:9-17:13: @0[5]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>_firecracker = Firework { strength: 1 };</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="15:24-15:48: @0[1]: _1 = Firework { strength: const 1_i32 }
+15:9-15:21: @0[2]: FakeRead(ForLet, _1)
+17:16-17:42: @0[4]: _2 = Firework { strength: const 100_i32 }
+17:9-17:13: @0[5]: FakeRead(ForLet, _2)"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="15:24-15:48: @0[1]: _1 = Firework { strength: const 1_i32 }
+15:9-15:21: @0[2]: FakeRead(ForLet, _1)
+17:16-17:42: @0[4]: _2 = Firework { strength: const 100_i32 }
+17:9-17:13: @0[5]: FakeRead(ForLet, _2)">    let _tnt = Firework { strength: 100 }<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="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="19:8-19:12: @0[8]: _4 = const true
+19:8-19:12: @0[9]: 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">        </span><span><span class="code odd" style="--layer: 1" title="20:18-20:41: @3[6]: _21 = const main::promoted[1]
+20:18-20:41: @3[7]: _11 = &amp;(*_21)
+20:18-20:41: @3[8]: _10 = &amp;(*_11)
+20:18-20:41: @3[9]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+20:9-20:43: @3[15]: _17 = ()
+20:9-20:43: @3[16]: FakeRead(ForMatchedPlace, _17)
+20:9-20:43: @3[17]: _20 = const main::promoted[0]
+20:9-20:43: @3[18]: _15 = &amp;(*_20)
+20:9-20:43: @3[19]: _14 = &amp;(*_15)
+20:9-20:43: @3[20]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+20:9-20:43: @3.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb4, unwind: bb12]
+20:9-20:43: @4.Call: _7 = _print(move _8) -&gt; [return: bb5, unwind: bb12]
+20:9-20:43: @5[5]: _6 = const ()
+21:16-21:22: @5[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@1,3,4,5,9,10⦊</span>println!("Exiting with error...");</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="20:18-20:41: @3[6]: _21 = const main::promoted[1]
+20:18-20:41: @3[7]: _11 = &amp;(*_21)
+20:18-20:41: @3[8]: _10 = &amp;(*_11)
+20:18-20:41: @3[9]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+20:9-20:43: @3[15]: _17 = ()
+20:9-20:43: @3[16]: FakeRead(ForMatchedPlace, _17)
+20:9-20:43: @3[17]: _20 = const main::promoted[0]
+20:9-20:43: @3[18]: _15 = &amp;(*_20)
+20:9-20:43: @3[19]: _14 = &amp;(*_15)
+20:9-20:43: @3[20]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+20:9-20:43: @3.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb4, unwind: bb12]
+20:9-20:43: @4.Call: _7 = _print(move _8) -&gt; [return: bb5, unwind: bb12]
+20:9-20:43: @5[5]: _6 = const ()
+21:16-21:22: @5[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)">        return Err(1)<span class="annotation">⦉@1,3,4,5,9,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="line"><span class="code" style="--layer: 0">    let _ = </span><span><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)"><span class="annotation">@2,6,7,8⦊</span>Firework { strength: 1000 };</span></span>
+<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)"></span></span>
+<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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..9530d12fb49
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html
@@ -0,0 +1,123 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>drop_trait.{impl#0}-drop - 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 drop(&amp;mut self) </span><span><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as Drop&gt;::drop::promoted[0]
+10:18-10:36: @0[7]: _7 = &amp;(*_19)
+10:18-10:36: @0[8]: _6 = &amp;(*_7)
+10:18-10:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+10:38-10:51: @0[17]: _14 = &amp;((*_1).0: i32)
+10:9-10:53: @0[18]: _13 = (move _14,)
+10:9-10:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+10:9-10:53: @0[22]: _15 = (_13.0: &amp;i32)
+10:9-10:53: @0[25]: _17 = &amp;(*_15)
+10:9-10:53: @0[27]: _18 = &lt;i32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r i32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+10:9-10:53: @0.Call: _16 = ArgumentV1::new::&lt;i32&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+10:9-10:53: @1[2]: _12 = [move _16]
+10:9-10:53: @1[5]: _11 = &amp;_12
+10:9-10:53: @1[6]: _10 = &amp;(*_11)
+10:9-10:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+10:9-10:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+10:9-10:53: @3[6]: _2 = const ()
+9:24-11:6: @3[8]: _0 = const ()
+11:6-11:6: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as Drop&gt;::drop::promoted[0]
+10:18-10:36: @0[7]: _7 = &amp;(*_19)
+10:18-10:36: @0[8]: _6 = &amp;(*_7)
+10:18-10:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+10:38-10:51: @0[17]: _14 = &amp;((*_1).0: i32)
+10:9-10:53: @0[18]: _13 = (move _14,)
+10:9-10:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+10:9-10:53: @0[22]: _15 = (_13.0: &amp;i32)
+10:9-10:53: @0[25]: _17 = &amp;(*_15)
+10:9-10:53: @0[27]: _18 = &lt;i32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r i32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+10:9-10:53: @0.Call: _16 = ArgumentV1::new::&lt;i32&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+10:9-10:53: @1[2]: _12 = [move _16]
+10:9-10:53: @1[5]: _11 = &amp;_12
+10:9-10:53: @1[6]: _10 = &amp;(*_11)
+10:9-10:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+10:9-10:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+10:9-10:53: @3[6]: _2 = const ()
+9:24-11:6: @3[8]: _0 = const ()
+11:6-11:6: @3.Return: return">        println!("BOOM times {}!!!", self.strength);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as Drop&gt;::drop::promoted[0]
+10:18-10:36: @0[7]: _7 = &amp;(*_19)
+10:18-10:36: @0[8]: _6 = &amp;(*_7)
+10:18-10:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+10:38-10:51: @0[17]: _14 = &amp;((*_1).0: i32)
+10:9-10:53: @0[18]: _13 = (move _14,)
+10:9-10:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+10:9-10:53: @0[22]: _15 = (_13.0: &amp;i32)
+10:9-10:53: @0[25]: _17 = &amp;(*_15)
+10:9-10:53: @0[27]: _18 = &lt;i32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r i32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+10:9-10:53: @0.Call: _16 = ArgumentV1::new::&lt;i32&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+10:9-10:53: @1[2]: _12 = [move _16]
+10:9-10:53: @1[5]: _11 = &amp;_12
+10:9-10:53: @1[6]: _10 = &amp;(*_11)
+10:9-10:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+10:9-10:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+10:9-10:53: @3[6]: _2 = const ()
+9:24-11:6: @3[8]: _0 = const ()
+11:6-11:6: @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.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..6dc893d28ff
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,167 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>generics.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() -&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="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]"><span class="annotation">@0,1,2,3⦊</span>mut firecracker = Firework { strength: 1 };</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    firecracker.set_strength(2);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    let mut tnt = Firework { strength: 100.1 };</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    tnt.set_strength(200.1);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    tnt.set_strength(300.3)<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">    if </span><span><span class="code even" style="--layer: 1" title="30:8-30:12: @3[4]: _10 = const true
+30:8-30:12: @3[5]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@0,1,2,3⦊</span>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="31:18-31:41: @6[6]: _27 = const main::promoted[1]
+31:18-31:41: @6[7]: _17 = &amp;(*_27)
+31:18-31:41: @6[8]: _16 = &amp;(*_17)
+31:18-31:41: @6[9]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
+31:9-31:43: @6[15]: _23 = ()
+31:9-31:43: @6[16]: FakeRead(ForMatchedPlace, _23)
+31:9-31:43: @6[17]: _26 = const main::promoted[0]
+31:9-31:43: @6[18]: _21 = &amp;(*_26)
+31:9-31:43: @6[19]: _20 = &amp;(*_21)
+31:9-31:43: @6[20]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+31:9-31:43: @6.Call: _14 = Arguments::new_v1(move _15, move _19) -&gt; [return: bb7, unwind: bb15]
+31:9-31:43: @7.Call: _13 = _print(move _14) -&gt; [return: bb8, unwind: bb15]
+31:9-31:43: @8[5]: _12 = const ()
+32:16-32:22: @8[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@4,6,7,8,12,13⦊</span>println!("Exiting with error...");</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="31:18-31:41: @6[6]: _27 = const main::promoted[1]
+31:18-31:41: @6[7]: _17 = &amp;(*_27)
+31:18-31:41: @6[8]: _16 = &amp;(*_17)
+31:18-31:41: @6[9]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
+31:9-31:43: @6[15]: _23 = ()
+31:9-31:43: @6[16]: FakeRead(ForMatchedPlace, _23)
+31:9-31:43: @6[17]: _26 = const main::promoted[0]
+31:9-31:43: @6[18]: _21 = &amp;(*_26)
+31:9-31:43: @6[19]: _20 = &amp;(*_21)
+31:9-31:43: @6[20]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+31:9-31:43: @6.Call: _14 = Arguments::new_v1(move _15, move _19) -&gt; [return: bb7, unwind: bb15]
+31:9-31:43: @7.Call: _13 = _print(move _14) -&gt; [return: bb8, unwind: bb15]
+31:9-31:43: @8[5]: _12 = const ()
+32:16-32:22: @8[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)">        return Err(1)<span class="annotation">⦉@4,6,7,8,12,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">    let _ = </span><span><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)"><span class="annotation">@5,9,10,11⦊</span>Firework { strength: 1000 };</span></span>
+<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)"></span></span>
+<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>
+</body>
+</html>
diff --git a/src/test/mir-opt/spanview_block.main.mir_map.0.html.mir b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html
index f8ecf143767..e31e47b81d4 100644
--- a/src/test/mir-opt/spanview_block.main.mir_map.0.html.mir
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html
@@ -1,8 +1,8 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>coverage_of_if_else - Code Regions</title>
-    <style>
+<title>generics.{impl#0}-set_strength - Coverage Spans</title>
+<style>
     .line {
         counter-increment: line;
     }
@@ -56,11 +56,20 @@
         /* requires hover over a span ONLY on its first line */
         display: inline-block;
     }
-    </style>
+</style>
 </head>
 <body>
-<div class="code" style="counter-reset: line 4"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="0: $DIR/spanview-block.rs:5:11: 5:13:
-    5:11-5:13: Assign: _0 = const ()
-    5:13-5:13: Return: return"><span class="annotation">0⦊</span>{}<span class="annotation">⦉0</span></span></span></span></div>
+<div class="code" style="counter-reset: line 9"><span class="line">    <span class="code" style="--layer: 0">fn set_strength(&amp;mut self, new_strength: T) </span><span><span class="code even" style="--layer: 1" title="11:25-11:37: @0[1]: _3 = _2
+11:9-11:37: @0[2]: ((*_1).0: T) = move _3
+10:49-12:6: @0[4]: _0 = const ()
+12:6-12:6: @0.Return: return"><span class="annotation">@0⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="11:25-11:37: @0[1]: _3 = _2
+11:9-11:37: @0[2]: ((*_1).0: T) = move _3
+10:49-12:6: @0[4]: _0 = const ()
+12:6-12:6: @0.Return: return">        self.strength = new_strength;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="11:25-11:37: @0[1]: _3 = _2
+11:9-11:37: @0[2]: ((*_1).0: T) = move _3
+10:49-12:6: @0[4]: _0 = const ()
+12:6-12: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.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..99a7df4a670
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html
@@ -0,0 +1,123 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>generics.{impl#1}-drop - 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 16"><span class="line">    <span class="code" style="--layer: 0">fn drop(&amp;mut self) </span><span><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const &lt;Firework&lt;T&gt; as Drop&gt;::drop::promoted[0]
+18:18-18:36: @0[7]: _7 = &amp;(*_19)
+18:18-18:36: @0[8]: _6 = &amp;(*_7)
+18:18-18:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+18:38-18:51: @0[17]: _14 = &amp;((*_1).0: T)
+18:9-18:53: @0[18]: _13 = (move _14,)
+18:9-18:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+18:9-18:53: @0[22]: _15 = (_13.0: &amp;T)
+18:9-18:53: @0[25]: _17 = &amp;(*_15)
+18:9-18:53: @0[27]: _18 = &lt;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+18:9-18:53: @0.Call: _16 = ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+18:9-18:53: @1[2]: _12 = [move _16]
+18:9-18:53: @1[5]: _11 = &amp;_12
+18:9-18:53: @1[6]: _10 = &amp;(*_11)
+18:9-18:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+18:9-18:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+18:9-18:53: @3[6]: _2 = const ()
+17:24-19:6: @3[8]: _0 = const ()
+19:6-19:6: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const &lt;Firework&lt;T&gt; as Drop&gt;::drop::promoted[0]
+18:18-18:36: @0[7]: _7 = &amp;(*_19)
+18:18-18:36: @0[8]: _6 = &amp;(*_7)
+18:18-18:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+18:38-18:51: @0[17]: _14 = &amp;((*_1).0: T)
+18:9-18:53: @0[18]: _13 = (move _14,)
+18:9-18:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+18:9-18:53: @0[22]: _15 = (_13.0: &amp;T)
+18:9-18:53: @0[25]: _17 = &amp;(*_15)
+18:9-18:53: @0[27]: _18 = &lt;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+18:9-18:53: @0.Call: _16 = ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+18:9-18:53: @1[2]: _12 = [move _16]
+18:9-18:53: @1[5]: _11 = &amp;_12
+18:9-18:53: @1[6]: _10 = &amp;(*_11)
+18:9-18:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+18:9-18:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+18:9-18:53: @3[6]: _2 = const ()
+17:24-19:6: @3[8]: _0 = const ()
+19:6-19:6: @3.Return: return">        println!("BOOM times {}!!!", self.strength);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const &lt;Firework&lt;T&gt; as Drop&gt;::drop::promoted[0]
+18:18-18:36: @0[7]: _7 = &amp;(*_19)
+18:18-18:36: @0[8]: _6 = &amp;(*_7)
+18:18-18:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+18:38-18:51: @0[17]: _14 = &amp;((*_1).0: T)
+18:9-18:53: @0[18]: _13 = (move _14,)
+18:9-18:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+18:9-18:53: @0[22]: _15 = (_13.0: &amp;T)
+18:9-18:53: @0[25]: _17 = &amp;(*_15)
+18:9-18:53: @0[27]: _18 = &lt;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+18:9-18:53: @0.Call: _16 = ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+18:9-18:53: @1[2]: _12 = [move _16]
+18:9-18:53: @1[5]: _11 = &amp;_12
+18:9-18:53: @1[6]: _10 = &amp;(*_11)
+18:9-18:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+18:9-18:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+18:9-18:53: @3[6]: _2 = const ()
+17:24-19:6: @3[8]: _0 = const ()
+19:6-19:6: @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.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..0379d900e94
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>if.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)"><span class="annotation">@0,1,2,3⦊</span>is_true</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    =</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        std::env::args().len()</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    ==</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        1</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    let</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        mut</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    countdown</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    =</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        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">    ;</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="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>
+<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>
+<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>
+<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>
+<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>
+<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>
+</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
new file mode 100644
index 00000000000..b51c5c84c0d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>if_else.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)"><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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)"></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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)">    let mut countdown = 0;</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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)">    if</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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)">        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="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">        countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">        =</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">            10</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">        ;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = 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">    else // Note coverage region difference without semicolon</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:9-22:16: @5[0]: _5 = const 100_i32
+20:9-22:16: @5[1]: _6 = const ()"><span class="annotation">@5⦊</span>countdown</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 ()">        =</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="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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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 ()">            100</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></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" 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-InTrait-default_trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..20c54d0e6b4
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>inner_items.main-InTrait-default_trait_func - 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 32"><span class="line">        <span class="code" style="--layer: 0">fn default_trait_func(&amp;mut self) </span><span><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return">            in_func(IN_CONST);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return">            self.trait_func(IN_CONST);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return">        }<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.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
new file mode 100644
index 00000000000..49639cc6884
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
@@ -0,0 +1,107 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>inner_items.main-in_func - 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 17"><span class="line">    <span class="code" style="--layer: 0">fn in_func(a: u32) {</span></span>
+<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>
+<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)
+21:18-21:26: @1[12]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+21:28-21:29: @1[20]: _18 = &amp;_3
+21:9-21:30: @1[21]: _17 = (move _18,)
+21:9-21:30: @1[23]: FakeRead(ForMatchedPlace, _17)
+21:9-21:30: @1[25]: _19 = (_17.0: &amp;u32)
+21:9-21:30: @1[28]: _21 = &amp;(*_19)
+21:9-21:30: @1[30]: _22 = &lt;u32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r u32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+21:9-21:30: @1.Call: _20 = ArgumentV1::new::&lt;u32&gt;(move _21, move _22) -&gt; [return: bb2, unwind: bb5]
+21:9-21:30: @2[2]: _16 = [move _20]
+21:9-21:30: @2[5]: _15 = &amp;_16
+21:9-21:30: @2[6]: _14 = &amp;(*_15)
+21:9-21:30: @2[7]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
+21:9-21:30: @3.Call: _7 = _print(move _8) -&gt; [return: bb4, unwind: bb5]
+21:9-21:30: @4[6]: _0 = const ()
+22:6-22:6: @4.Return: return"><span class="annotation">@1,2,3,4⦊</span>println!("c = {}", c)</span></span>
+<span class="line"><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)
+21:18-21:26: @1[12]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+21:28-21:29: @1[20]: _18 = &amp;_3
+21:9-21:30: @1[21]: _17 = (move _18,)
+21:9-21:30: @1[23]: FakeRead(ForMatchedPlace, _17)
+21:9-21:30: @1[25]: _19 = (_17.0: &amp;u32)
+21:9-21:30: @1[28]: _21 = &amp;(*_19)
+21:9-21:30: @1[30]: _22 = &lt;u32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r u32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+21:9-21:30: @1.Call: _20 = ArgumentV1::new::&lt;u32&gt;(move _21, move _22) -&gt; [return: bb2, unwind: bb5]
+21:9-21:30: @2[2]: _16 = [move _20]
+21:9-21:30: @2[5]: _15 = &amp;_16
+21:9-21:30: @2[6]: _14 = &amp;(*_15)
+21:9-21:30: @2[7]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
+21:9-21:30: @3.Call: _7 = _print(move _8) -&gt; [return: bb4, unwind: bb5]
+21:9-21:30: @4[6]: _0 = const ()
+22:6-22:6: @4.Return: return">    }<span class="annotation">⦉@1,2,3,4</span></span></span></span></div>
+</body>
+</html>
diff --git a/src/test/mir-opt/spanview_terminator.main.mir_map.0.html.mir 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 984b021384b..a2cf86de278 100644
--- a/src/test/mir-opt/spanview_terminator.main.mir_map.0.html.mir
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
@@ -1,8 +1,8 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>coverage_of_if_else - Code Regions</title>
-    <style>
+<title>inner_items.main-{impl#0}-trait_func - Coverage Spans</title>
+<style>
     .line {
         counter-increment: line;
     }
@@ -56,10 +56,17 @@
         /* requires hover over a span ONLY on its first line */
         display: inline-block;
     }
-    </style>
+</style>
 </head>
 <body>
-<div class="code" style="counter-reset: line 4"><span class="line"><span class="code" style="--layer: 0">fn main() {}</span><span><span class="code even" style="--layer: 1" title="0:Return: $DIR/spanview-terminator.rs:5:13: 5:13:
-    5:13-5:13: Return: return"><span class="annotation">0:Return⦊</span>‸<span class="annotation">⦉0:Return</span></span></span></span></div>
+<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">            </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>
+<span class="line"><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></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.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..56557b8ef95
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,171 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>inner_items.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_u32
+9:9-9: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="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_u32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)"></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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_u32
+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>
+<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>
+<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>
+<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>
+<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">    fn in_func(a: u32) {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        let b = 1;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        let c = a + b;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        println!("c = {}", c)</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">    struct InStruct {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        in_struct_field: u32,</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">    const IN_CONST: u32 = 1234;</span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    trait InTrait {</span></span>
+<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="line"><span class="code" style="--layer: 0">        fn default_trait_func(&amp;mut self) {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            in_func(IN_CONST);</span></span>
+<span class="line"><span class="code" style="--layer: 0">            self.trait_func(IN_CONST);</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="line"><span class="code" style="--layer: 0">    impl InTrait for InStruct {</span></span>
+<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">            self.in_struct_field += incr;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            in_func(self.in_struct_field);</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="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
+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
+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
+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>
+<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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return"><span class="annotation">@12,13⦊</span>mut val = InStruct {</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">        in_struct_field: 101,</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">    };</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return"></span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">    val.default_trait_func();</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">}<span class="annotation">⦉@12,13</span></span></span></span></div>
+</body>
+</html>
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
new file mode 100644
index 00000000000..defe743df60
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>lazy_boolean.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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]
+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: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]
+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: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]
+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: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)">    let (mut a, mut b, mut c) = (0, 0, 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[12]: _10 = _1
+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>
+<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>
+<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>
+<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>
+<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>
+<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="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
+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
+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>
+<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="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
+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
+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>
+<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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..dc26c796637
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>loop_break_value.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return"><span class="annotation">@0,1⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">    let result</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">        =</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            loop</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">        {</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            break</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            10</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">        }</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">    ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">}<span class="annotation">⦉@0,1</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
new file mode 100644
index 00000000000..4b21d3fc263
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>simple_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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9: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="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)"></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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+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"></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="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>
+<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>
+<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>
+<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>
+<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>
+<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>
+<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
+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
+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
+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="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="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: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
new file mode 100644
index 00000000000..5ba770ef607
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,190 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>simple_match.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb22]
+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: bb21]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 1_i32
+9:9-9: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="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb22]
+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: bb21]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 1_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)"></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: bb22]
+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: bb21]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 1_i32
+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>
+<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>
+<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>
+<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">    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="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)
+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" 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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()"><span class="annotation">@18⦊</span>{</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                z = countdown</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                ;</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                let y = countdown</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                ;</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                countdown = 10</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                ;</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">            }<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">            =&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="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.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
new file mode 100644
index 00000000000..9f993342340
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>try_error_result.call - 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 class="code" style="--layer: 0">fn call(return_error: bool) -&gt; Result&lt;(),()&gt; {</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:20: @0[1]: _2 = _1
+5:8-5:20: @0[2]: FakeRead(ForMatchedPlace, _2)"><span class="annotation">@0⦊</span>return_error<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="6:13-6:15: @3[1]: _3 = ()
+6:9-6:16: @3[2]: _0 = std::result::Result::&lt;(), ()&gt;::Err(move _3)"><span class="annotation">@1,3⦊</span>Err(())<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">    } 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>
+</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
new file mode 100644
index 00000000000..660c3031f35
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>try_error_result.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 11"><span class="line"><span class="code" style="--layer: 0">fn main() -&gt; Result&lt;(),()&gt; {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><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)"><span class="annotation">@0,1⦊</span>mut</span></span>
+<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">    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="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
+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>
+<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="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 = ()
+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>
+</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
new file mode 100644
index 00000000000..28f1d013c83
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,228 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>various_conditions.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 2"><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="4:25-4:26: @0[1]: _1 = const 0_u32
+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>
+<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>
+<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>
+<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
+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">    } 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>
+<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>
+<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>
+<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>
+<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="23:25-23:26: @25[3]: _21 = const 0_i32
+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>
+<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>
+<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>
+<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
+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
+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">    } 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>
+<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="39:25-39:26: @50[3]: _41 = const 0_i32
+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>
+<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>
+<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>
+<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
+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
+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">    } 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)
+53:18-53:27: @60[9]: _92 = const main::promoted[1]
+53:18-53:27: @60[10]: _67 = &amp;(*_92)
+53:18-53:27: @60[11]: _66 = &amp;(*_67)
+53:18-53:27: @60[12]: _65 = move _66 as &amp;[&amp;str] (Pointer(Unsize))
+53:9-53:29: @60[18]: _73 = ()
+53:9-53:29: @60[19]: FakeRead(ForMatchedPlace, _73)
+53:9-53:29: @60[20]: _91 = const main::promoted[0]
+53:9-53:29: @60[21]: _71 = &amp;(*_91)
+53:9-53:29: @60[22]: _70 = &amp;(*_71)
+53:9-53:29: @60[23]: _69 = move _70 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:9-53:29: @60.Call: _64 = Arguments::new_v1(move _65, move _69) -&gt; [return: bb75, unwind: bb103]
+53:9-53:29: @75.Call: _63 = _print(move _64) -&gt; [return: bb76, unwind: bb103]
+53:9-53:29: @76[5]: _62 = const ()
+54:9-54:15: @76[7]: _0 = const ()"><span class="annotation">@60,75,76⦊</span>should_be_reachable = countdown;</span></span>
+<span class="line"><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)
+53:18-53:27: @60[9]: _92 = const main::promoted[1]
+53:18-53:27: @60[10]: _67 = &amp;(*_92)
+53:18-53:27: @60[11]: _66 = &amp;(*_67)
+53:18-53:27: @60[12]: _65 = move _66 as &amp;[&amp;str] (Pointer(Unsize))
+53:9-53:29: @60[18]: _73 = ()
+53:9-53:29: @60[19]: FakeRead(ForMatchedPlace, _73)
+53:9-53:29: @60[20]: _91 = const main::promoted[0]
+53:9-53:29: @60[21]: _71 = &amp;(*_91)
+53:9-53:29: @60[22]: _70 = &amp;(*_71)
+53:9-53:29: @60[23]: _69 = move _70 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:9-53:29: @60.Call: _64 = Arguments::new_v1(move _65, move _69) -&gt; [return: bb75, unwind: bb103]
+53:9-53:29: @75.Call: _63 = _print(move _64) -&gt; [return: bb76, unwind: bb103]
+53:9-53:29: @76[5]: _62 = const ()
+54:9-54:15: @76[7]: _0 = const ()">        println!("reached");</span></span>
+<span class="line"><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)
+53:18-53:27: @60[9]: _92 = const main::promoted[1]
+53:18-53:27: @60[10]: _67 = &amp;(*_92)
+53:18-53:27: @60[11]: _66 = &amp;(*_67)
+53:18-53:27: @60[12]: _65 = move _66 as &amp;[&amp;str] (Pointer(Unsize))
+53:9-53:29: @60[18]: _73 = ()
+53:9-53:29: @60[19]: FakeRead(ForMatchedPlace, _73)
+53:9-53:29: @60[20]: _91 = const main::promoted[0]
+53:9-53:29: @60[21]: _71 = &amp;(*_91)
+53:9-53:29: @60[22]: _70 = &amp;(*_71)
+53:9-53:29: @60[23]: _69 = move _70 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:9-53:29: @60.Call: _64 = Arguments::new_v1(move _65, move _69) -&gt; [return: bb75, unwind: bb103]
+53:9-53:29: @75.Call: _63 = _print(move _64) -&gt; [return: bb76, unwind: bb103]
+53:9-53:29: @76[5]: _62 = const ()
+54:9-54:15: @76[7]: _0 = const ()">        return<span class="annotation">⦉@60,75,76</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">    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">    } 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>
+<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>
+<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>
+<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="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>
+</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
new file mode 100644
index 00000000000..b96789a9219
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-base/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>while_early_return.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 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
+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>
+<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>
+<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)">        0<span class="annotation">⦉@1,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">        if</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="12:13-12:22: @5[3]: _8 = _1
+12:13-14:14: @5[4]: _7 = Lt(move _8, const 5_i32)
+12:13-14:14: @5[6]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@3,5⦊</span>countdown</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="12:13-12:22: @5[3]: _8 = _1
+12:13-14:14: @5[4]: _7 = Lt(move _8, const 5_i32)
+12:13-14:14: @5[6]: FakeRead(ForMatchedPlace, _7)">                &lt;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="12:13-12:22: @5[3]: _8 = _1
+12:13-14:14: @5[4]: _7 = Lt(move _8, const 5_i32)
+12:13-14:14: @5[6]: FakeRead(ForMatchedPlace, _7)">            5<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="line"><span class="code" style="--layer: 0">            return</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="18:21-18:30: @8[2]: _11 = _1
+18:21-20:22: @8[3]: _10 = Gt(move _11, const 8_i32)
+18:21-20:22: @8[5]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@6,8⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="18:21-18:30: @8[2]: _11 = _1
+18:21-20:22: @8[3]: _10 = Gt(move _11, const 8_i32)
+18:21-20:22: @8[5]: FakeRead(ForMatchedPlace, _10)">                        &gt;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="18:21-18:30: @8[2]: _11 = _1
+18:21-20:22: @8[3]: _10 = Gt(move _11, const 8_i32)
+18:21-20:22: @8[5]: FakeRead(ForMatchedPlace, _10)">                    8<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">                    </span><span><span class="code even" style="--layer: 1" title="22:24-22:26: @11[1]: _12 = ()
+22:21-22:27: @11[2]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _12)"><span class="annotation">@9,11⦊</span>Ok(())<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">                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="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="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 = ()
+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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-link-dead-code/Makefile b/src/test/run-make-fulldeps/coverage-spanview-deadcode/Makefile
index 0578949b3c8..826e85b35e5 100644
--- a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-link-dead-code/Makefile
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/Makefile
@@ -4,8 +4,8 @@
 # LINK_DEAD_CODE requires ignore-msvc due to Issue #76038
 LINK_DEAD_CODE=yes
 
--include ../instrument-coverage-mir-cov-html-base/Makefile
+-include ../coverage-spanview-base/Makefile
 
 # ISSUE(76038): When targeting MSVC, Rust binaries built with both `-Z instrument-coverage` and
 # `-C link-dead-code` typically crash (with a seg-fault) or at best generate an empty `*.profraw`.
-# See ../instrument-coverage/coverage_tools.mk for more information.
\ No newline at end of file
+# See ../coverage/coverage_tools.mk for more information.
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
new file mode 100644
index 00000000000..43f75c574d0
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{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 32"><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">        let </span><span><span class="code even" style="--layer: 1" title="35:29-35:30: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
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
new file mode 100644
index 00000000000..8f07ec5fcde
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{closure#1} - 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 74"><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">        let </span><span><span class="code even" style="--layer: 1" title="77:29-77:30: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
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
new file mode 100644
index 00000000000..ca9031a1094
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{closure#2} - 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 17"><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">                let </span><span><span class="code even" style="--layer: 1" title="20:37-20:38: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
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
new file mode 100644
index 00000000000..820f8d9c6cf
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.main-{closure#3} - 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 59"><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">                let </span><span><span class="code even" style="--layer: 1" title="62:37-62:38: @0[1]: _2 = const 0_i32
+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>
+<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>
+<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;
+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;
+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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..f70576ca24e
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,4505 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>closure.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span>{</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    // Initialize test constants in a way that cannot be determined at compile time, to ensure</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    // dependent conditions.</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    let 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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    let is_false = ! is_true;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    let mut some_string = Some(String::from("the string content"));</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                }</span></span>
+<span class="line"><span class="code" style="--layer: 0">                "alt string 1".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    some_string = Some(String::from("the string content"));</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    let</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">        a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">    =</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+3:11-93:2: @33[8]: _0 = const ()">        <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span></span>
+<span class="line"><span class="code" style="--layer: 0">        "alt string 2".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span>;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    some_string = None;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+3:11-93:2: @33[8]: _0 = const ()">            <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">                    countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">                }</span></span>
+<span class="line"><span class="code" style="--layer: 0">                "alt string 3".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()"></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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    some_string = None;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    let</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">        a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">    =</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+3:11-93:2: @33[8]: _0 = const ()">        <span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</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 mut countdown = 0;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        if is_false {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            countdown = 10;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        }</span></span>
+<span class="line"><span class="code" style="--layer: 0">        "alt string 4".to_owned()</span></span>
+<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34⦊</span>;</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">    println!(</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        "The string or alt: {}"</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        ,</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        some_string</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">            .</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">            unwrap_or_else</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        (</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">            a</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">        )</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">    );</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: bb48]
+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: bb47]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+8:22-8:29: @3[3]: _6 = _1
+8:20-8:29: @3[4]: _5 = Not(move _6)
+8:9-8:17: @3[6]: FakeRead(ForLet, _5)
+10:32-10:66: @3.Call: _8 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb48]
+10:27-10:67: @4[0]: _7 = Option::&lt;String&gt;::Some(move _8)
+10:9-10:24: @5[1]: FakeRead(ForLet, _7)
+12:9-12:32: @5[8]: _102 = const main::promoted[3]
+12:9-12:32: @5[9]: _14 = &amp;(*_102)
+12:9-12:32: @5[10]: _13 = &amp;(*_14)
+12:9-12:32: @5[11]: _12 = move _13 as &amp;[&amp;str] (Pointer(Unsize))
+14:9-14:20: @5[21]: _23 = move _7
+14:9-26:10: @5.Call: _22 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb45]
+14:9-26:10: @6[2]: _21 = &amp;_22
+11:5-27:7: @6[3]: _20 = (move _21,)
+11:5-27:7: @6[5]: FakeRead(ForMatchedPlace, _20)
+11:5-27:7: @6[7]: _26 = (_20.0: &amp;std::string::String)
+11:5-27:7: @6[10]: _28 = &amp;(*_26)
+11:5-27:7: @6[12]: _29 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+11:5-27:7: @6.Call: _27 = ArgumentV1::new::&lt;String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb44]
+11:5-27:7: @7[2]: _19 = [move _27]
+11:5-27:7: @7[5]: _18 = &amp;_19
+11:5-27:7: @7[6]: _17 = &amp;(*_18)
+11:5-27:7: @7[7]: _16 = move _17 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+11:5-27:7: @7.Call: _11 = Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb44]
+11:5-27:7: @8.Call: _10 = _print(move _11) -&gt; [return: bb9, unwind: bb44]
+11:5-27:7: @10[6]: _9 = const ()
+29:24-29:58: @10.Call: _31 = &lt;String as From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb46]
+29:19-29:59: @11[0]: _30 = Option::&lt;String&gt;::Some(move _31)
+33:9-40:6: @14[3]: _33 = &amp;_5
+31:9-31:10: @14[6]: FakeRead(ForLet, _32)
+42:9-42:32: @14[13]: _101 = const main::promoted[2]
+42:9-42:32: @14[14]: _39 = &amp;(*_101)
+42:9-42:32: @14[15]: _38 = &amp;(*_39)
+42:9-42:32: @14[16]: _37 = move _38 as &amp;[&amp;str] (Pointer(Unsize))
+44:9-44:20: @14[26]: _48 = move _7
+48:13-48:14: @14[28]: _49 = _32
+44:9-49:10: @14.Call: _47 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb42]
+44:9-49:10: @15[2]: _46 = &amp;_47
+41:5-50:7: @15[3]: _45 = (move _46,)
+41:5-50:7: @15[5]: FakeRead(ForMatchedPlace, _45)
+41:5-50:7: @15[7]: _50 = (_45.0: &amp;std::string::String)
+41:5-50:7: @15[10]: _52 = &amp;(*_50)
+41:5-50:7: @15[12]: _53 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+41:5-50:7: @15.Call: _51 = ArgumentV1::new::&lt;String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb41]
+41:5-50:7: @16[2]: _44 = [move _51]
+41:5-50:7: @16[5]: _43 = &amp;_44
+41:5-50:7: @16[6]: _42 = &amp;(*_43)
+41:5-50:7: @16[7]: _41 = move _42 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+41:5-50:7: @16.Call: _36 = Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb41]
+41:5-50:7: @17.Call: _35 = _print(move _36) -&gt; [return: bb18, unwind: bb41]
+41:5-50:7: @19[6]: _34 = const ()
+52:19-52:23: @19[9]: _54 = Option::&lt;String&gt;::None
+54:9-54:32: @21[7]: _100 = const main::promoted[1]
+54:9-54:32: @21[8]: _60 = &amp;(*_100)
+54:9-54:32: @21[9]: _59 = &amp;(*_60)
+54:9-54:32: @21[10]: _58 = move _59 as &amp;[&amp;str] (Pointer(Unsize))
+56:9-56:20: @21[20]: _69 = move _7
+56:9-68:10: @21.Call: _68 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb39]
+56:9-68:10: @22[2]: _67 = &amp;_68
+53:5-69:7: @22[3]: _66 = (move _67,)
+53:5-69:7: @22[5]: FakeRead(ForMatchedPlace, _66)
+53:5-69:7: @22[7]: _72 = (_66.0: &amp;std::string::String)
+53:5-69:7: @22[10]: _74 = &amp;(*_72)
+53:5-69:7: @22[12]: _75 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+53:5-69:7: @22.Call: _73 = ArgumentV1::new::&lt;String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb38]
+53:5-69:7: @23[2]: _65 = [move _73]
+53:5-69:7: @23[5]: _64 = &amp;_65
+53:5-69:7: @23[6]: _63 = &amp;(*_64)
+53:5-69:7: @23[7]: _62 = move _63 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:5-69:7: @23.Call: _57 = Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb38]
+53:5-69:7: @24.Call: _56 = _print(move _57) -&gt; [return: bb25, unwind: bb38]
+53:5-69:7: @26[6]: _55 = const ()
+71:19-71:23: @26[9]: _76 = Option::&lt;String&gt;::None
+73:9-73:10: @28[6]: FakeRead(ForLet, _77)
+84:9-84:32: @28[13]: _99 = const main::promoted[0]
+84:9-84:32: @28[14]: _84 = &amp;(*_99)
+84:9-84:32: @28[15]: _83 = &amp;(*_84)
+84:9-84:32: @28[16]: _82 = move _83 as &amp;[&amp;str] (Pointer(Unsize))
+86:9-86:20: @28[26]: _93 = move _7
+90:13-90:14: @28[28]: _94 = _77
+86:9-91:10: @28.Call: _92 = Option::&lt;String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb36]
+86:9-91:10: @29[2]: _91 = &amp;_92
+83:5-92:7: @29[3]: _90 = (move _91,)
+83:5-92:7: @29[5]: FakeRead(ForMatchedPlace, _90)
+83:5-92:7: @29[7]: _95 = (_90.0: &amp;std::string::String)
+83:5-92:7: @29[10]: _97 = &amp;(*_95)
+83:5-92:7: @29[12]: _98 = &lt;String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::string::String, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+83:5-92:7: @29.Call: _96 = ArgumentV1::new::&lt;String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb35]
+83:5-92:7: @30[2]: _89 = [move _96]
+83:5-92:7: @30[5]: _88 = &amp;_89
+83:5-92:7: @30[6]: _87 = &amp;(*_88)
+83:5-92:7: @30[7]: _86 = move _87 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+83:5-92:7: @30.Call: _81 = Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb35]
+83:5-92:7: @31.Call: _80 = _print(move _81) -&gt; [return: bb32, unwind: bb35]
+83:5-92:7: @33[6]: _79 = const ()
+3:11-93:2: @33[8]: _0 = const ()
+93:2-93:2: @34.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34</span></span></span></span></div>
+</body>
+</html>
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
new file mode 100644
index 00000000000..494e6f20ea7
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>drop_trait.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 13"><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="15:24-15:48: @0[1]: _1 = Firework { strength: const 1_i32 }
+15:9-15:21: @0[2]: FakeRead(ForLet, _1)
+17:16-17:42: @0[4]: _2 = Firework { strength: const 100_i32 }
+17:9-17:13: @0[5]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>_firecracker = Firework { strength: 1 };</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="15:24-15:48: @0[1]: _1 = Firework { strength: const 1_i32 }
+15:9-15:21: @0[2]: FakeRead(ForLet, _1)
+17:16-17:42: @0[4]: _2 = Firework { strength: const 100_i32 }
+17:9-17:13: @0[5]: FakeRead(ForLet, _2)"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="15:24-15:48: @0[1]: _1 = Firework { strength: const 1_i32 }
+15:9-15:21: @0[2]: FakeRead(ForLet, _1)
+17:16-17:42: @0[4]: _2 = Firework { strength: const 100_i32 }
+17:9-17:13: @0[5]: FakeRead(ForLet, _2)">    let _tnt = Firework { strength: 100 }<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="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="19:8-19:12: @0[8]: _4 = const true
+19:8-19:12: @0[9]: 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">        </span><span><span class="code odd" style="--layer: 1" title="20:18-20:41: @3[6]: _21 = const main::promoted[1]
+20:18-20:41: @3[7]: _11 = &amp;(*_21)
+20:18-20:41: @3[8]: _10 = &amp;(*_11)
+20:18-20:41: @3[9]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+20:9-20:43: @3[15]: _17 = ()
+20:9-20:43: @3[16]: FakeRead(ForMatchedPlace, _17)
+20:9-20:43: @3[17]: _20 = const main::promoted[0]
+20:9-20:43: @3[18]: _15 = &amp;(*_20)
+20:9-20:43: @3[19]: _14 = &amp;(*_15)
+20:9-20:43: @3[20]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+20:9-20:43: @3.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb4, unwind: bb12]
+20:9-20:43: @4.Call: _7 = _print(move _8) -&gt; [return: bb5, unwind: bb12]
+20:9-20:43: @5[5]: _6 = const ()
+21:16-21:22: @5[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@1,3,4,5,9,10⦊</span>println!("Exiting with error...");</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="20:18-20:41: @3[6]: _21 = const main::promoted[1]
+20:18-20:41: @3[7]: _11 = &amp;(*_21)
+20:18-20:41: @3[8]: _10 = &amp;(*_11)
+20:18-20:41: @3[9]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+20:9-20:43: @3[15]: _17 = ()
+20:9-20:43: @3[16]: FakeRead(ForMatchedPlace, _17)
+20:9-20:43: @3[17]: _20 = const main::promoted[0]
+20:9-20:43: @3[18]: _15 = &amp;(*_20)
+20:9-20:43: @3[19]: _14 = &amp;(*_15)
+20:9-20:43: @3[20]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+20:9-20:43: @3.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb4, unwind: bb12]
+20:9-20:43: @4.Call: _7 = _print(move _8) -&gt; [return: bb5, unwind: bb12]
+20:9-20:43: @5[5]: _6 = const ()
+21:16-21:22: @5[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)">        return Err(1)<span class="annotation">⦉@1,3,4,5,9,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="line"><span class="code" style="--layer: 0">    let _ = </span><span><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)"><span class="annotation">@2,6,7,8⦊</span>Firework { strength: 1000 };</span></span>
+<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)"></span></span>
+<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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..9530d12fb49
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html
@@ -0,0 +1,123 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>drop_trait.{impl#0}-drop - 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 drop(&amp;mut self) </span><span><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as Drop&gt;::drop::promoted[0]
+10:18-10:36: @0[7]: _7 = &amp;(*_19)
+10:18-10:36: @0[8]: _6 = &amp;(*_7)
+10:18-10:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+10:38-10:51: @0[17]: _14 = &amp;((*_1).0: i32)
+10:9-10:53: @0[18]: _13 = (move _14,)
+10:9-10:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+10:9-10:53: @0[22]: _15 = (_13.0: &amp;i32)
+10:9-10:53: @0[25]: _17 = &amp;(*_15)
+10:9-10:53: @0[27]: _18 = &lt;i32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r i32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+10:9-10:53: @0.Call: _16 = ArgumentV1::new::&lt;i32&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+10:9-10:53: @1[2]: _12 = [move _16]
+10:9-10:53: @1[5]: _11 = &amp;_12
+10:9-10:53: @1[6]: _10 = &amp;(*_11)
+10:9-10:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+10:9-10:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+10:9-10:53: @3[6]: _2 = const ()
+9:24-11:6: @3[8]: _0 = const ()
+11:6-11:6: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as Drop&gt;::drop::promoted[0]
+10:18-10:36: @0[7]: _7 = &amp;(*_19)
+10:18-10:36: @0[8]: _6 = &amp;(*_7)
+10:18-10:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+10:38-10:51: @0[17]: _14 = &amp;((*_1).0: i32)
+10:9-10:53: @0[18]: _13 = (move _14,)
+10:9-10:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+10:9-10:53: @0[22]: _15 = (_13.0: &amp;i32)
+10:9-10:53: @0[25]: _17 = &amp;(*_15)
+10:9-10:53: @0[27]: _18 = &lt;i32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r i32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+10:9-10:53: @0.Call: _16 = ArgumentV1::new::&lt;i32&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+10:9-10:53: @1[2]: _12 = [move _16]
+10:9-10:53: @1[5]: _11 = &amp;_12
+10:9-10:53: @1[6]: _10 = &amp;(*_11)
+10:9-10:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+10:9-10:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+10:9-10:53: @3[6]: _2 = const ()
+9:24-11:6: @3[8]: _0 = const ()
+11:6-11:6: @3.Return: return">        println!("BOOM times {}!!!", self.strength);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as Drop&gt;::drop::promoted[0]
+10:18-10:36: @0[7]: _7 = &amp;(*_19)
+10:18-10:36: @0[8]: _6 = &amp;(*_7)
+10:18-10:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+10:38-10:51: @0[17]: _14 = &amp;((*_1).0: i32)
+10:9-10:53: @0[18]: _13 = (move _14,)
+10:9-10:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+10:9-10:53: @0[22]: _15 = (_13.0: &amp;i32)
+10:9-10:53: @0[25]: _17 = &amp;(*_15)
+10:9-10:53: @0[27]: _18 = &lt;i32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r i32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+10:9-10:53: @0.Call: _16 = ArgumentV1::new::&lt;i32&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+10:9-10:53: @1[2]: _12 = [move _16]
+10:9-10:53: @1[5]: _11 = &amp;_12
+10:9-10:53: @1[6]: _10 = &amp;(*_11)
+10:9-10:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+10:9-10:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+10:9-10:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+10:9-10:53: @3[6]: _2 = const ()
+9:24-11:6: @3[8]: _0 = const ()
+11:6-11:6: @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.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..6dc893d28ff
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,167 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>generics.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() -&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="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]"><span class="annotation">@0,1,2,3⦊</span>mut firecracker = Firework { strength: 1 };</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    firecracker.set_strength(2);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]"></span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    let mut tnt = Firework { strength: 100.1 };</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    tnt.set_strength(200.1);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="23:27-23:51: @0[1]: _1 = Firework::&lt;i32&gt; { strength: const 1_i32 }
+23:9-23:24: @0[2]: FakeRead(ForLet, _1)
+24:5-24:16: @0[5]: _3 = &amp;mut _1
+24:5-24:32: @0.Call: _2 = Firework::&lt;i32&gt;::set_strength(move _3, const 2_i32) -&gt; [return: bb1, unwind: bb16]
+26:19-26:47: @1[3]: _4 = Firework::&lt;f64&gt; { strength: const 100.09999999999999f64 }
+26:9-26:16: @1[4]: FakeRead(ForLet, _4)
+27:5-27:8: @1[7]: _6 = &amp;mut _4
+27:5-27:28: @1.Call: _5 = Firework::&lt;f64&gt;::set_strength(move _6, const 200.09999999999999f64) -&gt; [return: bb2, unwind: bb15]
+28:5-28:8: @2[4]: _8 = &amp;mut _4
+28:5-28:28: @2.Call: _7 = Firework::&lt;f64&gt;::set_strength(move _8, const 300.30000000000001f64) -&gt; [return: bb3, unwind: bb15]">    tnt.set_strength(300.3)<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">    if </span><span><span class="code even" style="--layer: 1" title="30:8-30:12: @3[4]: _10 = const true
+30:8-30:12: @3[5]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@0,1,2,3⦊</span>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="31:18-31:41: @6[6]: _27 = const main::promoted[1]
+31:18-31:41: @6[7]: _17 = &amp;(*_27)
+31:18-31:41: @6[8]: _16 = &amp;(*_17)
+31:18-31:41: @6[9]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
+31:9-31:43: @6[15]: _23 = ()
+31:9-31:43: @6[16]: FakeRead(ForMatchedPlace, _23)
+31:9-31:43: @6[17]: _26 = const main::promoted[0]
+31:9-31:43: @6[18]: _21 = &amp;(*_26)
+31:9-31:43: @6[19]: _20 = &amp;(*_21)
+31:9-31:43: @6[20]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+31:9-31:43: @6.Call: _14 = Arguments::new_v1(move _15, move _19) -&gt; [return: bb7, unwind: bb15]
+31:9-31:43: @7.Call: _13 = _print(move _14) -&gt; [return: bb8, unwind: bb15]
+31:9-31:43: @8[5]: _12 = const ()
+32:16-32:22: @8[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@4,6,7,8,12,13⦊</span>println!("Exiting with error...");</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="31:18-31:41: @6[6]: _27 = const main::promoted[1]
+31:18-31:41: @6[7]: _17 = &amp;(*_27)
+31:18-31:41: @6[8]: _16 = &amp;(*_17)
+31:18-31:41: @6[9]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
+31:9-31:43: @6[15]: _23 = ()
+31:9-31:43: @6[16]: FakeRead(ForMatchedPlace, _23)
+31:9-31:43: @6[17]: _26 = const main::promoted[0]
+31:9-31:43: @6[18]: _21 = &amp;(*_26)
+31:9-31:43: @6[19]: _20 = &amp;(*_21)
+31:9-31:43: @6[20]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+31:9-31:43: @6.Call: _14 = Arguments::new_v1(move _15, move _19) -&gt; [return: bb7, unwind: bb15]
+31:9-31:43: @7.Call: _13 = _print(move _14) -&gt; [return: bb8, unwind: bb15]
+31:9-31:43: @8[5]: _12 = const ()
+32:16-32:22: @8[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)">        return Err(1)<span class="annotation">⦉@4,6,7,8,12,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">    let _ = </span><span><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)"><span class="annotation">@5,9,10,11⦊</span>Firework { strength: 1000 };</span></span>
+<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)"></span></span>
+<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>
+</body>
+</html>
diff --git a/src/test/mir-opt/spanview_statement.main.mir_map.0.html.mir b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html
index 8a34b8b5dae..e31e47b81d4 100644
--- a/src/test/mir-opt/spanview_statement.main.mir_map.0.html.mir
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html
@@ -1,8 +1,8 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>coverage_of_if_else - Code Regions</title>
-    <style>
+<title>generics.{impl#0}-set_strength - Coverage Spans</title>
+<style>
     .line {
         counter-increment: line;
     }
@@ -56,11 +56,20 @@
         /* requires hover over a span ONLY on its first line */
         display: inline-block;
     }
-    </style>
+</style>
 </head>
 <body>
-<div class="code" style="counter-reset: line 4"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="0[0]: $DIR/spanview-statement.rs:5:11: 5:13:
-    5:11-5:13: Assign: _0 = const ()"><span class="annotation">0[0]⦊</span>{}<span class="annotation">⦉0[0]</span></span></span><span><span class="code odd" style="--layer: 1" title="0:Return: $DIR/spanview-statement.rs:5:13: 5:13:
-    5:13-5:13: Return: return"><span class="annotation">0:Return⦊</span>‸<span class="annotation">⦉0:Return</span></span></span></span></div>
+<div class="code" style="counter-reset: line 9"><span class="line">    <span class="code" style="--layer: 0">fn set_strength(&amp;mut self, new_strength: T) </span><span><span class="code even" style="--layer: 1" title="11:25-11:37: @0[1]: _3 = _2
+11:9-11:37: @0[2]: ((*_1).0: T) = move _3
+10:49-12:6: @0[4]: _0 = const ()
+12:6-12:6: @0.Return: return"><span class="annotation">@0⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="11:25-11:37: @0[1]: _3 = _2
+11:9-11:37: @0[2]: ((*_1).0: T) = move _3
+10:49-12:6: @0[4]: _0 = const ()
+12:6-12:6: @0.Return: return">        self.strength = new_strength;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="11:25-11:37: @0[1]: _3 = _2
+11:9-11:37: @0[2]: ((*_1).0: T) = move _3
+10:49-12:6: @0[4]: _0 = const ()
+12:6-12: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.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..99a7df4a670
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html
@@ -0,0 +1,123 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>generics.{impl#1}-drop - 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 16"><span class="line">    <span class="code" style="--layer: 0">fn drop(&amp;mut self) </span><span><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const &lt;Firework&lt;T&gt; as Drop&gt;::drop::promoted[0]
+18:18-18:36: @0[7]: _7 = &amp;(*_19)
+18:18-18:36: @0[8]: _6 = &amp;(*_7)
+18:18-18:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+18:38-18:51: @0[17]: _14 = &amp;((*_1).0: T)
+18:9-18:53: @0[18]: _13 = (move _14,)
+18:9-18:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+18:9-18:53: @0[22]: _15 = (_13.0: &amp;T)
+18:9-18:53: @0[25]: _17 = &amp;(*_15)
+18:9-18:53: @0[27]: _18 = &lt;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+18:9-18:53: @0.Call: _16 = ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+18:9-18:53: @1[2]: _12 = [move _16]
+18:9-18:53: @1[5]: _11 = &amp;_12
+18:9-18:53: @1[6]: _10 = &amp;(*_11)
+18:9-18:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+18:9-18:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+18:9-18:53: @3[6]: _2 = const ()
+17:24-19:6: @3[8]: _0 = const ()
+19:6-19:6: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const &lt;Firework&lt;T&gt; as Drop&gt;::drop::promoted[0]
+18:18-18:36: @0[7]: _7 = &amp;(*_19)
+18:18-18:36: @0[8]: _6 = &amp;(*_7)
+18:18-18:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+18:38-18:51: @0[17]: _14 = &amp;((*_1).0: T)
+18:9-18:53: @0[18]: _13 = (move _14,)
+18:9-18:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+18:9-18:53: @0[22]: _15 = (_13.0: &amp;T)
+18:9-18:53: @0[25]: _17 = &amp;(*_15)
+18:9-18:53: @0[27]: _18 = &lt;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+18:9-18:53: @0.Call: _16 = ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+18:9-18:53: @1[2]: _12 = [move _16]
+18:9-18:53: @1[5]: _11 = &amp;_12
+18:9-18:53: @1[6]: _10 = &amp;(*_11)
+18:9-18:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+18:9-18:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+18:9-18:53: @3[6]: _2 = const ()
+17:24-19:6: @3[8]: _0 = const ()
+19:6-19:6: @3.Return: return">        println!("BOOM times {}!!!", self.strength);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const &lt;Firework&lt;T&gt; as Drop&gt;::drop::promoted[0]
+18:18-18:36: @0[7]: _7 = &amp;(*_19)
+18:18-18:36: @0[8]: _6 = &amp;(*_7)
+18:18-18:36: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
+18:38-18:51: @0[17]: _14 = &amp;((*_1).0: T)
+18:9-18:53: @0[18]: _13 = (move _14,)
+18:9-18:53: @0[20]: FakeRead(ForMatchedPlace, _13)
+18:9-18:53: @0[22]: _15 = (_13.0: &amp;T)
+18:9-18:53: @0[25]: _17 = &amp;(*_15)
+18:9-18:53: @0[27]: _18 = &lt;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+18:9-18:53: @0.Call: _16 = ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
+18:9-18:53: @1[2]: _12 = [move _16]
+18:9-18:53: @1[5]: _11 = &amp;_12
+18:9-18:53: @1[6]: _10 = &amp;(*_11)
+18:9-18:53: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+18:9-18:53: @1.Call: _4 = Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
+18:9-18:53: @2.Call: _3 = _print(move _4) -&gt; [return: bb3, unwind: bb4]
+18:9-18:53: @3[6]: _2 = const ()
+17:24-19:6: @3[8]: _0 = const ()
+19:6-19:6: @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.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..0379d900e94
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>if.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)"><span class="annotation">@0,1,2,3⦊</span>is_true</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    =</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        std::env::args().len()</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    ==</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        1</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    let</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        mut</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    countdown</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">    =</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb9]
+10:9-10:25: @1[0]: _3 = &amp;_4
+10:9-10:31: @1.Call: _2 = &lt;Args as ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
+10:9-12:10: @2[1]: _1 = Eq(move _2, const 1_usize)
+8:5-8:12: @2[3]: FakeRead(ForLet, _1)
+18:9-18:10: @3[2]: _5 = const 0_i32
+15:9-16:14: @3[3]: FakeRead(ForLet, _5)">        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">    ;</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="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>
+<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>
+<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>
+<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>
+<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>
+<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>
+</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
new file mode 100644
index 00000000000..b51c5c84c0d
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>if_else.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)"><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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)"></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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)">    let mut countdown = 0;</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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)">    if</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: bb13]
+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: bb12]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)
+11:9-11:16: @3[6]: _7 = _1
+11:9-11:16: @3[7]: FakeRead(ForMatchedPlace, _7)">        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="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()"><span class="annotation">@4,6⦊</span>{</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">        countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">        =</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">            10</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = const ()">        ;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @6[0]: _5 = const 10_i32
+12:5-17:6: @6[1]: _6 = 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">    else // Note coverage region difference without semicolon</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:9-22:16: @5[0]: _5 = const 100_i32
+20:9-22:16: @5[1]: _6 = const ()"><span class="annotation">@5⦊</span>countdown</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 ()">        =</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="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
+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
+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
+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
+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
+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
+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
+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
+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
+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
+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 ()">            100</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></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" 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-InTrait-default_trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..20c54d0e6b4
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>inner_items.main-InTrait-default_trait_func - 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 32"><span class="line">        <span class="code" style="--layer: 0">fn default_trait_func(&amp;mut self) </span><span><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return">            in_func(IN_CONST);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return">            self.trait_func(IN_CONST);</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = in_func(const IN_CONST) -&gt; [return: bb1, unwind: bb3]
+35:13-35:17: @1[3]: _4 = &amp;mut (*_1)
+35:13-35:38: @1.Call: _3 = &lt;Self as InTrait&gt;::trait_func(move _4, const IN_CONST) -&gt; [return: bb2, unwind: bb3]
+33:42-36:10: @2[2]: _0 = const ()
+36:10-36:10: @2.Return: return">        }<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.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
new file mode 100644
index 00000000000..49639cc6884
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
@@ -0,0 +1,107 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>inner_items.main-in_func - 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 17"><span class="line">    <span class="code" style="--layer: 0">fn in_func(a: u32) {</span></span>
+<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>
+<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)
+21:18-21:26: @1[12]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+21:28-21:29: @1[20]: _18 = &amp;_3
+21:9-21:30: @1[21]: _17 = (move _18,)
+21:9-21:30: @1[23]: FakeRead(ForMatchedPlace, _17)
+21:9-21:30: @1[25]: _19 = (_17.0: &amp;u32)
+21:9-21:30: @1[28]: _21 = &amp;(*_19)
+21:9-21:30: @1[30]: _22 = &lt;u32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r u32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+21:9-21:30: @1.Call: _20 = ArgumentV1::new::&lt;u32&gt;(move _21, move _22) -&gt; [return: bb2, unwind: bb5]
+21:9-21:30: @2[2]: _16 = [move _20]
+21:9-21:30: @2[5]: _15 = &amp;_16
+21:9-21:30: @2[6]: _14 = &amp;(*_15)
+21:9-21:30: @2[7]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
+21:9-21:30: @3.Call: _7 = _print(move _8) -&gt; [return: bb4, unwind: bb5]
+21:9-21:30: @4[6]: _0 = const ()
+22:6-22:6: @4.Return: return"><span class="annotation">@1,2,3,4⦊</span>println!("c = {}", c)</span></span>
+<span class="line"><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)
+21:18-21:26: @1[12]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
+21:28-21:29: @1[20]: _18 = &amp;_3
+21:9-21:30: @1[21]: _17 = (move _18,)
+21:9-21:30: @1[23]: FakeRead(ForMatchedPlace, _17)
+21:9-21:30: @1[25]: _19 = (_17.0: &amp;u32)
+21:9-21:30: @1[28]: _21 = &amp;(*_19)
+21:9-21:30: @1[30]: _22 = &lt;u32 as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r u32, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
+21:9-21:30: @1.Call: _20 = ArgumentV1::new::&lt;u32&gt;(move _21, move _22) -&gt; [return: bb2, unwind: bb5]
+21:9-21:30: @2[2]: _16 = [move _20]
+21:9-21:30: @2[5]: _15 = &amp;_16
+21:9-21:30: @2[6]: _14 = &amp;(*_15)
+21:9-21:30: @2[7]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+21:9-21:30: @2.Call: _8 = Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
+21:9-21:30: @3.Call: _7 = _print(move _8) -&gt; [return: bb4, unwind: bb5]
+21:9-21:30: @4[6]: _0 = const ()
+22:6-22:6: @4.Return: return">    }<span class="annotation">⦉@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.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
new file mode 100644
index 00000000000..a2cf86de278
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>inner_items.main-{impl#0}-trait_func - 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 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">            </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>
+<span class="line"><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></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.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..56557b8ef95
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,171 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>inner_items.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_u32
+9:9-9: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="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_u32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)"></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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_u32
+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>
+<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>
+<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>
+<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>
+<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">    fn in_func(a: u32) {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        let b = 1;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        let c = a + b;</span></span>
+<span class="line"><span class="code" style="--layer: 0">        println!("c = {}", c)</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">    struct InStruct {</span></span>
+<span class="line"><span class="code" style="--layer: 0">        in_struct_field: u32,</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">    const IN_CONST: u32 = 1234;</span></span>
+<span class="line"><span class="code" style="--layer: 0"></span></span>
+<span class="line"><span class="code" style="--layer: 0">    trait InTrait {</span></span>
+<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="line"><span class="code" style="--layer: 0">        fn default_trait_func(&amp;mut self) {</span></span>
+<span class="line"><span class="code" style="--layer: 0">            in_func(IN_CONST);</span></span>
+<span class="line"><span class="code" style="--layer: 0">            self.trait_func(IN_CONST);</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="line"><span class="code" style="--layer: 0">    impl InTrait for InStruct {</span></span>
+<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">            self.in_struct_field += incr;</span></span>
+<span class="line"><span class="code" style="--layer: 0">            in_func(self.in_struct_field);</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="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
+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
+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
+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>
+<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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return"><span class="annotation">@12,13⦊</span>mut val = InStruct {</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">        in_struct_field: 101,</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">    };</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return"></span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">    val.default_trait_func();</span></span>
+<span class="line"><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)
+56:5-56:8: @12[7]: _14 = &amp;mut _12
+56:5-56:29: @12.Call: _13 = &lt;InStruct as InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb13, unwind: bb15]
+57:2-57:2: @13.Return: return">}<span class="annotation">⦉@12,13</span></span></span></span></div>
+</body>
+</html>
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
new file mode 100644
index 00000000000..defe743df60
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>lazy_boolean.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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]
+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: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]
+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: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]
+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: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)">    let (mut a, mut b, mut c) = (0, 0, 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[12]: _10 = _1
+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>
+<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>
+<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>
+<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>
+<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>
+<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="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
+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
+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>
+<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="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
+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
+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>
+<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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html
new file mode 100644
index 00000000000..dc26c796637
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>loop_break_value.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() </span><span><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return"><span class="annotation">@0,1⦊</span>{</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">    let result</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">        =</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            loop</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">        {</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            break</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            10</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">            ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">        }</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">    ;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="6:13-11:10: @0.FalseUnwind: falseUnwind -&gt; [real: bb1, cleanup: bb2]
+9:13-9:15: @1[0]: _1 = const 10_i32
+4:9-4:15: @1[1]: FakeRead(ForLet, _1)
+3:11-13:2: @1[2]: _0 = const ()
+13:2-13:2: @1.Return: return">}<span class="annotation">⦉@0,1</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
new file mode 100644
index 00000000000..4b21d3fc263
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>simple_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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9: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="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)"></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: bb15]
+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: bb14]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 0_i32
+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"></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="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>
+<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>
+<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>
+<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>
+<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>
+<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>
+<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
+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
+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
+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="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="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: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
new file mode 100644
index 00000000000..5ba770ef607
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,190 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>simple_match.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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
+<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: bb22]
+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: bb21]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 1_i32
+9:9-9: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="7:19-7:35: @0.Call: _4 = args() -&gt; [return: bb1, unwind: bb22]
+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: bb21]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 1_i32
+9:9-9:22: @3[3]: FakeRead(ForLet, _5)"></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: bb22]
+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: bb21]
+7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
+7:9-7:16: @2[3]: FakeRead(ForLet, _1)
+9:25-9:26: @3[2]: _5 = const 1_i32
+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>
+<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>
+<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>
+<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">    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="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)
+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" 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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()"><span class="annotation">@18⦊</span>{</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                z = countdown</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                ;</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                let y = countdown</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                ;</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                countdown = 10</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">                ;</span></span>
+<span class="line"><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
+33:25-33:34: @18[9]: _28 = _5
+33:21-33:22: @18[10]: FakeRead(ForLet, _28)
+35:17-35:31: @18[11]: _5 = const 10_i32
+30:13-37:14: @18[12]: _21 = const ()">            }<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">            =&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="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.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
new file mode 100644
index 00000000000..9f993342340
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>try_error_result.call - 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 class="code" style="--layer: 0">fn call(return_error: bool) -&gt; Result&lt;(),()&gt; {</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:20: @0[1]: _2 = _1
+5:8-5:20: @0[2]: FakeRead(ForMatchedPlace, _2)"><span class="annotation">@0⦊</span>return_error<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="6:13-6:15: @3[1]: _3 = ()
+6:9-6:16: @3[2]: _0 = std::result::Result::&lt;(), ()&gt;::Err(move _3)"><span class="annotation">@1,3⦊</span>Err(())<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">    } 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>
+</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
new file mode 100644
index 00000000000..660c3031f35
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>try_error_result.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 11"><span class="line"><span class="code" style="--layer: 0">fn main() -&gt; Result&lt;(),()&gt; {</span></span>
+<span class="line"><span class="code" style="--layer: 0">    let </span><span><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)"><span class="annotation">@0,1⦊</span>mut</span></span>
+<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">    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="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
+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>
+<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="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 = ()
+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>
+</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
new file mode 100644
index 00000000000..28f1d013c83
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.various_conditions/various_conditions.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,228 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>various_conditions.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 2"><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="4:25-4:26: @0[1]: _1 = const 0_u32
+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>
+<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>
+<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>
+<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
+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">    } 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>
+<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>
+<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>
+<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>
+<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="23:25-23:26: @25[3]: _21 = const 0_i32
+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>
+<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>
+<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>
+<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
+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
+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">    } 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>
+<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="39:25-39:26: @50[3]: _41 = const 0_i32
+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>
+<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>
+<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>
+<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
+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
+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">    } 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)
+53:18-53:27: @60[9]: _92 = const main::promoted[1]
+53:18-53:27: @60[10]: _67 = &amp;(*_92)
+53:18-53:27: @60[11]: _66 = &amp;(*_67)
+53:18-53:27: @60[12]: _65 = move _66 as &amp;[&amp;str] (Pointer(Unsize))
+53:9-53:29: @60[18]: _73 = ()
+53:9-53:29: @60[19]: FakeRead(ForMatchedPlace, _73)
+53:9-53:29: @60[20]: _91 = const main::promoted[0]
+53:9-53:29: @60[21]: _71 = &amp;(*_91)
+53:9-53:29: @60[22]: _70 = &amp;(*_71)
+53:9-53:29: @60[23]: _69 = move _70 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:9-53:29: @60.Call: _64 = Arguments::new_v1(move _65, move _69) -&gt; [return: bb75, unwind: bb103]
+53:9-53:29: @75.Call: _63 = _print(move _64) -&gt; [return: bb76, unwind: bb103]
+53:9-53:29: @76[5]: _62 = const ()
+54:9-54:15: @76[7]: _0 = const ()"><span class="annotation">@60,75,76⦊</span>should_be_reachable = countdown;</span></span>
+<span class="line"><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)
+53:18-53:27: @60[9]: _92 = const main::promoted[1]
+53:18-53:27: @60[10]: _67 = &amp;(*_92)
+53:18-53:27: @60[11]: _66 = &amp;(*_67)
+53:18-53:27: @60[12]: _65 = move _66 as &amp;[&amp;str] (Pointer(Unsize))
+53:9-53:29: @60[18]: _73 = ()
+53:9-53:29: @60[19]: FakeRead(ForMatchedPlace, _73)
+53:9-53:29: @60[20]: _91 = const main::promoted[0]
+53:9-53:29: @60[21]: _71 = &amp;(*_91)
+53:9-53:29: @60[22]: _70 = &amp;(*_71)
+53:9-53:29: @60[23]: _69 = move _70 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:9-53:29: @60.Call: _64 = Arguments::new_v1(move _65, move _69) -&gt; [return: bb75, unwind: bb103]
+53:9-53:29: @75.Call: _63 = _print(move _64) -&gt; [return: bb76, unwind: bb103]
+53:9-53:29: @76[5]: _62 = const ()
+54:9-54:15: @76[7]: _0 = const ()">        println!("reached");</span></span>
+<span class="line"><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)
+53:18-53:27: @60[9]: _92 = const main::promoted[1]
+53:18-53:27: @60[10]: _67 = &amp;(*_92)
+53:18-53:27: @60[11]: _66 = &amp;(*_67)
+53:18-53:27: @60[12]: _65 = move _66 as &amp;[&amp;str] (Pointer(Unsize))
+53:9-53:29: @60[18]: _73 = ()
+53:9-53:29: @60[19]: FakeRead(ForMatchedPlace, _73)
+53:9-53:29: @60[20]: _91 = const main::promoted[0]
+53:9-53:29: @60[21]: _71 = &amp;(*_91)
+53:9-53:29: @60[22]: _70 = &amp;(*_71)
+53:9-53:29: @60[23]: _69 = move _70 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
+53:9-53:29: @60.Call: _64 = Arguments::new_v1(move _65, move _69) -&gt; [return: bb75, unwind: bb103]
+53:9-53:29: @75.Call: _63 = _print(move _64) -&gt; [return: bb76, unwind: bb103]
+53:9-53:29: @76[5]: _62 = const ()
+54:9-54:15: @76[7]: _0 = const ()">        return<span class="annotation">⦉@60,75,76</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">    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">    } 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>
+<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>
+<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>
+<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="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>
+</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
new file mode 100644
index 00000000000..b96789a9219
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage-spanview-deadcode/expected_mir_dump.while_early_return/while_early_return.main.-------.InstrumentCoverage.0.html
@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>while_early_return.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 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
+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>
+<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>
+<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)">        0<span class="annotation">⦉@1,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">        if</span></span>
+<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="12:13-12:22: @5[3]: _8 = _1
+12:13-14:14: @5[4]: _7 = Lt(move _8, const 5_i32)
+12:13-14:14: @5[6]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@3,5⦊</span>countdown</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="12:13-12:22: @5[3]: _8 = _1
+12:13-14:14: @5[4]: _7 = Lt(move _8, const 5_i32)
+12:13-14:14: @5[6]: FakeRead(ForMatchedPlace, _7)">                &lt;</span></span>
+<span class="line"><span class="code even" style="--layer: 1" title="12:13-12:22: @5[3]: _8 = _1
+12:13-14:14: @5[4]: _7 = Lt(move _8, const 5_i32)
+12:13-14:14: @5[6]: FakeRead(ForMatchedPlace, _7)">            5<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="line"><span class="code" style="--layer: 0">            return</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="18:21-18:30: @8[2]: _11 = _1
+18:21-20:22: @8[3]: _10 = Gt(move _11, const 8_i32)
+18:21-20:22: @8[5]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@6,8⦊</span>countdown</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="18:21-18:30: @8[2]: _11 = _1
+18:21-20:22: @8[3]: _10 = Gt(move _11, const 8_i32)
+18:21-20:22: @8[5]: FakeRead(ForMatchedPlace, _10)">                        &gt;</span></span>
+<span class="line"><span class="code odd" style="--layer: 1" title="18:21-18:30: @8[2]: _11 = _1
+18:21-20:22: @8[3]: _10 = Gt(move _11, const 8_i32)
+18:21-20:22: @8[5]: FakeRead(ForMatchedPlace, _10)">                    8<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">                    </span><span><span class="code even" style="--layer: 1" title="22:24-22:26: @11[1]: _12 = ()
+22:21-22:27: @11[2]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _12)"><span class="annotation">@9,11⦊</span>Ok(())<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">                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="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="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 = ()
+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>
+</body>
+</html>
diff --git a/src/test/run-make-fulldeps/coverage/closure.rs b/src/test/run-make-fulldeps/coverage/closure.rs
new file mode 100644
index 00000000000..66bbbc55399
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/closure.rs
@@ -0,0 +1,93 @@
+#![allow(unused_assignments, unused_variables)]
+
+fn main() {
+    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    // dependent conditions.
+    let is_true = std::env::args().len() == 1;
+    let is_false = ! is_true;
+
+    let mut some_string = Some(String::from("the string content"));
+    println!(
+        "The string or alt: {}"
+        ,
+        some_string
+            .
+            unwrap_or_else
+        (
+            ||
+            {
+                let mut countdown = 0;
+                if is_false {
+                    countdown = 10;
+                }
+                "alt string 1".to_owned()
+            }
+        )
+    );
+
+    some_string = Some(String::from("the string content"));
+    let
+        a
+    =
+        ||
+    {
+        let mut countdown = 0;
+        if is_false {
+            countdown = 10;
+        }
+        "alt string 2".to_owned()
+    };
+    println!(
+        "The string or alt: {}"
+        ,
+        some_string
+            .
+            unwrap_or_else
+        (
+            a
+        )
+    );
+
+    some_string = None;
+    println!(
+        "The string or alt: {}"
+        ,
+        some_string
+            .
+            unwrap_or_else
+        (
+            ||
+            {
+                let mut countdown = 0;
+                if is_false {
+                    countdown = 10;
+                }
+                "alt string 3".to_owned()
+            }
+        )
+    );
+
+    some_string = None;
+    let
+        a
+    =
+        ||
+    {
+        let mut countdown = 0;
+        if is_false {
+            countdown = 10;
+        }
+        "alt string 4".to_owned()
+    };
+    println!(
+        "The string or alt: {}"
+        ,
+        some_string
+            .
+            unwrap_or_else
+        (
+            a
+        )
+    );
+}
diff --git a/src/test/run-make-fulldeps/instrument-coverage/compiletest-ignore-dir b/src/test/run-make-fulldeps/coverage/compiletest-ignore-dir
index d57f66a4489..abf8df8fdc9 100644
--- a/src/test/run-make-fulldeps/instrument-coverage/compiletest-ignore-dir
+++ b/src/test/run-make-fulldeps/coverage/compiletest-ignore-dir
@@ -1,3 +1,3 @@
 # Directory "instrument-coverage" supports the tests at prefix ../instrument-coverage-*
 
-# Use ./x.py [options] test src/test/run-make-fulldeps/instrument-coverage to run all related tests.
\ No newline at end of file
+# Use ./x.py [options] test src/test/run-make-fulldeps/instrument-coverage to run all related tests.
diff --git a/src/test/run-make-fulldeps/instrument-coverage/coverage_tools.mk b/src/test/run-make-fulldeps/coverage/coverage_tools.mk
index ad5f465c54f..ad5f465c54f 100644
--- a/src/test/run-make-fulldeps/instrument-coverage/coverage_tools.mk
+++ b/src/test/run-make-fulldeps/coverage/coverage_tools.mk
diff --git a/src/test/run-make-fulldeps/coverage/drop_trait.rs b/src/test/run-make-fulldeps/coverage/drop_trait.rs
new file mode 100644
index 00000000000..d15bfc0f877
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/drop_trait.rs
@@ -0,0 +1,33 @@
+#![allow(unused_assignments)]
+// expect-exit-status-1
+
+struct Firework {
+    strength: i32,
+}
+
+impl Drop for Firework {
+    fn drop(&mut self) {
+        println!("BOOM times {}!!!", self.strength);
+    }
+}
+
+fn main() -> Result<(),u8> {
+    let _firecracker = Firework { strength: 1 };
+
+    let _tnt = Firework { strength: 100 };
+
+    if true {
+        println!("Exiting with error...");
+        return Err(1);
+    }
+
+    let _ = Firework { strength: 1000 };
+
+    Ok(())
+}
+
+// Expected program output:
+//   Exiting with error...
+//   BOOM times 100!!!
+//   BOOM times 1!!!
+//   Error: 1
diff --git a/src/test/run-make-fulldeps/coverage/generics.rs b/src/test/run-make-fulldeps/coverage/generics.rs
new file mode 100644
index 00000000000..f4e64026944
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/generics.rs
@@ -0,0 +1,44 @@
+#![allow(unused_assignments)]
+// expect-exit-status-1
+
+struct Firework<T> where T: Copy + std::fmt::Display {
+    strength: T,
+}
+
+impl<T> Firework<T> where T: Copy + std::fmt::Display {
+    #[inline(always)]
+    fn set_strength(&mut self, new_strength: T) {
+        self.strength = new_strength;
+    }
+}
+
+impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display {
+    #[inline(always)]
+    fn drop(&mut self) {
+        println!("BOOM times {}!!!", self.strength);
+    }
+}
+
+fn main() -> Result<(),u8> {
+    let mut firecracker = Firework { strength: 1 };
+    firecracker.set_strength(2);
+
+    let mut tnt = Firework { strength: 100.1 };
+    tnt.set_strength(200.1);
+    tnt.set_strength(300.3);
+
+    if true {
+        println!("Exiting with error...");
+        return Err(1);
+    }
+
+    let _ = Firework { strength: 1000 };
+
+    Ok(())
+}
+
+// Expected program output:
+//   Exiting with error...
+//   BOOM times 100!!!
+//   BOOM times 1!!!
+//   Error: 1
diff --git a/src/test/run-make-fulldeps/coverage/if.rs b/src/test/run-make-fulldeps/coverage/if.rs
new file mode 100644
index 00000000000..8ad5042ff7b
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/if.rs
@@ -0,0 +1,28 @@
+#![allow(unused_assignments, unused_variables)]
+
+fn main() {
+    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    // dependent conditions.
+    let
+    is_true
+    =
+        std::env::args().len()
+    ==
+        1
+    ;
+    let
+        mut
+    countdown
+    =
+        0
+    ;
+    if
+        is_true
+    {
+        countdown
+        =
+            10
+        ;
+    }
+}
diff --git a/src/test/run-make-fulldeps/coverage/if_else.rs b/src/test/run-make-fulldeps/coverage/if_else.rs
new file mode 100644
index 00000000000..3ae4b7a7316
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/if_else.rs
@@ -0,0 +1,40 @@
+#![allow(unused_assignments)]
+
+fn main() {
+    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    // dependent conditions.
+    let is_true = std::env::args().len() == 1;
+
+    let mut countdown = 0;
+    if
+        is_true
+    {
+        countdown
+        =
+            10
+        ;
+    }
+    else // Note coverage region difference without semicolon
+    {
+        countdown
+        =
+            100
+    }
+
+    if
+        is_true
+    {
+        countdown
+        =
+            10
+        ;
+    }
+    else
+    {
+        countdown
+        =
+            100
+        ;
+    }
+}
diff --git a/src/test/run-make-fulldeps/coverage/inner_items.rs b/src/test/run-make-fulldeps/coverage/inner_items.rs
new file mode 100644
index 00000000000..66e76513e26
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/inner_items.rs
@@ -0,0 +1,57 @@
+#![allow(unused_assignments, unused_variables)]
+
+fn main() {
+    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    // dependent conditions.
+    let is_true = std::env::args().len() == 1;
+
+    let mut countdown = 0;
+    if is_true {
+        countdown = 10;
+    }
+
+    mod in_mod {
+        const IN_MOD_CONST: u32 = 1000;
+    }
+
+    fn in_func(a: u32) {
+        let b = 1;
+        let c = a + b;
+        println!("c = {}", c)
+    }
+
+    struct InStruct {
+        in_struct_field: u32,
+    }
+
+    const IN_CONST: u32 = 1234;
+
+    trait InTrait {
+        fn trait_func(&mut self, incr: u32);
+
+        fn default_trait_func(&mut self) {
+            in_func(IN_CONST);
+            self.trait_func(IN_CONST);
+        }
+    }
+
+    impl InTrait for InStruct {
+        fn trait_func(&mut self, incr: u32) {
+            self.in_struct_field += incr;
+            in_func(self.in_struct_field);
+        }
+    }
+
+    type InType = String;
+
+    if is_true {
+        in_func(countdown);
+    }
+
+    let mut val = InStruct {
+        in_struct_field: 101,
+    };
+
+    val.default_trait_func();
+}
diff --git a/src/test/run-make-fulldeps/coverage/lazy_boolean.rs b/src/test/run-make-fulldeps/coverage/lazy_boolean.rs
new file mode 100644
index 00000000000..1d83eb30dea
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/lazy_boolean.rs
@@ -0,0 +1,43 @@
+#![allow(unused_assignments, unused_variables)]
+
+fn main() {
+    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    // dependent conditions.
+    let is_true = std::env::args().len() == 1;
+
+    let (mut a, mut b, mut c) = (0, 0, 0);
+    if is_true {
+        a = 1;
+        b = 10;
+        c = 100;
+    }
+    let
+        somebool
+        =
+            a < b
+        ||
+            b < c
+    ;
+    let
+        somebool
+        =
+            b < a
+        ||
+            b < c
+    ;
+    let
+        somebool
+        =
+            a < b
+        &&
+            b < c
+    ;
+    let
+        somebool
+        =
+            b < a
+        &&
+            b < c
+    ;
+}
diff --git a/src/test/run-make-fulldeps/coverage/loop_break_value.rs b/src/test/run-make-fulldeps/coverage/loop_break_value.rs
new file mode 100644
index 00000000000..ba66d136de1
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/loop_break_value.rs
@@ -0,0 +1,13 @@
+#![allow(unused_assignments)]
+
+fn main() {
+    let result
+        =
+            loop
+        {
+            break
+            10
+            ;
+        }
+    ;
+}
diff --git a/src/test/run-make-fulldeps/coverage/simple_loop.rs b/src/test/run-make-fulldeps/coverage/simple_loop.rs
new file mode 100644
index 00000000000..6f7f23475b8
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/simple_loop.rs
@@ -0,0 +1,35 @@
+#![allow(unused_assignments)]
+
+fn main() {
+    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    // dependent conditions.
+    let is_true = std::env::args().len() == 1;
+
+    let mut countdown = 0;
+
+    if
+        is_true
+    {
+        countdown
+        =
+            10
+        ;
+    }
+
+    loop
+    {
+        if
+            countdown
+                ==
+            0
+        {
+            break
+            ;
+        }
+        countdown
+        -=
+        1
+        ;
+    }
+}
diff --git a/src/test/run-make-fulldeps/coverage/simple_match.rs b/src/test/run-make-fulldeps/coverage/simple_match.rs
new file mode 100644
index 00000000000..c9a24f7a9d3
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/simple_match.rs
@@ -0,0 +1,43 @@
+#![allow(unused_assignments)]
+
+fn main() {
+    // Initialize test constants in a way that cannot be determined at compile time, to ensure
+    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+    // dependent conditions.
+    let is_true = std::env::args().len() == 1;
+
+    let mut countdown = 1;
+    if is_true {
+        countdown = 0;
+    }
+
+    for
+        _
+    in
+        0..2
+    {
+        let z
+        ;
+        match
+            countdown
+        {
+            x
+            if
+                x
+                    <
+                1
+            =>
+            {
+                z = countdown
+                ;
+                let y = countdown
+                ;
+                countdown = 10
+                ;
+            }
+            _
+            =>
+            {}
+        }
+    }
+}
diff --git a/src/test/run-make-fulldeps/coverage/try_error_result.rs b/src/test/run-make-fulldeps/coverage/try_error_result.rs
new file mode 100644
index 00000000000..3a8f30e0482
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/try_error_result.rs
@@ -0,0 +1,35 @@
+#![allow(unused_assignments)]
+// expect-exit-status-1
+
+fn call(return_error: bool) -> Result<(),()> {
+    if return_error {
+        Err(())
+    } else {
+        Ok(())
+    }
+}
+
+fn main() -> Result<(),()> {
+    let mut
+        countdown = 10
+    ;
+    for
+        _
+    in
+        0..10
+    {
+        countdown
+            -= 1
+        ;
+        if
+            countdown < 5
+        {
+            call(/*return_error=*/ true)?;
+        }
+        else
+        {
+            call(/*return_error=*/ false)?;
+        }
+    }
+    Ok(())
+}
diff --git a/src/test/run-make-fulldeps/instrument-coverage/coverage_of_if_else.rs b/src/test/run-make-fulldeps/coverage/various_conditions.rs
index 91741cf8f0d..da206e28f31 100644
--- a/src/test/run-make-fulldeps/instrument-coverage/coverage_of_if_else.rs
+++ b/src/test/run-make-fulldeps/coverage/various_conditions.rs
@@ -1,4 +1,4 @@
-#![allow(unused_assignments)]
+#![allow(unused_assignments, unused_variables)]
 
 fn main() {
     let mut countdown = 0;
@@ -6,16 +6,19 @@ fn main() {
         countdown = 10;
     }
 
-    if countdown > 7 {
+    const B: u32 = 100;
+    let x = if countdown > 7 {
         countdown -= 4;
+        B
     } else if countdown > 2 {
         if countdown < 1 || countdown > 5 || countdown != 9 {
             countdown = 0;
         }
         countdown -= 5;
+        countdown
     } else {
         return;
-    }
+    };
 
     let mut countdown = 0;
     if true {
@@ -35,10 +38,10 @@ fn main() {
 
     let mut countdown = 0;
     if true {
-        countdown = 10;
+        countdown = 1;
     }
 
-    if countdown > 7 {
+    let z = if countdown > 7 {
         countdown -= 4;
     } else if countdown > 2 {
         if countdown < 1 || countdown > 5 || countdown != 9 {
@@ -46,6 +49,19 @@ fn main() {
         }
         countdown -= 5;
     } else {
+        let should_be_reachable = countdown;
+        println!("reached");
         return;
-    }
+    };
+
+    let w = if countdown > 7 {
+        countdown -= 4;
+    } else if countdown > 2 {
+        if countdown < 1 || countdown > 5 || countdown != 9 {
+            countdown = 0;
+        }
+        countdown -= 5;
+    } else {
+        return;
+    };
 }
diff --git a/src/test/run-make-fulldeps/coverage/while_early_return.rs b/src/test/run-make-fulldeps/coverage/while_early_return.rs
new file mode 100644
index 00000000000..14ba36238d6
--- /dev/null
+++ b/src/test/run-make-fulldeps/coverage/while_early_return.rs
@@ -0,0 +1,47 @@
+#![allow(unused_assignments)]
+// expect-exit-status-1
+
+fn main() -> Result<(),u8> {
+    let mut countdown = 10;
+    while
+        countdown
+            >
+        0
+    {
+        if
+            countdown
+                <
+            5
+        {
+            return
+                if
+                    countdown
+                        >
+                    8
+                {
+                    Ok(())
+                }
+                else
+                {
+                    Err(1)
+                }
+                ;
+        }
+        countdown
+            -=
+        1
+        ;
+    }
+    Ok(())
+}
+
+// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and
+// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux
+// and MacOS. But on Windows (MSVC, at least), the call to `std::process::exit()` exits the program
+// without saving the InstrProf coverage counters. The use of `std::process:exit()` is not critical
+// to the coverage test for early returns, but this is a limitation that should be fixed.
+//
+// FIXME(richkadel): Consider creating a new tests for coverage when calling `std::process::exit()`,
+// move the `ISSUE` comment to that test, and implement a new test directive that supports skipping
+// coverage tests when targeting specific platforms (at least skipping Windows, or MSVC if the
+// problem exists on MSVC only).
diff --git a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/typical_show_coverage.coverage_of_if_else.txt b/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/typical_show_coverage.coverage_of_if_else.txt
deleted file mode 100644
index 87ce3b4048f..00000000000
--- a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-base/typical_show_coverage.coverage_of_if_else.txt
+++ /dev/null
@@ -1,64 +0,0 @@
-    1|       |#![allow(unused_assignments)]
-    2|       |
-    3|       |fn main() {
-    4|       |    let mut countdown = 0;
-    5|      2|    if true {
-                     ^1
-    6|      2|        countdown = 10;
-    7|      2|    }
-    8|       |
-    9|      2|    if countdown > 7 {
-                     ^1
-   10|      2|        countdown -= 4;
-                      ^1
-   11|      2|    } else if countdown > 2 {
-                         ^0 ^0
-   12|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
-   13|      0|            countdown = 0;
-   14|      0|        }
-   15|      0|        countdown -= 5;
-   16|      0|    } else {
-   17|      0|        return;
-   18|      0|    }
-   19|       |
-   20|       |    let mut countdown = 0;
-   21|      2|    if true {
-                     ^1
-   22|      2|        countdown = 10;
-   23|      2|    }
-   24|       |
-   25|      2|    if countdown > 7 {
-                     ^1
-   26|      2|        countdown -= 4;
-                      ^1
-   27|      2|    } else if countdown > 2 {
-                         ^0 ^0
-   28|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
-   29|      0|            countdown = 0;
-   30|      0|        }
-   31|      0|        countdown -= 5;
-   32|      0|    } else {
-   33|      0|        return;
-   34|      0|    }
-   35|       |
-   36|       |    let mut countdown = 0;
-   37|      2|    if true {
-                     ^1
-   38|      2|        countdown = 10;
-   39|      2|    }
-   40|       |
-   41|      2|    if countdown > 7 {
-                     ^1
-   42|      2|        countdown -= 4;
-                      ^1
-   43|      2|    } else if countdown > 2 {
-                         ^0 ^0
-   44|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
-   45|      0|            countdown = 0;
-   46|      0|        }
-   47|      0|        countdown -= 5;
-   48|      0|    } else {
-   49|      0|        return;
-   50|      0|    }
-   51|      1|}
-
diff --git a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-link-dead-code/typical_show_coverage.coverage_of_if_else.txt b/src/test/run-make-fulldeps/instrument-coverage-cov-reports-link-dead-code/typical_show_coverage.coverage_of_if_else.txt
deleted file mode 100644
index 87ce3b4048f..00000000000
--- a/src/test/run-make-fulldeps/instrument-coverage-cov-reports-link-dead-code/typical_show_coverage.coverage_of_if_else.txt
+++ /dev/null
@@ -1,64 +0,0 @@
-    1|       |#![allow(unused_assignments)]
-    2|       |
-    3|       |fn main() {
-    4|       |    let mut countdown = 0;
-    5|      2|    if true {
-                     ^1
-    6|      2|        countdown = 10;
-    7|      2|    }
-    8|       |
-    9|      2|    if countdown > 7 {
-                     ^1
-   10|      2|        countdown -= 4;
-                      ^1
-   11|      2|    } else if countdown > 2 {
-                         ^0 ^0
-   12|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
-   13|      0|            countdown = 0;
-   14|      0|        }
-   15|      0|        countdown -= 5;
-   16|      0|    } else {
-   17|      0|        return;
-   18|      0|    }
-   19|       |
-   20|       |    let mut countdown = 0;
-   21|      2|    if true {
-                     ^1
-   22|      2|        countdown = 10;
-   23|      2|    }
-   24|       |
-   25|      2|    if countdown > 7 {
-                     ^1
-   26|      2|        countdown -= 4;
-                      ^1
-   27|      2|    } else if countdown > 2 {
-                         ^0 ^0
-   28|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
-   29|      0|            countdown = 0;
-   30|      0|        }
-   31|      0|        countdown -= 5;
-   32|      0|    } else {
-   33|      0|        return;
-   34|      0|    }
-   35|       |
-   36|       |    let mut countdown = 0;
-   37|      2|    if true {
-                     ^1
-   38|      2|        countdown = 10;
-   39|      2|    }
-   40|       |
-   41|      2|    if countdown > 7 {
-                     ^1
-   42|      2|        countdown -= 4;
-                      ^1
-   43|      2|    } else if countdown > 2 {
-                         ^0 ^0
-   44|      0|        if countdown < 1 || countdown > 5 || countdown != 9 {
-   45|      0|            countdown = 0;
-   46|      0|        }
-   47|      0|        countdown -= 5;
-   48|      0|    } else {
-   49|      0|        return;
-   50|      0|    }
-   51|      1|}
-
diff --git a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_if_else/coverage_of_if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_if_else/coverage_of_if_else.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index fcb6afb2636..00000000000
--- a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-base/expected_mir_dump.coverage_of_if_else/coverage_of_if_else.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,641 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>coverage_of_if_else - Code Regions</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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="bb1: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: FalseEdge: falseEdge -&gt; [real: bb3, imaginary: bb2]"><span class="annotation">1⦊</span></span></span><span class="code even" style="--layer: 2" title="bb3: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    6:9-6:23: Assign: _1 = const 10_i32
-    5:13-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"><span class="annotation">3⦊</span></span><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"><span class="annotation">2⦊</span>if </span><span class="code even" style="--layer: 4" title="bb0: ../instrument-coverage/coverage_of_if_else.rs:5:8: 5:12:
-    4:9-4:22: StorageLive: StorageLive(_1)
-    4:25-4:26: Assign: _1 = const 0_i32
-    4:9-4:22: FakeRead: FakeRead(ForLet, _1)
-    5:5-7:6: StorageLive: StorageLive(_2)
-    5:8-5:12: StorageLive: StorageLive(_3)
-    5:8-5:12: Assign: _3 = const true
-    5:8-5:12: FakeRead: FakeRead(ForMatchedPlace, _3)
-    5:5-7:6: SwitchInt: switchInt(_3) -&gt; [false: bb2, otherwise: bb1]"><span class="annotation">0⦊</span>true<span class="annotation">⦉0</span></span><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4">        countdown = 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4">    }<span class="annotation">⦉2</span></span><span class="code even" style="--layer: 2" title="bb3: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    6:9-6:23: Assign: _1 = const 10_i32
-    5:13-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"><span class="annotation">⦉3</span></span><span><span class="code even" style="--layer: 1" title="bb1: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: FalseEdge: falseEdge -&gt; [real: bb3, imaginary: bb2]"><span class="annotation">⦉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="bb5: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    9:5-18:6: FalseEdge: falseEdge -&gt; [real: bb7, imaginary: bb6]"><span class="annotation">5⦊</span></span></span><span class="code even" style="--layer: 2" title="bb8: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    10:9-10:23: Assign: _1 = move (_7.0: i32)
-    9:22-11:6: Assign: _4 = const ()
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">8⦊</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">24⦊</span>if </span><span class="code even" style="--layer: 4" title="bb4: ../instrument-coverage/coverage_of_if_else.rs:9:8: 9:21:
-    7:5-7:6: StorageDead: StorageDead(_3)
-    7:5-7:6: StorageDead: StorageDead(_2)
-    9:5-18:6: StorageLive: StorageLive(_4)
-    9:8-9:21: StorageLive: StorageLive(_5)
-    9:8-9:17: StorageLive: StorageLive(_6)
-    9:8-9:17: Assign: _6 = _1
-    9:8-9:21: Assign: _5 = Gt(move _6, const 7_i32)
-    9:20-9:21: StorageDead: StorageDead(_6)
-    9:8-9:21: FakeRead: FakeRead(ForMatchedPlace, _5)
-    9:5-18:6: SwitchInt: switchInt(_5) -&gt; [false: bb6, otherwise: bb5]"><span class="annotation">4⦊</span>countdown &gt; 7<span class="annotation">⦉4</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25">        </span><span class="code odd" style="--layer: 4" title="bb7: ../instrument-coverage/coverage_of_if_else.rs:10:9: 10:23:
-    10:9-10:23: Assign: _7 = CheckedSub(_1, const 4_i32)
-    10:9-10:23: Assert: assert(!move (_7.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 4_i32) -&gt; [success: bb8, unwind: bb78]"><span class="annotation">7⦊</span>countdown -= 4<span class="annotation">⦉7</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25">;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25">    } else </span><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]"><span class="annotation">9⦊</span>if </span><span class="code even" style="--layer: 5" title="bb6: ../instrument-coverage/coverage_of_if_else.rs:11:15: 11:28:
-    11:15-11:28: StorageLive: StorageLive(_8)
-    11:15-11:24: StorageLive: StorageLive(_9)
-    11:15-11:24: Assign: _9 = _1
-    11:15-11:28: Assign: _8 = Gt(move _9, const 2_i32)
-    11:27-11:28: StorageDead: StorageDead(_9)
-    11:15-11:28: FakeRead: FakeRead(ForMatchedPlace, _8)
-    11:12-18:6: SwitchInt: switchInt(_8) -&gt; [false: bb10, otherwise: bb9]"><span class="annotation">6⦊</span>countdown &gt; 2<span class="annotation">⦉6</span></span><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">        </span><span class="code odd" style="--layer: 5" title="bb20: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: FalseEdge: falseEdge -&gt; [real: bb22, imaginary: bb21]"><span class="annotation">20⦊</span></span><span class="code even" style="--layer: 6" title="bb22: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    13:13-13:26: Assign: _1 = const 0_i32
-    12:61-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">22⦊</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">21⦊</span>if </span><span class="code even" style="--layer: 8" title="bb14: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:46-12:60: StorageLive: StorageLive(_17)
-    12:46-12:55: StorageLive: StorageLive(_18)
-    12:46-12:55: Assign: _18 = _1
-    12:46-12:60: Assign: _17 = Ne(move _18, const 9_i32)
-    12:59-12:60: StorageDead: StorageDead(_18)
-    12:12-12:60: SwitchInt: switchInt(move _17) -&gt; [false: bb13, otherwise: bb12]"><span class="annotation">14⦊</span></span><span class="code even" style="--layer: 9" title="bb11: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:9-14:10: StorageLive: StorageLive(_10)
-    12:12-12:60: StorageLive: StorageLive(_11)
-    12:12-12:42: StorageLive: StorageLive(_12)
-    12:12-12:25: StorageLive: StorageLive(_13)
-    12:12-12:21: StorageLive: StorageLive(_14)
-    12:12-12:21: Assign: _14 = _1
-    12:12-12:25: Assign: _13 = Lt(move _14, const 1_i32)
-    12:24-12:25: StorageDead: StorageDead(_14)
-    12:12-12:42: SwitchInt: switchInt(move _13) -&gt; [false: bb18, otherwise: bb16]"><span class="annotation">11⦊</span></span><span class="code even" style="--layer: 10" title="bb13: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const false
-    12:12-12:60: Goto: goto -&gt; bb15"><span class="annotation">13⦊</span></span><span class="code even" style="--layer: 11" title="bb19: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:41-12:42: StorageDead: StorageDead(_15)
-    12:41-12:42: StorageDead: StorageDead(_13)
-    12:12-12:60: SwitchInt: switchInt(move _12) -&gt; [false: bb14, otherwise: bb12]"><span class="annotation">19⦊</span></span><span class="code even" style="--layer: 12" title="bb15: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:59-12:60: StorageDead: StorageDead(_17)
-    12:59-12:60: StorageDead: StorageDead(_12)
-    12:12-12:60: FakeRead: FakeRead(ForMatchedPlace, _11)
-    12:9-14:10: SwitchInt: switchInt(_11) -&gt; [false: bb21, otherwise: bb20]"><span class="annotation">15⦊</span></span><span class="code even" style="--layer: 13" title="bb12: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const true
-    12:12-12:60: Goto: goto -&gt; bb15"><span class="annotation">12⦊</span></span><span class="code even" style="--layer: 14" title="bb16: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const true
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">16⦊</span></span><span class="code even" style="--layer: 15" title="bb17: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const false
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">17⦊</span></span><span class="code even" style="--layer: 16" title="bb18: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:29-12:42: StorageLive: StorageLive(_15)
-    12:29-12:38: StorageLive: StorageLive(_16)
-    12:29-12:38: Assign: _16 = _1
-    12:29-12:42: Assign: _15 = Gt(move _16, const 5_i32)
-    12:41-12:42: StorageDead: StorageDead(_16)
-    12:12-12:42: SwitchInt: switchInt(move _15) -&gt; [false: bb17, otherwise: bb16]"><span class="annotation">18⦊</span>countdown &lt; 1 || countdown &gt; 5<span class="annotation">⦉18</span></span><span class="code even" style="--layer: 15" title="bb17: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const false
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">⦉17</span></span><span class="code even" style="--layer: 14" title="bb16: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const true
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">⦉16</span></span><span class="code even" style="--layer: 13" title="bb12: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const true
-    12:12-12:60: Goto: goto -&gt; bb15"> || countdown != 9<span class="annotation">⦉12</span></span><span class="code even" style="--layer: 12" title="bb15: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:59-12:60: StorageDead: StorageDead(_17)
-    12:59-12:60: StorageDead: StorageDead(_12)
-    12:12-12:60: FakeRead: FakeRead(ForMatchedPlace, _11)
-    12:9-14:10: SwitchInt: switchInt(_11) -&gt; [false: bb21, otherwise: bb20]"><span class="annotation">⦉15</span></span><span class="code even" style="--layer: 11" title="bb19: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:41-12:42: StorageDead: StorageDead(_15)
-    12:41-12:42: StorageDead: StorageDead(_13)
-    12:12-12:60: SwitchInt: switchInt(move _12) -&gt; [false: bb14, otherwise: bb12]"><span class="annotation">⦉19</span></span><span class="code even" style="--layer: 10" title="bb13: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const false
-    12:12-12:60: Goto: goto -&gt; bb15"><span class="annotation">⦉13</span></span><span class="code even" style="--layer: 9" title="bb11: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:9-14:10: StorageLive: StorageLive(_10)
-    12:12-12:60: StorageLive: StorageLive(_11)
-    12:12-12:42: StorageLive: StorageLive(_12)
-    12:12-12:25: StorageLive: StorageLive(_13)
-    12:12-12:21: StorageLive: StorageLive(_14)
-    12:12-12:21: Assign: _14 = _1
-    12:12-12:25: Assign: _13 = Lt(move _14, const 1_i32)
-    12:24-12:25: StorageDead: StorageDead(_14)
-    12:12-12:42: SwitchInt: switchInt(move _13) -&gt; [false: bb18, otherwise: bb16]"><span class="annotation">⦉11</span></span><span class="code even" style="--layer: 8" title="bb14: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:46-12:60: StorageLive: StorageLive(_17)
-    12:46-12:55: StorageLive: StorageLive(_18)
-    12:46-12:55: Assign: _18 = _1
-    12:46-12:60: Assign: _17 = Ne(move _18, const 9_i32)
-    12:59-12:60: StorageDead: StorageDead(_18)
-    12:12-12:60: SwitchInt: switchInt(move _17) -&gt; [false: bb13, otherwise: bb12]"><span class="annotation">⦉14</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23">        </span><span class="code odd" style="--layer: 8" title="bb23: ../instrument-coverage/coverage_of_if_else.rs:14:9: 15:23:
-    14:9-14:10: StorageDead: StorageDead(_11)
-    14:9-14:10: StorageDead: StorageDead(_10)
-    15:9-15:23: Assign: _19 = CheckedSub(_1, const 5_i32)
-    15:9-15:23: Assert: assert(!move (_19.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 5_i32) -&gt; [success: bb24, unwind: bb78]"><span class="annotation">23⦊</span>}</span><span class="code odd" style="--layer: 5" title="bb20: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: FalseEdge: falseEdge -&gt; [real: bb22, imaginary: bb21]"><span class="annotation">⦉20</span></span><span class="code even" style="--layer: 6" title="bb22: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    13:13-13:26: Assign: _1 = const 0_i32
-    12:61-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">⦉22</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">⦉21</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">⦉21</span></span><span class="code odd" style="--layer: 8" title="bb23: ../instrument-coverage/coverage_of_if_else.rs:14:9: 15:23:
-    14:9-14:10: StorageDead: StorageDead(_11)
-    14:9-14:10: StorageDead: StorageDead(_10)
-    15:9-15:23: Assign: _19 = CheckedSub(_1, const 5_i32)
-    15:9-15:23: Assert: assert(!move (_19.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 5_i32) -&gt; [success: bb24, unwind: bb78]"></span></span>
-<span class="line"><span class="code odd" style="--layer: 8" title="bb23: ../instrument-coverage/coverage_of_if_else.rs:14:9: 15:23:
-    14:9-14:10: StorageDead: StorageDead(_11)
-    14:9-14:10: StorageDead: StorageDead(_10)
-    15:9-15:23: Assign: _19 = CheckedSub(_1, const 5_i32)
-    15:9-15:23: Assert: assert(!move (_19.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 5_i32) -&gt; [success: bb24, unwind: bb78]">        countdown -= 5<span class="annotation">⦉23</span></span><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">    } else {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">        return;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">    }<span class="annotation">⦉9</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">⦉24</span></span><span class="code even" style="--layer: 2" title="bb8: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    10:9-10:23: Assign: _1 = move (_7.0: i32)
-    9:22-11:6: Assign: _4 = const ()
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">⦉8</span></span><span><span class="code odd" style="--layer: 1" title="bb5: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    9:5-18:6: FalseEdge: falseEdge -&gt; [real: bb7, imaginary: bb6]"><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">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="bb27: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><span class="annotation">27⦊</span></span></span><span class="code even" style="--layer: 2" title="bb28: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    22:9-22:23: Assign: _21 = const 10_i32
-    21:13-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><span class="annotation">28⦊</span></span><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]"><span class="annotation">26⦊</span>if </span><span class="code even" style="--layer: 4" title="bb25: ../instrument-coverage/coverage_of_if_else.rs:21:8: 21:12:
-    18:5-18:6: StorageDead: StorageDead(_5)
-    18:5-18:6: StorageDead: StorageDead(_4)
-    20:9-20:22: StorageLive: StorageLive(_21)
-    20:25-20:26: Assign: _21 = const 0_i32
-    20:9-20:22: FakeRead: FakeRead(ForLet, _21)
-    21:5-23:6: StorageLive: StorageLive(_22)
-    21:8-21:12: StorageLive: StorageLive(_23)
-    21:8-21:12: Assign: _23 = const true
-    21:8-21:12: FakeRead: FakeRead(ForMatchedPlace, _23)
-    21:5-23:6: SwitchInt: switchInt(_23) -&gt; [false: bb27, otherwise: bb26]"><span class="annotation">25⦊</span>true<span class="annotation">⦉25</span></span><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]">        countdown = 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]">    }<span class="annotation">⦉26</span></span><span class="code even" style="--layer: 2" title="bb28: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    22:9-22:23: Assign: _21 = const 10_i32
-    21:13-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><span class="annotation">⦉28</span></span><span><span class="code even" style="--layer: 1" title="bb27: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><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">    </span><span><span class="code odd" style="--layer: 1" title="bb49: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    31:9-31:23: Assign: _21 = move (_39.0: i32)
-    27:29-32:6: Assign: _24 = const ()
-    34:5-34:6: StorageDead: StorageDead(_28)
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">49⦊</span></span></span><span class="code even" style="--layer: 2" title="bb33: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    26:9-26:23: Assign: _21 = move (_27.0: i32)
-    25:22-27:6: Assign: _24 = const ()
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">33⦊</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]"><span class="annotation">30⦊</span>if </span><span class="code even" style="--layer: 4" title="bb29: ../instrument-coverage/coverage_of_if_else.rs:25:8: 25:21:
-    23:5-23:6: StorageDead: StorageDead(_23)
-    23:5-23:6: StorageDead: StorageDead(_22)
-    25:5-34:6: StorageLive: StorageLive(_24)
-    25:8-25:21: StorageLive: StorageLive(_25)
-    25:8-25:17: StorageLive: StorageLive(_26)
-    25:8-25:17: Assign: _26 = _21
-    25:8-25:21: Assign: _25 = Gt(move _26, const 7_i32)
-    25:20-25:21: StorageDead: StorageDead(_26)
-    25:8-25:21: FakeRead: FakeRead(ForMatchedPlace, _25)
-    25:5-34:6: SwitchInt: switchInt(_25) -&gt; [false: bb31, otherwise: bb30]"><span class="annotation">29⦊</span>countdown &gt; 7<span class="annotation">⦉29</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]">        </span><span class="code odd" style="--layer: 4" title="bb32: ../instrument-coverage/coverage_of_if_else.rs:26:9: 26:23:
-    26:9-26:23: Assign: _27 = CheckedSub(_21, const 4_i32)
-    26:9-26:23: Assert: assert(!move (_27.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 4_i32) -&gt; [success: bb33, unwind: bb78]"><span class="annotation">32⦊</span>countdown -= 4<span class="annotation">⦉32</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]">    } else </span><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]"><span class="annotation">34⦊</span>if </span><span class="code even" style="--layer: 5" title="bb31: ../instrument-coverage/coverage_of_if_else.rs:27:15: 27:28:
-    27:15-27:28: StorageLive: StorageLive(_28)
-    27:15-27:24: StorageLive: StorageLive(_29)
-    27:15-27:24: Assign: _29 = _21
-    27:15-27:28: Assign: _28 = Gt(move _29, const 2_i32)
-    27:27-27:28: StorageDead: StorageDead(_29)
-    27:15-27:28: FakeRead: FakeRead(ForMatchedPlace, _28)
-    27:12-34:6: SwitchInt: switchInt(_28) -&gt; [false: bb35, otherwise: bb34]"><span class="annotation">31⦊</span>countdown &gt; 2<span class="annotation">⦉31</span></span><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">        </span><span class="code odd" style="--layer: 5" title="bb46: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">46⦊</span></span><span class="code even" style="--layer: 6" title="bb47: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    29:13-29:26: Assign: _21 = const 0_i32
-    28:61-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">47⦊</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"><span class="annotation">45⦊</span>if </span><span class="code even" style="--layer: 8" title="bb44: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:41-28:42: StorageDead: StorageDead(_35)
-    28:41-28:42: StorageDead: StorageDead(_33)
-    28:12-28:60: SwitchInt: switchInt(move _32) -&gt; [false: bb39, otherwise: bb37]"><span class="annotation">44⦊</span></span><span class="code even" style="--layer: 9" title="bb38: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const false
-    28:12-28:60: Goto: goto -&gt; bb40"><span class="annotation">38⦊</span></span><span class="code even" style="--layer: 10" title="bb39: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:46-28:60: StorageLive: StorageLive(_37)
-    28:46-28:55: StorageLive: StorageLive(_38)
-    28:46-28:55: Assign: _38 = _21
-    28:46-28:60: Assign: _37 = Ne(move _38, const 9_i32)
-    28:59-28:60: StorageDead: StorageDead(_38)
-    28:12-28:60: SwitchInt: switchInt(move _37) -&gt; [false: bb38, otherwise: bb37]"><span class="annotation">39⦊</span></span><span class="code even" style="--layer: 11" title="bb40: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:59-28:60: StorageDead: StorageDead(_37)
-    28:59-28:60: StorageDead: StorageDead(_32)
-    28:12-28:60: FakeRead: FakeRead(ForMatchedPlace, _31)
-    28:9-30:10: SwitchInt: switchInt(_31) -&gt; [false: bb46, otherwise: bb45]"><span class="annotation">40⦊</span></span><span class="code even" style="--layer: 12" title="bb36: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:9-30:10: StorageLive: StorageLive(_30)
-    28:12-28:60: StorageLive: StorageLive(_31)
-    28:12-28:42: StorageLive: StorageLive(_32)
-    28:12-28:25: StorageLive: StorageLive(_33)
-    28:12-28:21: StorageLive: StorageLive(_34)
-    28:12-28:21: Assign: _34 = _21
-    28:12-28:25: Assign: _33 = Lt(move _34, const 1_i32)
-    28:24-28:25: StorageDead: StorageDead(_34)
-    28:12-28:42: SwitchInt: switchInt(move _33) -&gt; [false: bb43, otherwise: bb41]"><span class="annotation">36⦊</span></span><span class="code even" style="--layer: 13" title="bb37: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const true
-    28:12-28:60: Goto: goto -&gt; bb40"><span class="annotation">37⦊</span></span><span class="code even" style="--layer: 14" title="bb41: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const true
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">41⦊</span></span><span class="code even" style="--layer: 15" title="bb42: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const false
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">42⦊</span></span><span class="code even" style="--layer: 16" title="bb43: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:29-28:42: StorageLive: StorageLive(_35)
-    28:29-28:38: StorageLive: StorageLive(_36)
-    28:29-28:38: Assign: _36 = _21
-    28:29-28:42: Assign: _35 = Gt(move _36, const 5_i32)
-    28:41-28:42: StorageDead: StorageDead(_36)
-    28:12-28:42: SwitchInt: switchInt(move _35) -&gt; [false: bb42, otherwise: bb41]"><span class="annotation">43⦊</span>countdown &lt; 1 || countdown &gt; 5<span class="annotation">⦉43</span></span><span class="code even" style="--layer: 15" title="bb42: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const false
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">⦉42</span></span><span class="code even" style="--layer: 14" title="bb41: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const true
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">⦉41</span></span><span class="code even" style="--layer: 13" title="bb37: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const true
-    28:12-28:60: Goto: goto -&gt; bb40"> || countdown != 9<span class="annotation">⦉37</span></span><span class="code even" style="--layer: 12" title="bb36: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:9-30:10: StorageLive: StorageLive(_30)
-    28:12-28:60: StorageLive: StorageLive(_31)
-    28:12-28:42: StorageLive: StorageLive(_32)
-    28:12-28:25: StorageLive: StorageLive(_33)
-    28:12-28:21: StorageLive: StorageLive(_34)
-    28:12-28:21: Assign: _34 = _21
-    28:12-28:25: Assign: _33 = Lt(move _34, const 1_i32)
-    28:24-28:25: StorageDead: StorageDead(_34)
-    28:12-28:42: SwitchInt: switchInt(move _33) -&gt; [false: bb43, otherwise: bb41]"><span class="annotation">⦉36</span></span><span class="code even" style="--layer: 11" title="bb40: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:59-28:60: StorageDead: StorageDead(_37)
-    28:59-28:60: StorageDead: StorageDead(_32)
-    28:12-28:60: FakeRead: FakeRead(ForMatchedPlace, _31)
-    28:9-30:10: SwitchInt: switchInt(_31) -&gt; [false: bb46, otherwise: bb45]"><span class="annotation">⦉40</span></span><span class="code even" style="--layer: 10" title="bb39: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:46-28:60: StorageLive: StorageLive(_37)
-    28:46-28:55: StorageLive: StorageLive(_38)
-    28:46-28:55: Assign: _38 = _21
-    28:46-28:60: Assign: _37 = Ne(move _38, const 9_i32)
-    28:59-28:60: StorageDead: StorageDead(_38)
-    28:12-28:60: SwitchInt: switchInt(move _37) -&gt; [false: bb38, otherwise: bb37]"><span class="annotation">⦉39</span></span><span class="code even" style="--layer: 9" title="bb38: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const false
-    28:12-28:60: Goto: goto -&gt; bb40"><span class="annotation">⦉38</span></span><span class="code even" style="--layer: 8" title="bb44: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:41-28:42: StorageDead: StorageDead(_35)
-    28:41-28:42: StorageDead: StorageDead(_33)
-    28:12-28:60: SwitchInt: switchInt(move _32) -&gt; [false: bb39, otherwise: bb37]"><span class="annotation">⦉44</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]">        </span><span class="code odd" style="--layer: 8" title="bb48: ../instrument-coverage/coverage_of_if_else.rs:30:9: 31:23:
-    30:9-30:10: StorageDead: StorageDead(_31)
-    30:9-30:10: StorageDead: StorageDead(_30)
-    31:9-31:23: Assign: _39 = CheckedSub(_21, const 5_i32)
-    31:9-31:23: Assert: assert(!move (_39.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 5_i32) -&gt; [success: bb49, unwind: bb78]"><span class="annotation">48⦊</span>}</span><span class="code odd" style="--layer: 5" title="bb46: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">⦉46</span></span><span class="code even" style="--layer: 6" title="bb47: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    29:13-29:26: Assign: _21 = const 0_i32
-    28:61-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">⦉47</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"><span class="annotation">⦉45</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"><span class="annotation">⦉45</span></span><span class="code odd" style="--layer: 8" title="bb48: ../instrument-coverage/coverage_of_if_else.rs:30:9: 31:23:
-    30:9-30:10: StorageDead: StorageDead(_31)
-    30:9-30:10: StorageDead: StorageDead(_30)
-    31:9-31:23: Assign: _39 = CheckedSub(_21, const 5_i32)
-    31:9-31:23: Assert: assert(!move (_39.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 5_i32) -&gt; [success: bb49, unwind: bb78]"></span></span>
-<span class="line"><span class="code odd" style="--layer: 8" title="bb48: ../instrument-coverage/coverage_of_if_else.rs:30:9: 31:23:
-    30:9-30:10: StorageDead: StorageDead(_31)
-    30:9-30:10: StorageDead: StorageDead(_30)
-    31:9-31:23: Assign: _39 = CheckedSub(_21, const 5_i32)
-    31:9-31:23: Assert: assert(!move (_39.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 5_i32) -&gt; [success: bb49, unwind: bb78]">        countdown -= 5<span class="annotation">⦉48</span></span><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">    } else {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">        return;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">    }<span class="annotation">⦉34</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]"><span class="annotation">⦉30</span></span><span class="code even" style="--layer: 2" title="bb33: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    26:9-26:23: Assign: _21 = move (_27.0: i32)
-    25:22-27:6: Assign: _24 = const ()
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">⦉33</span></span><span><span class="code odd" style="--layer: 1" title="bb49: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    31:9-31:23: Assign: _21 = move (_39.0: i32)
-    27:29-32:6: Assign: _24 = const ()
-    34:5-34:6: StorageDead: StorageDead(_28)
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">⦉49</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 mut countdown = 0;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="bb52: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"><span class="annotation">52⦊</span></span></span><span class="code even" style="--layer: 2" title="bb51: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: FalseEdge: falseEdge -&gt; [real: bb53, imaginary: bb52]"><span class="annotation">51⦊</span></span><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"><span class="annotation">53⦊</span>if </span><span class="code even" style="--layer: 4" title="bb50: ../instrument-coverage/coverage_of_if_else.rs:37:8: 37:12:
-    34:5-34:6: StorageDead: StorageDead(_25)
-    34:5-34:6: StorageDead: StorageDead(_24)
-    36:9-36:22: StorageLive: StorageLive(_41)
-    36:25-36:26: Assign: _41 = const 0_i32
-    36:9-36:22: FakeRead: FakeRead(ForLet, _41)
-    37:5-39:6: StorageLive: StorageLive(_42)
-    37:8-37:12: StorageLive: StorageLive(_43)
-    37:8-37:12: Assign: _43 = const true
-    37:8-37:12: FakeRead: FakeRead(ForMatchedPlace, _43)
-    37:5-39:6: SwitchInt: switchInt(_43) -&gt; [false: bb52, otherwise: bb51]"><span class="annotation">50⦊</span>true<span class="annotation">⦉50</span></span><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54">        countdown = 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54">    }<span class="annotation">⦉53</span></span><span class="code even" style="--layer: 2" title="bb51: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: FalseEdge: falseEdge -&gt; [real: bb53, imaginary: bb52]"><span class="annotation">⦉51</span></span><span><span class="code even" style="--layer: 1" title="bb52: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"><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">    </span><span><span class="code odd" style="--layer: 1" title="bb74: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    47:9-47:23: Assign: _41 = move (_58.0: i32)
-    43:29-48:6: Assign: _0 = const ()
-    50:5-50:6: StorageDead: StorageDead(_47)
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">74⦊</span></span></span><span class="code even" style="--layer: 2" title="bb55: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    41:5-50:6: FalseEdge: falseEdge -&gt; [real: bb57, imaginary: bb56]"><span class="annotation">55⦊</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">58⦊</span>if </span><span class="code even" style="--layer: 4" title="bb54: ../instrument-coverage/coverage_of_if_else.rs:41:8: 41:21:
-    39:5-39:6: StorageDead: StorageDead(_43)
-    39:5-39:6: StorageDead: StorageDead(_42)
-    41:8-41:21: StorageLive: StorageLive(_44)
-    41:8-41:17: StorageLive: StorageLive(_45)
-    41:8-41:17: Assign: _45 = _41
-    41:8-41:21: Assign: _44 = Gt(move _45, const 7_i32)
-    41:20-41:21: StorageDead: StorageDead(_45)
-    41:8-41:21: FakeRead: FakeRead(ForMatchedPlace, _44)
-    41:5-50:6: SwitchInt: switchInt(_44) -&gt; [false: bb56, otherwise: bb55]"><span class="annotation">54⦊</span>countdown &gt; 7<span class="annotation">⦉54</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75">        </span><span class="code odd" style="--layer: 4" title="bb57: ../instrument-coverage/coverage_of_if_else.rs:42:9: 42:23:
-    42:9-42:23: Assign: _46 = CheckedSub(_41, const 4_i32)
-    42:9-42:23: Assert: assert(!move (_46.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 4_i32) -&gt; [success: bb58, unwind: bb78]"><span class="annotation">57⦊</span>countdown -= 4<span class="annotation">⦉57</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75">;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75">    } else </span><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]"><span class="annotation">59⦊</span>if </span><span class="code even" style="--layer: 5" title="bb56: ../instrument-coverage/coverage_of_if_else.rs:43:15: 43:28:
-    43:15-43:28: StorageLive: StorageLive(_47)
-    43:15-43:24: StorageLive: StorageLive(_48)
-    43:15-43:24: Assign: _48 = _41
-    43:15-43:28: Assign: _47 = Gt(move _48, const 2_i32)
-    43:27-43:28: StorageDead: StorageDead(_48)
-    43:15-43:28: FakeRead: FakeRead(ForMatchedPlace, _47)
-    43:12-50:6: SwitchInt: switchInt(_47) -&gt; [false: bb60, otherwise: bb59]"><span class="annotation">56⦊</span>countdown &gt; 2<span class="annotation">⦉56</span></span><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">        </span><span class="code odd" style="--layer: 5" title="bb71: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">71⦊</span></span><span class="code even" style="--layer: 6" title="bb72: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    45:13-45:26: Assign: _41 = const 0_i32
-    44:61-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">72⦊</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"><span class="annotation">70⦊</span>if </span><span class="code even" style="--layer: 8" title="bb63: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const false
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">63⦊</span></span><span class="code even" style="--layer: 9" title="bb64: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:46-44:60: StorageLive: StorageLive(_56)
-    44:46-44:55: StorageLive: StorageLive(_57)
-    44:46-44:55: Assign: _57 = _41
-    44:46-44:60: Assign: _56 = Ne(move _57, const 9_i32)
-    44:59-44:60: StorageDead: StorageDead(_57)
-    44:12-44:60: SwitchInt: switchInt(move _56) -&gt; [false: bb63, otherwise: bb62]"><span class="annotation">64⦊</span></span><span class="code even" style="--layer: 10" title="bb65: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:59-44:60: StorageDead: StorageDead(_56)
-    44:59-44:60: StorageDead: StorageDead(_51)
-    44:12-44:60: FakeRead: FakeRead(ForMatchedPlace, _50)
-    44:9-46:10: SwitchInt: switchInt(_50) -&gt; [false: bb71, otherwise: bb70]"><span class="annotation">65⦊</span></span><span class="code even" style="--layer: 11" title="bb62: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const true
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">62⦊</span></span><span class="code even" style="--layer: 12" title="bb69: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:41-44:42: StorageDead: StorageDead(_54)
-    44:41-44:42: StorageDead: StorageDead(_52)
-    44:12-44:60: SwitchInt: switchInt(move _51) -&gt; [false: bb64, otherwise: bb62]"><span class="annotation">69⦊</span></span><span class="code even" style="--layer: 13" title="bb61: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:9-46:10: StorageLive: StorageLive(_49)
-    44:12-44:60: StorageLive: StorageLive(_50)
-    44:12-44:42: StorageLive: StorageLive(_51)
-    44:12-44:25: StorageLive: StorageLive(_52)
-    44:12-44:21: StorageLive: StorageLive(_53)
-    44:12-44:21: Assign: _53 = _41
-    44:12-44:25: Assign: _52 = Lt(move _53, const 1_i32)
-    44:24-44:25: StorageDead: StorageDead(_53)
-    44:12-44:42: SwitchInt: switchInt(move _52) -&gt; [false: bb68, otherwise: bb66]"><span class="annotation">61⦊</span></span><span class="code even" style="--layer: 14" title="bb67: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:12-44:42: Assign: _51 = const false
-    44:12-44:42: Goto: goto -&gt; bb69"><span class="annotation">67⦊</span></span><span class="code even" style="--layer: 15" title="bb68: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:29-44:42: StorageLive: StorageLive(_54)
-    44:29-44:38: StorageLive: StorageLive(_55)
-    44:29-44:38: Assign: _55 = _41
-    44:29-44:42: Assign: _54 = Gt(move _55, const 5_i32)
-    44:41-44:42: StorageDead: StorageDead(_55)
-    44:12-44:42: SwitchInt: switchInt(move _54) -&gt; [false: bb67, otherwise: bb66]"><span class="annotation">68⦊</span></span><span class="code even" style="--layer: 16" title="bb66: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:12-44:42: Assign: _51 = const true
-    44:12-44:42: Goto: goto -&gt; bb69"><span class="annotation">66⦊</span>countdown &lt; 1 || countdown &gt; 5<span class="annotation">⦉66</span></span><span class="code even" style="--layer: 15" title="bb68: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:29-44:42: StorageLive: StorageLive(_54)
-    44:29-44:38: StorageLive: StorageLive(_55)
-    44:29-44:38: Assign: _55 = _41
-    44:29-44:42: Assign: _54 = Gt(move _55, const 5_i32)
-    44:41-44:42: StorageDead: StorageDead(_55)
-    44:12-44:42: SwitchInt: switchInt(move _54) -&gt; [false: bb67, otherwise: bb66]"><span class="annotation">⦉68</span></span><span class="code even" style="--layer: 14" title="bb67: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:12-44:42: Assign: _51 = const false
-    44:12-44:42: Goto: goto -&gt; bb69"><span class="annotation">⦉67</span></span><span class="code even" style="--layer: 13" title="bb61: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:9-46:10: StorageLive: StorageLive(_49)
-    44:12-44:60: StorageLive: StorageLive(_50)
-    44:12-44:42: StorageLive: StorageLive(_51)
-    44:12-44:25: StorageLive: StorageLive(_52)
-    44:12-44:21: StorageLive: StorageLive(_53)
-    44:12-44:21: Assign: _53 = _41
-    44:12-44:25: Assign: _52 = Lt(move _53, const 1_i32)
-    44:24-44:25: StorageDead: StorageDead(_53)
-    44:12-44:42: SwitchInt: switchInt(move _52) -&gt; [false: bb68, otherwise: bb66]"> || countdown != 9<span class="annotation">⦉61</span></span><span class="code even" style="--layer: 12" title="bb69: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:41-44:42: StorageDead: StorageDead(_54)
-    44:41-44:42: StorageDead: StorageDead(_52)
-    44:12-44:60: SwitchInt: switchInt(move _51) -&gt; [false: bb64, otherwise: bb62]"><span class="annotation">⦉69</span></span><span class="code even" style="--layer: 11" title="bb62: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const true
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">⦉62</span></span><span class="code even" style="--layer: 10" title="bb65: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:59-44:60: StorageDead: StorageDead(_56)
-    44:59-44:60: StorageDead: StorageDead(_51)
-    44:12-44:60: FakeRead: FakeRead(ForMatchedPlace, _50)
-    44:9-46:10: SwitchInt: switchInt(_50) -&gt; [false: bb71, otherwise: bb70]"><span class="annotation">⦉65</span></span><span class="code even" style="--layer: 9" title="bb64: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:46-44:60: StorageLive: StorageLive(_56)
-    44:46-44:55: StorageLive: StorageLive(_57)
-    44:46-44:55: Assign: _57 = _41
-    44:46-44:60: Assign: _56 = Ne(move _57, const 9_i32)
-    44:59-44:60: StorageDead: StorageDead(_57)
-    44:12-44:60: SwitchInt: switchInt(move _56) -&gt; [false: bb63, otherwise: bb62]"><span class="annotation">⦉64</span></span><span class="code even" style="--layer: 8" title="bb63: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const false
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">⦉63</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]">        </span><span class="code odd" style="--layer: 8" title="bb73: ../instrument-coverage/coverage_of_if_else.rs:46:9: 47:23:
-    46:9-46:10: StorageDead: StorageDead(_50)
-    46:9-46:10: StorageDead: StorageDead(_49)
-    47:9-47:23: Assign: _58 = CheckedSub(_41, const 5_i32)
-    47:9-47:23: Assert: assert(!move (_58.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 5_i32) -&gt; [success: bb74, unwind: bb78]"><span class="annotation">73⦊</span>}</span><span class="code odd" style="--layer: 5" title="bb71: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">⦉71</span></span><span class="code even" style="--layer: 6" title="bb72: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    45:13-45:26: Assign: _41 = const 0_i32
-    44:61-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">⦉72</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"><span class="annotation">⦉70</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"><span class="annotation">⦉70</span></span><span class="code odd" style="--layer: 8" title="bb73: ../instrument-coverage/coverage_of_if_else.rs:46:9: 47:23:
-    46:9-46:10: StorageDead: StorageDead(_50)
-    46:9-46:10: StorageDead: StorageDead(_49)
-    47:9-47:23: Assign: _58 = CheckedSub(_41, const 5_i32)
-    47:9-47:23: Assert: assert(!move (_58.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 5_i32) -&gt; [success: bb74, unwind: bb78]"></span></span>
-<span class="line"><span class="code odd" style="--layer: 8" title="bb73: ../instrument-coverage/coverage_of_if_else.rs:46:9: 47:23:
-    46:9-46:10: StorageDead: StorageDead(_50)
-    46:9-46:10: StorageDead: StorageDead(_49)
-    47:9-47:23: Assign: _58 = CheckedSub(_41, const 5_i32)
-    47:9-47:23: Assert: assert(!move (_58.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 5_i32) -&gt; [success: bb74, unwind: bb78]">        countdown -= 5<span class="annotation">⦉73</span></span><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">    } else {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">        return;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">    }<span class="annotation">⦉59</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">⦉58</span></span><span class="code even" style="--layer: 2" title="bb55: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    41:5-50:6: FalseEdge: falseEdge -&gt; [real: bb57, imaginary: bb56]"><span class="annotation">⦉55</span></span><span><span class="code odd" style="--layer: 1" title="bb74: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    47:9-47:23: Assign: _41 = move (_58.0: i32)
-    43:29-48:6: Assign: _0 = const ()
-    50:5-50:6: StorageDead: StorageDead(_47)
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">⦉74</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span><span class="code even" style="--layer: 1" title="bb75: ../instrument-coverage/coverage_of_if_else.rs:51:1: 51:2:
-    51:1-51:2: StorageDead: StorageDead(_41)
-    51:1-51:2: StorageDead: StorageDead(_21)
-    51:1-51:2: StorageDead: StorageDead(_1)
-    51:1-51:2: StorageDead: StorageDead(_44)
-    51:2-51:2: Goto: goto -&gt; bb77"><span class="annotation">75⦊</span>}<span class="annotation">⦉75</span></span></span><span><span class="code odd" style="--layer: 1" title="bb77: ../instrument-coverage/coverage_of_if_else.rs:51:2: 51:2:
-    51:2-51:2: Return: return"><span class="annotation">77⦊</span>‸<span class="annotation">⦉77</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-link-dead-code/expected_mir_dump.coverage_of_if_else/coverage_of_if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-link-dead-code/expected_mir_dump.coverage_of_if_else/coverage_of_if_else.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index fcb6afb2636..00000000000
--- a/src/test/run-make-fulldeps/instrument-coverage-mir-cov-html-link-dead-code/expected_mir_dump.coverage_of_if_else/coverage_of_if_else.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,641 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>coverage_of_if_else - Code Regions</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 2"><span class="line"><span class="code" style="--layer: 0">fn main() {</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="bb1: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: FalseEdge: falseEdge -&gt; [real: bb3, imaginary: bb2]"><span class="annotation">1⦊</span></span></span><span class="code even" style="--layer: 2" title="bb3: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    6:9-6:23: Assign: _1 = const 10_i32
-    5:13-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"><span class="annotation">3⦊</span></span><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"><span class="annotation">2⦊</span>if </span><span class="code even" style="--layer: 4" title="bb0: ../instrument-coverage/coverage_of_if_else.rs:5:8: 5:12:
-    4:9-4:22: StorageLive: StorageLive(_1)
-    4:25-4:26: Assign: _1 = const 0_i32
-    4:9-4:22: FakeRead: FakeRead(ForLet, _1)
-    5:5-7:6: StorageLive: StorageLive(_2)
-    5:8-5:12: StorageLive: StorageLive(_3)
-    5:8-5:12: Assign: _3 = const true
-    5:8-5:12: FakeRead: FakeRead(ForMatchedPlace, _3)
-    5:5-7:6: SwitchInt: switchInt(_3) -&gt; [false: bb2, otherwise: bb1]"><span class="annotation">0⦊</span>true<span class="annotation">⦉0</span></span><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4">        countdown = 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb2: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4">    }<span class="annotation">⦉2</span></span><span class="code even" style="--layer: 2" title="bb3: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    6:9-6:23: Assign: _1 = const 10_i32
-    5:13-7:6: Assign: _2 = const ()
-    5:5-7:6: Goto: goto -&gt; bb4"><span class="annotation">⦉3</span></span><span><span class="code even" style="--layer: 1" title="bb1: ../instrument-coverage/coverage_of_if_else.rs:5:5: 7:6:
-    5:5-7:6: FalseEdge: falseEdge -&gt; [real: bb3, imaginary: bb2]"><span class="annotation">⦉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="bb5: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    9:5-18:6: FalseEdge: falseEdge -&gt; [real: bb7, imaginary: bb6]"><span class="annotation">5⦊</span></span></span><span class="code even" style="--layer: 2" title="bb8: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    10:9-10:23: Assign: _1 = move (_7.0: i32)
-    9:22-11:6: Assign: _4 = const ()
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">8⦊</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">24⦊</span>if </span><span class="code even" style="--layer: 4" title="bb4: ../instrument-coverage/coverage_of_if_else.rs:9:8: 9:21:
-    7:5-7:6: StorageDead: StorageDead(_3)
-    7:5-7:6: StorageDead: StorageDead(_2)
-    9:5-18:6: StorageLive: StorageLive(_4)
-    9:8-9:21: StorageLive: StorageLive(_5)
-    9:8-9:17: StorageLive: StorageLive(_6)
-    9:8-9:17: Assign: _6 = _1
-    9:8-9:21: Assign: _5 = Gt(move _6, const 7_i32)
-    9:20-9:21: StorageDead: StorageDead(_6)
-    9:8-9:21: FakeRead: FakeRead(ForMatchedPlace, _5)
-    9:5-18:6: SwitchInt: switchInt(_5) -&gt; [false: bb6, otherwise: bb5]"><span class="annotation">4⦊</span>countdown &gt; 7<span class="annotation">⦉4</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25">        </span><span class="code odd" style="--layer: 4" title="bb7: ../instrument-coverage/coverage_of_if_else.rs:10:9: 10:23:
-    10:9-10:23: Assign: _7 = CheckedSub(_1, const 4_i32)
-    10:9-10:23: Assert: assert(!move (_7.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 4_i32) -&gt; [success: bb8, unwind: bb78]"><span class="annotation">7⦊</span>countdown -= 4<span class="annotation">⦉7</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25">;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25">    } else </span><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]"><span class="annotation">9⦊</span>if </span><span class="code even" style="--layer: 5" title="bb6: ../instrument-coverage/coverage_of_if_else.rs:11:15: 11:28:
-    11:15-11:28: StorageLive: StorageLive(_8)
-    11:15-11:24: StorageLive: StorageLive(_9)
-    11:15-11:24: Assign: _9 = _1
-    11:15-11:28: Assign: _8 = Gt(move _9, const 2_i32)
-    11:27-11:28: StorageDead: StorageDead(_9)
-    11:15-11:28: FakeRead: FakeRead(ForMatchedPlace, _8)
-    11:12-18:6: SwitchInt: switchInt(_8) -&gt; [false: bb10, otherwise: bb9]"><span class="annotation">6⦊</span>countdown &gt; 2<span class="annotation">⦉6</span></span><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">        </span><span class="code odd" style="--layer: 5" title="bb20: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: FalseEdge: falseEdge -&gt; [real: bb22, imaginary: bb21]"><span class="annotation">20⦊</span></span><span class="code even" style="--layer: 6" title="bb22: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    13:13-13:26: Assign: _1 = const 0_i32
-    12:61-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">22⦊</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">21⦊</span>if </span><span class="code even" style="--layer: 8" title="bb14: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:46-12:60: StorageLive: StorageLive(_17)
-    12:46-12:55: StorageLive: StorageLive(_18)
-    12:46-12:55: Assign: _18 = _1
-    12:46-12:60: Assign: _17 = Ne(move _18, const 9_i32)
-    12:59-12:60: StorageDead: StorageDead(_18)
-    12:12-12:60: SwitchInt: switchInt(move _17) -&gt; [false: bb13, otherwise: bb12]"><span class="annotation">14⦊</span></span><span class="code even" style="--layer: 9" title="bb11: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:9-14:10: StorageLive: StorageLive(_10)
-    12:12-12:60: StorageLive: StorageLive(_11)
-    12:12-12:42: StorageLive: StorageLive(_12)
-    12:12-12:25: StorageLive: StorageLive(_13)
-    12:12-12:21: StorageLive: StorageLive(_14)
-    12:12-12:21: Assign: _14 = _1
-    12:12-12:25: Assign: _13 = Lt(move _14, const 1_i32)
-    12:24-12:25: StorageDead: StorageDead(_14)
-    12:12-12:42: SwitchInt: switchInt(move _13) -&gt; [false: bb18, otherwise: bb16]"><span class="annotation">11⦊</span></span><span class="code even" style="--layer: 10" title="bb13: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const false
-    12:12-12:60: Goto: goto -&gt; bb15"><span class="annotation">13⦊</span></span><span class="code even" style="--layer: 11" title="bb19: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:41-12:42: StorageDead: StorageDead(_15)
-    12:41-12:42: StorageDead: StorageDead(_13)
-    12:12-12:60: SwitchInt: switchInt(move _12) -&gt; [false: bb14, otherwise: bb12]"><span class="annotation">19⦊</span></span><span class="code even" style="--layer: 12" title="bb15: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:59-12:60: StorageDead: StorageDead(_17)
-    12:59-12:60: StorageDead: StorageDead(_12)
-    12:12-12:60: FakeRead: FakeRead(ForMatchedPlace, _11)
-    12:9-14:10: SwitchInt: switchInt(_11) -&gt; [false: bb21, otherwise: bb20]"><span class="annotation">15⦊</span></span><span class="code even" style="--layer: 13" title="bb12: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const true
-    12:12-12:60: Goto: goto -&gt; bb15"><span class="annotation">12⦊</span></span><span class="code even" style="--layer: 14" title="bb16: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const true
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">16⦊</span></span><span class="code even" style="--layer: 15" title="bb17: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const false
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">17⦊</span></span><span class="code even" style="--layer: 16" title="bb18: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:29-12:42: StorageLive: StorageLive(_15)
-    12:29-12:38: StorageLive: StorageLive(_16)
-    12:29-12:38: Assign: _16 = _1
-    12:29-12:42: Assign: _15 = Gt(move _16, const 5_i32)
-    12:41-12:42: StorageDead: StorageDead(_16)
-    12:12-12:42: SwitchInt: switchInt(move _15) -&gt; [false: bb17, otherwise: bb16]"><span class="annotation">18⦊</span>countdown &lt; 1 || countdown &gt; 5<span class="annotation">⦉18</span></span><span class="code even" style="--layer: 15" title="bb17: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const false
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">⦉17</span></span><span class="code even" style="--layer: 14" title="bb16: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:42:
-    12:12-12:42: Assign: _12 = const true
-    12:12-12:42: Goto: goto -&gt; bb19"><span class="annotation">⦉16</span></span><span class="code even" style="--layer: 13" title="bb12: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const true
-    12:12-12:60: Goto: goto -&gt; bb15"> || countdown != 9<span class="annotation">⦉12</span></span><span class="code even" style="--layer: 12" title="bb15: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:59-12:60: StorageDead: StorageDead(_17)
-    12:59-12:60: StorageDead: StorageDead(_12)
-    12:12-12:60: FakeRead: FakeRead(ForMatchedPlace, _11)
-    12:9-14:10: SwitchInt: switchInt(_11) -&gt; [false: bb21, otherwise: bb20]"><span class="annotation">⦉15</span></span><span class="code even" style="--layer: 11" title="bb19: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:41-12:42: StorageDead: StorageDead(_15)
-    12:41-12:42: StorageDead: StorageDead(_13)
-    12:12-12:60: SwitchInt: switchInt(move _12) -&gt; [false: bb14, otherwise: bb12]"><span class="annotation">⦉19</span></span><span class="code even" style="--layer: 10" title="bb13: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:12-12:60: Assign: _11 = const false
-    12:12-12:60: Goto: goto -&gt; bb15"><span class="annotation">⦉13</span></span><span class="code even" style="--layer: 9" title="bb11: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:9-14:10: StorageLive: StorageLive(_10)
-    12:12-12:60: StorageLive: StorageLive(_11)
-    12:12-12:42: StorageLive: StorageLive(_12)
-    12:12-12:25: StorageLive: StorageLive(_13)
-    12:12-12:21: StorageLive: StorageLive(_14)
-    12:12-12:21: Assign: _14 = _1
-    12:12-12:25: Assign: _13 = Lt(move _14, const 1_i32)
-    12:24-12:25: StorageDead: StorageDead(_14)
-    12:12-12:42: SwitchInt: switchInt(move _13) -&gt; [false: bb18, otherwise: bb16]"><span class="annotation">⦉11</span></span><span class="code even" style="--layer: 8" title="bb14: ../instrument-coverage/coverage_of_if_else.rs:12:12: 12:60:
-    12:46-12:60: StorageLive: StorageLive(_17)
-    12:46-12:55: StorageLive: StorageLive(_18)
-    12:46-12:55: Assign: _18 = _1
-    12:46-12:60: Assign: _17 = Ne(move _18, const 9_i32)
-    12:59-12:60: StorageDead: StorageDead(_18)
-    12:12-12:60: SwitchInt: switchInt(move _17) -&gt; [false: bb13, otherwise: bb12]"><span class="annotation">⦉14</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23">        </span><span class="code odd" style="--layer: 8" title="bb23: ../instrument-coverage/coverage_of_if_else.rs:14:9: 15:23:
-    14:9-14:10: StorageDead: StorageDead(_11)
-    14:9-14:10: StorageDead: StorageDead(_10)
-    15:9-15:23: Assign: _19 = CheckedSub(_1, const 5_i32)
-    15:9-15:23: Assert: assert(!move (_19.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 5_i32) -&gt; [success: bb24, unwind: bb78]"><span class="annotation">23⦊</span>}</span><span class="code odd" style="--layer: 5" title="bb20: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: FalseEdge: falseEdge -&gt; [real: bb22, imaginary: bb21]"><span class="annotation">⦉20</span></span><span class="code even" style="--layer: 6" title="bb22: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    13:13-13:26: Assign: _1 = const 0_i32
-    12:61-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">⦉22</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">⦉21</span></span><span class="code even" style="--layer: 7" title="bb21: ../instrument-coverage/coverage_of_if_else.rs:12:9: 14:10:
-    12:9-14:10: Assign: _10 = const ()
-    12:9-14:10: Goto: goto -&gt; bb23"><span class="annotation">⦉21</span></span><span class="code odd" style="--layer: 8" title="bb23: ../instrument-coverage/coverage_of_if_else.rs:14:9: 15:23:
-    14:9-14:10: StorageDead: StorageDead(_11)
-    14:9-14:10: StorageDead: StorageDead(_10)
-    15:9-15:23: Assign: _19 = CheckedSub(_1, const 5_i32)
-    15:9-15:23: Assert: assert(!move (_19.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 5_i32) -&gt; [success: bb24, unwind: bb78]"></span></span>
-<span class="line"><span class="code odd" style="--layer: 8" title="bb23: ../instrument-coverage/coverage_of_if_else.rs:14:9: 15:23:
-    14:9-14:10: StorageDead: StorageDead(_11)
-    14:9-14:10: StorageDead: StorageDead(_10)
-    15:9-15:23: Assign: _19 = CheckedSub(_1, const 5_i32)
-    15:9-15:23: Assert: assert(!move (_19.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _1, const 5_i32) -&gt; [success: bb24, unwind: bb78]">        countdown -= 5<span class="annotation">⦉23</span></span><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">    } else {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">        return;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb9: ../instrument-coverage/coverage_of_if_else.rs:11:12: 18:6:
-    11:12-18:6: FalseEdge: falseEdge -&gt; [real: bb11, imaginary: bb10]">    }<span class="annotation">⦉9</span></span><span class="code even" style="--layer: 3" title="bb24: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    15:9-15:23: Assign: _1 = move (_19.0: i32)
-    11:29-16:6: Assign: _4 = const ()
-    18:5-18:6: StorageDead: StorageDead(_8)
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">⦉24</span></span><span class="code even" style="--layer: 2" title="bb8: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    10:9-10:23: Assign: _1 = move (_7.0: i32)
-    9:22-11:6: Assign: _4 = const ()
-    9:5-18:6: Goto: goto -&gt; bb25"><span class="annotation">⦉8</span></span><span><span class="code odd" style="--layer: 1" title="bb5: ../instrument-coverage/coverage_of_if_else.rs:9:5: 18:6:
-    9:5-18:6: FalseEdge: falseEdge -&gt; [real: bb7, imaginary: bb6]"><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">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="bb27: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><span class="annotation">27⦊</span></span></span><span class="code even" style="--layer: 2" title="bb28: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    22:9-22:23: Assign: _21 = const 10_i32
-    21:13-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><span class="annotation">28⦊</span></span><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]"><span class="annotation">26⦊</span>if </span><span class="code even" style="--layer: 4" title="bb25: ../instrument-coverage/coverage_of_if_else.rs:21:8: 21:12:
-    18:5-18:6: StorageDead: StorageDead(_5)
-    18:5-18:6: StorageDead: StorageDead(_4)
-    20:9-20:22: StorageLive: StorageLive(_21)
-    20:25-20:26: Assign: _21 = const 0_i32
-    20:9-20:22: FakeRead: FakeRead(ForLet, _21)
-    21:5-23:6: StorageLive: StorageLive(_22)
-    21:8-21:12: StorageLive: StorageLive(_23)
-    21:8-21:12: Assign: _23 = const true
-    21:8-21:12: FakeRead: FakeRead(ForMatchedPlace, _23)
-    21:5-23:6: SwitchInt: switchInt(_23) -&gt; [false: bb27, otherwise: bb26]"><span class="annotation">25⦊</span>true<span class="annotation">⦉25</span></span><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]">        countdown = 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb26: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: FalseEdge: falseEdge -&gt; [real: bb28, imaginary: bb27]">    }<span class="annotation">⦉26</span></span><span class="code even" style="--layer: 2" title="bb28: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    22:9-22:23: Assign: _21 = const 10_i32
-    21:13-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><span class="annotation">⦉28</span></span><span><span class="code even" style="--layer: 1" title="bb27: ../instrument-coverage/coverage_of_if_else.rs:21:5: 23:6:
-    21:5-23:6: Assign: _22 = const ()
-    21:5-23:6: Goto: goto -&gt; bb29"><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">    </span><span><span class="code odd" style="--layer: 1" title="bb49: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    31:9-31:23: Assign: _21 = move (_39.0: i32)
-    27:29-32:6: Assign: _24 = const ()
-    34:5-34:6: StorageDead: StorageDead(_28)
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">49⦊</span></span></span><span class="code even" style="--layer: 2" title="bb33: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    26:9-26:23: Assign: _21 = move (_27.0: i32)
-    25:22-27:6: Assign: _24 = const ()
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">33⦊</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]"><span class="annotation">30⦊</span>if </span><span class="code even" style="--layer: 4" title="bb29: ../instrument-coverage/coverage_of_if_else.rs:25:8: 25:21:
-    23:5-23:6: StorageDead: StorageDead(_23)
-    23:5-23:6: StorageDead: StorageDead(_22)
-    25:5-34:6: StorageLive: StorageLive(_24)
-    25:8-25:21: StorageLive: StorageLive(_25)
-    25:8-25:17: StorageLive: StorageLive(_26)
-    25:8-25:17: Assign: _26 = _21
-    25:8-25:21: Assign: _25 = Gt(move _26, const 7_i32)
-    25:20-25:21: StorageDead: StorageDead(_26)
-    25:8-25:21: FakeRead: FakeRead(ForMatchedPlace, _25)
-    25:5-34:6: SwitchInt: switchInt(_25) -&gt; [false: bb31, otherwise: bb30]"><span class="annotation">29⦊</span>countdown &gt; 7<span class="annotation">⦉29</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]">        </span><span class="code odd" style="--layer: 4" title="bb32: ../instrument-coverage/coverage_of_if_else.rs:26:9: 26:23:
-    26:9-26:23: Assign: _27 = CheckedSub(_21, const 4_i32)
-    26:9-26:23: Assert: assert(!move (_27.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 4_i32) -&gt; [success: bb33, unwind: bb78]"><span class="annotation">32⦊</span>countdown -= 4<span class="annotation">⦉32</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]">    } else </span><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]"><span class="annotation">34⦊</span>if </span><span class="code even" style="--layer: 5" title="bb31: ../instrument-coverage/coverage_of_if_else.rs:27:15: 27:28:
-    27:15-27:28: StorageLive: StorageLive(_28)
-    27:15-27:24: StorageLive: StorageLive(_29)
-    27:15-27:24: Assign: _29 = _21
-    27:15-27:28: Assign: _28 = Gt(move _29, const 2_i32)
-    27:27-27:28: StorageDead: StorageDead(_29)
-    27:15-27:28: FakeRead: FakeRead(ForMatchedPlace, _28)
-    27:12-34:6: SwitchInt: switchInt(_28) -&gt; [false: bb35, otherwise: bb34]"><span class="annotation">31⦊</span>countdown &gt; 2<span class="annotation">⦉31</span></span><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">        </span><span class="code odd" style="--layer: 5" title="bb46: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">46⦊</span></span><span class="code even" style="--layer: 6" title="bb47: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    29:13-29:26: Assign: _21 = const 0_i32
-    28:61-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">47⦊</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"><span class="annotation">45⦊</span>if </span><span class="code even" style="--layer: 8" title="bb44: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:41-28:42: StorageDead: StorageDead(_35)
-    28:41-28:42: StorageDead: StorageDead(_33)
-    28:12-28:60: SwitchInt: switchInt(move _32) -&gt; [false: bb39, otherwise: bb37]"><span class="annotation">44⦊</span></span><span class="code even" style="--layer: 9" title="bb38: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const false
-    28:12-28:60: Goto: goto -&gt; bb40"><span class="annotation">38⦊</span></span><span class="code even" style="--layer: 10" title="bb39: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:46-28:60: StorageLive: StorageLive(_37)
-    28:46-28:55: StorageLive: StorageLive(_38)
-    28:46-28:55: Assign: _38 = _21
-    28:46-28:60: Assign: _37 = Ne(move _38, const 9_i32)
-    28:59-28:60: StorageDead: StorageDead(_38)
-    28:12-28:60: SwitchInt: switchInt(move _37) -&gt; [false: bb38, otherwise: bb37]"><span class="annotation">39⦊</span></span><span class="code even" style="--layer: 11" title="bb40: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:59-28:60: StorageDead: StorageDead(_37)
-    28:59-28:60: StorageDead: StorageDead(_32)
-    28:12-28:60: FakeRead: FakeRead(ForMatchedPlace, _31)
-    28:9-30:10: SwitchInt: switchInt(_31) -&gt; [false: bb46, otherwise: bb45]"><span class="annotation">40⦊</span></span><span class="code even" style="--layer: 12" title="bb36: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:9-30:10: StorageLive: StorageLive(_30)
-    28:12-28:60: StorageLive: StorageLive(_31)
-    28:12-28:42: StorageLive: StorageLive(_32)
-    28:12-28:25: StorageLive: StorageLive(_33)
-    28:12-28:21: StorageLive: StorageLive(_34)
-    28:12-28:21: Assign: _34 = _21
-    28:12-28:25: Assign: _33 = Lt(move _34, const 1_i32)
-    28:24-28:25: StorageDead: StorageDead(_34)
-    28:12-28:42: SwitchInt: switchInt(move _33) -&gt; [false: bb43, otherwise: bb41]"><span class="annotation">36⦊</span></span><span class="code even" style="--layer: 13" title="bb37: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const true
-    28:12-28:60: Goto: goto -&gt; bb40"><span class="annotation">37⦊</span></span><span class="code even" style="--layer: 14" title="bb41: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const true
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">41⦊</span></span><span class="code even" style="--layer: 15" title="bb42: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const false
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">42⦊</span></span><span class="code even" style="--layer: 16" title="bb43: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:29-28:42: StorageLive: StorageLive(_35)
-    28:29-28:38: StorageLive: StorageLive(_36)
-    28:29-28:38: Assign: _36 = _21
-    28:29-28:42: Assign: _35 = Gt(move _36, const 5_i32)
-    28:41-28:42: StorageDead: StorageDead(_36)
-    28:12-28:42: SwitchInt: switchInt(move _35) -&gt; [false: bb42, otherwise: bb41]"><span class="annotation">43⦊</span>countdown &lt; 1 || countdown &gt; 5<span class="annotation">⦉43</span></span><span class="code even" style="--layer: 15" title="bb42: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const false
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">⦉42</span></span><span class="code even" style="--layer: 14" title="bb41: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:42:
-    28:12-28:42: Assign: _32 = const true
-    28:12-28:42: Goto: goto -&gt; bb44"><span class="annotation">⦉41</span></span><span class="code even" style="--layer: 13" title="bb37: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const true
-    28:12-28:60: Goto: goto -&gt; bb40"> || countdown != 9<span class="annotation">⦉37</span></span><span class="code even" style="--layer: 12" title="bb36: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:9-30:10: StorageLive: StorageLive(_30)
-    28:12-28:60: StorageLive: StorageLive(_31)
-    28:12-28:42: StorageLive: StorageLive(_32)
-    28:12-28:25: StorageLive: StorageLive(_33)
-    28:12-28:21: StorageLive: StorageLive(_34)
-    28:12-28:21: Assign: _34 = _21
-    28:12-28:25: Assign: _33 = Lt(move _34, const 1_i32)
-    28:24-28:25: StorageDead: StorageDead(_34)
-    28:12-28:42: SwitchInt: switchInt(move _33) -&gt; [false: bb43, otherwise: bb41]"><span class="annotation">⦉36</span></span><span class="code even" style="--layer: 11" title="bb40: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:59-28:60: StorageDead: StorageDead(_37)
-    28:59-28:60: StorageDead: StorageDead(_32)
-    28:12-28:60: FakeRead: FakeRead(ForMatchedPlace, _31)
-    28:9-30:10: SwitchInt: switchInt(_31) -&gt; [false: bb46, otherwise: bb45]"><span class="annotation">⦉40</span></span><span class="code even" style="--layer: 10" title="bb39: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:46-28:60: StorageLive: StorageLive(_37)
-    28:46-28:55: StorageLive: StorageLive(_38)
-    28:46-28:55: Assign: _38 = _21
-    28:46-28:60: Assign: _37 = Ne(move _38, const 9_i32)
-    28:59-28:60: StorageDead: StorageDead(_38)
-    28:12-28:60: SwitchInt: switchInt(move _37) -&gt; [false: bb38, otherwise: bb37]"><span class="annotation">⦉39</span></span><span class="code even" style="--layer: 9" title="bb38: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:12-28:60: Assign: _31 = const false
-    28:12-28:60: Goto: goto -&gt; bb40"><span class="annotation">⦉38</span></span><span class="code even" style="--layer: 8" title="bb44: ../instrument-coverage/coverage_of_if_else.rs:28:12: 28:60:
-    28:41-28:42: StorageDead: StorageDead(_35)
-    28:41-28:42: StorageDead: StorageDead(_33)
-    28:12-28:60: SwitchInt: switchInt(move _32) -&gt; [false: bb39, otherwise: bb37]"><span class="annotation">⦉44</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]">        </span><span class="code odd" style="--layer: 8" title="bb48: ../instrument-coverage/coverage_of_if_else.rs:30:9: 31:23:
-    30:9-30:10: StorageDead: StorageDead(_31)
-    30:9-30:10: StorageDead: StorageDead(_30)
-    31:9-31:23: Assign: _39 = CheckedSub(_21, const 5_i32)
-    31:9-31:23: Assert: assert(!move (_39.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 5_i32) -&gt; [success: bb49, unwind: bb78]"><span class="annotation">48⦊</span>}</span><span class="code odd" style="--layer: 5" title="bb46: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">⦉46</span></span><span class="code even" style="--layer: 6" title="bb47: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    29:13-29:26: Assign: _21 = const 0_i32
-    28:61-30:10: Assign: _30 = const ()
-    28:9-30:10: Goto: goto -&gt; bb48"><span class="annotation">⦉47</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"><span class="annotation">⦉45</span></span><span class="code even" style="--layer: 7" title="bb45: ../instrument-coverage/coverage_of_if_else.rs:28:9: 30:10:
-    28:9-30:10: FalseEdge: falseEdge -&gt; [real: bb47, imaginary: bb46]"><span class="annotation">⦉45</span></span><span class="code odd" style="--layer: 8" title="bb48: ../instrument-coverage/coverage_of_if_else.rs:30:9: 31:23:
-    30:9-30:10: StorageDead: StorageDead(_31)
-    30:9-30:10: StorageDead: StorageDead(_30)
-    31:9-31:23: Assign: _39 = CheckedSub(_21, const 5_i32)
-    31:9-31:23: Assert: assert(!move (_39.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 5_i32) -&gt; [success: bb49, unwind: bb78]"></span></span>
-<span class="line"><span class="code odd" style="--layer: 8" title="bb48: ../instrument-coverage/coverage_of_if_else.rs:30:9: 31:23:
-    30:9-30:10: StorageDead: StorageDead(_31)
-    30:9-30:10: StorageDead: StorageDead(_30)
-    31:9-31:23: Assign: _39 = CheckedSub(_21, const 5_i32)
-    31:9-31:23: Assert: assert(!move (_39.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _21, const 5_i32) -&gt; [success: bb49, unwind: bb78]">        countdown -= 5<span class="annotation">⦉48</span></span><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">    } else {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">        return;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb34: ../instrument-coverage/coverage_of_if_else.rs:27:12: 34:6:
-    27:12-34:6: FalseEdge: falseEdge -&gt; [real: bb36, imaginary: bb35]">    }<span class="annotation">⦉34</span></span><span class="code even" style="--layer: 3" title="bb30: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    25:5-34:6: FalseEdge: falseEdge -&gt; [real: bb32, imaginary: bb31]"><span class="annotation">⦉30</span></span><span class="code even" style="--layer: 2" title="bb33: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    26:9-26:23: Assign: _21 = move (_27.0: i32)
-    25:22-27:6: Assign: _24 = const ()
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">⦉33</span></span><span><span class="code odd" style="--layer: 1" title="bb49: ../instrument-coverage/coverage_of_if_else.rs:25:5: 34:6:
-    31:9-31:23: Assign: _21 = move (_39.0: i32)
-    27:29-32:6: Assign: _24 = const ()
-    34:5-34:6: StorageDead: StorageDead(_28)
-    25:5-34:6: Goto: goto -&gt; bb50"><span class="annotation">⦉49</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 mut countdown = 0;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="bb52: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"><span class="annotation">52⦊</span></span></span><span class="code even" style="--layer: 2" title="bb51: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: FalseEdge: falseEdge -&gt; [real: bb53, imaginary: bb52]"><span class="annotation">51⦊</span></span><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"><span class="annotation">53⦊</span>if </span><span class="code even" style="--layer: 4" title="bb50: ../instrument-coverage/coverage_of_if_else.rs:37:8: 37:12:
-    34:5-34:6: StorageDead: StorageDead(_25)
-    34:5-34:6: StorageDead: StorageDead(_24)
-    36:9-36:22: StorageLive: StorageLive(_41)
-    36:25-36:26: Assign: _41 = const 0_i32
-    36:9-36:22: FakeRead: FakeRead(ForLet, _41)
-    37:5-39:6: StorageLive: StorageLive(_42)
-    37:8-37:12: StorageLive: StorageLive(_43)
-    37:8-37:12: Assign: _43 = const true
-    37:8-37:12: FakeRead: FakeRead(ForMatchedPlace, _43)
-    37:5-39:6: SwitchInt: switchInt(_43) -&gt; [false: bb52, otherwise: bb51]"><span class="annotation">50⦊</span>true<span class="annotation">⦉50</span></span><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54">        countdown = 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb53: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    38:9-38:23: Assign: _41 = const 10_i32
-    37:13-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54">    }<span class="annotation">⦉53</span></span><span class="code even" style="--layer: 2" title="bb51: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: FalseEdge: falseEdge -&gt; [real: bb53, imaginary: bb52]"><span class="annotation">⦉51</span></span><span><span class="code even" style="--layer: 1" title="bb52: ../instrument-coverage/coverage_of_if_else.rs:37:5: 39:6:
-    37:5-39:6: Assign: _42 = const ()
-    37:5-39:6: Goto: goto -&gt; bb54"><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">    </span><span><span class="code odd" style="--layer: 1" title="bb74: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    47:9-47:23: Assign: _41 = move (_58.0: i32)
-    43:29-48:6: Assign: _0 = const ()
-    50:5-50:6: StorageDead: StorageDead(_47)
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">74⦊</span></span></span><span class="code even" style="--layer: 2" title="bb55: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    41:5-50:6: FalseEdge: falseEdge -&gt; [real: bb57, imaginary: bb56]"><span class="annotation">55⦊</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">58⦊</span>if </span><span class="code even" style="--layer: 4" title="bb54: ../instrument-coverage/coverage_of_if_else.rs:41:8: 41:21:
-    39:5-39:6: StorageDead: StorageDead(_43)
-    39:5-39:6: StorageDead: StorageDead(_42)
-    41:8-41:21: StorageLive: StorageLive(_44)
-    41:8-41:17: StorageLive: StorageLive(_45)
-    41:8-41:17: Assign: _45 = _41
-    41:8-41:21: Assign: _44 = Gt(move _45, const 7_i32)
-    41:20-41:21: StorageDead: StorageDead(_45)
-    41:8-41:21: FakeRead: FakeRead(ForMatchedPlace, _44)
-    41:5-50:6: SwitchInt: switchInt(_44) -&gt; [false: bb56, otherwise: bb55]"><span class="annotation">54⦊</span>countdown &gt; 7<span class="annotation">⦉54</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75">        </span><span class="code odd" style="--layer: 4" title="bb57: ../instrument-coverage/coverage_of_if_else.rs:42:9: 42:23:
-    42:9-42:23: Assign: _46 = CheckedSub(_41, const 4_i32)
-    42:9-42:23: Assert: assert(!move (_46.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 4_i32) -&gt; [success: bb58, unwind: bb78]"><span class="annotation">57⦊</span>countdown -= 4<span class="annotation">⦉57</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75">;</span></span>
-<span class="line"><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75">    } else </span><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]"><span class="annotation">59⦊</span>if </span><span class="code even" style="--layer: 5" title="bb56: ../instrument-coverage/coverage_of_if_else.rs:43:15: 43:28:
-    43:15-43:28: StorageLive: StorageLive(_47)
-    43:15-43:24: StorageLive: StorageLive(_48)
-    43:15-43:24: Assign: _48 = _41
-    43:15-43:28: Assign: _47 = Gt(move _48, const 2_i32)
-    43:27-43:28: StorageDead: StorageDead(_48)
-    43:15-43:28: FakeRead: FakeRead(ForMatchedPlace, _47)
-    43:12-50:6: SwitchInt: switchInt(_47) -&gt; [false: bb60, otherwise: bb59]"><span class="annotation">56⦊</span>countdown &gt; 2<span class="annotation">⦉56</span></span><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">        </span><span class="code odd" style="--layer: 5" title="bb71: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">71⦊</span></span><span class="code even" style="--layer: 6" title="bb72: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    45:13-45:26: Assign: _41 = const 0_i32
-    44:61-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">72⦊</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"><span class="annotation">70⦊</span>if </span><span class="code even" style="--layer: 8" title="bb63: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const false
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">63⦊</span></span><span class="code even" style="--layer: 9" title="bb64: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:46-44:60: StorageLive: StorageLive(_56)
-    44:46-44:55: StorageLive: StorageLive(_57)
-    44:46-44:55: Assign: _57 = _41
-    44:46-44:60: Assign: _56 = Ne(move _57, const 9_i32)
-    44:59-44:60: StorageDead: StorageDead(_57)
-    44:12-44:60: SwitchInt: switchInt(move _56) -&gt; [false: bb63, otherwise: bb62]"><span class="annotation">64⦊</span></span><span class="code even" style="--layer: 10" title="bb65: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:59-44:60: StorageDead: StorageDead(_56)
-    44:59-44:60: StorageDead: StorageDead(_51)
-    44:12-44:60: FakeRead: FakeRead(ForMatchedPlace, _50)
-    44:9-46:10: SwitchInt: switchInt(_50) -&gt; [false: bb71, otherwise: bb70]"><span class="annotation">65⦊</span></span><span class="code even" style="--layer: 11" title="bb62: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const true
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">62⦊</span></span><span class="code even" style="--layer: 12" title="bb69: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:41-44:42: StorageDead: StorageDead(_54)
-    44:41-44:42: StorageDead: StorageDead(_52)
-    44:12-44:60: SwitchInt: switchInt(move _51) -&gt; [false: bb64, otherwise: bb62]"><span class="annotation">69⦊</span></span><span class="code even" style="--layer: 13" title="bb61: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:9-46:10: StorageLive: StorageLive(_49)
-    44:12-44:60: StorageLive: StorageLive(_50)
-    44:12-44:42: StorageLive: StorageLive(_51)
-    44:12-44:25: StorageLive: StorageLive(_52)
-    44:12-44:21: StorageLive: StorageLive(_53)
-    44:12-44:21: Assign: _53 = _41
-    44:12-44:25: Assign: _52 = Lt(move _53, const 1_i32)
-    44:24-44:25: StorageDead: StorageDead(_53)
-    44:12-44:42: SwitchInt: switchInt(move _52) -&gt; [false: bb68, otherwise: bb66]"><span class="annotation">61⦊</span></span><span class="code even" style="--layer: 14" title="bb67: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:12-44:42: Assign: _51 = const false
-    44:12-44:42: Goto: goto -&gt; bb69"><span class="annotation">67⦊</span></span><span class="code even" style="--layer: 15" title="bb68: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:29-44:42: StorageLive: StorageLive(_54)
-    44:29-44:38: StorageLive: StorageLive(_55)
-    44:29-44:38: Assign: _55 = _41
-    44:29-44:42: Assign: _54 = Gt(move _55, const 5_i32)
-    44:41-44:42: StorageDead: StorageDead(_55)
-    44:12-44:42: SwitchInt: switchInt(move _54) -&gt; [false: bb67, otherwise: bb66]"><span class="annotation">68⦊</span></span><span class="code even" style="--layer: 16" title="bb66: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:12-44:42: Assign: _51 = const true
-    44:12-44:42: Goto: goto -&gt; bb69"><span class="annotation">66⦊</span>countdown &lt; 1 || countdown &gt; 5<span class="annotation">⦉66</span></span><span class="code even" style="--layer: 15" title="bb68: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:29-44:42: StorageLive: StorageLive(_54)
-    44:29-44:38: StorageLive: StorageLive(_55)
-    44:29-44:38: Assign: _55 = _41
-    44:29-44:42: Assign: _54 = Gt(move _55, const 5_i32)
-    44:41-44:42: StorageDead: StorageDead(_55)
-    44:12-44:42: SwitchInt: switchInt(move _54) -&gt; [false: bb67, otherwise: bb66]"><span class="annotation">⦉68</span></span><span class="code even" style="--layer: 14" title="bb67: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:42:
-    44:12-44:42: Assign: _51 = const false
-    44:12-44:42: Goto: goto -&gt; bb69"><span class="annotation">⦉67</span></span><span class="code even" style="--layer: 13" title="bb61: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:9-46:10: StorageLive: StorageLive(_49)
-    44:12-44:60: StorageLive: StorageLive(_50)
-    44:12-44:42: StorageLive: StorageLive(_51)
-    44:12-44:25: StorageLive: StorageLive(_52)
-    44:12-44:21: StorageLive: StorageLive(_53)
-    44:12-44:21: Assign: _53 = _41
-    44:12-44:25: Assign: _52 = Lt(move _53, const 1_i32)
-    44:24-44:25: StorageDead: StorageDead(_53)
-    44:12-44:42: SwitchInt: switchInt(move _52) -&gt; [false: bb68, otherwise: bb66]"> || countdown != 9<span class="annotation">⦉61</span></span><span class="code even" style="--layer: 12" title="bb69: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:41-44:42: StorageDead: StorageDead(_54)
-    44:41-44:42: StorageDead: StorageDead(_52)
-    44:12-44:60: SwitchInt: switchInt(move _51) -&gt; [false: bb64, otherwise: bb62]"><span class="annotation">⦉69</span></span><span class="code even" style="--layer: 11" title="bb62: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const true
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">⦉62</span></span><span class="code even" style="--layer: 10" title="bb65: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:59-44:60: StorageDead: StorageDead(_56)
-    44:59-44:60: StorageDead: StorageDead(_51)
-    44:12-44:60: FakeRead: FakeRead(ForMatchedPlace, _50)
-    44:9-46:10: SwitchInt: switchInt(_50) -&gt; [false: bb71, otherwise: bb70]"><span class="annotation">⦉65</span></span><span class="code even" style="--layer: 9" title="bb64: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:46-44:60: StorageLive: StorageLive(_56)
-    44:46-44:55: StorageLive: StorageLive(_57)
-    44:46-44:55: Assign: _57 = _41
-    44:46-44:60: Assign: _56 = Ne(move _57, const 9_i32)
-    44:59-44:60: StorageDead: StorageDead(_57)
-    44:12-44:60: SwitchInt: switchInt(move _56) -&gt; [false: bb63, otherwise: bb62]"><span class="annotation">⦉64</span></span><span class="code even" style="--layer: 8" title="bb63: ../instrument-coverage/coverage_of_if_else.rs:44:12: 44:60:
-    44:12-44:60: Assign: _50 = const false
-    44:12-44:60: Goto: goto -&gt; bb65"><span class="annotation">⦉63</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"> {</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]">        </span><span class="code odd" style="--layer: 8" title="bb73: ../instrument-coverage/coverage_of_if_else.rs:46:9: 47:23:
-    46:9-46:10: StorageDead: StorageDead(_50)
-    46:9-46:10: StorageDead: StorageDead(_49)
-    47:9-47:23: Assign: _58 = CheckedSub(_41, const 5_i32)
-    47:9-47:23: Assert: assert(!move (_58.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 5_i32) -&gt; [success: bb74, unwind: bb78]"><span class="annotation">73⦊</span>}</span><span class="code odd" style="--layer: 5" title="bb71: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">⦉71</span></span><span class="code even" style="--layer: 6" title="bb72: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    45:13-45:26: Assign: _41 = const 0_i32
-    44:61-46:10: Assign: _49 = const ()
-    44:9-46:10: Goto: goto -&gt; bb73"><span class="annotation">⦉72</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"><span class="annotation">⦉70</span></span><span class="code even" style="--layer: 7" title="bb70: ../instrument-coverage/coverage_of_if_else.rs:44:9: 46:10:
-    44:9-46:10: FalseEdge: falseEdge -&gt; [real: bb72, imaginary: bb71]"><span class="annotation">⦉70</span></span><span class="code odd" style="--layer: 8" title="bb73: ../instrument-coverage/coverage_of_if_else.rs:46:9: 47:23:
-    46:9-46:10: StorageDead: StorageDead(_50)
-    46:9-46:10: StorageDead: StorageDead(_49)
-    47:9-47:23: Assign: _58 = CheckedSub(_41, const 5_i32)
-    47:9-47:23: Assert: assert(!move (_58.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 5_i32) -&gt; [success: bb74, unwind: bb78]"></span></span>
-<span class="line"><span class="code odd" style="--layer: 8" title="bb73: ../instrument-coverage/coverage_of_if_else.rs:46:9: 47:23:
-    46:9-46:10: StorageDead: StorageDead(_50)
-    46:9-46:10: StorageDead: StorageDead(_49)
-    47:9-47:23: Assign: _58 = CheckedSub(_41, const 5_i32)
-    47:9-47:23: Assert: assert(!move (_58.1: bool), &quot;attempt to compute `{} - {}`, which would overflow&quot;, _41, const 5_i32) -&gt; [success: bb74, unwind: bb78]">        countdown -= 5<span class="annotation">⦉73</span></span><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">    } else {</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">        return;</span></span>
-<span class="line"><span class="code even" style="--layer: 4" title="bb59: ../instrument-coverage/coverage_of_if_else.rs:43:12: 50:6:
-    43:12-50:6: FalseEdge: falseEdge -&gt; [real: bb61, imaginary: bb60]">    }<span class="annotation">⦉59</span></span><span class="code even" style="--layer: 3" title="bb58: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    42:9-42:23: Assign: _41 = move (_46.0: i32)
-    41:22-43:6: Assign: _0 = const ()
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">⦉58</span></span><span class="code even" style="--layer: 2" title="bb55: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    41:5-50:6: FalseEdge: falseEdge -&gt; [real: bb57, imaginary: bb56]"><span class="annotation">⦉55</span></span><span><span class="code odd" style="--layer: 1" title="bb74: ../instrument-coverage/coverage_of_if_else.rs:41:5: 50:6:
-    47:9-47:23: Assign: _41 = move (_58.0: i32)
-    43:29-48:6: Assign: _0 = const ()
-    50:5-50:6: StorageDead: StorageDead(_47)
-    41:5-50:6: Goto: goto -&gt; bb75"><span class="annotation">⦉74</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span><span class="code even" style="--layer: 1" title="bb75: ../instrument-coverage/coverage_of_if_else.rs:51:1: 51:2:
-    51:1-51:2: StorageDead: StorageDead(_41)
-    51:1-51:2: StorageDead: StorageDead(_21)
-    51:1-51:2: StorageDead: StorageDead(_1)
-    51:1-51:2: StorageDead: StorageDead(_44)
-    51:2-51:2: Goto: goto -&gt; bb77"><span class="annotation">75⦊</span>}<span class="annotation">⦉75</span></span></span><span><span class="code odd" style="--layer: 1" title="bb77: ../instrument-coverage/coverage_of_if_else.rs:51:2: 51:2:
-    51:2-51:2: Return: return"><span class="annotation">77⦊</span>‸<span class="annotation">⦉77</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index acad316d807..d85558ea2f5 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -3199,8 +3199,18 @@ impl<'test> TestCx<'test> {
                     from_file = format!("{}.{}.mir", test_name, first_pass);
                     to_file = Some(second_file);
                 } else {
-                    expected_file =
-                        format!("{}{}.mir", test_name.trim_end_matches(".mir"), bit_width);
+                    let ext_re = Regex::new(r#"(\.(mir|dot|html))$"#).unwrap();
+                    let cap = ext_re
+                        .captures_iter(test_name)
+                        .next()
+                        .expect("test_name has an invalid extension");
+                    let extension = cap.get(1).unwrap().as_str();
+                    expected_file = format!(
+                        "{}{}{}",
+                        test_name.trim_end_matches(extension),
+                        bit_width,
+                        extension,
+                    );
                     from_file = test_name.to_string();
                     assert!(
                         test_names.next().is_none(),
diff --git a/src/tools/rust-demangler/Cargo.toml b/src/tools/rust-demangler/Cargo.toml
index 0b8d974d255..c978bbe20e8 100644
--- a/src/tools/rust-demangler/Cargo.toml
+++ b/src/tools/rust-demangler/Cargo.toml
@@ -1,10 +1,11 @@
 [package]
 authors = ["The Rust Project Developers"]
 name = "rust-demangler"
-version = "0.0.0"
+version = "0.0.1"
 edition = "2018"
 
 [dependencies]
+regex = "1.0"
 rustc-demangle = "0.1"
 
 [[bin]]
diff --git a/src/tools/rust-demangler/main.rs b/src/tools/rust-demangler/main.rs
index a9f1011c450..e1e49230ad1 100644
--- a/src/tools/rust-demangler/main.rs
+++ b/src/tools/rust-demangler/main.rs
@@ -22,18 +22,51 @@
 //!   --instr-profile=main.profdata ./main --show-line-counts-or-regions
 //! ```
 
+use regex::Regex;
 use rustc_demangle::demangle;
 use std::io::{self, Read, Write};
 
+const REPLACE_COLONS: &str = "::";
+
 fn main() -> io::Result<()> {
+    let mut strip_crate_disambiguators = Some(Regex::new(r"\[[a-f0-9]{16}\]::").unwrap());
+
+    let mut args = std::env::args();
+    let progname = args.next().unwrap();
+    for arg in args {
+        if arg == "--disambiguators" || arg == "-d" {
+            strip_crate_disambiguators = None;
+        } else {
+            eprintln!();
+            eprintln!("Usage: {} [-d|--disambiguators]", progname);
+            eprintln!();
+            eprintln!(
+                "This tool converts a list of Rust mangled symbols (one per line) into a\n
+                corresponding list of demangled symbols."
+            );
+            eprintln!();
+            eprintln!(
+                "With -d (--disambiguators), Rust symbols mangled with the v0 symbol mangler may\n\
+                include crate disambiguators (a 16 character hex value in square brackets).\n\
+                Crate disambiguators are removed by default."
+            );
+            eprintln!();
+            std::process::exit(1)
+        }
+    }
+
     let mut buffer = String::new();
     io::stdin().read_to_string(&mut buffer)?;
     let lines = buffer.lines();
-    let mut demangled = Vec::new();
+    let mut demangled_lines = Vec::new();
     for mangled in lines {
-        demangled.push(demangle(mangled).to_string());
+        let mut demangled = demangle(mangled).to_string();
+        if let Some(re) = &strip_crate_disambiguators {
+            demangled = re.replace_all(&demangled, REPLACE_COLONS).to_string();
+        }
+        demangled_lines.push(demangled);
     }
-    demangled.push("".to_string());
-    io::stdout().write_all(demangled.join("\n").as_bytes())?;
+    demangled_lines.push("".to_string());
+    io::stdout().write_all(demangled_lines.join("\n").as_bytes())?;
     Ok(())
 }