diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
index 0549db06806e2..2b8c8d3697384 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -28,6 +28,7 @@ use std::fmt;
 
 use super::InferCtxtPrivExt;
 use crate::traits::query::evaluate_obligation::InferCtxtExt as _;
+use rustc_middle::ty::print::with_no_trimmed_paths;
 
 #[derive(Debug)]
 pub enum GeneratorInteriorOrUpvar {
@@ -440,7 +441,8 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                 {
                     // Missing generic type parameter bound.
                     let param_name = self_ty.to_string();
-                    let constraint = trait_ref.print_only_trait_path().to_string();
+                    let constraint =
+                        with_no_trimmed_paths(|| trait_ref.print_only_trait_path().to_string());
                     if suggest_constraining_type_param(
                         self.tcx,
                         generics,
diff --git a/compiler/rustc_typeck/src/check/upvar.rs b/compiler/rustc_typeck/src/check/upvar.rs
index 91021b3f6f589..6f8dd39958c04 100644
--- a/compiler/rustc_typeck/src/check/upvar.rs
+++ b/compiler/rustc_typeck/src/check/upvar.rs
@@ -34,6 +34,7 @@ use super::FnCtxt;
 
 use crate::expr_use_visitor as euv;
 use rustc_data_structures::fx::FxIndexMap;
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::def_id::LocalDefId;
@@ -91,7 +92,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InferBorrowKindVisitor<'a, 'tcx> {
         if let hir::ExprKind::Closure(cc, _, body_id, _, _) = expr.kind {
             let body = self.fcx.tcx.hir().body(body_id);
             self.visit_body(body);
-            self.fcx.analyze_closure(expr.hir_id, expr.span, body, cc);
+            self.fcx.analyze_closure(expr.hir_id, expr.span, body_id, body, cc);
         }
 
         intravisit::walk_expr(self, expr);
@@ -104,6 +105,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         closure_hir_id: hir::HirId,
         span: Span,
+        body_id: hir::BodyId,
         body: &'tcx hir::Body<'tcx>,
         capture_clause: hir::CaptureBy,
     ) {
@@ -167,7 +169,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let closure_hir_id = self.tcx.hir().local_def_id_to_hir_id(local_def_id);
         if should_do_migration_analysis(self.tcx, closure_hir_id) {
-            self.perform_2229_migration_anaysis(closure_def_id, capture_clause, span);
+            self.perform_2229_migration_anaysis(closure_def_id, body_id, capture_clause, span);
         }
 
         // We now fake capture information for all variables that are mentioned within the closure
@@ -465,6 +467,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn perform_2229_migration_anaysis(
         &self,
         closure_def_id: DefId,
+        body_id: hir::BodyId,
         capture_clause: hir::CaptureBy,
         span: Span,
     ) {
@@ -476,7 +479,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         );
 
         if !need_migrations.is_empty() {
-            let migrations_text = migration_suggestion_for_2229(self.tcx, &need_migrations);
+            let (migration_string, migrated_variables_concat) =
+                migration_suggestion_for_2229(self.tcx, &need_migrations);
 
             let local_def_id = closure_def_id.expect_local();
             let closure_hir_id = self.tcx.hir().local_def_id_to_hir_id(local_def_id);
@@ -488,7 +492,35 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let mut diagnostics_builder = lint.build(
                         "drop order affected for closure because of `capture_disjoint_fields`",
                     );
-                    diagnostics_builder.note(&migrations_text);
+                    let closure_body_span = self.tcx.hir().span(body_id.hir_id);
+                    let (sugg, app) =
+                        match self.tcx.sess.source_map().span_to_snippet(closure_body_span) {
+                            Ok(s) => {
+                                let trimmed = s.trim_start();
+
+                                // If the closure contains a block then replace the opening brace
+                                // with "{ let _ = (..); "
+                                let sugg = if let Some('{') = trimmed.chars().next() {
+                                    format!("{{ {}; {}", migration_string, &trimmed[1..])
+                                } else {
+                                    format!("{{ {}; {} }}", migration_string, s)
+                                };
+                                (sugg, Applicability::MachineApplicable)
+                            }
+                            Err(_) => (migration_string.clone(), Applicability::HasPlaceholders),
+                        };
+
+                    let diagnostic_msg = format!(
+                        "add a dummy let to cause {} to be fully captured",
+                        migrated_variables_concat
+                    );
+
+                    diagnostics_builder.span_suggestion(
+                        closure_body_span,
+                        &diagnostic_msg,
+                        sugg,
+                        app,
+                    );
                     diagnostics_builder.emit();
                 },
             );
@@ -621,7 +653,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// `w[c]`.
     /// Notation:
     /// - Ty(place): Type of place
-    /// - `(a, b)`: Represents the function parameters `base_path_ty` and `captured_projs`
+    /// - `(a, b)`: Represents the function parameters `base_path_ty` and `captured_by_move_projs`
     /// respectively.
     /// ```
     ///                  (Ty(w), [ &[p, x], &[c] ])
@@ -682,7 +714,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         closure_def_id: DefId,
         closure_span: Span,
         base_path_ty: Ty<'tcx>,
-        captured_projs: Vec<&[Projection<'tcx>]>,
+        captured_by_move_projs: Vec<&[Projection<'tcx>]>,
     ) -> bool {
         let needs_drop = |ty: Ty<'tcx>| {
             ty.needs_drop(self.tcx, self.tcx.param_env(closure_def_id.expect_local()))
@@ -707,9 +739,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         //
         // eg. If `a.b` is captured and we are processing `a.b`, then we can't have the closure also
         //     capture `a.b.c`, because that voilates min capture.
-        let is_completely_captured = captured_projs.iter().any(|projs| projs.is_empty());
+        let is_completely_captured = captured_by_move_projs.iter().any(|projs| projs.is_empty());
 
-        assert!(!is_completely_captured || (captured_projs.len() == 1));
+        assert!(!is_completely_captured || (captured_by_move_projs.len() == 1));
 
         if is_completely_captured {
             // The place is captured entirely, so doesn't matter if needs dtor, it will be drop
@@ -717,23 +749,27 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return false;
         }
 
+        if captured_by_move_projs.is_empty() {
+            return needs_drop(base_path_ty);
+        }
+
         if is_drop_defined_for_ty {
             // If drop is implemented for this type then we need it to be fully captured,
-            // which we know it is not because of the previous check. Therefore we need to
-            // do migrate.
-            return true;
-        }
+            // and we know it is not completely captured because of the previous checks.
 
-        if captured_projs.is_empty() {
-            return needs_drop(base_path_ty);
+            // Note that this is a bug in the user code that will be reported by the
+            // borrow checker, since we can't move out of drop types.
+
+            // The bug exists in the user's code pre-migration, and we don't migrate here.
+            return false;
         }
 
         match base_path_ty.kind() {
             // Observations:
-            // - `captured_projs` is not empty. Therefore we can call
-            //   `captured_projs.first().unwrap()` safely.
-            // - All entries in `captured_projs` have atleast one projection.
-            //   Therefore we can call `captured_projs.first().unwrap().first().unwrap()` safely.
+            // - `captured_by_move_projs` is not empty. Therefore we can call
+            //   `captured_by_move_projs.first().unwrap()` safely.
+            // - All entries in `captured_by_move_projs` have atleast one projection.
+            //   Therefore we can call `captured_by_move_projs.first().unwrap().first().unwrap()` safely.
 
             // We don't capture derefs in case of move captures, which would have be applied to
             // access any further paths.
@@ -743,19 +779,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
             ty::Adt(def, substs) => {
                 // Multi-varaint enums are captured in entirety,
-                // which would've been handled in the case of single empty slice in `captured_projs`.
+                // which would've been handled in the case of single empty slice in `captured_by_move_projs`.
                 assert_eq!(def.variants.len(), 1);
 
                 // Only Field projections can be applied to a non-box Adt.
                 assert!(
-                    captured_projs.iter().all(|projs| matches!(
+                    captured_by_move_projs.iter().all(|projs| matches!(
                         projs.first().unwrap().kind,
                         ProjectionKind::Field(..)
                     ))
                 );
                 def.variants.get(VariantIdx::new(0)).unwrap().fields.iter().enumerate().any(
                     |(i, field)| {
-                        let paths_using_field = captured_projs
+                        let paths_using_field = captured_by_move_projs
                             .iter()
                             .filter_map(|projs| {
                                 if let ProjectionKind::Field(field_idx, _) =
@@ -782,14 +818,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             ty::Tuple(..) => {
                 // Only Field projections can be applied to a tuple.
                 assert!(
-                    captured_projs.iter().all(|projs| matches!(
+                    captured_by_move_projs.iter().all(|projs| matches!(
                         projs.first().unwrap().kind,
                         ProjectionKind::Field(..)
                     ))
                 );
 
                 base_path_ty.tuple_fields().enumerate().any(|(i, element_ty)| {
-                    let paths_using_field = captured_projs
+                    let paths_using_field = captured_by_move_projs
                         .iter()
                         .filter_map(|projs| {
                             if let ProjectionKind::Field(field_idx, _) = projs.first().unwrap().kind
@@ -1515,12 +1551,29 @@ fn should_do_migration_analysis(tcx: TyCtxt<'_>, closure_id: hir::HirId) -> bool
     !matches!(level, lint::Level::Allow)
 }
 
-fn migration_suggestion_for_2229(tcx: TyCtxt<'_>, need_migrations: &Vec<hir::HirId>) -> String {
-    let need_migrations_strings =
-        need_migrations.iter().map(|v| format!("{}", var_name(tcx, *v))).collect::<Vec<_>>();
-    let migrations_list_concat = need_migrations_strings.join(", ");
+/// Return a two string tuple (s1, s2)
+/// - s1: Line of code that is needed for the migration: eg: `let _ = (&x, ...)`.
+/// - s2: Comma separated names of the variables being migrated.
+fn migration_suggestion_for_2229(
+    tcx: TyCtxt<'_>,
+    need_migrations: &Vec<hir::HirId>,
+) -> (String, String) {
+    let need_migrations_variables =
+        need_migrations.iter().map(|v| var_name(tcx, *v)).collect::<Vec<_>>();
+
+    let migration_ref_concat =
+        need_migrations_variables.iter().map(|v| format!("&{}", v)).collect::<Vec<_>>().join(", ");
+
+    let migration_string = if 1 == need_migrations.len() {
+        format!("let _ = {}", migration_ref_concat)
+    } else {
+        format!("let _ = ({})", migration_ref_concat)
+    };
+
+    let migrated_variables_concat =
+        need_migrations_variables.iter().map(|v| format!("`{}`", v)).collect::<Vec<_>>().join(", ");
 
-    format!("drop(&({}));", migrations_list_concat)
+    (migration_string, migrated_variables_concat)
 }
 
 /// Helper function to determine if we need to escalate CaptureKind from
diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs
index bcbdffabc7fbe..324e894bafd23 100644
--- a/library/alloc/src/vec/into_iter.rs
+++ b/library/alloc/src/vec/into_iter.rs
@@ -85,20 +85,29 @@ impl<T, A: Allocator> IntoIter<T, A> {
         ptr::slice_from_raw_parts_mut(self.ptr as *mut T, self.len())
     }
 
-    pub(super) fn drop_remaining(&mut self) {
-        unsafe {
-            ptr::drop_in_place(self.as_mut_slice());
-        }
-        self.ptr = self.end;
-    }
+    /// Drops remaining elements and relinquishes the backing allocation.
+    ///
+    /// This is roughly equivalent to the following, but more efficient
+    ///
+    /// ```
+    /// # let mut into_iter = Vec::<u8>::with_capacity(10).into_iter();
+    /// (&mut into_iter).for_each(core::mem::drop);
+    /// unsafe { core::ptr::write(&mut into_iter, Vec::new().into_iter()); }
+    /// ```
+    pub(super) fn forget_allocation_drop_remaining(&mut self) {
+        let remaining = self.as_raw_mut_slice();
 
-    /// Relinquishes the backing allocation, equivalent to
-    /// `ptr::write(&mut self, Vec::new().into_iter())`
-    pub(super) fn forget_allocation(&mut self) {
+        // overwrite the individual fields instead of creating a new
+        // struct and then overwriting &mut self.
+        // this creates less assembly
         self.cap = 0;
         self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) };
         self.ptr = self.buf.as_ptr();
         self.end = self.buf.as_ptr();
+
+        unsafe {
+            ptr::drop_in_place(remaining);
+        }
     }
 }
 
diff --git a/library/alloc/src/vec/source_iter_marker.rs b/library/alloc/src/vec/source_iter_marker.rs
index 50882fc17673e..e857d284d3ab6 100644
--- a/library/alloc/src/vec/source_iter_marker.rs
+++ b/library/alloc/src/vec/source_iter_marker.rs
@@ -69,9 +69,9 @@ where
         }
 
         // drop any remaining values at the tail of the source
-        src.drop_remaining();
         // but prevent drop of the allocation itself once IntoIter goes out of scope
-        src.forget_allocation();
+        // if the drop panics then we also leak any elements collected into dst_buf
+        src.forget_allocation_drop_remaining();
 
         let vec = unsafe { Vec::from_raw_parts(dst_buf, len, cap) };
 
diff --git a/library/alloc/tests/vec.rs b/library/alloc/tests/vec.rs
index c142536cd2dfb..b926c697d58ab 100644
--- a/library/alloc/tests/vec.rs
+++ b/library/alloc/tests/vec.rs
@@ -1027,7 +1027,7 @@ fn test_from_iter_specialization_head_tail_drop() {
 }
 
 #[test]
-fn test_from_iter_specialization_panic_drop() {
+fn test_from_iter_specialization_panic_during_iteration_drops() {
     let drop_count: Vec<_> = (0..=2).map(|_| Rc::new(())).collect();
     let src: Vec<_> = drop_count.iter().cloned().collect();
     let iter = src.into_iter();
@@ -1050,6 +1050,42 @@ fn test_from_iter_specialization_panic_drop() {
     );
 }
 
+#[test]
+fn test_from_iter_specialization_panic_during_drop_leaks() {
+    static mut DROP_COUNTER: usize = 0;
+
+    #[derive(Debug)]
+    enum Droppable {
+        DroppedTwice(Box<i32>),
+        PanicOnDrop,
+    }
+
+    impl Drop for Droppable {
+        fn drop(&mut self) {
+            match self {
+                Droppable::DroppedTwice(_) => {
+                    unsafe {
+                        DROP_COUNTER += 1;
+                    }
+                    println!("Dropping!")
+                }
+                Droppable::PanicOnDrop => {
+                    if !std::thread::panicking() {
+                        panic!();
+                    }
+                }
+            }
+        }
+    }
+
+    let _ = std::panic::catch_unwind(AssertUnwindSafe(|| {
+        let v = vec![Droppable::DroppedTwice(Box::new(123)), Droppable::PanicOnDrop];
+        let _ = v.into_iter().take(0).collect::<Vec<_>>();
+    }));
+
+    assert_eq!(unsafe { DROP_COUNTER }, 1);
+}
+
 #[test]
 fn test_cow_from() {
     let borrowed: &[_] = &["borrowed", "(slice)"];
diff --git a/library/std/src/sys/unix/thread.rs b/library/std/src/sys/unix/thread.rs
index 01a12dcf5a2af..b8f43caec32a3 100644
--- a/library/std/src/sys/unix/thread.rs
+++ b/library/std/src/sys/unix/thread.rs
@@ -343,6 +343,20 @@ pub mod guard {
             // it can eventually grow to. It cannot be used to determine
             // the position of kernel's stack guard.
             None
+        } else if cfg!(target_os = "freebsd") {
+            // FreeBSD's stack autogrows, and optionally includes a guard page
+            // at the bottom.  If we try to remap the bottom of the stack
+            // ourselves, FreeBSD's guard page moves upwards.  So we'll just use
+            // the builtin guard page.
+            let stackaddr = get_stack_start_aligned()?;
+            let guardaddr = stackaddr as usize;
+            // Technically the number of guard pages is tunable and controlled
+            // by the security.bsd.stack_guard_page sysctl, but there are
+            // few reasons to change it from the default.  The default value has
+            // been 1 ever since FreeBSD 11.1 and 10.4.
+            const GUARD_PAGES: usize = 1;
+            let guard = guardaddr..guardaddr + GUARD_PAGES * page_size;
+            Some(guard)
         } else {
             // Reallocate the last page of the stack.
             // This ensures SIGBUS will be raised on
@@ -371,9 +385,8 @@ pub mod guard {
             }
 
             let guardaddr = stackaddr as usize;
-            let offset = if cfg!(target_os = "freebsd") { 2 } else { 1 };
 
-            Some(guardaddr..guardaddr + offset * page_size)
+            Some(guardaddr..guardaddr + page_size)
         }
     }
 
@@ -417,11 +430,7 @@ pub mod guard {
             assert_eq!(libc::pthread_attr_getstack(&attr, &mut stackaddr, &mut size), 0);
 
             let stackaddr = stackaddr as usize;
-            ret = if cfg!(target_os = "freebsd") {
-                // FIXME does freebsd really fault *below* the guard addr?
-                let guardaddr = stackaddr - guardsize;
-                Some(guardaddr - PAGE_SIZE.load(Ordering::Relaxed)..guardaddr)
-            } else if cfg!(target_os = "netbsd") {
+            ret = if cfg!(any(target_os = "freebsd", target_os = "netbsd")) {
                 Some(stackaddr - guardsize..stackaddr)
             } else if cfg!(all(target_os = "linux", target_env = "musl")) {
                 Some(stackaddr - guardsize..stackaddr)
diff --git a/library/std/src/sys/windows/alloc.rs b/library/std/src/sys/windows/alloc.rs
index 99b4d6c72a0e3..af93cd7a3e27d 100644
--- a/library/std/src/sys/windows/alloc.rs
+++ b/library/std/src/sys/windows/alloc.rs
@@ -1,61 +1,246 @@
+#![deny(unsafe_op_in_unsafe_fn)]
+
 use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::ffi::c_void;
+use crate::ptr;
+use crate::sync::atomic::{AtomicPtr, Ordering};
 use crate::sys::c;
 use crate::sys_common::alloc::{realloc_fallback, MIN_ALIGN};
 
-#[repr(C)]
-struct Header(*mut u8);
+#[cfg(test)]
+mod tests;
+
+// Heap memory management on Windows is done by using the system Heap API (heapapi.h)
+// See https://docs.microsoft.com/windows/win32/api/heapapi/
+
+// Flag to indicate that the memory returned by `HeapAlloc` should be zeroed.
+const HEAP_ZERO_MEMORY: c::DWORD = 0x00000008;
 
-unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {
-    &mut *(ptr as *mut Header).offset(-1)
+extern "system" {
+    // Get a handle to the default heap of the current process, or null if the operation fails.
+    //
+    // SAFETY: Successful calls to this function within the same process are assumed to
+    // always return the same handle, which remains valid for the entire lifetime of the process.
+    //
+    // See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-getprocessheap
+    fn GetProcessHeap() -> c::HANDLE;
+
+    // Allocate a block of `dwBytes` bytes of memory from a given heap `hHeap`.
+    // The allocated memory may be uninitialized, or zeroed if `dwFlags` is
+    // set to `HEAP_ZERO_MEMORY`.
+    //
+    // Returns a pointer to the newly-allocated memory or null if the operation fails.
+    // The returned pointer will be aligned to at least `MIN_ALIGN`.
+    //
+    // SAFETY:
+    //  - `hHeap` must be a non-null handle returned by `GetProcessHeap`.
+    //  - `dwFlags` must be set to either zero or `HEAP_ZERO_MEMORY`.
+    //
+    // Note that `dwBytes` is allowed to be zero, contrary to some other allocators.
+    //
+    // See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-heapalloc
+    fn HeapAlloc(hHeap: c::HANDLE, dwFlags: c::DWORD, dwBytes: c::SIZE_T) -> c::LPVOID;
+
+    // Reallocate a block of memory behind a given pointer `lpMem` from a given heap `hHeap`,
+    // to a block of at least `dwBytes` bytes, either shrinking the block in place,
+    // or allocating at a new location, copying memory, and freeing the original location.
+    //
+    // Returns a pointer to the reallocated memory or null if the operation fails.
+    // The returned pointer will be aligned to at least `MIN_ALIGN`.
+    // If the operation fails the given block will never have been freed.
+    //
+    // SAFETY:
+    //  - `hHeap` must be a non-null handle returned by `GetProcessHeap`.
+    //  - `dwFlags` must be set to zero.
+    //  - `lpMem` must be a non-null pointer to an allocated block returned by `HeapAlloc` or
+    //     `HeapReAlloc`, that has not already been freed.
+    // If the block was successfully reallocated at a new location, pointers pointing to
+    // the freed memory, such as `lpMem`, must not be dereferenced ever again.
+    //
+    // Note that `dwBytes` is allowed to be zero, contrary to some other allocators.
+    //
+    // See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-heaprealloc
+    fn HeapReAlloc(
+        hHeap: c::HANDLE,
+        dwFlags: c::DWORD,
+        lpMem: c::LPVOID,
+        dwBytes: c::SIZE_T,
+    ) -> c::LPVOID;
+
+    // Free a block of memory behind a given pointer `lpMem` from a given heap `hHeap`.
+    // Returns a nonzero value if the operation is successful, and zero if the operation fails.
+    //
+    // SAFETY:
+    //  - `hHeap` must be a non-null handle returned by `GetProcessHeap`.
+    //  - `dwFlags` must be set to zero.
+    //  - `lpMem` must be a pointer to an allocated block returned by `HeapAlloc` or `HeapReAlloc`,
+    //     that has not already been freed.
+    // If the block was successfully freed, pointers pointing to the freed memory, such as `lpMem`,
+    // must not be dereferenced ever again.
+    //
+    // Note that `lpMem` is allowed to be null, which will not cause the operation to fail.
+    //
+    // See https://docs.microsoft.com/windows/win32/api/heapapi/nf-heapapi-heapfree
+    fn HeapFree(hHeap: c::HANDLE, dwFlags: c::DWORD, lpMem: c::LPVOID) -> c::BOOL;
 }
 
-unsafe fn align_ptr(ptr: *mut u8, align: usize) -> *mut u8 {
-    let aligned = ptr.add(align - (ptr as usize & (align - 1)));
-    *get_header(aligned) = Header(ptr);
-    aligned
+// Cached handle to the default heap of the current process.
+// Either a non-null handle returned by `GetProcessHeap`, or null when not yet initialized or `GetProcessHeap` failed.
+static HEAP: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut());
+
+// Get a handle to the default heap of the current process, or null if the operation fails.
+// If this operation is successful, `HEAP` will be successfully initialized and contain
+// a non-null handle returned by `GetProcessHeap`.
+#[inline]
+fn init_or_get_process_heap() -> c::HANDLE {
+    let heap = HEAP.load(Ordering::Relaxed);
+    if heap.is_null() {
+        // `HEAP` has not yet been successfully initialized
+        let heap = unsafe { GetProcessHeap() };
+        if !heap.is_null() {
+            // SAFETY: No locking is needed because within the same process,
+            // successful calls to `GetProcessHeap` will always return the same value, even on different threads.
+            HEAP.store(heap, Ordering::Release);
+
+            // SAFETY: `HEAP` contains a non-null handle returned by `GetProcessHeap`
+            heap
+        } else {
+            // Could not get the current process heap.
+            ptr::null_mut()
+        }
+    } else {
+        // SAFETY: `HEAP` contains a non-null handle returned by `GetProcessHeap`
+        heap
+    }
 }
 
+// Get a non-null handle to the default heap of the current process.
+// SAFETY: `HEAP` must have been successfully initialized.
 #[inline]
-unsafe fn allocate_with_flags(layout: Layout, flags: c::DWORD) -> *mut u8 {
-    if layout.align() <= MIN_ALIGN {
-        return c::HeapAlloc(c::GetProcessHeap(), flags, layout.size()) as *mut u8;
+unsafe fn get_process_heap() -> c::HANDLE {
+    HEAP.load(Ordering::Acquire)
+}
+
+// Header containing a pointer to the start of an allocated block.
+// SAFETY: Size and alignment must be <= `MIN_ALIGN`.
+#[repr(C)]
+struct Header(*mut u8);
+
+// Allocate a block of optionally zeroed memory for a given `layout`.
+// SAFETY: Returns a pointer satisfying the guarantees of `System` about allocated pointers,
+// or null if the operation fails. If this returns non-null `HEAP` will have been successfully
+// initialized.
+#[inline]
+unsafe fn allocate(layout: Layout, zeroed: bool) -> *mut u8 {
+    let heap = init_or_get_process_heap();
+    if heap.is_null() {
+        // Allocation has failed, could not get the current process heap.
+        return ptr::null_mut();
     }
 
-    let size = layout.size() + layout.align();
-    let ptr = c::HeapAlloc(c::GetProcessHeap(), flags, size);
-    if ptr.is_null() { ptr as *mut u8 } else { align_ptr(ptr as *mut u8, layout.align()) }
+    // Allocated memory will be either zeroed or uninitialized.
+    let flags = if zeroed { HEAP_ZERO_MEMORY } else { 0 };
+
+    if layout.align() <= MIN_ALIGN {
+        // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`.
+        // The returned pointer points to the start of an allocated block.
+        unsafe { HeapAlloc(heap, flags, layout.size()) as *mut u8 }
+    } else {
+        // Allocate extra padding in order to be able to satisfy the alignment.
+        let total = layout.align() + layout.size();
+
+        // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`.
+        let ptr = unsafe { HeapAlloc(heap, flags, total) as *mut u8 };
+        if ptr.is_null() {
+            // Allocation has failed.
+            return ptr::null_mut();
+        }
+
+        // Create a correctly aligned pointer offset from the start of the allocated block,
+        // and write a header before it.
+
+        let offset = layout.align() - (ptr as usize & (layout.align() - 1));
+        // SAFETY: `MIN_ALIGN` <= `offset` <= `layout.align()` and the size of the allocated
+        // block is `layout.align() + layout.size()`. `aligned` will thus be a correctly aligned
+        // pointer inside the allocated block with at least `layout.size()` bytes after it and at
+        // least `MIN_ALIGN` bytes of padding before it.
+        let aligned = unsafe { ptr.add(offset) };
+        // SAFETY: Because the size and alignment of a header is <= `MIN_ALIGN` and `aligned`
+        // is aligned to at least `MIN_ALIGN` and has at least `MIN_ALIGN` bytes of padding before
+        // it, it is safe to write a header directly before it.
+        unsafe { ptr::write((aligned as *mut Header).offset(-1), Header(ptr)) };
+
+        // SAFETY: The returned pointer does not point to the to the start of an allocated block,
+        // but there is a header readable directly before it containing the location of the start
+        // of the block.
+        aligned
+    }
 }
 
+// All pointers returned by this allocator have, in addition to the guarantees of `GlobalAlloc`, the
+// following properties:
+//
+// If the pointer was allocated or reallocated with a `layout` specifying an alignment <= `MIN_ALIGN`
+// the pointer will be aligned to at least `MIN_ALIGN` and point to the start of the allocated block.
+//
+// If the pointer was allocated or reallocated with a `layout` specifying an alignment > `MIN_ALIGN`
+// the pointer will be aligned to the specified alignment and not point to the start of the allocated block.
+// Instead there will be a header readable directly before the returned pointer, containing the actual
+// location of the start of the block.
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
     #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        allocate_with_flags(layout, 0)
+        // SAFETY: Pointers returned by `allocate` satisfy the guarantees of `System`
+        let zeroed = false;
+        unsafe { allocate(layout, zeroed) }
     }
 
     #[inline]
     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        allocate_with_flags(layout, c::HEAP_ZERO_MEMORY)
+        // SAFETY: Pointers returned by `allocate` satisfy the guarantees of `System`
+        let zeroed = true;
+        unsafe { allocate(layout, zeroed) }
     }
 
     #[inline]
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        if layout.align() <= MIN_ALIGN {
-            let err = c::HeapFree(c::GetProcessHeap(), 0, ptr as c::LPVOID);
-            debug_assert!(err != 0, "Failed to free heap memory: {}", c::GetLastError());
-        } else {
-            let header = get_header(ptr);
-            let err = c::HeapFree(c::GetProcessHeap(), 0, header.0 as c::LPVOID);
-            debug_assert!(err != 0, "Failed to free heap memory: {}", c::GetLastError());
-        }
+        let block = {
+            if layout.align() <= MIN_ALIGN {
+                ptr
+            } else {
+                // The location of the start of the block is stored in the padding before `ptr`.
+
+                // SAFETY: Because of the contract of `System`, `ptr` is guaranteed to be non-null
+                // and have a header readable directly before it.
+                unsafe { ptr::read((ptr as *mut Header).offset(-1)).0 }
+            }
+        };
+
+        // SAFETY: because `ptr` has been successfully allocated with this allocator,
+        // `HEAP` must have been successfully initialized.
+        let heap = unsafe { get_process_heap() };
+
+        // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`,
+        // `block` is a pointer to the start of an allocated block.
+        unsafe { HeapFree(heap, 0, block as c::LPVOID) };
     }
 
     #[inline]
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
         if layout.align() <= MIN_ALIGN {
-            c::HeapReAlloc(c::GetProcessHeap(), 0, ptr as c::LPVOID, new_size) as *mut u8
+            // SAFETY: because `ptr` has been successfully allocated with this allocator,
+            // `HEAP` must have been successfully initialized.
+            let heap = unsafe { get_process_heap() };
+
+            // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`,
+            // `ptr` is a pointer to the start of an allocated block.
+            // The returned pointer points to the start of an allocated block.
+            unsafe { HeapReAlloc(heap, 0, ptr as c::LPVOID, new_size) as *mut u8 }
         } else {
-            realloc_fallback(self, ptr, layout, new_size)
+            // SAFETY: `realloc_fallback` is implemented using `dealloc` and `alloc`, which will
+            // correctly handle `ptr` and return a pointer satisfying the guarantees of `System`
+            unsafe { realloc_fallback(self, ptr, layout, new_size) }
         }
     }
 }
diff --git a/library/std/src/sys/windows/alloc/tests.rs b/library/std/src/sys/windows/alloc/tests.rs
new file mode 100644
index 0000000000000..674a3e1d92d17
--- /dev/null
+++ b/library/std/src/sys/windows/alloc/tests.rs
@@ -0,0 +1,9 @@
+use super::{Header, MIN_ALIGN};
+use crate::mem;
+
+#[test]
+fn alloc_header() {
+    // Header must fit in the padding before an aligned pointer
+    assert!(mem::size_of::<Header>() <= MIN_ALIGN);
+    assert!(mem::align_of::<Header>() <= MIN_ALIGN);
+}
diff --git a/library/std/src/sys/windows/c.rs b/library/std/src/sys/windows/c.rs
index 9789ed085e29d..3e4176ef7f8fe 100644
--- a/library/std/src/sys/windows/c.rs
+++ b/library/std/src/sys/windows/c.rs
@@ -285,8 +285,6 @@ pub const FD_SETSIZE: usize = 64;
 
 pub const STACK_SIZE_PARAM_IS_A_RESERVATION: DWORD = 0x00010000;
 
-pub const HEAP_ZERO_MEMORY: DWORD = 0x00000008;
-
 pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;
 
 #[repr(C)]
@@ -1017,11 +1015,6 @@ extern "system" {
         timeout: *const timeval,
     ) -> c_int;
 
-    pub fn GetProcessHeap() -> HANDLE;
-    pub fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
-    pub fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
-    pub fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
-
     // >= Vista / Server 2008
     // https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createsymboliclinkw
     pub fn CreateSymbolicLinkW(
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index ecb6378f31fb4..246e0ebbb2ba0 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -3,6 +3,7 @@ use std::convert::TryFrom;
 use std::ffi::OsStr;
 use std::fmt;
 use std::path::PathBuf;
+use std::str::FromStr;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_session::config::{self, parse_crate_types_from_list, parse_externs, CrateType};
@@ -266,6 +267,34 @@ crate struct RenderOptions {
     /// If `true`, generate a JSON file in the crate folder instead of HTML redirection files.
     crate generate_redirect_map: bool,
     crate unstable_features: rustc_feature::UnstableFeatures,
+    crate emit: Vec<EmitType>,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+crate enum EmitType {
+    Unversioned,
+    Toolchain,
+    InvocationSpecific,
+}
+
+impl FromStr for EmitType {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use EmitType::*;
+        match s {
+            "unversioned-shared-resources" => Ok(Unversioned),
+            "toolchain-shared-resources" => Ok(Toolchain),
+            "invocation-specific" => Ok(InvocationSpecific),
+            _ => Err(()),
+        }
+    }
+}
+
+impl RenderOptions {
+    crate fn should_emit_crate(&self) -> bool {
+        self.emit.is_empty() || self.emit.contains(&EmitType::InvocationSpecific)
+    }
 }
 
 impl Options {
@@ -334,6 +363,19 @@ impl Options {
         // check for deprecated options
         check_deprecated_options(&matches, &diag);
 
+        let mut emit = Vec::new();
+        for list in matches.opt_strs("emit") {
+            for kind in list.split(',') {
+                match kind.parse() {
+                    Ok(kind) => emit.push(kind),
+                    Err(()) => {
+                        diag.err(&format!("unrecognized emission type: {}", kind));
+                        return Err(1);
+                    }
+                }
+            }
+        }
+
         let to_check = matches.opt_strs("check-theme");
         if !to_check.is_empty() {
             let paths = theme::load_css_paths(static_files::themes::LIGHT.as_bytes());
@@ -641,6 +683,7 @@ impl Options {
                 unstable_features: rustc_feature::UnstableFeatures::from_environment(
                     crate_name.as_deref(),
                 ),
+                emit,
             },
             crate_name,
             output_format,
diff --git a/src/librustdoc/formats/renderer.rs b/src/librustdoc/formats/renderer.rs
index 4e0f3a4e3c317..ae97cd64fb5fb 100644
--- a/src/librustdoc/formats/renderer.rs
+++ b/src/librustdoc/formats/renderer.rs
@@ -63,10 +63,15 @@ crate fn run_format<'tcx, T: FormatRenderer<'tcx>>(
 ) -> Result<(), Error> {
     let prof = &tcx.sess.prof;
 
+    let emit_crate = options.should_emit_crate();
     let (mut format_renderer, krate) = prof
         .extra_verbose_generic_activity("create_renderer", T::descr())
         .run(|| T::init(krate, options, edition, cache, tcx))?;
 
+    if !emit_crate {
+        return Ok(());
+    }
+
     // Render the crate documentation
     let crate_name = krate.name;
     let mut work = vec![(format_renderer.make_child_renderer(), krate.module)];
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 0ffb4d616da1a..07c850a20a9a4 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -79,17 +79,6 @@ crate struct Context<'tcx> {
 rustc_data_structures::static_assert_size!(Context<'_>, 152);
 
 impl<'tcx> Context<'tcx> {
-    pub(super) fn path(&self, filename: &str) -> PathBuf {
-        // We use splitn vs Path::extension here because we might get a filename
-        // like `style.min.css` and we want to process that into
-        // `style-suffix.min.css`.  Path::extension would just return `css`
-        // which would result in `style.min-suffix.css` which isn't what we
-        // want.
-        let (base, ext) = filename.split_once('.').unwrap();
-        let filename = format!("{}{}.{}", base, self.shared.resource_suffix, ext);
-        self.dst.join(&filename)
-    }
-
     pub(super) fn tcx(&self) -> TyCtxt<'tcx> {
         self.shared.tcx
     }
@@ -301,6 +290,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
     ) -> Result<(Self, clean::Crate), Error> {
         // need to save a copy of the options for rendering the index page
         let md_opts = options.clone();
+        let emit_crate = options.should_emit_crate();
         let RenderOptions {
             output,
             external_html,
@@ -406,7 +396,9 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
 
         let dst = output;
         scx.ensure_dir(&dst)?;
-        krate = sources::render(&dst, &mut scx, krate)?;
+        if emit_crate {
+            krate = sources::render(&dst, &mut scx, krate)?;
+        }
 
         // Build our search index
         let index = build_index(&krate, &mut cache, tcx);
@@ -489,7 +481,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             |buf: &mut Buffer| all.print(buf),
             &self.shared.style_files,
         );
-        self.shared.fs.write(&final_file, v.as_bytes())?;
+        self.shared.fs.write(final_file, v.as_bytes())?;
 
         // Generating settings page.
         page.title = "Rustdoc settings";
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index dc96755211622..59dc4ef944909 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -13,8 +13,8 @@ use serde::Serialize;
 
 use super::{collect_paths_for_type, ensure_trailing_slash, Context, BASIC_KEYWORDS};
 use crate::clean::Crate;
-use crate::config::RenderOptions;
-use crate::docfs::{DocFS, PathError};
+use crate::config::{EmitType, RenderOptions};
+use crate::docfs::PathError;
 use crate::error::Error;
 use crate::formats::FormatRenderer;
 use crate::html::{layout, static_files};
@@ -40,6 +40,102 @@ crate static FILES_UNVERSIONED: Lazy<FxHashMap<&str, &[u8]>> = Lazy::new(|| {
     }
 });
 
+enum SharedResource<'a> {
+    /// This file will never change, no matter what toolchain is used to build it.
+    ///
+    /// It does not have a resource suffix.
+    Unversioned { name: &'static str },
+    /// This file may change depending on the toolchain.
+    ///
+    /// It has a resource suffix.
+    ToolchainSpecific { basename: &'static str },
+    /// This file may change for any crate within a build, or based on the CLI arguments.
+    ///
+    /// This differs from normal invocation-specific files because it has a resource suffix.
+    InvocationSpecific { basename: &'a str },
+}
+
+impl SharedResource<'_> {
+    fn extension(&self) -> Option<&OsStr> {
+        use SharedResource::*;
+        match self {
+            Unversioned { name }
+            | ToolchainSpecific { basename: name }
+            | InvocationSpecific { basename: name } => Path::new(name).extension(),
+        }
+    }
+
+    fn path(&self, cx: &Context<'_>) -> PathBuf {
+        match self {
+            SharedResource::Unversioned { name } => cx.dst.join(name),
+            SharedResource::ToolchainSpecific { basename } => cx.suffix_path(basename),
+            SharedResource::InvocationSpecific { basename } => cx.suffix_path(basename),
+        }
+    }
+
+    fn should_emit(&self, emit: &[EmitType]) -> bool {
+        if emit.is_empty() {
+            return true;
+        }
+        let kind = match self {
+            SharedResource::Unversioned { .. } => EmitType::Unversioned,
+            SharedResource::ToolchainSpecific { .. } => EmitType::Toolchain,
+            SharedResource::InvocationSpecific { .. } => EmitType::InvocationSpecific,
+        };
+        emit.contains(&kind)
+    }
+}
+
+impl Context<'_> {
+    fn suffix_path(&self, filename: &str) -> PathBuf {
+        // We use splitn vs Path::extension here because we might get a filename
+        // like `style.min.css` and we want to process that into
+        // `style-suffix.min.css`.  Path::extension would just return `css`
+        // which would result in `style.min-suffix.css` which isn't what we
+        // want.
+        let (base, ext) = filename.split_once('.').unwrap();
+        let filename = format!("{}{}.{}", base, self.shared.resource_suffix, ext);
+        self.dst.join(&filename)
+    }
+
+    fn write_shared<C: AsRef<[u8]>>(
+        &self,
+        resource: SharedResource<'_>,
+        contents: C,
+        emit: &[EmitType],
+    ) -> Result<(), Error> {
+        if resource.should_emit(emit) {
+            self.shared.fs.write(resource.path(self), contents)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn write_minify(
+        &self,
+        resource: SharedResource<'_>,
+        contents: &str,
+        minify: bool,
+        emit: &[EmitType],
+    ) -> Result<(), Error> {
+        let tmp;
+        let contents = if minify {
+            tmp = if resource.extension() == Some(&OsStr::new("css")) {
+                minifier::css::minify(contents).map_err(|e| {
+                    Error::new(format!("failed to minify CSS file: {}", e), resource.path(self))
+                })?
+            } else {
+                minifier::js::minify(contents)
+            };
+            tmp.as_bytes()
+        } else {
+            contents.as_bytes()
+        };
+
+        self.write_shared(resource, contents, emit)
+    }
+}
+
 pub(super) fn write_shared(
     cx: &Context<'_>,
     krate: &Crate,
@@ -52,27 +148,31 @@ pub(super) fn write_shared(
     let lock_file = cx.dst.join(".lock");
     let _lock = try_err!(flock::Lock::new(&lock_file, true, true, true), &lock_file);
 
+    // The weird `: &_` is to work around a borrowck bug: https://github.com/rust-lang/rust/issues/41078#issuecomment-293646723
+    let write_minify = |p, c: &_| {
+        cx.write_minify(
+            SharedResource::ToolchainSpecific { basename: p },
+            c,
+            options.enable_minification,
+            &options.emit,
+        )
+    };
+    // Toolchain resources should never be dynamic.
+    let write_toolchain = |p: &'static _, c: &'static _| {
+        cx.write_shared(SharedResource::ToolchainSpecific { basename: p }, c, &options.emit)
+    };
+
+    // Crate resources should always be dynamic.
+    let write_crate = |p: &_, make_content: &dyn Fn() -> Result<Vec<u8>, Error>| {
+        let content = make_content()?;
+        cx.write_shared(SharedResource::InvocationSpecific { basename: p }, content, &options.emit)
+    };
+
     // Add all the static files. These may already exist, but we just
     // overwrite them anyway to make sure that they're fresh and up-to-date.
-
-    write_minify(
-        &cx.shared.fs,
-        cx.path("rustdoc.css"),
-        static_files::RUSTDOC_CSS,
-        options.enable_minification,
-    )?;
-    write_minify(
-        &cx.shared.fs,
-        cx.path("settings.css"),
-        static_files::SETTINGS_CSS,
-        options.enable_minification,
-    )?;
-    write_minify(
-        &cx.shared.fs,
-        cx.path("noscript.css"),
-        static_files::NOSCRIPT_CSS,
-        options.enable_minification,
-    )?;
+    write_minify("rustdoc.css", static_files::RUSTDOC_CSS)?;
+    write_minify("settings.css", static_files::SETTINGS_CSS)?;
+    write_minify("noscript.css", static_files::NOSCRIPT_CSS)?;
 
     // To avoid "light.css" to be overwritten, we'll first run over the received themes and only
     // then we'll run over the "official" styles.
@@ -85,106 +185,73 @@ pub(super) fn write_shared(
 
         // Handle the official themes
         match theme {
-            "light" => write_minify(
-                &cx.shared.fs,
-                cx.path("light.css"),
-                static_files::themes::LIGHT,
-                options.enable_minification,
-            )?,
-            "dark" => write_minify(
-                &cx.shared.fs,
-                cx.path("dark.css"),
-                static_files::themes::DARK,
-                options.enable_minification,
-            )?,
-            "ayu" => write_minify(
-                &cx.shared.fs,
-                cx.path("ayu.css"),
-                static_files::themes::AYU,
-                options.enable_minification,
-            )?,
+            "light" => write_minify("light.css", static_files::themes::LIGHT)?,
+            "dark" => write_minify("dark.css", static_files::themes::DARK)?,
+            "ayu" => write_minify("ayu.css", static_files::themes::AYU)?,
             _ => {
                 // Handle added third-party themes
-                let content = try_err!(fs::read(&entry.path), &entry.path);
-                cx.shared
-                    .fs
-                    .write(cx.path(&format!("{}.{}", theme, extension)), content.as_slice())?;
+                let filename = format!("{}.{}", theme, extension);
+                write_crate(&filename, &|| Ok(try_err!(fs::read(&entry.path), &entry.path)))?;
             }
         };
 
         themes.insert(theme.to_owned());
     }
 
-    let write = |p, c| cx.shared.fs.write(p, c);
     if (*cx.shared).layout.logo.is_empty() {
-        write(cx.path("rust-logo.png"), static_files::RUST_LOGO)?;
+        write_toolchain("rust-logo.png", static_files::RUST_LOGO)?;
     }
     if (*cx.shared).layout.favicon.is_empty() {
-        write(cx.path("favicon.svg"), static_files::RUST_FAVICON_SVG)?;
-        write(cx.path("favicon-16x16.png"), static_files::RUST_FAVICON_PNG_16)?;
-        write(cx.path("favicon-32x32.png"), static_files::RUST_FAVICON_PNG_32)?;
+        write_toolchain("favicon.svg", static_files::RUST_FAVICON_SVG)?;
+        write_toolchain("favicon-16x16.png", static_files::RUST_FAVICON_PNG_16)?;
+        write_toolchain("favicon-32x32.png", static_files::RUST_FAVICON_PNG_32)?;
     }
-    write(cx.path("brush.svg"), static_files::BRUSH_SVG)?;
-    write(cx.path("wheel.svg"), static_files::WHEEL_SVG)?;
-    write(cx.path("down-arrow.svg"), static_files::DOWN_ARROW_SVG)?;
+    write_toolchain("brush.svg", static_files::BRUSH_SVG)?;
+    write_toolchain("wheel.svg", static_files::WHEEL_SVG)?;
+    write_toolchain("down-arrow.svg", static_files::DOWN_ARROW_SVG)?;
 
     let mut themes: Vec<&String> = themes.iter().collect();
     themes.sort();
 
+    // FIXME: this should probably not be a toolchain file since it depends on `--theme`.
+    // But it seems a shame to copy it over and over when it's almost always the same.
+    // Maybe we can change the representation to move this out of main.js?
     write_minify(
-        &cx.shared.fs,
-        cx.path("main.js"),
+        "main.js",
         &static_files::MAIN_JS.replace(
             "/* INSERT THEMES HERE */",
             &format!(" = {}", serde_json::to_string(&themes).unwrap()),
         ),
-        options.enable_minification,
-    )?;
-    write_minify(
-        &cx.shared.fs,
-        cx.path("settings.js"),
-        static_files::SETTINGS_JS,
-        options.enable_minification,
     )?;
+    write_minify("settings.js", static_files::SETTINGS_JS)?;
     if cx.shared.include_sources {
-        write_minify(
-            &cx.shared.fs,
-            cx.path("source-script.js"),
-            static_files::sidebar::SOURCE_SCRIPT,
-            options.enable_minification,
-        )?;
+        write_minify("source-script.js", static_files::sidebar::SOURCE_SCRIPT)?;
     }
 
     {
         write_minify(
-            &cx.shared.fs,
-            cx.path("storage.js"),
+            "storage.js",
             &format!(
                 "var resourcesSuffix = \"{}\";{}",
                 cx.shared.resource_suffix,
                 static_files::STORAGE_JS
             ),
-            options.enable_minification,
         )?;
     }
 
     if let Some(ref css) = cx.shared.layout.css_file_extension {
-        let out = cx.path("theme.css");
         let buffer = try_err!(fs::read_to_string(css), css);
-        if !options.enable_minification {
-            cx.shared.fs.write(&out, &buffer)?;
-        } else {
-            write_minify(&cx.shared.fs, out, &buffer, options.enable_minification)?;
-        }
+        // This varies based on the invocation, so it can't go through the write_minify wrapper.
+        cx.write_minify(
+            SharedResource::InvocationSpecific { basename: "theme.css" },
+            &buffer,
+            options.enable_minification,
+            &options.emit,
+        )?;
     }
-    write_minify(
-        &cx.shared.fs,
-        cx.path("normalize.css"),
-        static_files::NORMALIZE_CSS,
-        options.enable_minification,
-    )?;
-    for (file, contents) in &*FILES_UNVERSIONED {
-        write(cx.dst.join(file), contents)?;
+    write_minify("normalize.css", static_files::NORMALIZE_CSS)?;
+    for (name, contents) in &*FILES_UNVERSIONED {
+        cx.write_shared(SharedResource::Unversioned { name }, contents, &options.emit)?;
     }
 
     fn collect(path: &Path, krate: &str, key: &str) -> io::Result<(Vec<String>, Vec<String>)> {
@@ -312,19 +379,22 @@ pub(super) fn write_shared(
         }
 
         let dst = cx.dst.join(&format!("source-files{}.js", cx.shared.resource_suffix));
-        let (mut all_sources, _krates) =
-            try_err!(collect(&dst, &krate.name.as_str(), "sourcesIndex"), &dst);
-        all_sources.push(format!(
-            "sourcesIndex[\"{}\"] = {};",
-            &krate.name,
-            hierarchy.to_json_string()
-        ));
-        all_sources.sort();
-        let v = format!(
-            "var N = null;var sourcesIndex = {{}};\n{}\ncreateSourceSidebar();\n",
-            all_sources.join("\n")
-        );
-        cx.shared.fs.write(&dst, v.as_bytes())?;
+        let make_sources = || {
+            let (mut all_sources, _krates) =
+                try_err!(collect(&dst, &krate.name.as_str(), "sourcesIndex"), &dst);
+            all_sources.push(format!(
+                "sourcesIndex[\"{}\"] = {};",
+                &krate.name,
+                hierarchy.to_json_string()
+            ));
+            all_sources.sort();
+            Ok(format!(
+                "var N = null;var sourcesIndex = {{}};\n{}\ncreateSourceSidebar();\n",
+                all_sources.join("\n")
+            )
+            .into_bytes())
+        };
+        write_crate("source-files.js", &make_sources)?;
     }
 
     // Update the search index and crate list.
@@ -337,17 +407,17 @@ pub(super) fn write_shared(
     // Sort the indexes by crate so the file will be generated identically even
     // with rustdoc running in parallel.
     all_indexes.sort();
-    {
+    write_crate("search-index.js", &|| {
         let mut v = String::from("var searchIndex = JSON.parse('{\\\n");
         v.push_str(&all_indexes.join(",\\\n"));
         v.push_str("\\\n}');\ninitSearch(searchIndex);");
-        cx.shared.fs.write(&dst, &v)?;
-    }
+        Ok(v.into_bytes())
+    })?;
 
-    let crate_list_dst = cx.dst.join(&format!("crates{}.js", cx.shared.resource_suffix));
-    let crate_list =
-        format!("window.ALL_CRATES = [{}];", krates.iter().map(|k| format!("\"{}\"", k)).join(","));
-    cx.shared.fs.write(&crate_list_dst, &crate_list)?;
+    write_crate("crates.js", &|| {
+        let krates = krates.iter().map(|k| format!("\"{}\"", k)).join(",");
+        Ok(format!("window.ALL_CRATES = [{}];", krates).into_bytes())
+    })?;
 
     if options.enable_index_page {
         if let Some(index_page) = options.index_page.clone() {
@@ -481,21 +551,3 @@ pub(super) fn write_shared(
     }
     Ok(())
 }
-
-fn write_minify(
-    fs: &DocFS,
-    dst: PathBuf,
-    contents: &str,
-    enable_minification: bool,
-) -> Result<(), Error> {
-    if enable_minification {
-        if dst.extension() == Some(&OsStr::new("css")) {
-            let res = try_none!(minifier::css::minify(contents).ok(), &dst);
-            fs.write(dst, res.as_bytes())
-        } else {
-            fs.write(dst, minifier::js::minify(contents).as_bytes())
-        }
-    } else {
-        fs.write(dst, contents.as_bytes())
-    }
-}
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index dabc21e3a447c..54a6fc625a615 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -527,6 +527,14 @@ fn opts() -> Vec<RustcOptGroup> {
         unstable("print", |o| {
             o.optmulti("", "print", "Rustdoc information to print on stdout", "[unversioned-files]")
         }),
+        unstable("emit", |o| {
+            o.optmulti(
+                "",
+                "emit",
+                "Comma separated list of types of output for rustdoc to emit",
+                "[unversioned-shared-resources,toolchain-shared-resources,invocation-specific]",
+            )
+        }),
     ]
 }
 
diff --git a/src/test/run-make-fulldeps/coverage-reports/Makefile b/src/test/run-make-fulldeps/coverage-reports/Makefile
index dd5e28b449cd4..d3d398f1fac29 100644
--- a/src/test/run-make-fulldeps/coverage-reports/Makefile
+++ b/src/test/run-make-fulldeps/coverage-reports/Makefile
@@ -61,13 +61,6 @@ endif
 LLVM_COV_IGNORE_FILES=\
 	--ignore-filename-regex='(uses_crate.rs|uses_inline_crate.rs)'
 
-# When generating `expected_*` results (using `x.py test --bless`), the `--debug` flag is forced.
-# If assertions are disabled, the command will fail with an error, rather than attempt to generate
-# only partial results.
-ifdef RUSTC_BLESS_TEST
-DEBUG_FLAG=--debug
-endif
-
 all: $(patsubst $(SOURCEDIR)/lib/%.rs,%,$(wildcard $(SOURCEDIR)/lib/*.rs)) $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs))
 
 # Ensure there are no `expected` results for tests that may have been removed or renamed
@@ -177,76 +170,3 @@ else
 			false \
 		)
 endif
-
-####################################################################################################
-
-# The following Makefile content was used to copy the generated `counters` files
-# to `expected_` files (when `--bless`ed) and to compare them via `diff`; but for
-# multiple reasons, these files cannot easily be used for test validation:
-#
-#   * Output lines can be produced in non-deterministic order (depending on the
-#     target platform, and sometimes on unrelated codegen changes).
-#   * Some lines include demangled function names, making them more challenging
-#     to interpret and compare.
-#
-# The files are still generated (in `$(TMPDIR)`) to support developers wanting
-# to inspect the counters, for debugging purposes.
-#
-# ifdef RUSTC_BLESS_TEST
-# 	cp "$(TMPDIR)"/actual_show_coverage_counters.$@.txt \
-# 			expected_show_coverage_counters.$@.txt
-# else
-#
-# ifdef DEBUG_FLAG
-# 	$(DIFF) expected_show_coverage_counters.$@.txt "$(TMPDIR)"/actual_show_coverage_counters.$@.txt || \
-# 		( grep -q '^\/\/ ignore-llvm-cov-show-diffs' $(SOURCEDIR)/$@.rs && \
-# 			>&2 echo 'diff failed, but suppressed with `// ignore-llvm-cov-show-diffs` in $(SOURCEDIR)/$@.rs' \
-# 		) || \
-# 		( >&2 echo 'diff failed, and not suppressed without `// ignore-llvm-cov-show-diffs` in $(SOURCEDIR)/$@.rs'; \
-# 			>&2 echo '(Ignore anyway until mangled function names in "counters" files are demangled.)' \
-# 		)
-# endif
-#
-# endif
-
-####################################################################################################
-
-# The following Makefile content, and short JSON script, were used to generate
-# coverage reports in JSON when the `llvm-cov show` reports were less reliable for
-# testing. At the present time, however, the `llvm-cov show` results, and methods
-# for comparing them, are working for all tests, making the JSON reports redundant.
-#
-# If this changes in the future, the scripts are left here, commented out, but can
-# be resurrected if desired. This could be used to compare *only* the JSON files;
-# and in that case, the `llvm-cov show` reports can be ignored by inserting
-# `// ignore-llvm-cov-show-diffs` at the top of the source file.
-#
-# 	# Generate a coverage report in JSON, using `llvm-cov export`, and fail if
-# 	# there are differences from the expected output.
-# 	"$(LLVM_BIN_DIR)"/llvm-cov export \
-# 			$(LLVM_COV_IGNORE_FILES) \
-# 			--summary-only \
-# 			--instr-profile="$(TMPDIR)"/$@.profdata \
-# 			$(call BIN,"$(TMPDIR)"/$@) \
-# 		| "$(PYTHON)" $(BASEDIR)/prettify_json.py \
-# 		> "$(TMPDIR)"/actual_export_coverage.$@.json
-#
-# ifdef RUSTC_BLESS_TEST
-# 	cp "$(TMPDIR)"/actual_export_coverage.$@.json expected_export_coverage.$@.json
-# else
-# 	# Check that exported JSON coverage data matches what we expect (`--bless` refreshes `expected`)
-# 	$(DIFF) expected_export_coverage.$@.json "$(TMPDIR)"/actual_export_coverage.$@.json
-# endif
-#
-# # # If generating coverage reports in JSON, this Makefile is accompanied by
-# # # a Python script, `prettify_json.py`, which is defined:
-# #
-# # #!/usr/bin/env python
-# #
-# # import sys
-# # import json
-# #
-# # # Try to decode line in order to ensure it is a valid JSON document
-# # for line in sys.stdin:
-# #     parsed = json.loads(line)
-# #     print (json.dumps(parsed, indent=2, separators=(',', ': '), sort_keys=True))
diff --git a/src/test/run-make-fulldeps/coverage-spanview/Makefile b/src/test/run-make-fulldeps/coverage-spanview/Makefile
deleted file mode 100644
index b3d1009dbd092..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/Makefile
+++ /dev/null
@@ -1,92 +0,0 @@
-# needs-profiler-support
-# min-llvm-version: 11.0
-
--include ../coverage/coverage_tools.mk
-
-BASEDIR=../coverage-spanview
-SOURCEDIR=../coverage
-
-define SPANVIEW_HEADER
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.%s/%s
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-endef
-export SPANVIEW_HEADER
-
-all: $(patsubst $(SOURCEDIR)/lib/%.rs,%,$(wildcard $(SOURCEDIR)/lib/*.rs)) $(patsubst $(SOURCEDIR)/%.rs,%,$(wildcard $(SOURCEDIR)/*.rs))
-
-# Ensure there are no `expected` results for tests that may have been removed or renamed
-.PHONY: clear_expected_if_blessed
-clear_expected_if_blessed:
-ifdef RUSTC_BLESS_TEST
-	rm -rf expected_mir_dump.*/
-endif
-
--include clear_expected_if_blessed
-
-# FIXME(richkadel): The actions for these two types of targets (libraries and binaries) should be
-# combined.
-
-%: $(SOURCEDIR)/lib/%.rs
-	# Compile the test library with coverage instrumentation
-	$(RUSTC) $(SOURCEDIR)/lib/$@.rs \
-	    $$( sed -n 's/^\/\/ compile-flags: \([^#]*\).*/\1/p' $(SOURCEDIR)/lib/$@.rs ) \
-			--crate-type rlib \
-			-Ztrim-diagnostic-paths=no \
-			-Zdump-mir=InstrumentCoverage -Zdump-mir-spanview -Zdump-mir-dir="$(TMPDIR)"/mir_dump.$@ \
-			-Zinstrument-coverage
-
-	for path in "$(TMPDIR)"/mir_dump.$@/*; do \
-		file="$$(basename "$$path")"; \
-		urlescaped="$$("$(PYTHON)" $(BASEDIR)/escape_url.py $$file)" || exit $$?; \
-		printf "$$SPANVIEW_HEADER\n" "$@" "$$urlescaped" > "$$path".modified; \
-		tail -n +2 "$$path" >> "$$path".modified; \
-		mv "$$path".modified "$$path"; \
-	done && true # for/done ends in non-zero status
-
-ifdef RUSTC_BLESS_TEST
-	mkdir -p expected_mir_dump.$@
-	cp "$(TMPDIR)"/mir_dump.$@/*InstrumentCoverage.0.html expected_mir_dump.$@/
-else
-	# Check that the selected `mir_dump` files match what we expect (`--bless` refreshes `expected`)
-	mkdir -p "$(TMPDIR)"/actual_mir_dump.$@
-	rm -f "$(TMPDIR)"/actual_mir_dump.$@/*
-	cp "$(TMPDIR)"/mir_dump.$@/*InstrumentCoverage.0.html "$(TMPDIR)"/actual_mir_dump.$@/
-	$(DIFF) -r expected_mir_dump.$@/ "$(TMPDIR)"/actual_mir_dump.$@/
-endif
-
-%: $(SOURCEDIR)/%.rs
-	# Compile the test program with coverage instrumentation
-	$(RUSTC) $(SOURCEDIR)/$@.rs \
-			$$( sed -n 's/^\/\/ compile-flags: \([^#]*\).*/\1/p' $(SOURCEDIR)/$@.rs ) \
-			-L "$(TMPDIR)" \
-			-Ztrim-diagnostic-paths=no \
-			-Zdump-mir=InstrumentCoverage -Zdump-mir-spanview -Zdump-mir-dir="$(TMPDIR)"/mir_dump.$@ \
-			-Zinstrument-coverage
-
-	for path in "$(TMPDIR)"/mir_dump.$@/*; do \
-		file="$$(basename "$$path")"; \
-		urlescaped="$$("$(PYTHON)" $(BASEDIR)/escape_url.py $$file)" || exit $$?; \
-		printf "$$SPANVIEW_HEADER\n" "$@" "$$urlescaped" > "$$path".modified; \
-		tail -n +2 "$$path" >> "$$path".modified; \
-		mv "$$path".modified "$$path"; \
-	done && true # for/done ends in non-zero status
-
-ifdef RUSTC_BLESS_TEST
-	mkdir -p expected_mir_dump.$@
-	cp "$(TMPDIR)"/mir_dump.$@/*InstrumentCoverage.0.html expected_mir_dump.$@/
-else
-	# Check that the selected `mir_dump` files match what we expect (`--bless` refreshes `expected`)
-	mkdir -p "$(TMPDIR)"/actual_mir_dump.$@
-	rm -f "$(TMPDIR)"/actual_mir_dump.$@/*
-	cp "$(TMPDIR)"/mir_dump.$@/*InstrumentCoverage.0.html "$(TMPDIR)"/actual_mir_dump.$@/
-	$(DIFF) -r expected_mir_dump.$@/ "$(TMPDIR)"/actual_mir_dump.$@/
-endif
diff --git a/src/test/run-make-fulldeps/coverage-spanview/escape_url.py b/src/test/run-make-fulldeps/coverage-spanview/escape_url.py
deleted file mode 100644
index b725ed4630302..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/escape_url.py
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-
-# Support python 2 or 3
-try:
-    from urllib.parse import quote
-except ImportError:
-    from urllib import quote
-
-# Converts the input string into a valid URL parameter string.
-print (quote(' '.join(sys.argv[1:])))
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 176587af25be0..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,106 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>abort.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><span class="code even" style="--layer: 1" title="15:25-15:27: @0[1]: _1 = const 10_i32
-15:9-15:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>fn main() -&gt; Result&lt;(), u8&gt; {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="15:25-15:27: @0[1]: _1 = const 10_i32
-15:9-15:22: @0[2]: FakeRead(ForLet, _1)">    let 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">    while </span><span><span class="code odd" style="--layer: 1" title="16:11-16:20: @2[2]: _5 = _1
-16:11-16:24: @2[3]: _4 = Gt(move _5, const 0_i32)
-16:11-16:24: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>countdown &gt; 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">        if </span><span><span class="code even" style="--layer: 1" title="17:12-17:21: @5[3]: _8 = _1
-17:12-17:25: @5[4]: _7 = Lt(move _8, const 5_i32)"><span class="annotation">@3,5⦊</span>countdown &lt; 5<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="18:13-18:31: @6.Call: _9 = might_abort(const false) -&gt; [return: bb8, unwind: bb19]
-17:26-19:10: @8[1]: _6 = const ()"><span class="annotation">@6,8⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="18:13-18:31: @6.Call: _9 = might_abort(const false) -&gt; [return: bb8, unwind: bb19]
-17:26-19:10: @8[1]: _6 = const ()">            might_abort(false);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="18:13-18:31: @6.Call: _9 = might_abort(const false) -&gt; [return: bb8, unwind: bb19]
-17:26-19:10: @8[1]: _6 = const ()">        }<span class="annotation">⦉@6,8</span></span></span><span><span class="code even" style="--layer: 1" title="19:10-19:10: @7[0]: _6 = const ()"><span class="annotation">@7⦊</span>‸<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        // See discussion (below the `Notes` section) on coverage results for the closing brace.</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="21:12-21:21: @9[5]: _12 = _1
-21:12-21:25: @9[6]: _11 = Lt(move _12, const 5_i32)"><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="code even" style="--layer: 1" title="21:28-21:46: @10.Call: _13 = might_abort(const false) -&gt; [return: bb12, unwind: bb19]
-21:26-21:49: @12[1]: _10 = const ()"><span class="annotation">@10,12⦊</span>{ might_abort(false); }<span class="annotation">⦉@10,12</span></span></span><span><span class="code odd" style="--layer: 1" title="21:49-21:49: @11[0]: _10 = const ()"><span class="annotation">@11⦊</span>‸<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"> // Counts for different regions on one line.</span></span>
-<span class="line"><span class="code" style="--layer: 0">        // For the following example, the closing brace is the last character on the line.</span></span>
-<span class="line"><span class="code" style="--layer: 0">        // This shows the character after the closing brace is highlighted, even if that next</span></span>
-<span class="line"><span class="code" style="--layer: 0">        // character is a newline.</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="25:12-25:21: @13[5]: _16 = _1
-25:12-25:25: @13[6]: _15 = Lt(move _16, const 5_i32)"><span class="annotation">@13⦊</span>countdown &lt; 5<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="25:28-25:46: @14.Call: _17 = might_abort(const false) -&gt; [return: bb16, unwind: bb19]
-25:26-25:49: @16[1]: _14 = const ()"><span class="annotation">@14,16⦊</span>{ might_abort(false); }<span class="annotation">⦉@14,16</span></span></span><span><span class="code even" style="--layer: 1" title="25:49-25:49: @15[0]: _14 = const ()"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="26:9-26:23: @17[2]: _18 = CheckedSub(_1, const 1_i32)
-26:9-26:23: @18[0]: _1 = move (_18.0: i32)"><span class="annotation">@17,18⦊</span>countdown -= 1<span class="annotation">⦉@17,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">    </span><span><span class="code even" style="--layer: 1" title="28:8-28:10: @4[4]: _20 = ()
-28:5-28:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _20)
-29:2-29:2: @4.Return: return"><span class="annotation">@4⦊</span>Ok(())</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:8-28:10: @4[4]: _20 = ()
-28:5-28:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _20)
-29:2-29:2: @4.Return: return">}<span class="annotation">⦉@4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html
deleted file mode 100644
index a302b974ae1d2..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,163 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>abort.might_abort - 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 4"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0⦊</span>fn might_abort(should_abort: bool) <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="6:8-6:20: @0[1]: _2 = _1"><span class="annotation">@0⦊</span>should_abort<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:18-7:31: @1[6]: _33 = const might_abort::promoted[3]
-7:18-7:31: @1[7]: _9 = &amp;(*_33)
-7:18-7:31: @1[8]: _8 = &amp;(*_9)
-7:18-7:31: @1[9]: _7 = move _8 as &amp;[&amp;str] (Pointer(Unsize))
-7:9-7:33: @1[15]: _15 = ()
-7:9-7:33: @1[16]: FakeRead(ForMatchedPlace, _15)
-7:9-7:33: @1[17]: _32 = const might_abort::promoted[2]
-7:9-7:33: @1[18]: _13 = &amp;(*_32)
-7:9-7:33: @1[19]: _12 = &amp;(*_13)
-7:9-7:33: @1[20]: _11 = move _12 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-7:9-7:33: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -&gt; [return: bb3, unwind: bb7]
-7:9-7:33: @3.Call: _5 = std::io::_print(move _6) -&gt; [return: bb4, unwind: bb7]
-7:9-7:33: @4[5]: _4 = const ()
-8:9-8:37: @4.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;panics and aborts&quot;) -&gt; bb7"><span class="annotation">@1,3,4⦊</span>println!("aborting...");</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="7:18-7:31: @1[6]: _33 = const might_abort::promoted[3]
-7:18-7:31: @1[7]: _9 = &amp;(*_33)
-7:18-7:31: @1[8]: _8 = &amp;(*_9)
-7:18-7:31: @1[9]: _7 = move _8 as &amp;[&amp;str] (Pointer(Unsize))
-7:9-7:33: @1[15]: _15 = ()
-7:9-7:33: @1[16]: FakeRead(ForMatchedPlace, _15)
-7:9-7:33: @1[17]: _32 = const might_abort::promoted[2]
-7:9-7:33: @1[18]: _13 = &amp;(*_32)
-7:9-7:33: @1[19]: _12 = &amp;(*_13)
-7:9-7:33: @1[20]: _11 = move _12 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-7:9-7:33: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -&gt; [return: bb3, unwind: bb7]
-7:9-7:33: @3.Call: _5 = std::io::_print(move _6) -&gt; [return: bb4, unwind: bb7]
-7:9-7:33: @4[5]: _4 = const ()
-8:9-8:37: @4.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;panics and aborts&quot;) -&gt; bb7">        panic!("panics and aborts");<span class="annotation">⦉@1,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else </span><span><span class="code even" style="--layer: 1" title="10:18-10:31: @2[6]: _31 = const might_abort::promoted[1]
-10:18-10:31: @2[7]: _23 = &amp;(*_31)
-10:18-10:31: @2[8]: _22 = &amp;(*_23)
-10:18-10:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-10:9-10:33: @2[15]: _29 = ()
-10:9-10:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-10:9-10:33: @2[17]: _30 = const might_abort::promoted[0]
-10:9-10:33: @2[18]: _27 = &amp;(*_30)
-10:9-10:33: @2[19]: _26 = &amp;(*_27)
-10:9-10:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-10:9-10:33: @6[5]: _18 = const ()
-9:12-11:6: @6[7]: _0 = const ()
-12:2-12:2: @6.Return: return"><span class="annotation">@2,5,6⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:31: @2[6]: _31 = const might_abort::promoted[1]
-10:18-10:31: @2[7]: _23 = &amp;(*_31)
-10:18-10:31: @2[8]: _22 = &amp;(*_23)
-10:18-10:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-10:9-10:33: @2[15]: _29 = ()
-10:9-10:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-10:9-10:33: @2[17]: _30 = const might_abort::promoted[0]
-10:9-10:33: @2[18]: _27 = &amp;(*_30)
-10:9-10:33: @2[19]: _26 = &amp;(*_27)
-10:9-10:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-10:9-10:33: @6[5]: _18 = const ()
-9:12-11:6: @6[7]: _0 = const ()
-12:2-12:2: @6.Return: return">        println!("Don't Panic");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:31: @2[6]: _31 = const might_abort::promoted[1]
-10:18-10:31: @2[7]: _23 = &amp;(*_31)
-10:18-10:31: @2[8]: _22 = &amp;(*_23)
-10:18-10:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-10:9-10:33: @2[15]: _29 = ()
-10:9-10:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-10:9-10:33: @2[17]: _30 = const might_abort::promoted[0]
-10:9-10:33: @2[18]: _27 = &amp;(*_30)
-10:9-10:33: @2[19]: _26 = &amp;(*_27)
-10:9-10:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-10:9-10:33: @6[5]: _18 = const ()
-9:12-11:6: @6[7]: _0 = const ()
-12:2-12:2: @6.Return: return">    }</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:31: @2[6]: _31 = const might_abort::promoted[1]
-10:18-10:31: @2[7]: _23 = &amp;(*_31)
-10:18-10:31: @2[8]: _22 = &amp;(*_23)
-10:18-10:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-10:9-10:33: @2[15]: _29 = ()
-10:9-10:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-10:9-10:33: @2[17]: _30 = const might_abort::promoted[0]
-10:9-10:33: @2[18]: _27 = &amp;(*_30)
-10:9-10:33: @2[19]: _26 = &amp;(*_27)
-10:9-10:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-10:9-10:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-10:9-10:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-10:9-10:33: @6[5]: _18 = const ()
-9:12-11:6: @6[7]: _0 = const ()
-12:2-12:2: @6.Return: return">}<span class="annotation">⦉@2,5,6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 365e94cd31e50..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,102 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>assert.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 8"><span class="line"><span><span class="code even" style="--layer: 1" title="10:25-10:27: @0[1]: _1 = const 10_i32
-10:9-10:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>fn main() -&gt; Result&lt;(),u8&gt; {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:25-10:27: @0[1]: _1 = const 10_i32
-10:9-10:22: @0[2]: FakeRead(ForLet, _1)">    let 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">    while </span><span><span class="code odd" style="--layer: 1" title="11:11-11:20: @2[2]: _5 = _1
-11:11-11:24: @2[3]: _4 = Gt(move _5, const 0_i32)
-11:11-11:24: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>countdown &gt; 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">        if </span><span><span class="code even" style="--layer: 1" title="12:12-12:21: @5[3]: _8 = _1
-12:12-12:26: @5[4]: _7 = Eq(move _8, const 1_i32)"><span class="annotation">@3,5⦊</span>countdown == 1<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="13:13-13:33: @6.Call: _9 = might_fail_assert(const 3_u32) -&gt; [return: bb8, unwind: bb15]
-12:27-14:10: @8[1]: _6 = const ()"><span class="annotation">@6,8⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="13:13-13:33: @6.Call: _9 = might_fail_assert(const 3_u32) -&gt; [return: bb8, unwind: bb15]
-12:27-14:10: @8[1]: _6 = const ()">            might_fail_assert(3);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="13:13-13:33: @6.Call: _9 = might_fail_assert(const 3_u32) -&gt; [return: bb8, unwind: bb15]
-12:27-14:10: @8[1]: _6 = const ()">        }<span class="annotation">⦉@6,8</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code even" style="--layer: 1" title="14:19-14:28: @7[2]: _11 = _1
-14:19-14:32: @7[3]: _10 = Lt(move _11, const 5_i32)"><span class="annotation">@7⦊</span>countdown &lt; 5<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="15:13-15:33: @9.Call: _12 = might_fail_assert(const 2_u32) -&gt; [return: bb11, unwind: bb15]
-14:33-16:10: @11[1]: _6 = const ()"><span class="annotation">@9,11⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="15:13-15:33: @9.Call: _12 = might_fail_assert(const 2_u32) -&gt; [return: bb11, unwind: bb15]
-14:33-16:10: @11[1]: _6 = const ()">            might_fail_assert(2);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="15:13-15:33: @9.Call: _12 = might_fail_assert(const 2_u32) -&gt; [return: bb11, unwind: bb15]
-14:33-16:10: @11[1]: _6 = const ()">        }<span class="annotation">⦉@9,11</span></span></span><span><span class="code even" style="--layer: 1" title="16:10-16:10: @10[0]: _6 = const ()"><span class="annotation">@10⦊</span>‸<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="code odd" style="--layer: 1" title="17:9-17:23: @13[2]: _13 = CheckedSub(_1, const 1_i32)
-17:9-17:23: @14[0]: _1 = move (_13.0: i32)"><span class="annotation">@13,14⦊</span>countdown -= 1<span class="annotation">⦉@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">    </span><span><span class="code even" style="--layer: 1" title="19:8-19:10: @4[4]: _15 = ()
-19:5-19:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _15)
-20:2-20:2: @4.Return: return"><span class="annotation">@4⦊</span>Ok(())</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:8-19:10: @4[4]: _15 = ()
-19:5-19:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _15)
-20:2-20:2: @4.Return: return">}<span class="annotation">⦉@4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html
deleted file mode 100644
index db72a5306ff70..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,97 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>assert.might_fail_assert - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1,2,3,4⦊</span>fn might_fail_assert(one_plus_one: u32) <span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">{</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="5:14-5:32: @0[6]: _53 = const might_fail_assert::promoted[3]
-5:14-5:32: @0[7]: _7 = &amp;(*_53)
-5:14-5:32: @0[8]: _6 = &amp;(*_7)
-5:14-5:32: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-5:34-5:46: @0[17]: _14 = &amp;_1
-5:5-5:48: @0[18]: _13 = (move _14,)
-5:5-5:48: @0[20]: FakeRead(ForMatchedPlace, _13)
-5:5-5:48: @0[22]: _15 = (_13.0: &amp;u32)
-5:5-5:48: @0[25]: _17 = &amp;(*_15)
-5:5-5:48: @0[27]: _18 = &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))
-5:5-5:48: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb8]
-5:5-5:48: @1[2]: _12 = [move _16]
-5:5-5:48: @1[5]: _11 = &amp;_12
-5:5-5:48: @1[6]: _10 = &amp;(*_11)
-5:5-5:48: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-5:5-5:48: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb8]
-5:5-5:48: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb8]
-5:5-5:48: @3[6]: _2 = const ()"><span class="annotation">@0,1,2,3,4⦊</span>println!("does 1 + 1 = {}?", one_plus_one);<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    assert_eq!(</span><span><span class="code even" style="--layer: 1" title="6:16-6:21: @3[11]: _23 = CheckedAdd(const 1_u32, const 1_u32)"><span class="annotation">@0,1,2,3,4⦊</span>1 + 1<span class="annotation">⦉@0,1,2,3,4</span></span></span><span class="code" style="--layer: 0">, one_plus_one, </span><span><span class="code odd" style="--layer: 1" title="6:37-6:61: @5[19]: _51 = const might_fail_assert::promoted[1]
-6:37-6:61: @5[20]: _43 = &amp;(*_51)
-6:37-6:61: @5[21]: _42 = &amp;(*_43)
-6:37-6:61: @5[22]: _41 = move _42 as &amp;[&amp;str] (Pointer(Unsize))"><span class="annotation">@5,7⦊</span>"the argument was wrong"<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 even" style="--layer: 1" title="7:2-7:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 21bfce701fe6e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.c-{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 4"><span class="line">                        <span><span class="code even" style="--layer: 1" title="6:8-6:9: @0[5]: _5 = _3
-6:8-6:14: @0[6]: _4 = Eq(move _5, const 8_u8)"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:8-6:9: @0[5]: _5 = _3
-6:8-6:14: @0[6]: _4 = Eq(move _5, const 8_u8)">    if x == 8<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:10: @1[0]: _0 = const 1_u8"><span class="annotation">@1⦊</span>1<span class="annotation">⦉@1</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="9:9-9:10: @2[0]: _0 = const 0_u8"><span class="annotation">@2⦊</span>0<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="11:2-11:2: @3.Return: return"><span class="annotation">@3⦊</span>‸<span class="annotation">⦉@3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 3eee0dd4100ed..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,80 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.c - 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 4"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn c(x: u8) -&gt; u8 <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">    if x == 8 {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        1</span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        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></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 7cf34f077954f..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.d-{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 12"><span class="line">                   <span><span class="code even" style="--layer: 1" title="13:22-13:23: @0[0]: _0 = const 1_u8
-13:25-13:25: @0.Return: return"><span class="annotation">@0⦊</span>‸<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">{ 1 }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 5c7f6e00224a0..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.d - 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 12"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn d() -&gt; u8 <span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">{ 1 }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 1f95a7d35af88..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.e-{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 14"><span class="line">                   <span><span class="code even" style="--layer: 1" title="15:22-15:23: @0[0]: _0 = const 1_u8
-15:25-15:25: @0.Return: return"><span class="annotation">@0⦊</span>‸<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">{ 1 }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e.-------.InstrumentCoverage.0.html
deleted file mode 100644
index ee3b7b1d7ffc7..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.e - 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 14"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn e() -&gt; u8 <span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">{ 1 }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 64fc1568b0085..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,84 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.executor-block_on-VTABLE-{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 23"><span class="line">        <span><span class="code even" style="--layer: 1" title="24:38-24:74: @1[3]: _13 = (move _14,)
-24:38-24:74: @1[5]: FakeRead(ForMatchedPlace, _13)
-24:38-24:74: @1[7]: _25 = (_13.0: &amp;std::fmt::Arguments)
-24:38-24:74: @1[10]: _27 = &amp;(*_25)
-24:38-24:74: @1[12]: _28 = &lt;std::fmt::Arguments as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::fmt::Arguments, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-24:38-24:74: @1.Call: _26 = std::fmt::ArgumentV1::new::&lt;std::fmt::Arguments&gt;(move _27, move _28) -&gt; [return: bb2, unwind: bb4]
-24:38-24:74: @2[2]: _12 = [move _26]
-24:38-24:74: @2[5]: _11 = &amp;_12
-24:38-24:74: @2[6]: _10 = &amp;(*_11)
-24:38-24:74: @2[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-24:38-24:74: @2.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 1bbcfa5744b6b..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,84 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-%7Bclosure%231%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.executor-block_on-VTABLE-{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 23"><span class="line">        <span><span class="code even" style="--layer: 1" title="24:38-24:74: @1[3]: _13 = (move _14,)
-24:38-24:74: @1[5]: FakeRead(ForMatchedPlace, _13)
-24:38-24:74: @1[7]: _25 = (_13.0: &amp;std::fmt::Arguments)
-24:38-24:74: @1[10]: _27 = &amp;(*_25)
-24:38-24:74: @1[12]: _28 = &lt;std::fmt::Arguments as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::fmt::Arguments, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-24:38-24:74: @1.Call: _26 = std::fmt::ArgumentV1::new::&lt;std::fmt::Arguments&gt;(move _27, move _28) -&gt; [return: bb2, unwind: bb4]
-24:38-24:74: @2[2]: _12 = [move _26]
-24:38-24:74: @2[5]: _11 = &amp;_12
-24:38-24:74: @2[6]: _10 = &amp;(*_11)
-24:38-24:74: @2[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-24:38-24:74: @2.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 14cb98d20c988..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,84 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-%7Bclosure%232%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.executor-block_on-VTABLE-{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 23"><span class="line">        <span><span class="code even" style="--layer: 1" title="24:38-24:74: @1[3]: _13 = (move _14,)
-24:38-24:74: @1[5]: FakeRead(ForMatchedPlace, _13)
-24:38-24:74: @1[7]: _25 = (_13.0: &amp;std::fmt::Arguments)
-24:38-24:74: @1[10]: _27 = &amp;(*_25)
-24:38-24:74: @1[12]: _28 = &lt;std::fmt::Arguments as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::fmt::Arguments, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-24:38-24:74: @1.Call: _26 = std::fmt::ArgumentV1::new::&lt;std::fmt::Arguments&gt;(move _27, move _28) -&gt; [return: bb2, unwind: bb4]
-24:38-24:74: @2[2]: _12 = [move _26]
-24:38-24:74: @2[5]: _11 = &amp;_12
-24:38-24:74: @2[6]: _10 = &amp;(*_11)
-24:38-24:74: @2[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-24:38-24:74: @2.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb3, unwind: bb4]"><span class="annotation">@0,1,2,3⦊</span>‸<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">$crate::panicking::panic_fmt($crate::format_args!($fmt, $($arg)+))</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#3}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#3}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index ef2fe7d06825d..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#3}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-%7Bclosure%233%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.executor-block_on-VTABLE-{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 116"><span class="line">            <span class="code" style="--layer: 0">|_| </span><span><span class="code even" style="--layer: 1" title="117:17-117:19: @0[0]: _0 = ()
-117:19-117:19: @0.Return: return"><span class="annotation">@0⦊</span>()<span class="annotation">⦉@0</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 9a5bd6e42cd37..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,239 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.executor-block_on - 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 109"><span class="line">    <span><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)"><span class="annotation">@0,1,2,3,4,5⦊</span>pub fn block_on&lt;F: Future&gt;(mut future: F) -&gt; F::Output {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">        let mut future = unsafe { Pin::new_unchecked(&amp;mut future) };</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">        static VTABLE: RawWakerVTable = RawWakerVTable::new(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">            |_| unimplemented!("clone"),</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">            |_| unimplemented!("wake"),</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">            |_| unimplemented!("wake_by_ref"),</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">            |_| (),</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">        );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &amp;VTABLE)) };</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="111:54-111:65: @0[2]: _3 = &amp;mut _1
-111:35-111:66: @0.Call: _2 = std::pin::Pin::&lt;&amp;mut F&gt;::new_unchecked(move _3) -&gt; [return: bb1, unwind: bb20]
-111:13-111:23: @1[1]: FakeRead(ForLet, _2)
-119:60-119:77: @1.Call: _6 = std::ptr::null::&lt;()&gt;() -&gt; [return: bb2, unwind: bb20]
-119:80-119:86: @2[3]: _9 = const {alloc0: &amp;std::task::RawWakerVTable}
-119:79-119:86: @2[4]: _8 = &amp;(*_9)
-119:79-119:86: @2[5]: _7 = &amp;(*_8)
-119:46-119:87: @2.Call: _5 = std::task::RawWaker::new(move _6, move _7) -&gt; [return: bb3, unwind: bb20]
-119:30-119:88: @3.Call: _4 = std::task::Waker::from_raw(move _5) -&gt; [return: bb4, unwind: bb20]
-119:13-119:18: @4[1]: FakeRead(ForLet, _4)
-120:47-120:53: @4[7]: _12 = &amp;_4
-120:47-120:53: @4[8]: _11 = &amp;(*_12)
-120:27-120:54: @4.Call: _10 = std::task::Context::from_waker(move _11) -&gt; [return: bb5, unwind: bb19]
-120:13-120:24: @5[1]: FakeRead(ForLet, _10)">        let mut context = Context::from_waker(&amp;waker)<span class="annotation">⦉@0,1,2,3,4,5</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        loop {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            if let Poll::Ready(</span><span><span class="code odd" style="--layer: 1" title="123:32-123:35: @12[1]: _20 = move ((_14 as Ready).0: &lt;F as std::future::Future&gt;::Output)"><span class="annotation">@10,12,14,15,16,17⦊</span>val<span class="annotation">⦉@10,12,14,15,16,17</span></span></span><span class="code" style="--layer: 0">) = </span><span><span class="code even" style="--layer: 1" title="123:39-123:45: @7[3]: _16 = &amp;mut _2
-123:39-123:54: @7.Call: _15 = std::pin::Pin::&lt;&amp;mut F&gt;::as_mut(move _16) -&gt; [return: bb8, unwind: bb19]
-123:60-123:72: @8[3]: _18 = &amp;mut _10
-123:60-123:72: @8[4]: _17 = &amp;mut (*_18)
-123:39-123:73: @8.Call: _14 = &lt;F as std::future::Future&gt;::poll(move _15, move _17) -&gt; [return: bb9, unwind: bb19]
-123:39-123:73: @9[2]: FakeRead(ForMatchedPlace, _14)"><span class="annotation">@6,7,8,9⦊</span>future.as_mut().poll(&amp;mut context)<span class="annotation">⦉@6,7,8,9</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">                break </span><span><span class="code odd" style="--layer: 1" title="124:23-124:26: @12[2]: _0 = move _20"><span class="annotation">@10,12,14,15,16,17⦊</span>val<span class="annotation">⦉@10,12,14,15,16,17</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code even" style="--layer: 1" title="125:14-125:14: @11[0]: _13 = const ()"><span class="annotation">@11,13⦊</span>‸<span class="annotation">⦉@11,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="code odd" style="--layer: 1" title="127:6-127:6: @17.Return: return"><span class="annotation">@10,12,14,15,16,17⦊</span>‸<span class="annotation">⦉@10,12,14,15,16,17</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 74b62673ac94b..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.f-{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 16"><span class="line">                   <span><span class="code even" style="--layer: 1" title="17:22-17:23: @0[0]: _0 = const 1_u8
-17:25-17:25: @0.Return: return"><span class="annotation">@0⦊</span>‸<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">{ 1 }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f.-------.InstrumentCoverage.0.html
deleted file mode 100644
index a31bca54df2e5..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.f - 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><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn f() -&gt; u8 <span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">{ 1 }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index b8c53cccabda1..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.foo-{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 18"><span class="line">                             <span><span class="code even" style="--layer: 1" title="19:32-19:43: @0[0]: _0 = [const false; 10]
-19:45-19:45: @0.Return: return"><span class="annotation">@0⦊</span>‸<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">{ [false; 10] }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo.-------.InstrumentCoverage.0.html
deleted file mode 100644
index cf72a9d532c79..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.foo - 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 18"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn foo() -&gt; [bool; 10] <span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">{ [false; 10] }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index b10012621b7dd..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.g-{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 20"><span class="line">                      <span><span class="code even" style="--layer: 1" title="22:11-22:12: @0[3]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@0,3,4⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:11-22:12: @0[3]: FakeRead(ForMatchedPlace, _3)">    match x<span class="annotation">⦉@0,3,4</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="23:9-23:10: @17[3]: _4 = _3"><span class="annotation">@17⦊</span>y<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0"> if </span><span><span class="code even" style="--layer: 1" title="23:14-23:17: @3.Call: _8 = e() -&gt; [return: bb4, unwind: bb58]
-23:14-23:17: @4[0]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@0,3,4⦊</span>e()<span class="annotation">⦉@0,3,4</span></span></span><span class="code" style="--layer: 0">.await == </span><span><span class="code odd" style="--layer: 1" title="23:27-23:28: @15[2]: _24 = (*_5)"><span class="annotation">@10,13,15,16⦊</span>y<span class="annotation">⦉@10,13,15,16</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code even" style="--layer: 1" title="23:32-23:34: @17[4]: _0 = ()"><span class="annotation">@17⦊</span>()<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="24:9-24:10: @33[3]: _25 = _3"><span class="annotation">@33⦊</span>y<span class="annotation">⦉@33</span></span></span><span class="code" style="--layer: 0"> if </span><span><span class="code even" style="--layer: 1" title="24:14-24:17: @19.Call: _29 = f() -&gt; [return: bb20, unwind: bb51]
-24:14-24:17: @20[0]: FakeRead(ForMatchedPlace, _29)"><span class="annotation">@1,19,20⦊</span>f()<span class="annotation">⦉@1,19,20</span></span></span><span class="code" style="--layer: 0">.await == </span><span><span class="code odd" style="--layer: 1" title="24:27-24:28: @31[2]: _44 = (*_26)"><span class="annotation">@26,29,31,32⦊</span>y<span class="annotation">⦉@26,29,31,32</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code even" style="--layer: 1" title="24:32-24:34: @33[4]: _0 = ()"><span class="annotation">@33⦊</span>()<span class="annotation">⦉@33</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _ =&gt; </span><span><span class="code odd" style="--layer: 1" title="25:14-25:16: @2[0]: _0 = ()"><span class="annotation">@2⦊</span>()<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="27:2-27:2: @36.Return: return"><span class="annotation">@35,36⦊</span>‸<span class="annotation">⦉@35,36</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 973995477b9aa..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,80 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.g - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 20"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>pub async fn g(x: u8) <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">    match x {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        y if e().await == y =&gt; (),</span></span>
-<span class="line"><span class="code" style="--layer: 0">        y if f().await == y =&gt; (),</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="line"><span class="code" style="--layer: 0">}</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 6b4b43f836580..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.h-{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 28"><span class="line">                     <span><span class="code even" style="--layer: 1" title="32:11-32:12: @0[3]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@0,2,3⦊</span>{ // The function signature is counted when called, but the body is not</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="32:11-32:12: @0[3]: FakeRead(ForMatchedPlace, _3)">                       // executed (not awaited) so the open brace has a `0` count (at least when</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="32:11-32:12: @0[3]: FakeRead(ForMatchedPlace, _3)">                       // displayed with `llvm-cov show` in color-mode).</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="32:11-32:12: @0[3]: FakeRead(ForMatchedPlace, _3)">    match x<span class="annotation">⦉@0,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="33:9-33:10: @17[3]: _4 = _3"><span class="annotation">@17⦊</span>y<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0"> if </span><span><span class="code even" style="--layer: 1" title="33:14-33:19: @2.Call: _8 = foo() -&gt; [return: bb3, unwind: bb33]
-33:14-33:19: @3[0]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@0,2,3⦊</span>foo()<span class="annotation">⦉@0,2,3</span></span></span><span class="code" style="--layer: 0">.await[</span><span><span class="code odd" style="--layer: 1" title="33:26-33:27: @14[2]: _24 = (*_5)"><span class="annotation">@9,12,14,15,16⦊</span>y<span class="annotation">⦉@9,12,14,15,16</span></span></span><span class="code" style="--layer: 0">] =&gt; </span><span><span class="code even" style="--layer: 1" title="33:32-33:34: @17[4]: _0 = ()"><span class="annotation">@17⦊</span>()<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _ =&gt; </span><span><span class="code odd" style="--layer: 1" title="34:14-34:16: @1[0]: _0 = ()"><span class="annotation">@1⦊</span>()<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 even" style="--layer: 1" title="36:2-36:2: @20.Return: return"><span class="annotation">@19,20⦊</span>‸<span class="annotation">⦉@19,20</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h.-------.InstrumentCoverage.0.html
deleted file mode 100644
index f2ea01281fe1e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,81 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.h - 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 28"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn h(x: usize) <span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">{ // The function signature is counted when called, but the body is not</span></span>
-<span class="line"><span class="code" style="--layer: 0">                       // executed (not awaited) so the open brace has a `0` count (at least when</span></span>
-<span class="line"><span class="code" style="--layer: 0">                       // displayed with `llvm-cov show` in color-mode).</span></span>
-<span class="line"><span class="code" style="--layer: 0">    match x {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        y if foo().await[y] =&gt; (),</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="line"><span class="code" style="--layer: 0">}</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 1c63875a8be9b..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,89 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.i-{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 37"><span class="line">                  <span><span class="code even" style="--layer: 1" title="42:11-42:12: @0[3]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@0,3,4⦊</span>{ // line coverage is 1, but there are 2 regions:</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="42:11-42:12: @0[3]: FakeRead(ForMatchedPlace, _3)">                    // (a) the function signature, counted when the function is called; and</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="42:11-42:12: @0[3]: FakeRead(ForMatchedPlace, _3)">                    // (b) the open brace for the function body, counted once when the body is</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="42:11-42:12: @0[3]: FakeRead(ForMatchedPlace, _3)">                    // executed asynchronously.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="42:11-42:12: @0[3]: FakeRead(ForMatchedPlace, _3)">    match x<span class="annotation">⦉@0,3,4</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="43:9-43:10: @17[3]: _4 = _3"><span class="annotation">@17,19⦊</span>y<span class="annotation">⦉@17,19</span></span></span><span class="code" style="--layer: 0"> if </span><span><span class="code even" style="--layer: 1" title="43:16-43:17: @3[6]: _9 = _3
-43:14-43:18: @3.Call: _8 = c(move _9) -&gt; [return: bb4, unwind: bb82]
-43:14-43:18: @4[1]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@0,3,4⦊</span>c(x)<span class="annotation">⦉@0,3,4</span></span></span><span class="code" style="--layer: 0">.await == </span><span><span class="code odd" style="--layer: 1" title="43:28-43:29: @15[3]: _26 = (*_5)
-43:28-43:33: @15[4]: _25 = Add(move _26, const 1_u8)"><span class="annotation">@10,13,15,16⦊</span>y + 1<span class="annotation">⦉@10,13,15,16</span></span></span><span class="code" style="--layer: 0"> =&gt; { </span><span><span class="code even" style="--layer: 1" title="43:39-43:42: @17.Call: _28 = d() -&gt; [return: bb19, unwind: bb75]
-43:39-43:42: @19[0]: FakeRead(ForMatchedPlace, _28)"><span class="annotation">@17,19⦊</span>d()<span class="annotation">⦉@17,19</span></span></span><span class="code" style="--layer: 0">.await; }</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="44:9-44:10: @46[3]: _43 = _3"><span class="annotation">@46⦊</span>y<span class="annotation">⦉@46</span></span></span><span class="code" style="--layer: 0"> if </span><span><span class="code even" style="--layer: 1" title="44:14-44:17: @32.Call: _47 = f() -&gt; [return: bb33, unwind: bb68]
-44:14-44:17: @33[0]: FakeRead(ForMatchedPlace, _47)"><span class="annotation">@1,32,33⦊</span>f()<span class="annotation">⦉@1,32,33</span></span></span><span class="code" style="--layer: 0">.await == </span><span><span class="code odd" style="--layer: 1" title="44:27-44:28: @44[3]: _63 = (*_44)
-44:27-44:32: @44[4]: _62 = Add(move _63, const 1_u8)"><span class="annotation">@39,42,44,45⦊</span>y + 1<span class="annotation">⦉@39,42,44,45</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code even" style="--layer: 1" title="44:36-44:38: @46[4]: _0 = ()"><span class="annotation">@46⦊</span>()<span class="annotation">⦉@46</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _ =&gt; </span><span><span class="code odd" style="--layer: 1" title="45:14-45:16: @2[0]: _0 = ()"><span class="annotation">@2⦊</span>()<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="47:2-47:2: @49.Return: return"><span class="annotation">@48,49⦊</span>‸<span class="annotation">⦉@48,49</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i.-------.InstrumentCoverage.0.html
deleted file mode 100644
index e5dc6ecd4eb63..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.i - 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 37"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn i(x: u8) <span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">{ // line coverage is 1, but there are 2 regions:</span></span>
-<span class="line"><span class="code" style="--layer: 0">                    // (a) the function signature, counted when the function is called; and</span></span>
-<span class="line"><span class="code" style="--layer: 0">                    // (b) the open brace for the function body, counted once when the body is</span></span>
-<span class="line"><span class="code" style="--layer: 0">                    // executed asynchronously.</span></span>
-<span class="line"><span class="code" style="--layer: 0">    match x {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        y if c(x).await == y + 1 =&gt; { d().await; }</span></span>
-<span class="line"><span class="code" style="--layer: 0">        y if f().await == y + 1 =&gt; (),</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="line"><span class="code" style="--layer: 0">}</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-c.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-c.-------.InstrumentCoverage.0.html
deleted file mode 100644
index e6384b7598fc2..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-c.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,90 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-c.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.j-c - 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 50"><span class="line">    <span><span class="code even" style="--layer: 1" title="52:12-52:13: @0[2]: _3 = _1
-52:12-52:18: @0[3]: _2 = Eq(move _3, const 8_u8)"><span class="annotation">@0⦊</span>fn c(x: u8) -&gt; u8 {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="52:12-52:13: @0[2]: _3 = _1
-52:12-52:18: @0[3]: _2 = Eq(move _3, const 8_u8)">        if x == 8<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="53:13-53:14: @1[0]: _0 = const 1_u8"><span class="annotation">@1⦊</span>1<span class="annotation">⦉@1</span></span></span><span class="code" style="--layer: 0"> // This line appears covered, but the 1-character expression span covering the `1`</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // `fn j()` executes the open brace for the funciton body, followed by the function's</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // first executable statement, `match x`. Inner function declarations are not</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // "visible" to the MIR for `j()`, so the code region counts all lines between the</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // open brace and the first statement as executed, which is, in a sense, true.</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // `llvm-cov show` overcomes this kind of situation by showing the actual counts</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // of the enclosed coverages, (that is, the `1` expression was not executed, and</span></span>
-<span class="line"><span class="code" style="--layer: 0">              // accurately displays a `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="63:13-63:14: @2[0]: _0 = const 0_u8"><span class="annotation">@2⦊</span>0<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="65:6-65:6: @3.Return: return"><span class="annotation">@3⦊</span>‸<span class="annotation">⦉@3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-d.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-d.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4eed8ee60dd64..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-d.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-d.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.j-d - 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 65"><span class="line">    <span><span class="code even" style="--layer: 1" title="66:20-66:21: @0[0]: _0 = const 1_u8
-66:23-66:23: @0.Return: return"><span class="annotation">@0⦊</span>fn d() -&gt; u8 { 1 }<span class="annotation">⦉@0</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-f.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-f.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 6e80c8c786ecb..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-f.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-f.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.j-f - 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 66"><span class="line">    <span><span class="code even" style="--layer: 1" title="67:20-67:21: @0[0]: _0 = const 1_u8
-67:23-67:23: @0.Return: return"><span class="annotation">@0⦊</span>fn f() -&gt; u8 { 1 }<span class="annotation">⦉@0</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 2b43c7bd25d90..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,106 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.j - 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 48"><span class="line"><span><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)"><span class="annotation">@0,3,4⦊</span>fn j(x: u8) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    // non-async versions of `c()`, `d()`, and `f()` to make it similar to async `i()`.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    fn c(x: u8) -&gt; u8 {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">        if x == 8 {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">            1 // This line appears covered, but the 1-character expression span covering the `1`</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // `fn j()` executes the open brace for the funciton body, followed by the function's</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // first executable statement, `match x`. Inner function declarations are not</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // "visible" to the MIR for `j()`, so the code region counts all lines between the</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // open brace and the first statement as executed, which is, in a sense, true.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // `llvm-cov show` overcomes this kind of situation by showing the actual counts</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // of the enclosed coverages, (that is, the `1` expression was not executed, and</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">              // accurately displays a `0`).</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">        } else {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">            0</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">        }</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    }</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    fn d() -&gt; u8 { 1 }</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    fn f() -&gt; u8 { 1 }</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:11-68:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    match x<span class="annotation">⦉@0,3,4</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="69:9-69:10: @5[3]: _2 = _1"><span class="annotation">@5,7⦊</span>y<span class="annotation">⦉@5,7</span></span></span><span class="code" style="--layer: 0"> if </span><span><span class="code even" style="--layer: 1" title="69:16-69:17: @3[5]: _6 = _1
-69:14-69:18: @3.Call: _5 = j::c(move _6) -&gt; [return: bb4, unwind: bb13]
-69:22-69:23: @4[3]: _8 = (*_3)
-69:22-69:27: @4[4]: _7 = Add(move _8, const 1_u8)
-69:14-69:27: @4[6]: _4 = Eq(move _5, move _7)"><span class="annotation">@0,3,4⦊</span>c(x) == y + 1<span class="annotation">⦉@0,3,4</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code odd" style="--layer: 1" title="69:33-69:36: @5.Call: _9 = j::d() -&gt; [return: bb7, unwind: bb13]
-69:31-69:39: @7[1]: _0 = const ()"><span class="annotation">@5,7⦊</span>{ d(); }<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 even" style="--layer: 1" title="70:9-70:10: @10[3]: _10 = _1"><span class="annotation">@10⦊</span>y<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0"> if </span><span><span class="code odd" style="--layer: 1" title="70:14-70:17: @8.Call: _13 = j::f() -&gt; [return: bb9, unwind: bb13]
-70:21-70:22: @9[2]: _15 = (*_11)
-70:21-70:26: @9[3]: _14 = Add(move _15, const 1_u8)
-70:14-70:26: @9[5]: _12 = Eq(move _13, move _14)"><span class="annotation">@1,8,9⦊</span>f() == y + 1<span class="annotation">⦉@1,8,9</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code even" style="--layer: 1" title="70:30-70:32: @10[4]: _0 = ()"><span class="annotation">@10⦊</span>()<span class="annotation">⦉@10</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="code odd" style="--layer: 1" title="71:14-71:16: @2[0]: _0 = ()"><span class="annotation">@2⦊</span>()<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="73:2-73: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/expected_mir_dump.async/async.k.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.k.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 5792521bb2c57..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.k.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,80 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.k.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.k - 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><span class="code even" style="--layer: 1" title="76:11-76:12: @0[0]: FakeRead(ForMatchedPlace, _1)"><span class="annotation">@0⦊</span>fn k(x: u8) { // unused function</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="76:11-76:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    match x<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        1 =&gt; </span><span><span class="code odd" style="--layer: 1" title="77:14-77:16: @4[0]: _0 = ()"><span class="annotation">@1,4⦊</span>()<span class="annotation">⦉@1,4</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        2 =&gt; </span><span><span class="code even" style="--layer: 1" title="78:14-78:16: @5[0]: _0 = ()"><span class="annotation">@2,5⦊</span>()<span class="annotation">⦉@2,5</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="code odd" style="--layer: 1" title="79:14-79:16: @3[0]: _0 = ()"><span class="annotation">@3⦊</span>()<span class="annotation">⦉@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">}</span><span><span class="code even" style="--layer: 1" title="81:2-81:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.l.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.l.-------.InstrumentCoverage.0.html
deleted file mode 100644
index cd92b88c24cbb..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.l.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,80 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.l.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.l - 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 82"><span class="line"><span><span class="code even" style="--layer: 1" title="84:11-84:12: @0[0]: FakeRead(ForMatchedPlace, _1)"><span class="annotation">@0⦊</span>fn l(x: u8) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="84:11-84:12: @0[0]: FakeRead(ForMatchedPlace, _1)">    match x<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        1 =&gt; </span><span><span class="code odd" style="--layer: 1" title="85:14-85:16: @4[0]: _0 = ()"><span class="annotation">@1,4⦊</span>()<span class="annotation">⦉@1,4</span></span></span><span class="code" style="--layer: 0">,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        2 =&gt; </span><span><span class="code even" style="--layer: 1" title="86:14-86:16: @5[0]: _0 = ()"><span class="annotation">@2,5⦊</span>()<span class="annotation">⦉@2,5</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="code odd" style="--layer: 1" title="87:14-87:16: @3[0]: _0 = ()"><span class="annotation">@3⦊</span>()<span class="annotation">⦉@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">}</span><span><span class="code even" style="--layer: 1" title="89:2-89:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 5cec484a964da..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,78 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.m-{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 90"><span class="line">                        <span><span class="code even" style="--layer: 1" title="91:25-91:34: @0[1]: _3 = (_1.0: u8)
-91:25-91:34: @0[2]: FakeRead(ForLet, _3)
-91:27-91:28: @0[4]: _4 = _3
-91:27-91:32: @0[5]: _0 = Sub(move _4, const 1_u8)
-91:34-91:34: @0.Return: return"><span class="annotation">@0⦊</span>{ x - 1 }<span class="annotation">⦉@0</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 04412c1d99427..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.m - 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 90"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>async fn m(x: u8) -&gt; u8 <span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">{ x - 1 }</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index b892af0ed37d5..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,190 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>async.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 92"><span class="line"><span><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10,11,12,13⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">    let _ = g(10);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">    let _ = h(9);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">    let mut future = Box::pin(i(8));</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">    j(7);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">    l(6);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">    let _ = m(5);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">    executor::block_on(future.as_mut());</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="94:13-94:18: @0.Call: _1 = g(const 10_u8) -&gt; [return: bb1, unwind: bb16]
-95:13-95:17: @2.Call: _2 = h(const 9_usize) -&gt; [return: bb3, unwind: bb16]
-96:31-96:35: @4.Call: _4 = i(const 8_u8) -&gt; [return: bb5, unwind: bb16]
-96:22-96:36: @5.Call: _3 = std::boxed::Box::&lt;impl std::future::Future&gt;::pin(move _4) -&gt; [return: bb6, unwind: bb15]
-96:9-96:19: @6[1]: FakeRead(ForLet, _3)
-97:5-97:9: @6.Call: _5 = j(const 7_u8) -&gt; [return: bb7, unwind: bb14]
-98:5-98:9: @7.Call: _6 = l(const 6_u8) -&gt; [return: bb8, unwind: bb14]
-99:13-99:17: @8.Call: _7 = m(const 5_u8) -&gt; [return: bb9, unwind: bb14]
-100:24-100:30: @10[4]: _10 = &amp;mut _3
-100:24-100:39: @10.Call: _9 = std::pin::Pin::&lt;std::boxed::Box&lt;impl std::future::Future&gt;&gt;::as_mut(move _10) -&gt; [return: bb11, unwind: bb14]
-100:5-100:40: @11.Call: _8 = executor::block_on::&lt;std::pin::Pin&lt;&amp;mut impl std::future::Future&gt;&gt;(move _9) -&gt; [return: bb12, unwind: bb14]
-93:11-101:2: @12[2]: _0 = const ()
-101:2-101:2: @13.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10,11,12,13</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 3998295a0525e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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="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)
-36:12-36:20: @0[5]: _4 = (*((*_1).0: &amp;bool))"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><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)
-36:12-36:20: @0[5]: _4 = (*((*_1).0: &amp;bool))">        let mut countdown = 0;</span></span>
-<span class="line"><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)
-36:12-36:20: @0[5]: _4 = (*((*_1).0: &amp;bool))">        if 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: @1[0]: _2 = const 10_i32
-36:21-38:10: @1[1]: _3 = const ()"><span class="annotation">@1⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="37:13-37:27: @1[0]: _2 = const 10_i32
-36:21-38:10: @1[1]: _3 = const ()">            countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="37:13-37:27: @1[0]: _2 = const 10_i32
-36:21-38:10: @1[1]: _3 = const ()">        }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="38:10-38:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="39:9-39:23: @3[4]: _6 = const &quot;alt string 2&quot;
-39:9-39:23: @3[5]: _5 = &amp;(*_6)
-39:9-39:34: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-40:6-40:6: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 2".to_owned()</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="39:9-39:23: @3[4]: _6 = const &quot;alt string 2&quot;
-39:9-39:23: @3[5]: _5 = &amp;(*_6)
-39:9-39:34: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-40:6-40:6: @4.Return: return">    }<span class="annotation">⦉@3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 3bdfe71b48c27..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%2310%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#10} - 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="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)
-21:20-21:28: @0[5]: _4 = (*(_1.0: &amp;bool))"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><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)
-21:20-21:28: @0[5]: _4 = (*(_1.0: &amp;bool))">                let mut countdown = 0;</span></span>
-<span class="line"><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)
-21:20-21:28: @0[5]: _4 = (*(_1.0: &amp;bool))">                if 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: @1[0]: _2 = const 10_i32
-21:29-23:18: @1[1]: _3 = const ()"><span class="annotation">@1⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:21-22:35: @1[0]: _2 = const 10_i32
-21:29-23:18: @1[1]: _3 = const ()">                    countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:21-22:35: @1[0]: _2 = const 10_i32
-21:29-23:18: @1[1]: _3 = const ()">                }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="23:18-23:18: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="24:17-24:31: @3[4]: _6 = const &quot;alt string 1&quot;
-24:17-24:31: @3[5]: _5 = &amp;(*_6)
-24:17-24:42: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-25:14-25:14: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 1".to_owned()</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="24:17-24:31: @3[4]: _6 = const &quot;alt string 1&quot;
-24:17-24:31: @3[5]: _5 = &amp;(*_6)
-24:17-24:42: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-25:14-25:14: @4.Return: return">            }<span class="annotation">⦉@3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4b3f04b5a0c7e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%2311%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#11} - 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="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)
-63:20-63:28: @0[5]: _4 = (*(_1.0: &amp;bool))"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><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)
-63:20-63:28: @0[5]: _4 = (*(_1.0: &amp;bool))">                let mut countdown = 0;</span></span>
-<span class="line"><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)
-63:20-63:28: @0[5]: _4 = (*(_1.0: &amp;bool))">                if 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: @1[0]: _2 = const 10_i32
-63:29-65:18: @1[1]: _3 = const ()"><span class="annotation">@1⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="64:21-64:35: @1[0]: _2 = const 10_i32
-63:29-65:18: @1[1]: _3 = const ()">                    countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="64:21-64:35: @1[0]: _2 = const 10_i32
-63:29-65:18: @1[1]: _3 = const ()">                }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="65:18-65:18: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="66:17-66:31: @3[4]: _6 = const &quot;alt string 3&quot;
-66:17-66:31: @3[5]: _5 = &amp;(*_6)
-66:17-66:42: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-67:14-67:14: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 3".to_owned()</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="66:17-66:31: @3[4]: _6 = const &quot;alt string 3&quot;
-66:17-66:31: @3[5]: _5 = &amp;(*_6)
-66:17-66:42: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-67:14-67:14: @4.Return: return">            }<span class="annotation">⦉@3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 8ae494178f70b..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%231%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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="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)
-78:12-78:20: @0[5]: _4 = (*((*_1).0: &amp;bool))"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><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)
-78:12-78:20: @0[5]: _4 = (*((*_1).0: &amp;bool))">        let mut countdown = 0;</span></span>
-<span class="line"><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)
-78:12-78:20: @0[5]: _4 = (*((*_1).0: &amp;bool))">        if 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: @1[0]: _2 = const 10_i32
-78:21-80:10: @1[1]: _3 = const ()"><span class="annotation">@1⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="79:13-79:27: @1[0]: _2 = const 10_i32
-78:21-80:10: @1[1]: _3 = const ()">            countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="79:13-79:27: @1[0]: _2 = const 10_i32
-78:21-80:10: @1[1]: _3 = const ()">        }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="80:10-80:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="81:9-81:23: @3[4]: _6 = const &quot;alt string 4&quot;
-81:9-81:23: @3[5]: _5 = &amp;(*_6)
-81:9-81:34: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-82:6-82:6: @4.Return: return"><span class="annotation">@3,4⦊</span>"alt string 4".to_owned()</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="81:9-81:23: @3[4]: _6 = const &quot;alt string 4&quot;
-81:9-81:23: @3[5]: _5 = &amp;(*_6)
-81:9-81:34: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-82:6-82:6: @4.Return: return">    }<span class="annotation">⦉@3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index ad40ba57d69be..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,128 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%232%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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 96"><span class="line">        <span class="code" style="--layer: 0">|val|</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="99:29-99:30: @0[1]: _3 = const 0_i32
-99:13-99:26: @0[2]: FakeRead(ForLet, _3)
-100:12-100:20: @0[5]: _5 = (*((*_1).0: &amp;bool))"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="99:29-99:30: @0[1]: _3 = const 0_i32
-99:13-99:26: @0[2]: FakeRead(ForLet, _3)
-100:12-100:20: @0[5]: _5 = (*((*_1).0: &amp;bool))">        let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="99:29-99:30: @0[1]: _3 = const 0_i32
-99:13-99:26: @0[2]: FakeRead(ForLet, _3)
-100:12-100:20: @0[5]: _5 = (*((*_1).0: &amp;bool))">        if 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="101:13-101:27: @1[0]: _3 = const 10_i32
-100:21-102:10: @1[1]: _4 = const ()"><span class="annotation">@1⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="101:13-101:27: @1[0]: _3 = const 10_i32
-100:21-102:10: @1[1]: _4 = const ()">            countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="101:13-101:27: @1[0]: _3 = const 10_i32
-100:21-102:10: @1[1]: _4 = const ()">        }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="102:10-102:10: @2[0]: _4 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="103:17-103:23: @3[7]: _22 = const main::{closure#2}::promoted[0]
-103:17-103:23: @3[8]: _10 = &amp;(*_22)
-103:17-103:23: @3[9]: _9 = &amp;(*_10)
-103:17-103:23: @3[10]: _8 = move _9 as &amp;[&amp;str] (Pointer(Unsize))
-103:25-103:28: @3[18]: _17 = &amp;_2
-103:9-103:29: @3[19]: _16 = (move _17,)
-103:9-103:29: @3[21]: FakeRead(ForMatchedPlace, _16)
-103:9-103:29: @3[23]: _18 = (_16.0: &amp;&amp;str)
-103:9-103:29: @3[26]: _20 = &amp;(*_18)
-103:9-103:29: @3[28]: _21 = &lt;&amp;str as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r &amp;str, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-103:9-103:29: @3.Call: _19 = std::fmt::ArgumentV1::new::&lt;&amp;str&gt;(move _20, move _21) -&gt; [return: bb4, unwind: bb8]
-103:9-103:29: @4[2]: _15 = [move _19]
-103:9-103:29: @4[5]: _14 = &amp;_15
-103:9-103:29: @4[6]: _13 = &amp;(*_14)
-103:9-103:29: @4[7]: _12 = move _13 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-103:9-103:29: @4.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -&gt; [return: bb5, unwind: bb8]
-103:9-103:29: @5.Call: _6 = std::fmt::format(move _7) -&gt; [return: bb6, unwind: bb8]
-103:9-103:29: @6[1]: FakeRead(ForLet, _6)
-103:9-103:29: @6[6]: _0 = move _6
-104:6-104:6: @7.Return: return"><span class="annotation">@3,4,5,6,7⦊</span>format!("'{}'", val)</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="103:17-103:23: @3[7]: _22 = const main::{closure#2}::promoted[0]
-103:17-103:23: @3[8]: _10 = &amp;(*_22)
-103:17-103:23: @3[9]: _9 = &amp;(*_10)
-103:17-103:23: @3[10]: _8 = move _9 as &amp;[&amp;str] (Pointer(Unsize))
-103:25-103:28: @3[18]: _17 = &amp;_2
-103:9-103:29: @3[19]: _16 = (move _17,)
-103:9-103:29: @3[21]: FakeRead(ForMatchedPlace, _16)
-103:9-103:29: @3[23]: _18 = (_16.0: &amp;&amp;str)
-103:9-103:29: @3[26]: _20 = &amp;(*_18)
-103:9-103:29: @3[28]: _21 = &lt;&amp;str as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r &amp;str, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-103:9-103:29: @3.Call: _19 = std::fmt::ArgumentV1::new::&lt;&amp;str&gt;(move _20, move _21) -&gt; [return: bb4, unwind: bb8]
-103:9-103:29: @4[2]: _15 = [move _19]
-103:9-103:29: @4[5]: _14 = &amp;_15
-103:9-103:29: @4[6]: _13 = &amp;(*_14)
-103:9-103:29: @4[7]: _12 = move _13 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-103:9-103:29: @4.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -&gt; [return: bb5, unwind: bb8]
-103:9-103:29: @5.Call: _6 = std::fmt::format(move _7) -&gt; [return: bb6, unwind: bb8]
-103:9-103:29: @6[1]: FakeRead(ForLet, _6)
-103:9-103:29: @6[6]: _0 = move _6
-104:6-104:6: @7.Return: return">    }<span class="annotation">⦉@3,4,5,6,7</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 23101d76a8ef4..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,91 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%233%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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 119"><span class="line">        <span class="code" style="--layer: 0">|</span></span>
-<span class="line"><span class="code" style="--layer: 0">            mut countdown</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="124:12-124:20: @0[2]: _4 = (*((*_1).0: &amp;bool))"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="124:12-124:20: @0[2]: _4 = (*((*_1).0: &amp;bool))">        if 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="125:13-125:27: @1[0]: _2 = const 10_i32
-124:21-126:10: @1[1]: _3 = const ()"><span class="annotation">@1⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="125:13-125:27: @1[0]: _2 = const 10_i32
-124:21-126:10: @1[1]: _3 = const ()">            countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="125:13-125:27: @1[0]: _2 = const 10_i32
-124:21-126:10: @1[1]: _3 = const ()">        }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="126:10-126:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="127:9-127:35: @3[4]: _6 = const &quot;closure should be unused&quot;
-127:9-127:35: @3[5]: _5 = &amp;(*_6)
-127:9-127:46: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-128:6-128:6: @4.Return: return"><span class="annotation">@3,4⦊</span>"closure should be unused".to_owned()</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="127:9-127:35: @3[4]: _6 = const &quot;closure should be unused&quot;
-127:9-127:35: @3[5]: _5 = &amp;(*_6)
-127:9-127:46: @3.Call: _0 = &lt;str as std::borrow::ToOwned&gt;::to_owned(move _5) -&gt; [return: bb4, unwind: bb5]
-128:6-128:6: @4.Return: return">    }<span class="annotation">⦉@3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#4}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#4}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 420135e143dbf..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#4}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,76 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%234%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#4} - 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 130"><span class="line">                                <span class="code" style="--layer: 0">| _unused_arg: u8 | </span><span><span class="code even" style="--layer: 1" title="131:53-131:67: @0[0]: (*((*_1).0: &amp;mut i32)) = Add((*((*_1).0: &amp;mut i32)), const 1_i32)
-131:53-131:67: @0[1]: _0 = const ()
-131:67-131:67: @0.Return: return"><span class="annotation">@0⦊</span>countdown += 1<span class="annotation">⦉@0</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 1c19aa8eeefaa..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,115 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%235%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#5} - 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 95"><span class="line">                      <span><span class="code even" style="--layer: 1" title="96:23-98:6: @0[5]: _15 = const main::{closure#5}::promoted[1]
-96:23-98:6: @0[6]: _7 = &amp;(*_15)
-96:23-98:6: @0[7]: _6 = &amp;(*_7)
-96:23-98:6: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-97:28-97:61: @0[14]: _13 = ()
-97:28-97:61: @0[15]: FakeRead(ForMatchedPlace, _13)
-97:28-97:61: @0[16]: _14 = const main::{closure#5}::promoted[0]
-97:28-97:61: @0[17]: _11 = &amp;(*_14)
-97:28-97:61: @0[18]: _10 = &amp;(*_11)
-97:28-97:61: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-97:28-97:61: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-97:9-97:62: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-96:23-98:6: @2[5]: _0 = const ()
-96:23-98:6: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="96:23-98:6: @0[5]: _15 = const main::{closure#5}::promoted[1]
-96:23-98:6: @0[6]: _7 = &amp;(*_15)
-96:23-98:6: @0[7]: _6 = &amp;(*_7)
-96:23-98:6: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-97:28-97:61: @0[14]: _13 = ()
-97:28-97:61: @0[15]: FakeRead(ForMatchedPlace, _13)
-97:28-97:61: @0[16]: _14 = const main::{closure#5}::promoted[0]
-97:28-97:61: @0[17]: _11 = &amp;(*_14)
-97:28-97:61: @0[18]: _10 = &amp;(*_11)
-97:28-97:61: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-97:28-97:61: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-97:9-97:62: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-96:23-98:6: @2[5]: _0 = const ()
-96:23-98:6: @2.Return: return">        $crate::io::_print($crate::format_args_nl!($($arg)*));</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="96:23-98:6: @0[5]: _15 = const main::{closure#5}::promoted[1]
-96:23-98:6: @0[6]: _7 = &amp;(*_15)
-96:23-98:6: @0[7]: _6 = &amp;(*_7)
-96:23-98:6: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-97:28-97:61: @0[14]: _13 = ()
-97:28-97:61: @0[15]: FakeRead(ForMatchedPlace, _13)
-97:28-97:61: @0[16]: _14 = const main::{closure#5}::promoted[0]
-97:28-97:61: @0[17]: _11 = &amp;(*_14)
-97:28-97:61: @0[18]: _10 = &amp;(*_11)
-97:28-97:61: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-97:28-97:61: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-97:9-97:62: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-96:23-98:6: @2[5]: _0 = const ()
-96:23-98:6: @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/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 74c75c6c46ca2..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,87 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%236%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#6} - 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 140"><span class="line">                                      <span class="code" style="--layer: 0">| _unused_arg: u8 | </span><span><span class="code even" style="--layer: 1" title="141:70-141:82: @0[5]: _15 = const main::{closure#6}::promoted[1]
-141:70-141:82: @0[6]: _7 = &amp;(*_15)
-141:70-141:82: @0[7]: _6 = &amp;(*_7)
-141:70-141:82: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-141:61-141:83: @0[14]: _13 = ()
-141:61-141:83: @0[15]: FakeRead(ForMatchedPlace, _13)
-141:61-141:83: @0[16]: _14 = const main::{closure#6}::promoted[0]
-141:61-141:83: @0[17]: _11 = &amp;(*_14)
-141:61-141:83: @0[18]: _10 = &amp;(*_11)
-141:61-141:83: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-141:61-141:83: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-141:61-141:83: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-141:61-141:83: @2[5]: _0 = const ()
-141:85-141:85: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{ println!("not called") }<span class="annotation">⦉@0,1,2</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 386fb1b9e6f95..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,115 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%237%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#7} - 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 142"><span class="line">                                   <span class="code" style="--layer: 0">| _unused_arg: u8 | </span><span><span class="code even" style="--layer: 1" title="144:18-144:30: @0[5]: _15 = const main::{closure#7}::promoted[1]
-144:18-144:30: @0[6]: _7 = &amp;(*_15)
-144:18-144:30: @0[7]: _6 = &amp;(*_7)
-144:18-144:30: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-144:9-144:31: @0[14]: _13 = ()
-144:9-144:31: @0[15]: FakeRead(ForMatchedPlace, _13)
-144:9-144:31: @0[16]: _14 = const main::{closure#7}::promoted[0]
-144:9-144:31: @0[17]: _11 = &amp;(*_14)
-144:9-144:31: @0[18]: _10 = &amp;(*_11)
-144:9-144:31: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-144:9-144:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-144:9-144:31: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-144:9-144:31: @2[5]: _0 = const ()
-145:6-145:6: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="144:18-144:30: @0[5]: _15 = const main::{closure#7}::promoted[1]
-144:18-144:30: @0[6]: _7 = &amp;(*_15)
-144:18-144:30: @0[7]: _6 = &amp;(*_7)
-144:18-144:30: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-144:9-144:31: @0[14]: _13 = ()
-144:9-144:31: @0[15]: FakeRead(ForMatchedPlace, _13)
-144:9-144:31: @0[16]: _14 = const main::{closure#7}::promoted[0]
-144:9-144:31: @0[17]: _11 = &amp;(*_14)
-144:9-144:31: @0[18]: _10 = &amp;(*_11)
-144:9-144:31: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-144:9-144:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-144:9-144:31: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-144:9-144:31: @2[5]: _0 = const ()
-145:6-145:6: @2.Return: return">        println!("not called")</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="144:18-144:30: @0[5]: _15 = const main::{closure#7}::promoted[1]
-144:18-144:30: @0[6]: _7 = &amp;(*_15)
-144:18-144:30: @0[7]: _6 = &amp;(*_7)
-144:18-144:30: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-144:9-144:31: @0[14]: _13 = ()
-144:9-144:31: @0[15]: FakeRead(ForMatchedPlace, _13)
-144:9-144:31: @0[16]: _14 = const main::{closure#7}::promoted[0]
-144:9-144:31: @0[17]: _11 = &amp;(*_14)
-144:9-144:31: @0[18]: _10 = &amp;(*_11)
-144:9-144:31: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-144:9-144:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-144:9-144:31: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-144:9-144:31: @2[5]: _0 = const ()
-145:6-145:6: @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/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index f9da6ac9dfc34..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,89 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%238%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#8} - 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 146"><span class="line">                                   <span class="code" style="--layer: 0">|</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _unused_arg: u8</span></span>
-<span class="line"><span class="code" style="--layer: 0">    | </span><span><span class="code even" style="--layer: 1" title="149:18-149:30: @0[5]: _15 = const main::{closure#8}::promoted[1]
-149:18-149:30: @0[6]: _7 = &amp;(*_15)
-149:18-149:30: @0[7]: _6 = &amp;(*_7)
-149:18-149:30: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-149:9-149:31: @0[14]: _13 = ()
-149:9-149:31: @0[15]: FakeRead(ForMatchedPlace, _13)
-149:9-149:31: @0[16]: _14 = const main::{closure#8}::promoted[0]
-149:9-149:31: @0[17]: _11 = &amp;(*_14)
-149:9-149:31: @0[18]: _10 = &amp;(*_11)
-149:9-149:31: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-149:9-149:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-149:9-149:31: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-149:9-149:31: @2[5]: _0 = const ()
-149:33-149:33: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{ println!("not called") }<span class="annotation">⦉@0,1,2</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index e259fc9bb67e7..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,89 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-%7Bclosure%239%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>closure.main-{closure#9} - 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 150"><span class="line">                                          <span class="code" style="--layer: 0">|</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _unused_arg: u8</span></span>
-<span class="line"><span class="code" style="--layer: 0">    | </span><span><span class="code even" style="--layer: 1" title="153:18-153:30: @0[5]: _15 = const main::{closure#9}::promoted[1]
-153:18-153:30: @0[6]: _7 = &amp;(*_15)
-153:18-153:30: @0[7]: _6 = &amp;(*_7)
-153:18-153:30: @0[8]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-153:9-153:31: @0[14]: _13 = ()
-153:9-153:31: @0[15]: FakeRead(ForMatchedPlace, _13)
-153:9-153:31: @0[16]: _14 = const main::{closure#9}::promoted[0]
-153:9-153:31: @0[17]: _11 = &amp;(*_14)
-153:9-153:31: @0[18]: _10 = &amp;(*_11)
-153:9-153:31: @0[19]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-153:9-153:31: @0.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb1, unwind: bb3]
-153:9-153:31: @1.Call: _3 = std::io::_print(move _4) -&gt; [return: bb2, unwind: bb3]
-153:9-153:31: @2[5]: _0 = const ()
-153:33-153:33: @2.Return: return"><span class="annotation">@0,1,2⦊</span>{ println!("not called") }<span class="annotation">⦉@0,1,2</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index a7d1728114ec9..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,10921 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _0 = const ()">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _0 = const ()">    println!(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        ,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        some_string</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _0 = const ()">            .</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        (</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42</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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _0 = const ()">        )</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _0 = const ()">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _0 = const ()">    let</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _0 = const ()">        a</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _0 = const ()">    =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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-155:2: @41[38]: _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,35,36,37,38,39,40,41,42</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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">    println!(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        ,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        some_string</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">            .</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        (</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">            a</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        )</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">    println!(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        ,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        some_string</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">            .</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _0 = const ()">        (</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42</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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _0 = const ()">        )</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _0 = const ()">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _0 = const ()">    let</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _0 = const ()">        a</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _0 = const ()">    =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42</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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">    println!(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">        ,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">        some_string</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">            .</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">        (</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">            a</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">        )</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">    let</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">        quote_closure</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _0 = const ()">    =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|val|</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">        format!("'{}'", val)</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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">    println!(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">        "Repeated, quoted string: {:?}"</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">        ,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">        std::iter::repeat("repeat me")</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">            .take(5)</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">            .map</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">        (</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">            quote_closure</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">        )</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">            .collect::&lt;Vec&lt;_&gt;&gt;()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">    let</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">        _unused_closure</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _0 = const ()">    =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|</span></span>
-<span class="line"><span class="code" style="--layer: 0">            mut countdown</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 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">        "closure should be unused".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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-3:11-155:2: @41[38]: _0 = const ()">    let mut countdown = 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-3:11-155:2: @41[38]: _0 = const ()">    let _short_unused_closure = <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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | countdown += 1</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-3:11-155:2: @41[38]: _0 = const ()">    // Macros can sometimes confuse the coverage results. Compare this next assignment, with an</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-3:11-155:2: @41[38]: _0 = const ()">    // unused closure that invokes the `println!()` macro, with the closure assignment above, that</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-3:11-155:2: @41[38]: _0 = const ()">    // does not use a macro. The closure above correctly shows `0` executions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-3:11-155:2: @41[38]: _0 = const ()">    let _short_unused_closure = <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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | println!("not called")</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-3:11-155:2: @41[38]: _0 = const ()">    // The closure assignment above is executed, with a line count of `1`, but the `println!()`</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-3:11-155:2: @41[38]: _0 = const ()">    // could not have been called, and yet, there is no indication that it wasn't...</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-3:11-155:2: @41[38]: _0 = const ()">    // ...but adding block braces gives the expected result, showing the block was not executed.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-3:11-155:2: @41[38]: _0 = const ()">    let _short_unused_closure_block = <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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-3:11-155:2: @41[38]: _0 = const ()">    let _shortish_unused_closure = <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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">| _unused_arg: u8 | {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        println!("not called")</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 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-3:11-155:2: @41[38]: _0 = const ()">    let _as_short_unused_closure = <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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _unused_arg: u8</span></span>
-<span class="line"><span class="code" style="--layer: 0">    | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-151:9-151:40: @41[37]: FakeRead(ForLet, _132)
-3:11-155:2: @41[38]: _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,35,36,37,38,39,40,41,42⦊</span>;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-151:9-151:40: @41[37]: FakeRead(ForLet, _132)
-3:11-155:2: @41[38]: _0 = const ()"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-151:9-151:40: @41[37]: FakeRead(ForLet, _132)
-3:11-155:2: @41[38]: _0 = const ()">    let _almost_as_short_unused_closure = <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,35,36,37,38,39,40,41,42</span></span></span><span class="code" style="--layer: 0">|</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _unused_arg: u8</span></span>
-<span class="line"><span class="code" style="--layer: 0">    | { println!("not called") }</span><span><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-151:9-151:40: @41[37]: FakeRead(ForLet, _132)
-3:11-155:2: @41[38]: _0 = const ()
-155:2-155:2: @42.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,35,36,37,38,39,40,41,42⦊</span></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-151:9-151:40: @41[37]: FakeRead(ForLet, _132)
-3:11-155:2: @41[38]: _0 = const ()
-155:2-155:2: @42.Return: return">    ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb57]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb56]
-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;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb4, unwind: bb57]
-10:27-10:67: @4[0]: _7 = std::option::Option::&lt;std::string::String&gt;::Some(move _8)
-10:9-10:24: @5[1]: FakeRead(ForLet, _7)
-12:9-12:32: @5[8]: _137 = const main::promoted[4]
-12:9-12:32: @5[9]: _14 = &amp;(*_137)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:18:13: 25:14]&gt;(move _23, move _24) -&gt; [return: bb6, unwind: bb54]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _28, move _29) -&gt; [return: bb7, unwind: bb53]
-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 = std::fmt::Arguments::new_v1(move _12, move _16) -&gt; [return: bb8, unwind: bb53]
-11:5-27:7: @8.Call: _10 = std::io::_print(move _11) -&gt; [return: bb9, unwind: bb53]
-11:5-27:7: @10[6]: _9 = const ()
-29:24-29:58: @10.Call: _31 = &lt;std::string::String as std::convert::From&lt;&amp;str&gt;&gt;::from(const &quot;the string content&quot;) -&gt; [return: bb11, unwind: bb55]
-29:19-29:59: @11[0]: _30 = std::option::Option::&lt;std::string::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]: _136 = const main::promoted[3]
-42:9-42:32: @14[14]: _39 = &amp;(*_136)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:33:9: 40:6]&gt;(move _48, move _49) -&gt; [return: bb15, unwind: bb51]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _52, move _53) -&gt; [return: bb16, unwind: bb50]
-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 = std::fmt::Arguments::new_v1(move _37, move _41) -&gt; [return: bb17, unwind: bb50]
-41:5-50:7: @17.Call: _35 = std::io::_print(move _36) -&gt; [return: bb18, unwind: bb50]
-41:5-50:7: @19[6]: _34 = const ()
-52:19-52:23: @19[9]: _54 = std::option::Option::&lt;std::string::String&gt;::None
-54:9-54:32: @21[7]: _135 = const main::promoted[2]
-54:9-54:32: @21[8]: _60 = &amp;(*_135)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:60:13: 67:14]&gt;(move _69, move _70) -&gt; [return: bb22, unwind: bb48]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _74, move _75) -&gt; [return: bb23, unwind: bb47]
-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 = std::fmt::Arguments::new_v1(move _58, move _62) -&gt; [return: bb24, unwind: bb47]
-53:5-69:7: @24.Call: _56 = std::io::_print(move _57) -&gt; [return: bb25, unwind: bb47]
-53:5-69:7: @26[6]: _55 = const ()
-71:19-71:23: @26[9]: _76 = std::option::Option::&lt;std::string::String&gt;::None
-75:9-82:6: @28[3]: _78 = &amp;_5
-73:9-73:10: @28[6]: FakeRead(ForLet, _77)
-84:9-84:32: @28[13]: _134 = const main::promoted[1]
-84:9-84:32: @28[14]: _84 = &amp;(*_134)
-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 = std::option::Option::&lt;std::string::String&gt;::unwrap_or_else::&lt;[closure@../coverage/closure.rs:75:9: 82:6]&gt;(move _93, move _94) -&gt; [return: bb29, unwind: bb45]
-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;std::string::String as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::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 = std::fmt::ArgumentV1::new::&lt;std::string::String&gt;(move _97, move _98) -&gt; [return: bb30, unwind: bb44]
-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 = std::fmt::Arguments::new_v1(move _82, move _86) -&gt; [return: bb31, unwind: bb44]
-83:5-92:7: @31.Call: _80 = std::io::_print(move _81) -&gt; [return: bb32, unwind: bb44]
-83:5-92:7: @33[6]: _79 = const ()
-97:9-104:6: @33[10]: _100 = &amp;_5
-95:9-95:22: @33[13]: FakeRead(ForLet, _99)
-106:9-106:40: @33[20]: _133 = const main::promoted[0]
-106:9-106:40: @33[21]: _106 = &amp;(*_133)
-106:9-106:40: @33[22]: _105 = &amp;(*_106)
-106:9-106:40: @33[23]: _104 = move _105 as &amp;[&amp;str] (Pointer(Unsize))
-108:9-108:39: @33.Call: _117 = std::iter::repeat::&lt;&amp;str&gt;(const &quot;repeat me&quot;) -&gt; [return: bb34, unwind: bb55]
-108:9-109:21: @34.Call: _116 = &lt;std::iter::Repeat&lt;&amp;str&gt; as std::iter::Iterator&gt;::take(move _117, const 5_usize) -&gt; [return: bb35, unwind: bb55]
-112:13-112:26: @35[2]: _118 = _99
-108:9-113:10: @35.Call: _115 = &lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt; as std::iter::Iterator&gt;::map::&lt;std::string::String, [closure@../coverage/closure.rs:97:9: 104:6]&gt;(move _116, move _118) -&gt; [return: bb36, unwind: bb55]
-108:9-114:33: @36.Call: _114 = &lt;std::iter::Map&lt;std::iter::Take&lt;std::iter::Repeat&lt;&amp;str&gt;&gt;, [closure@../coverage/closure.rs:97:9: 104:6]&gt; as std::iter::Iterator&gt;::collect::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _115) -&gt; [return: bb37, unwind: bb55]
-108:9-114:33: @37[1]: _113 = &amp;_114
-105:5-115:7: @37[2]: _112 = (move _113,)
-105:5-115:7: @37[4]: FakeRead(ForMatchedPlace, _112)
-105:5-115:7: @37[6]: _119 = (_112.0: &amp;std::vec::Vec&lt;std::string::String&gt;)
-105:5-115:7: @37[9]: _121 = &amp;(*_119)
-105:5-115:7: @37[11]: _122 = &lt;std::vec::Vec&lt;std::string::String&gt; as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r std::vec::Vec&lt;std::string::String&gt;, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-105:5-115:7: @37.Call: _120 = std::fmt::ArgumentV1::new::&lt;std::vec::Vec&lt;std::string::String&gt;&gt;(move _121, move _122) -&gt; [return: bb38, unwind: bb43]
-105:5-115:7: @38[2]: _111 = [move _120]
-105:5-115:7: @38[5]: _110 = &amp;_111
-105:5-115:7: @38[6]: _109 = &amp;(*_110)
-105:5-115:7: @38[7]: _108 = move _109 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-105:5-115:7: @38.Call: _103 = std::fmt::Arguments::new_v1(move _104, move _108) -&gt; [return: bb39, unwind: bb43]
-105:5-115:7: @39.Call: _102 = std::io::_print(move _103) -&gt; [return: bb40, unwind: bb43]
-105:5-115:7: @41[6]: _101 = const ()
-118:9-118:24: @41[13]: FakeRead(ForLet, _123)
-130:25-130:27: @41[15]: _125 = const 10_i32
-130:9-130:22: @41[16]: FakeRead(ForLet, _125)
-131:33-131:67: @41[19]: _127 = &amp;mut _125
-131:9-131:30: @41[22]: FakeRead(ForLet, _126)
-136:9-136:30: @41[25]: FakeRead(ForLet, _128)
-141:9-141:36: @41[28]: FakeRead(ForLet, _129)
-143:9-143:33: @41[31]: FakeRead(ForLet, _130)
-147:9-147:33: @41[34]: FakeRead(ForLet, _131)
-151:9-151:40: @41[37]: FakeRead(ForLet, _132)
-3:11-155:2: @41[38]: _0 = const ()
-155:2-155:2: @42.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,35,36,37,38,39,40,41,42</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 3d1b737ec2d7e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,307 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>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><span class="code even" style="--layer: 1"><span class="annotation">@0⦊</span>fn main() <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 even" style="--layer: 1" title="4:25-4:26: @0[1]: _1 = const 0_u32
-4:9-4:22: @0[2]: FakeRead(ForLet, _1)
-5:8-5:12: @0[5]: _3 = const true"><span class="annotation">@0⦊</span>mut countdown = 0;</span></span>
-<span class="line"><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)
-5:8-5:12: @0[5]: _3 = const true">    if 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: @1[0]: _1 = const 10_u32
-5:13-7:6: @1[1]: _2 = const ()"><span class="annotation">@1⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="6:9-6:23: @1[0]: _1 = const 10_u32
-5:13-7:6: @1[1]: _2 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="6:9-6:23: @1[0]: _1 = const 10_u32
-5:13-7:6: @1[1]: _2 = const ()">    }<span class="annotation">⦉@1</span></span></span><span><span class="code even" style="--layer: 1" title="7:6-7:6: @2[0]: _2 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    const B: u32 = 100;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="10:9-10:10: @19[1]: FakeRead(ForLet, _4)"><span class="annotation">@19⦊</span>x<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="10:16-10:25: @3[5]: _6 = _1
-10:16-10:29: @3[6]: _5 = Gt(move _6, const 7_u32)"><span class="annotation">@3⦊</span>countdown &gt; 7<span class="annotation">⦉@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="11:9-11:23: @4[0]: _7 = CheckedSub(_1, const 4_u32)
-11:9-11:23: @6[0]: _1 = move (_7.0: u32)
-12:9-12:10: @6[1]: _4 = const main::B"><span class="annotation">@4,6⦊</span>countdown -= 4;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @4[0]: _7 = CheckedSub(_1, const 4_u32)
-11:9-11:23: @6[0]: _1 = move (_7.0: u32)
-12:9-12:10: @6[1]: _4 = const main::B">        B<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 if </span><span><span class="code even" style="--layer: 1" title="13:15-13:24: @5[2]: _9 = _1
-13:15-13:28: @5[3]: _8 = Gt(move _9, const 2_u32)"><span class="annotation">@5⦊</span>countdown &gt; 2<span class="annotation">⦉@5</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: @7[5]: _14 = _1
-14:12-14:25: @7[6]: _13 = Lt(move _14, const 1_u32)"><span class="annotation">@7⦊</span>countdown &lt; 1<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="14:29-14:38: @13[2]: _16 = _1
-14:29-14:42: @13[3]: _15 = Gt(move _16, const 5_u32)"><span class="annotation">@13⦊</span>countdown &gt; 5<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="14:46-14:55: @10[2]: _18 = _1
-14:46-14:60: @10[3]: _17 = Ne(move _18, const 9_u32)"><span class="annotation">@10⦊</span>countdown != 9<span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="15:13-15:26: @15[0]: _1 = const 0_u32
-14:61-16:10: @15[1]: _10 = const ()"><span class="annotation">@15⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="15:13-15:26: @15[0]: _1 = const 0_u32
-14:61-16:10: @15[1]: _10 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="15:13-15:26: @15[0]: _1 = const 0_u32
-14:61-16:10: @15[1]: _10 = const ()">        }<span class="annotation">⦉@15</span></span></span><span><span class="code odd" style="--layer: 1" title="16:10-16:10: @16[0]: _10 = 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="code even" style="--layer: 1" title="17:9-17:23: @17[2]: _19 = CheckedSub(_1, const 5_u32)
-17:9-17:23: @18[0]: _1 = move (_19.0: u32)
-18:9-18:18: @18[1]: _4 = _1"><span class="annotation">@17,18⦊</span>countdown -= 5;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="17:9-17:23: @17[2]: _19 = CheckedSub(_1, const 5_u32)
-17:9-17:23: @18[0]: _1 = move (_19.0: u32)
-18:9-18:18: @18[1]: _4 = _1">        countdown<span class="annotation">⦉@17,18</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: @8[0]: _0 = const ()"><span class="annotation">@8⦊</span>return<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    };</span></span>
-<span class="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: @19[3]: _21 = const 0_i32
-23:9-23:22: @19[4]: FakeRead(ForLet, _21)
-24:8-24:12: @19[7]: _23 = const true"><span class="annotation">@19⦊</span>mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:25-23:26: @19[3]: _21 = const 0_i32
-23:9-23:22: @19[4]: FakeRead(ForLet, _21)
-24:8-24:12: @19[7]: _23 = const true">    if true<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="25:9-25:23: @20[0]: _21 = const 10_i32
-24:13-26:6: @20[1]: _22 = const ()"><span class="annotation">@20⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:23: @20[0]: _21 = const 10_i32
-24:13-26:6: @20[1]: _22 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:23: @20[0]: _21 = const 10_i32
-24:13-26:6: @20[1]: _22 = const ()">    }<span class="annotation">⦉@20</span></span></span><span><span class="code even" style="--layer: 1" title="26:6-26:6: @21[0]: _22 = const ()"><span class="annotation">@21⦊</span>‸<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="28:8-28:17: @22[5]: _26 = _21
-28:8-28:21: @22[6]: _25 = Gt(move _26, const 7_i32)"><span class="annotation">@22⦊</span>countdown &gt; 7<span class="annotation">⦉@22</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="29:9-29:23: @23[0]: _27 = CheckedSub(_21, const 4_i32)
-29:9-29:23: @25[0]: _21 = move (_27.0: i32)
-28:22-30:6: @25[1]: _24 = const ()"><span class="annotation">@23,25⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="29:9-29:23: @23[0]: _27 = CheckedSub(_21, const 4_i32)
-29:9-29:23: @25[0]: _21 = move (_27.0: i32)
-28:22-30:6: @25[1]: _24 = const ()">        countdown -= 4;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="29:9-29:23: @23[0]: _27 = CheckedSub(_21, const 4_i32)
-29:9-29:23: @25[0]: _21 = move (_27.0: i32)
-28:22-30:6: @25[1]: _24 = const ()">    }<span class="annotation">⦉@23,25</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code odd" style="--layer: 1" title="30:15-30:24: @24[2]: _29 = _21
-30:15-30:28: @24[3]: _28 = Gt(move _29, const 2_i32)"><span class="annotation">@24⦊</span>countdown &gt; 2<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code even" style="--layer: 1" title="31:12-31:21: @26[5]: _34 = _21
-31:12-31:25: @26[6]: _33 = Lt(move _34, const 1_i32)"><span class="annotation">@26⦊</span>countdown &lt; 1<span class="annotation">⦉@26</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="31:29-31:38: @32[2]: _36 = _21
-31:29-31:42: @32[3]: _35 = Gt(move _36, const 5_i32)"><span class="annotation">@32⦊</span>countdown &gt; 5<span class="annotation">⦉@32</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="31:46-31:55: @29[2]: _38 = _21
-31:46-31:60: @29[3]: _37 = Ne(move _38, const 9_i32)"><span class="annotation">@29⦊</span>countdown != 9<span class="annotation">⦉@29</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="32:13-32:26: @34[0]: _21 = const 0_i32
-31:61-33:10: @34[1]: _30 = const ()"><span class="annotation">@34⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="32:13-32:26: @34[0]: _21 = const 0_i32
-31:61-33:10: @34[1]: _30 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="32:13-32:26: @34[0]: _21 = const 0_i32
-31:61-33:10: @34[1]: _30 = const ()">        }<span class="annotation">⦉@34</span></span></span><span><span class="code even" style="--layer: 1" title="33:10-33:10: @35[0]: _30 = const ()"><span class="annotation">@35⦊</span>‸<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="code odd" style="--layer: 1" title="34:9-34:23: @36[2]: _39 = CheckedSub(_21, const 5_i32)
-34:9-34:23: @37[0]: _21 = move (_39.0: i32)"><span class="annotation">@36,37⦊</span>countdown -= 5<span class="annotation">⦉@36,37</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: @27[0]: _0 = const ()"><span class="annotation">@27⦊</span>return<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="line"><span class="code" style="--layer: 0">    if </span><span><span class="code odd" style="--layer: 1" title="39:8-39:12: @38[4]: _42 = const true"><span class="annotation">@38⦊</span>true<span class="annotation">⦉@38</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="40:29-40:30: @39[1]: _43 = const 0_i32
-40:13-40:26: @39[2]: FakeRead(ForLet, _43)
-41:12-41:16: @39[5]: _45 = const true"><span class="annotation">@39⦊</span>mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="40:29-40:30: @39[1]: _43 = const 0_i32
-40:13-40:26: @39[2]: FakeRead(ForLet, _43)
-41:12-41:16: @39[5]: _45 = const true">        if true<span class="annotation">⦉@39</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="42:13-42:27: @41[0]: _43 = const 10_i32
-41:17-43:10: @41[1]: _44 = const ()"><span class="annotation">@41⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="42:13-42:27: @41[0]: _43 = const 10_i32
-41:17-43:10: @41[1]: _44 = const ()">            countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="42:13-42:27: @41[0]: _43 = const 10_i32
-41:17-43:10: @41[1]: _44 = const ()">        }<span class="annotation">⦉@41</span></span></span><span><span class="code even" style="--layer: 1" title="43:10-43:10: @42[0]: _44 = const ()"><span class="annotation">@42⦊</span>‸<span class="annotation">⦉@42</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        if </span><span><span class="code odd" style="--layer: 1" title="45:12-45:21: @43[4]: _47 = _43
-45:12-45:25: @43[5]: _46 = Gt(move _47, const 7_i32)"><span class="annotation">@43⦊</span>countdown &gt; 7<span class="annotation">⦉@43</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="46:13-46:27: @44[0]: _48 = CheckedSub(_43, const 4_i32)
-46:13-46:27: @46[0]: _43 = move (_48.0: i32)
-45:26-47:10: @46[1]: _41 = const ()"><span class="annotation">@44,46⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="46:13-46:27: @44[0]: _48 = CheckedSub(_43, const 4_i32)
-46:13-46:27: @46[0]: _43 = move (_48.0: i32)
-45:26-47:10: @46[1]: _41 = const ()">            countdown -= 4;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="46:13-46:27: @44[0]: _48 = CheckedSub(_43, const 4_i32)
-46:13-46:27: @46[0]: _43 = move (_48.0: i32)
-45:26-47:10: @46[1]: _41 = const ()">        }<span class="annotation">⦉@44,46</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        else if </span><span><span class="code odd" style="--layer: 1" title="48:17-48:26: @45[2]: _50 = _43
-48:17-48:30: @45[3]: _49 = Gt(move _50, const 2_i32)"><span class="annotation">@45⦊</span>countdown &gt; 2<span class="annotation">⦉@45</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="49:16-49:25: @47[5]: _55 = _43
-49:16-49:29: @47[6]: _54 = Lt(move _55, const 1_i32)"><span class="annotation">@47⦊</span>countdown &lt; 1<span class="annotation">⦉@47</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="49:33-49:42: @53[2]: _57 = _43
-49:33-49:46: @53[3]: _56 = Gt(move _57, const 5_i32)"><span class="annotation">@53⦊</span>countdown &gt; 5<span class="annotation">⦉@53</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="49:50-49:59: @50[2]: _59 = _43
-49:50-49:64: @50[3]: _58 = Ne(move _59, const 9_i32)"><span class="annotation">@50⦊</span>countdown != 9<span class="annotation">⦉@50</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="50:17-50:30: @55[0]: _43 = const 0_i32
-49:65-51:14: @55[1]: _51 = const ()"><span class="annotation">@55⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="50:17-50:30: @55[0]: _43 = const 0_i32
-49:65-51:14: @55[1]: _51 = const ()">                countdown = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="50:17-50:30: @55[0]: _43 = const 0_i32
-49:65-51:14: @55[1]: _51 = const ()">            }<span class="annotation">⦉@55</span></span></span><span><span class="code even" style="--layer: 1" title="51:14-51:14: @56[0]: _51 = const ()"><span class="annotation">@56⦊</span>‸<span class="annotation">⦉@56</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="52:13-52:27: @57[2]: _60 = CheckedSub(_43, const 5_i32)
-52:13-52:27: @58[0]: _43 = move (_60.0: i32)"><span class="annotation">@57,58⦊</span>countdown -= 5<span class="annotation">⦉@57,58</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="54:13-54:19: @48[0]: _0 = const ()"><span class="annotation">@48⦊</span>return<span class="annotation">⦉@48</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="56:6-56:6: @40[0]: _41 = const ()"><span class="annotation">@40⦊</span>‸<span class="annotation">⦉@40</span></span></span><span class="code" style="--layer: 0"> // Note: closing brace shows uncovered (vs. `0` for implicit else) because condition literal</span></span>
-<span class="line"><span class="code" style="--layer: 0">      // `true` was const-evaluated. The compiler knows the `if` block will be executed.</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="59:25-59:26: @60[3]: _62 = const 0_i32
-59:9-59:22: @60[4]: FakeRead(ForLet, _62)
-60:8-60:12: @60[7]: _64 = const true"><span class="annotation">@60⦊</span>mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="59:25-59:26: @60[3]: _62 = const 0_i32
-59:9-59:22: @60[4]: FakeRead(ForLet, _62)
-60:8-60:12: @60[7]: _64 = const true">    if true<span class="annotation">⦉@60</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="61:9-61:22: @61[0]: _62 = const 1_i32
-60:13-62:6: @61[1]: _63 = const ()"><span class="annotation">@61⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="61:9-61:22: @61[0]: _62 = const 1_i32
-60:13-62:6: @61[1]: _63 = const ()">        countdown = 1;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="61:9-61:22: @61[0]: _62 = const 1_i32
-60:13-62:6: @61[1]: _63 = const ()">    }<span class="annotation">⦉@61</span></span></span><span><span class="code even" style="--layer: 1" title="62:6-62:6: @62[0]: _63 = const ()"><span class="annotation">@62⦊</span>‸<span class="annotation">⦉@62</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="64:9-64:10: @81[1]: FakeRead(ForLet, _65)"><span class="annotation">@81⦊</span>z<span class="annotation">⦉@81</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code even" style="--layer: 1" title="64:16-64:25: @63[5]: _67 = _62
-64:16-64:29: @63[6]: _66 = Gt(move _67, const 7_i32)"><span class="annotation">@63⦊</span>countdown &gt; 7<span class="annotation">⦉@63</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="65:9-65:23: @64[0]: _68 = CheckedSub(_62, const 4_i32)
-65:9-65:23: @66[0]: _62 = move (_68.0: i32)
-64:30-66:6: @66[1]: _65 = const ()"><span class="annotation">@64,66⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="65:9-65:23: @64[0]: _68 = CheckedSub(_62, const 4_i32)
-65:9-65:23: @66[0]: _62 = move (_68.0: i32)
-64:30-66:6: @66[1]: _65 = const ()">        countdown -= 4;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="65:9-65:23: @64[0]: _68 = CheckedSub(_62, const 4_i32)
-65:9-65:23: @66[0]: _62 = move (_68.0: i32)
-64:30-66:6: @66[1]: _65 = const ()">    }<span class="annotation">⦉@64,66</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code even" style="--layer: 1" title="66:15-66:24: @65[2]: _70 = _62
-66:15-66:28: @65[3]: _69 = Gt(move _70, const 2_i32)"><span class="annotation">@65⦊</span>countdown &gt; 2<span class="annotation">⦉@65</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="67:12-67:21: @67[5]: _75 = _62
-67:12-67:25: @67[6]: _74 = Lt(move _75, const 1_i32)"><span class="annotation">@67⦊</span>countdown &lt; 1<span class="annotation">⦉@67</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code even" style="--layer: 1" title="67:29-67:38: @73[2]: _77 = _62
-67:29-67:42: @73[3]: _76 = Gt(move _77, const 5_i32)"><span class="annotation">@73⦊</span>countdown &gt; 5<span class="annotation">⦉@73</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="67:46-67:55: @70[2]: _79 = _62
-67:46-67:60: @70[3]: _78 = Ne(move _79, const 9_i32)"><span class="annotation">@70⦊</span>countdown != 9<span class="annotation">⦉@70</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="68:13-68:26: @75[0]: _62 = const 0_i32
-67:61-69:10: @75[1]: _71 = const ()"><span class="annotation">@75⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:13-68:26: @75[0]: _62 = const 0_i32
-67:61-69:10: @75[1]: _71 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="68:13-68:26: @75[0]: _62 = const 0_i32
-67:61-69:10: @75[1]: _71 = const ()">        }<span class="annotation">⦉@75</span></span></span><span><span class="code odd" style="--layer: 1" title="69:10-69:10: @76[0]: _71 = const ()"><span class="annotation">@76⦊</span>‸<span class="annotation">⦉@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="code even" style="--layer: 1" title="70:9-70:23: @77[2]: _80 = CheckedSub(_62, const 5_i32)
-70:9-70:23: @78[0]: _62 = move (_80.0: i32)"><span class="annotation">@77,78⦊</span>countdown -= 5<span class="annotation">⦉@77,78</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 odd" style="--layer: 1" title="72:35-72:44: @68[1]: _82 = _62
-72:13-72:32: @68[2]: FakeRead(ForLet, _82)
-73:18-73:27: @68[9]: _113 = const main::promoted[1]
-73:18-73:27: @68[10]: _88 = &amp;(*_113)
-73:18-73:27: @68[11]: _87 = &amp;(*_88)
-73:18-73:27: @68[12]: _86 = move _87 as &amp;[&amp;str] (Pointer(Unsize))
-73:9-73:29: @68[18]: _94 = ()
-73:9-73:29: @68[19]: FakeRead(ForMatchedPlace, _94)
-73:9-73:29: @68[20]: _112 = const main::promoted[0]
-73:9-73:29: @68[21]: _92 = &amp;(*_112)
-73:9-73:29: @68[22]: _91 = &amp;(*_92)
-73:9-73:29: @68[23]: _90 = move _91 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-73:9-73:29: @68.Call: _85 = std::fmt::Arguments::new_v1(move _86, move _90) -&gt; [return: bb79, unwind: bb102]
-73:9-73:29: @79.Call: _84 = std::io::_print(move _85) -&gt; [return: bb80, unwind: bb102]
-73:9-73:29: @80[5]: _83 = const ()
-74:9-74:15: @80[7]: _0 = const ()"><span class="annotation">@68,79,80⦊</span>should_be_reachable = countdown;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="72:35-72:44: @68[1]: _82 = _62
-72:13-72:32: @68[2]: FakeRead(ForLet, _82)
-73:18-73:27: @68[9]: _113 = const main::promoted[1]
-73:18-73:27: @68[10]: _88 = &amp;(*_113)
-73:18-73:27: @68[11]: _87 = &amp;(*_88)
-73:18-73:27: @68[12]: _86 = move _87 as &amp;[&amp;str] (Pointer(Unsize))
-73:9-73:29: @68[18]: _94 = ()
-73:9-73:29: @68[19]: FakeRead(ForMatchedPlace, _94)
-73:9-73:29: @68[20]: _112 = const main::promoted[0]
-73:9-73:29: @68[21]: _92 = &amp;(*_112)
-73:9-73:29: @68[22]: _91 = &amp;(*_92)
-73:9-73:29: @68[23]: _90 = move _91 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-73:9-73:29: @68.Call: _85 = std::fmt::Arguments::new_v1(move _86, move _90) -&gt; [return: bb79, unwind: bb102]
-73:9-73:29: @79.Call: _84 = std::io::_print(move _85) -&gt; [return: bb80, unwind: bb102]
-73:9-73:29: @80[5]: _83 = const ()
-74:9-74:15: @80[7]: _0 = const ()">        println!("reached");</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="72:35-72:44: @68[1]: _82 = _62
-72:13-72:32: @68[2]: FakeRead(ForLet, _82)
-73:18-73:27: @68[9]: _113 = const main::promoted[1]
-73:18-73:27: @68[10]: _88 = &amp;(*_113)
-73:18-73:27: @68[11]: _87 = &amp;(*_88)
-73:18-73:27: @68[12]: _86 = move _87 as &amp;[&amp;str] (Pointer(Unsize))
-73:9-73:29: @68[18]: _94 = ()
-73:9-73:29: @68[19]: FakeRead(ForMatchedPlace, _94)
-73:9-73:29: @68[20]: _112 = const main::promoted[0]
-73:9-73:29: @68[21]: _92 = &amp;(*_112)
-73:9-73:29: @68[22]: _91 = &amp;(*_92)
-73:9-73:29: @68[23]: _90 = move _91 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-73:9-73:29: @68.Call: _85 = std::fmt::Arguments::new_v1(move _86, move _90) -&gt; [return: bb79, unwind: bb102]
-73:9-73:29: @79.Call: _84 = std::io::_print(move _85) -&gt; [return: bb80, unwind: bb102]
-73:9-73:29: @80[5]: _83 = const ()
-74:9-74:15: @80[7]: _0 = const ()">        return<span class="annotation">⦉@68,79,80</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    };</span></span>
-<span class="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:9-77:10: @97[1]: FakeRead(ForLet, _95)"><span class="annotation">@97⦊</span>w<span class="annotation">⦉@97</span></span></span><span class="code" style="--layer: 0"> = if </span><span><span class="code odd" style="--layer: 1" title="77:16-77:25: @81[5]: _97 = _62
-77:16-77:29: @81[6]: _96 = Gt(move _97, const 7_i32)"><span class="annotation">@81⦊</span>countdown &gt; 7<span class="annotation">⦉@81</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="78:9-78:23: @82[0]: _98 = CheckedSub(_62, const 4_i32)
-78:9-78:23: @84[0]: _62 = move (_98.0: i32)
-77:30-79:6: @84[1]: _95 = const ()"><span class="annotation">@82,84⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="78:9-78:23: @82[0]: _98 = CheckedSub(_62, const 4_i32)
-78:9-78:23: @84[0]: _62 = move (_98.0: i32)
-77:30-79:6: @84[1]: _95 = const ()">        countdown -= 4;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="78:9-78:23: @82[0]: _98 = CheckedSub(_62, const 4_i32)
-78:9-78:23: @84[0]: _62 = move (_98.0: i32)
-77:30-79:6: @84[1]: _95 = const ()">    }<span class="annotation">⦉@82,84</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code odd" style="--layer: 1" title="79:15-79:24: @83[2]: _100 = _62
-79:15-79:28: @83[3]: _99 = Gt(move _100, const 2_i32)"><span class="annotation">@83⦊</span>countdown &gt; 2<span class="annotation">⦉@83</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="80:12-80:21: @85[5]: _105 = _62
-80:12-80:25: @85[6]: _104 = Lt(move _105, const 1_i32)"><span class="annotation">@85⦊</span>countdown &lt; 1<span class="annotation">⦉@85</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="80:29-80:38: @91[2]: _107 = _62
-80:29-80:42: @91[3]: _106 = Gt(move _107, 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 even" style="--layer: 1" title="80:46-80:55: @88[2]: _109 = _62
-80:46-80:60: @88[3]: _108 = Ne(move _109, const 9_i32)"><span class="annotation">@88⦊</span>countdown != 9<span class="annotation">⦉@88</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="81:13-81:26: @93[0]: _62 = const 0_i32
-80:61-82:10: @93[1]: _101 = const ()"><span class="annotation">@93⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="81:13-81:26: @93[0]: _62 = const 0_i32
-80:61-82:10: @93[1]: _101 = const ()">            countdown = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="81:13-81:26: @93[0]: _62 = const 0_i32
-80:61-82:10: @93[1]: _101 = const ()">        }<span class="annotation">⦉@93</span></span></span><span><span class="code even" style="--layer: 1" title="82:10-82:10: @94[0]: _101 = const ()"><span class="annotation">@94⦊</span>‸<span class="annotation">⦉@94</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="83:9-83:23: @95[2]: _110 = CheckedSub(_62, const 5_i32)
-83:9-83:23: @96[0]: _62 = move (_110.0: i32)"><span class="annotation">@95,96⦊</span>countdown -= 5<span class="annotation">⦉@95,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="85:9-85:15: @86[0]: _0 = const ()"><span class="annotation">@86⦊</span>return<span class="annotation">⦉@86</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="87:2-87:2: @101.Return: return"><span class="annotation">@101⦊</span>‸<span class="annotation">⦉@101</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index be06ddd126da9..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,143 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>dead_code.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 26"><span class="line"><span><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1">    // 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="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1">    // 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="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1">    let is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:19-31:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-31:19-31:35: @1[0]: _3 = &amp;_4
-31:19-31:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-31:19-31:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-31:9-31:16: @2[3]: FakeRead(ForLet, _1)
-33:25-33:26: @3[2]: _5 = const 0_i32
-33:9-33:22: @3[3]: FakeRead(ForLet, _5)
-34:8-34:15: @3[5]: _6 = _1">    if 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="35:9-35:23: @4[0]: _5 = const 10_i32
-34:16-36:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-35:23: @4[0]: _5 = const 10_i32
-34:16-36:6: @4[1]: _0 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-35:23: @4[0]: _5 = const 10_i32
-34:16-36:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="36:6-36:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="37:2-37:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 7f2d8d3c8ec1e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,143 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>dead_code.unused_fn - 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 14"><span class="line"><span><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>fn unused_fn() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1">    // 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="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1">    // 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="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1">    let is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:19-19:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-19:19-19:35: @1[0]: _3 = &amp;_4
-19:19-19:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-19:19-19:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-19:9-19:16: @2[3]: FakeRead(ForLet, _1)
-21:25-21:26: @3[2]: _5 = const 0_i32
-21:9-21:22: @3[3]: FakeRead(ForLet, _5)
-22:8-22:15: @3[5]: _6 = _1">    if 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="23:9-23:23: @4[0]: _5 = const 10_i32
-22:16-24:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:9-23:23: @4[0]: _5 = const 10_i32
-22:16-24:6: @4[1]: _0 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:9-23:23: @4[0]: _5 = const 10_i32
-22:16-24:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="24:6-24:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="25:2-25:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html
deleted file mode 100644
index be44f71348c17..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,143 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>dead_code.unused_pub_fn_not_in_library - 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><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>pub fn unused_pub_fn_not_in_library() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1">    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 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-10:8-10:15: @3[5]: _6 = _1">    if 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: @4[0]: _5 = const 10_i32
-10:16-12:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @4[0]: _5 = const 10_i32
-10:16-12:6: @4[1]: _0 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @4[0]: _5 = const 10_i32
-10:16-12:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="12:6-12:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="13:2-13:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 95813decf9f6a..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,96 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>doctest.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 72"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0⦊</span>fn main() <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="74:8-74:12: @0[1]: _1 = const true"><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="75:9-75:26: @4[0]: _2 = const ()"><span class="annotation">@4⦊</span></span></span><span class="code even" style="--layer: 2" title="75:9-75:26: @3[1]: _15 = core::panicking::AssertKind::Eq
-75:9-75:26: @3[2]: FakeRead(ForLet, _15)
-75:9-75:26: @3[5]: _17 = move _15
-75:9-75:26: @3[8]: _19 = &amp;(*_8)
-75:9-75:26: @3[9]: _18 = &amp;(*_19)
-75:9-75:26: @3[12]: _21 = &amp;(*_9)
-75:9-75:26: @3[13]: _20 = &amp;(*_21)
-75:9-75:26: @3[15]: _22 = std::option::Option::&lt;std::fmt::Arguments&gt;::None
-75:9-75:26: @3.Call: core::panicking::assert_failed::&lt;i32, i32&gt;(move _17, move _18, move _20, move _22) -&gt; bb8"><span class="annotation">@3⦊</span>assert_eq!(1, 1);<span class="annotation">⦉@3</span></span><span><span class="code odd" style="--layer: 1" title="75:9-75:26: @4[0]: _2 = const ()"><span class="annotation">⦉@4</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="77:9-77:26: @6[0]: _23 = const ()"><span class="annotation">@6⦊</span></span></span><span class="code even" style="--layer: 2" title="77:9-77:26: @5[1]: _36 = core::panicking::AssertKind::Eq
-77:9-77:26: @5[2]: FakeRead(ForLet, _36)
-77:9-77:26: @5[5]: _38 = move _36
-77:9-77:26: @5[8]: _40 = &amp;(*_29)
-77:9-77:26: @5[9]: _39 = &amp;(*_40)
-77:9-77:26: @5[12]: _42 = &amp;(*_30)
-77:9-77:26: @5[13]: _41 = &amp;(*_42)
-77:9-77:26: @5[15]: _43 = std::option::Option::&lt;std::fmt::Arguments&gt;::None
-77:9-77:26: @5.Call: core::panicking::assert_failed::&lt;i32, i32&gt;(move _38, move _39, move _41, move _43) -&gt; bb8"><span class="annotation">@5⦊</span>assert_eq!(1, 2);<span class="annotation">⦉@5</span></span><span><span class="code even" style="--layer: 1" title="77:9-77:26: @6[0]: _23 = const ()"><span class="annotation">⦉@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 odd" style="--layer: 1" title="79:2-79: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/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 3a41d3482b0b9..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,113 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>doctest_crate.fn_run_in_doctests - 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 1"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0⦊</span>pub fn fn_run_in_doctests(conditional: usize) <span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">{</span></span>
-<span class="line"><span class="code" style="--layer: 0">    match </span><span><span class="code even" style="--layer: 1" title="3:11-3:22: @0[0]: FakeRead(ForMatchedPlace, _1)"><span class="annotation">@0⦊</span>conditional<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        1 =&gt; </span><span><span class="code odd" style="--layer: 1" title="4:14-4:30: @7[0]: _0 = const ()"><span class="annotation">@7⦊</span></span></span><span class="code even" style="--layer: 2" title="4:14-4:30: @6[1]: _14 = core::panicking::AssertKind::Eq
-4:14-4:30: @6[2]: FakeRead(ForLet, _14)
-4:14-4:30: @6[5]: _16 = move _14
-4:14-4:30: @6[8]: _18 = &amp;(*_7)
-4:14-4:30: @6[9]: _17 = &amp;(*_18)
-4:14-4:30: @6[12]: _20 = &amp;(*_8)
-4:14-4:30: @6[13]: _19 = &amp;(*_20)
-4:14-4:30: @6[15]: _21 = std::option::Option::&lt;std::fmt::Arguments&gt;::None
-4:14-4:30: @6.Call: core::panicking::assert_failed::&lt;i32, i32&gt;(move _16, move _17, move _19, move _21) -&gt; bb17"><span class="annotation">@6⦊</span>assert_eq!(1, 1)<span class="annotation">⦉@6</span></span><span><span class="code odd" style="--layer: 1" title="4:14-4:30: @7[0]: _0 = const ()"><span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0">, // this is run,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        2 =&gt; </span><span><span class="code even" style="--layer: 1" title="5:14-5:30: @10[0]: _0 = const ()"><span class="annotation">@10⦊</span></span></span><span class="code even" style="--layer: 2" title="5:14-5:30: @9[1]: _34 = core::panicking::AssertKind::Eq
-5:14-5:30: @9[2]: FakeRead(ForLet, _34)
-5:14-5:30: @9[5]: _36 = move _34
-5:14-5:30: @9[8]: _38 = &amp;(*_27)
-5:14-5:30: @9[9]: _37 = &amp;(*_38)
-5:14-5:30: @9[12]: _40 = &amp;(*_28)
-5:14-5:30: @9[13]: _39 = &amp;(*_40)
-5:14-5:30: @9[15]: _41 = std::option::Option::&lt;std::fmt::Arguments&gt;::None
-5:14-5:30: @9.Call: core::panicking::assert_failed::&lt;i32, i32&gt;(move _36, move _37, move _39, move _41) -&gt; bb17"><span class="annotation">@9⦊</span>assert_eq!(1, 1)<span class="annotation">⦉@9</span></span><span><span class="code even" style="--layer: 1" title="5:14-5:30: @10[0]: _0 = const ()"><span class="annotation">⦉@10</span></span></span><span class="code" style="--layer: 0">, // this,</span></span>
-<span class="line"><span class="code" style="--layer: 0">        3 =&gt; </span><span><span class="code odd" style="--layer: 1" title="6:14-6:30: @13[0]: _0 = const ()"><span class="annotation">@13⦊</span></span></span><span class="code even" style="--layer: 2" title="6:14-6:30: @12[1]: _54 = core::panicking::AssertKind::Eq
-6:14-6:30: @12[2]: FakeRead(ForLet, _54)
-6:14-6:30: @12[5]: _56 = move _54
-6:14-6:30: @12[8]: _58 = &amp;(*_47)
-6:14-6:30: @12[9]: _57 = &amp;(*_58)
-6:14-6:30: @12[12]: _60 = &amp;(*_48)
-6:14-6:30: @12[13]: _59 = &amp;(*_60)
-6:14-6:30: @12[15]: _61 = std::option::Option::&lt;std::fmt::Arguments&gt;::None
-6:14-6:30: @12.Call: core::panicking::assert_failed::&lt;i32, i32&gt;(move _56, move _57, move _59, move _61) -&gt; bb17"><span class="annotation">@12⦊</span>assert_eq!(1, 1)<span class="annotation">⦉@12</span></span><span><span class="code odd" style="--layer: 1" title="6:14-6:30: @13[0]: _0 = const ()"><span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0">, // and this too</span></span>
-<span class="line"><span class="code" style="--layer: 0">        _ =&gt; </span><span><span class="code even" style="--layer: 1" title="7:14-7:30: @15[0]: _0 = const ()"><span class="annotation">@15⦊</span></span></span><span class="code even" style="--layer: 2" title="7:14-7:30: @14[1]: _74 = core::panicking::AssertKind::Eq
-7:14-7:30: @14[2]: FakeRead(ForLet, _74)
-7:14-7:30: @14[5]: _76 = move _74
-7:14-7:30: @14[8]: _78 = &amp;(*_67)
-7:14-7:30: @14[9]: _77 = &amp;(*_78)
-7:14-7:30: @14[12]: _80 = &amp;(*_68)
-7:14-7:30: @14[13]: _79 = &amp;(*_80)
-7:14-7:30: @14[15]: _81 = std::option::Option::&lt;std::fmt::Arguments&gt;::None
-7:14-7:30: @14.Call: core::panicking::assert_failed::&lt;i32, i32&gt;(move _76, move _77, move _79, move _81) -&gt; bb17"><span class="annotation">@14⦊</span>assert_eq!(1, 2)<span class="annotation">⦉@14</span></span><span><span class="code even" style="--layer: 1" title="7:14-7:30: @15[0]: _0 = const ()"><span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0">, // however this is not</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="9:2-9:2: @16.Return: return"><span class="annotation">@16⦊</span>‸<span class="annotation">⦉@16</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 66a6e776a0622..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,152 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><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)
-19:8-19:12: @0[8]: _4 = const true"><span class="annotation">@0⦊</span>fn main() -&gt; Result&lt;(),u8&gt; {</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)
-19:8-19:12: @0[8]: _4 = const true">    let _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)
-19:8-19:12: @0[8]: _4 = const true"></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)
-19:8-19:12: @0[8]: _4 = const true">    let _tnt = Firework { strength: 100 };</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)
-19:8-19:12: @0[8]: _4 = const true"></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)
-19:8-19:12: @0[8]: _4 = const true">    if 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: @1[6]: _21 = const main::promoted[1]
-20:18-20:41: @1[7]: _11 = &amp;(*_21)
-20:18-20:41: @1[8]: _10 = &amp;(*_11)
-20:18-20:41: @1[9]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
-20:9-20:43: @1[15]: _17 = ()
-20:9-20:43: @1[16]: FakeRead(ForMatchedPlace, _17)
-20:9-20:43: @1[17]: _20 = const main::promoted[0]
-20:9-20:43: @1[18]: _15 = &amp;(*_20)
-20:9-20:43: @1[19]: _14 = &amp;(*_15)
-20:9-20:43: @1[20]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-20:9-20:43: @1.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb11]
-20:9-20:43: @3.Call: _7 = std::io::_print(move _8) -&gt; [return: bb4, unwind: bb11]
-20:9-20:43: @4[5]: _6 = const ()
-21:16-21:22: @4[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@1,3,4,8,9⦊</span>println!("Exiting with error...");</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="20:18-20:41: @1[6]: _21 = const main::promoted[1]
-20:18-20:41: @1[7]: _11 = &amp;(*_21)
-20:18-20:41: @1[8]: _10 = &amp;(*_11)
-20:18-20:41: @1[9]: _9 = move _10 as &amp;[&amp;str] (Pointer(Unsize))
-20:9-20:43: @1[15]: _17 = ()
-20:9-20:43: @1[16]: FakeRead(ForMatchedPlace, _17)
-20:9-20:43: @1[17]: _20 = const main::promoted[0]
-20:9-20:43: @1[18]: _15 = &amp;(*_20)
-20:9-20:43: @1[19]: _14 = &amp;(*_15)
-20:9-20:43: @1[20]: _13 = move _14 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-20:9-20:43: @1.Call: _8 = std::fmt::Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb11]
-20:9-20:43: @3.Call: _7 = std::io::_print(move _8) -&gt; [return: bb4, unwind: bb11]
-20:9-20:43: @4[5]: _6 = const ()
-21:16-21:22: @4[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)">        return Err(1)<span class="annotation">⦉@1,3,4,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="code even" style="--layer: 1" title="22:6-22:6: @2[0]: _3 = const ()
-24:13-24:40: @2[4]: _18 = Firework { strength: const 1000_i32 }
-26:8-26:10: @5[2]: _19 = ()
-26:5-26:11: @5[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _19)"><span class="annotation">@2,5,6,7⦊</span></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:6-22:6: @2[0]: _3 = const ()
-24:13-24:40: @2[4]: _18 = Firework { strength: const 1000_i32 }
-26:8-26:10: @5[2]: _19 = ()
-26:5-26:11: @5[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _19)"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:6-22:6: @2[0]: _3 = const ()
-24:13-24:40: @2[4]: _18 = Firework { strength: const 1000_i32 }
-26:8-26:10: @5[2]: _19 = ()
-26:5-26:11: @5[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _19)">    let _ = Firework { strength: 1000 };</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:6-22:6: @2[0]: _3 = const ()
-24:13-24:40: @2[4]: _18 = Firework { strength: const 1000_i32 }
-26:8-26:10: @5[2]: _19 = ()
-26:5-26:11: @5[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _19)"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:6-22:6: @2[0]: _3 = const ()
-24:13-24:40: @2[4]: _18 = Firework { strength: const 1000_i32 }
-26:8-26:10: @5[2]: _19 = ()
-26:5-26:11: @5[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _19)">    Ok(())<span class="annotation">⦉@2,5,6,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="27:2-27:2: @10.Return: return"><span class="annotation">@10⦊</span>‸<span class="annotation">⦉@10</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 57d56c5cf7369..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.%7Bimpl%230%7D-drop.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as std::ops::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-10:9-10:53: @2.Call: _3 = std::io::_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>fn drop(&amp;mut self) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:18-10:36: @0[6]: _19 = const &lt;Firework as std::ops::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-10:9-10:53: @2.Call: _3 = std::io::_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 std::ops::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-10:9-10:53: @2.Call: _3 = std::io::_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/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 098c140425160..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,237 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true"><span class="annotation">@0,1,2,3⦊</span>fn main() -&gt; Result&lt;(),u8&gt; {</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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true">    let 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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true">    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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true"></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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true">    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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true">    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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true">    tnt.set_strength(300.3);</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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true"></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: bb15]
-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: bb14]
-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: bb14]
-30:8-30:12: @3[4]: _10 = const true">    if 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: @4[6]: _27 = const main::promoted[1]
-31:18-31:41: @4[7]: _17 = &amp;(*_27)
-31:18-31:41: @4[8]: _16 = &amp;(*_17)
-31:18-31:41: @4[9]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
-31:9-31:43: @4[15]: _23 = ()
-31:9-31:43: @4[16]: FakeRead(ForMatchedPlace, _23)
-31:9-31:43: @4[17]: _26 = const main::promoted[0]
-31:9-31:43: @4[18]: _21 = &amp;(*_26)
-31:9-31:43: @4[19]: _20 = &amp;(*_21)
-31:9-31:43: @4[20]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-31:9-31:43: @4.Call: _14 = std::fmt::Arguments::new_v1(move _15, move _19) -&gt; [return: bb6, unwind: bb14]
-31:9-31:43: @6.Call: _13 = std::io::_print(move _14) -&gt; [return: bb7, unwind: bb14]
-31:9-31:43: @7[5]: _12 = const ()
-32:16-32:22: @7[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@4,6,7,11,12⦊</span>println!("Exiting with error...");</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="31:18-31:41: @4[6]: _27 = const main::promoted[1]
-31:18-31:41: @4[7]: _17 = &amp;(*_27)
-31:18-31:41: @4[8]: _16 = &amp;(*_17)
-31:18-31:41: @4[9]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
-31:9-31:43: @4[15]: _23 = ()
-31:9-31:43: @4[16]: FakeRead(ForMatchedPlace, _23)
-31:9-31:43: @4[17]: _26 = const main::promoted[0]
-31:9-31:43: @4[18]: _21 = &amp;(*_26)
-31:9-31:43: @4[19]: _20 = &amp;(*_21)
-31:9-31:43: @4[20]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-31:9-31:43: @4.Call: _14 = std::fmt::Arguments::new_v1(move _15, move _19) -&gt; [return: bb6, unwind: bb14]
-31:9-31:43: @6.Call: _13 = std::io::_print(move _14) -&gt; [return: bb7, unwind: bb14]
-31:9-31:43: @7[5]: _12 = const ()
-32:16-32:22: @7[7]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)">        return Err(1)<span class="annotation">⦉@4,6,7,11,12</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)"><span class="annotation">@5,8,9,10⦊</span> // The remaining lines below have no coverage because `if true` (with the constant literal</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">      // `true`) is guaranteed to execute the `then` block, which is also guaranteed to `return`.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">      // Thankfully, in the normal case, conditions are not guaranteed ahead of time, and as shown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">      // in other tests, the lines below would have coverage (which would show they had `0`</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">      // executions, assuming the condition still evaluated to `true`).</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">    let _ = Firework { strength: 1000 };</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:6-33:6: @5[0]: _9 = const ()
-39:13-39:40: @5[4]: _24 = Firework::&lt;i32&gt; { strength: const 1000_i32 }
-41:8-41:10: @8[2]: _25 = ()
-41:5-41:11: @8[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _25)">    Ok(())<span class="annotation">⦉@5,8,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="code odd" style="--layer: 1" title="42:2-42:2: @13.Return: return"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 329641d47bdbc..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,85 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.%7Bimpl%230%7D-set_strength.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>generics.{impl#0}-set_strength - 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 9"><span class="line">    <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>fn set_strength(&amp;mut self, new_strength: T) {</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/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4908bc7b4a772..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.%7Bimpl%231%7D-drop.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="18:18-18:36: @0[6]: _19 = const &lt;Firework&lt;T&gt; as std::ops::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-18:9-18:53: @2.Call: _3 = std::io::_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>fn drop(&amp;mut self) {</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 std::ops::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-18:9-18:53: @2.Call: _3 = std::io::_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 std::ops::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-18:9-18:53: @2.Call: _3 = std::io::_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/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index d6eccf57846ef..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,238 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    // 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="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    // 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="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    let</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    is_true</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">        std::env::args().len()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    ==</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">        1</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    let</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">        mut</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">        0</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">    if</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:9-10:25: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-10:9-10:25: @1[0]: _3 = &amp;_4
-10:9-10:31: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-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)
-21:9-21:16: @3[5]: _6 = _1">        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: @4[0]: _5 = const 10_i32
-22:5-27:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @4[0]: _5 = const 10_i32
-22:5-27:6: @4[1]: _0 = const ()">        countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @4[0]: _5 = const 10_i32
-22:5-27:6: @4[1]: _0 = const ()">        =</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @4[0]: _5 = const 10_i32
-22:5-27:6: @4[1]: _0 = const ()">            10</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @4[0]: _5 = const 10_i32
-22:5-27:6: @4[1]: _0 = const ()">        ;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:9-25:15: @4[0]: _5 = const 10_i32
-22:5-27:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="27:6-27:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="28:2-28:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index e0f0ac4020594..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,195 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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">    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 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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">    if</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb11]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb10]
-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">        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: @4[0]: _5 = const 10_i32
-12:5-17:6: @4[1]: _6 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @4[0]: _5 = const 10_i32
-12:5-17:6: @4[1]: _6 = const ()">        countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @4[0]: _5 = const 10_i32
-12:5-17:6: @4[1]: _6 = const ()">        =</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @4[0]: _5 = const 10_i32
-12:5-17:6: @4[1]: _6 = const ()">            10</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @4[0]: _5 = const 10_i32
-12:5-17:6: @4[1]: _6 = const ()">        ;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="13:9-15:15: @4[0]: _5 = const 10_i32
-12:5-17:6: @4[1]: _6 = const ()">    }<span class="annotation">⦉@4</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: @6[3]: _8 = _1"><span class="annotation">@6⦊</span>is_true<span class="annotation">⦉@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:9-30:15: @7[0]: _5 = const 10_i32
-27:5-32:6: @7[1]: _0 = const ()"><span class="annotation">@7⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @7[0]: _5 = const 10_i32
-27:5-32:6: @7[1]: _0 = const ()">        countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @7[0]: _5 = const 10_i32
-27:5-32:6: @7[1]: _0 = const ()">        =</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @7[0]: _5 = const 10_i32
-27:5-32:6: @7[1]: _0 = const ()">            10</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @7[0]: _5 = const 10_i32
-27:5-32:6: @7[1]: _0 = const ()">        ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="28:9-30:15: @7[0]: _5 = const 10_i32
-27:5-32:6: @7[1]: _0 = const ()">    }<span class="annotation">⦉@7</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: @8[0]: _5 = const 100_i32
-34:5-39:6: @8[1]: _0 = const ()"><span class="annotation">@8⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @8[0]: _5 = const 100_i32
-34:5-39:6: @8[1]: _0 = const ()">        countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @8[0]: _5 = const 100_i32
-34:5-39:6: @8[1]: _0 = const ()">        =</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @8[0]: _5 = const 100_i32
-34:5-39:6: @8[1]: _0 = const ()">            100</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @8[0]: _5 = const 100_i32
-34:5-39:6: @8[1]: _0 = const ()">        ;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="35:9-37:16: @8[0]: _5 = const 100_i32
-34:5-39:6: @8[1]: _0 = const ()">    }<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code even" style="--layer: 1" title="40:2-40:2: @9.Return: return"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.display.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.display.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 6287516636ea9..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.display.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,161 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.display.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>inline.display - 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 40"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>fn display&lt;T: Display&gt;(xs: &amp;[T]) <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">    for </span><span><span class="code odd" style="--layer: 1" title="42:9-42:10: @8[1]: _13 = ((_9 as Some).0: &amp;T)
-42:9-42:10: @8[3]: _14 = _13
-42:9-42:10: @8[4]: _7 = move _14
-42:9-42:10: @8[5]: _8 = const ()
-42:9-42:10: @8[13]: FakeRead(ForLet, _16)"><span class="annotation">@6,8,9,10,11⦊</span>x<span class="annotation">⦉@6,8,9,10,11</span></span></span><span class="code" style="--layer: 0"> in </span><span><span class="code odd" style="--layer: 1" title="42:14-42:16: @8[12]: _16 = _7
-43:16-43:20: @8[20]: _47 = const display::&lt;T&gt;::promoted[2]
-43:16-43:20: @8[21]: _22 = &amp;(*_47)
-43:16-43:20: @8[22]: _21 = &amp;(*_22)
-43:16-43:20: @8[23]: _20 = move _21 as &amp;[&amp;str] (Pointer(Unsize))
-43:22-43:23: @8[31]: _29 = &amp;_16
-43:9-43:25: @8[32]: _28 = (move _29,)
-43:9-43:25: @8[34]: FakeRead(ForMatchedPlace, _28)
-43:9-43:25: @8[36]: _30 = (_28.0: &amp;&amp;T)
-43:9-43:25: @8[39]: _32 = &amp;(*_30)
-43:9-43:25: @8[41]: _33 = &lt;&amp;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r &amp;T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-43:9-43:25: @8.Call: _31 = std::fmt::ArgumentV1::new::&lt;&amp;T&gt;(move _32, move _33) -&gt; [return: bb9, unwind: bb14]
-43:9-43:25: @9[2]: _27 = [move _31]
-43:9-43:25: @9[5]: _26 = &amp;_27
-43:9-43:25: @9[6]: _25 = &amp;(*_26)
-43:9-43:25: @9[7]: _24 = move _25 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-43:9-43:25: @9.Call: _19 = std::fmt::Arguments::new_v1(move _20, move _24) -&gt; [return: bb10, unwind: bb14]
-43:9-43:25: @10.Call: _18 = std::io::_print(move _19) -&gt; [return: bb11, unwind: bb14]
-42:17-44:6: @11[6]: _17 = const ()"><span class="annotation">@6,8,9,10,11⦊</span>xs {</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="42:14-42:16: @8[12]: _16 = _7
-43:16-43:20: @8[20]: _47 = const display::&lt;T&gt;::promoted[2]
-43:16-43:20: @8[21]: _22 = &amp;(*_47)
-43:16-43:20: @8[22]: _21 = &amp;(*_22)
-43:16-43:20: @8[23]: _20 = move _21 as &amp;[&amp;str] (Pointer(Unsize))
-43:22-43:23: @8[31]: _29 = &amp;_16
-43:9-43:25: @8[32]: _28 = (move _29,)
-43:9-43:25: @8[34]: FakeRead(ForMatchedPlace, _28)
-43:9-43:25: @8[36]: _30 = (_28.0: &amp;&amp;T)
-43:9-43:25: @8[39]: _32 = &amp;(*_30)
-43:9-43:25: @8[41]: _33 = &lt;&amp;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r &amp;T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-43:9-43:25: @8.Call: _31 = std::fmt::ArgumentV1::new::&lt;&amp;T&gt;(move _32, move _33) -&gt; [return: bb9, unwind: bb14]
-43:9-43:25: @9[2]: _27 = [move _31]
-43:9-43:25: @9[5]: _26 = &amp;_27
-43:9-43:25: @9[6]: _25 = &amp;(*_26)
-43:9-43:25: @9[7]: _24 = move _25 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-43:9-43:25: @9.Call: _19 = std::fmt::Arguments::new_v1(move _20, move _24) -&gt; [return: bb10, unwind: bb14]
-43:9-43:25: @10.Call: _18 = std::io::_print(move _19) -&gt; [return: bb11, unwind: bb14]
-42:17-44:6: @11[6]: _17 = const ()">        print!("{}", x);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="42:14-42:16: @8[12]: _16 = _7
-43:16-43:20: @8[20]: _47 = const display::&lt;T&gt;::promoted[2]
-43:16-43:20: @8[21]: _22 = &amp;(*_47)
-43:16-43:20: @8[22]: _21 = &amp;(*_22)
-43:16-43:20: @8[23]: _20 = move _21 as &amp;[&amp;str] (Pointer(Unsize))
-43:22-43:23: @8[31]: _29 = &amp;_16
-43:9-43:25: @8[32]: _28 = (move _29,)
-43:9-43:25: @8[34]: FakeRead(ForMatchedPlace, _28)
-43:9-43:25: @8[36]: _30 = (_28.0: &amp;&amp;T)
-43:9-43:25: @8[39]: _32 = &amp;(*_30)
-43:9-43:25: @8[41]: _33 = &lt;&amp;T as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r &amp;T, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-43:9-43:25: @8.Call: _31 = std::fmt::ArgumentV1::new::&lt;&amp;T&gt;(move _32, move _33) -&gt; [return: bb9, unwind: bb14]
-43:9-43:25: @9[2]: _27 = [move _31]
-43:9-43:25: @9[5]: _26 = &amp;_27
-43:9-43:25: @9[6]: _25 = &amp;(*_26)
-43:9-43:25: @9[7]: _24 = move _25 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-43:9-43:25: @9.Call: _19 = std::fmt::Arguments::new_v1(move _20, move _24) -&gt; [return: bb10, unwind: bb14]
-43:9-43:25: @10.Call: _18 = std::io::_print(move _19) -&gt; [return: bb11, unwind: bb14]
-42:17-44:6: @11[6]: _17 = const ()">    }<span class="annotation">⦉@6,8,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 even" style="--layer: 1" title="45:5-45:16: @5[13]: _46 = const display::&lt;T&gt;::promoted[1]
-45:5-45:16: @5[14]: _38 = &amp;(*_46)
-45:5-45:16: @5[15]: _37 = &amp;(*_38)
-45:5-45:16: @5[16]: _36 = move _37 as &amp;[&amp;str] (Pointer(Unsize))
-45:5-45:16: @5[22]: _44 = ()
-45:5-45:16: @5[23]: FakeRead(ForMatchedPlace, _44)
-45:5-45:16: @5[24]: _45 = const display::&lt;T&gt;::promoted[0]
-45:5-45:16: @5[25]: _42 = &amp;(*_45)
-45:5-45:16: @5[26]: _41 = &amp;(*_42)
-45:5-45:16: @5[27]: _40 = move _41 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-45:5-45:16: @5.Call: _35 = std::fmt::Arguments::new_v1(move _36, move _40) -&gt; [return: bb12, unwind: bb14]
-45:5-45:16: @12.Call: _34 = std::io::_print(move _35) -&gt; [return: bb13, unwind: bb14]
-46:2-46:2: @13.Return: return"><span class="annotation">@5,12,13⦊</span>println!();</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="45:5-45:16: @5[13]: _46 = const display::&lt;T&gt;::promoted[1]
-45:5-45:16: @5[14]: _38 = &amp;(*_46)
-45:5-45:16: @5[15]: _37 = &amp;(*_38)
-45:5-45:16: @5[16]: _36 = move _37 as &amp;[&amp;str] (Pointer(Unsize))
-45:5-45:16: @5[22]: _44 = ()
-45:5-45:16: @5[23]: FakeRead(ForMatchedPlace, _44)
-45:5-45:16: @5[24]: _45 = const display::&lt;T&gt;::promoted[0]
-45:5-45:16: @5[25]: _42 = &amp;(*_45)
-45:5-45:16: @5[26]: _41 = &amp;(*_42)
-45:5-45:16: @5[27]: _40 = move _41 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-45:5-45:16: @5.Call: _35 = std::fmt::Arguments::new_v1(move _36, move _40) -&gt; [return: bb12, unwind: bb14]
-45:5-45:16: @12.Call: _34 = std::io::_print(move _35) -&gt; [return: bb13, unwind: bb14]
-46:2-46:2: @13.Return: return">}<span class="annotation">⦉@5,12,13</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.error.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.error.-------.InstrumentCoverage.0.html
deleted file mode 100644
index bbf19c3e446f9..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.error.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,79 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.error.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>inline.error - 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 48"><span class="line"><span><span class="code even" style="--layer: 1" title="50:5-50:21: @0.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;error&quot;) -&gt; bb1
-49:12-51:2: @1.Resume: resume"><span class="annotation">@0,1⦊</span>fn error() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="50:5-50:21: @0.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;error&quot;) -&gt; bb1
-49:12-51:2: @1.Resume: resume">    panic!("error");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="50:5-50:21: @0.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;error&quot;) -&gt; bb1
-49:12-51:2: @1.Resume: resume">}<span class="annotation">⦉@0,1</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.length.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.length.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 8e8efb6d9f6b1..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.length.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.length.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>inline.length - 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 29"><span class="line"><span><span class="code even" style="--layer: 1" title="31:5-31:7: @0[1]: _2 = &amp;(*_1)
-31:5-31:13: @0.Call: _0 = core::slice::&lt;impl [T]&gt;::len(move _2) -&gt; [return: bb1, unwind: bb2]
-32:2-32:2: @1.Return: return"><span class="annotation">@0,1⦊</span>fn length&lt;T&gt;(xs: &amp;[T]) -&gt; usize {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:5-31:7: @0[1]: _2 = &amp;(*_1)
-31:5-31:13: @0.Call: _0 = core::slice::&lt;impl [T]&gt;::len(move _2) -&gt; [return: bb1, unwind: bb2]
-32:2-32:2: @1.Return: return">    xs.len()</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:5-31:7: @0[1]: _2 = &amp;(*_1)
-31:5-31:13: @0.Call: _0 = core::slice::&lt;impl [T]&gt;::len(move _2) -&gt; [return: bb1, unwind: bb2]
-32:2-32: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/expected_mir_dump.inline/inline.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4ec2e9beede30..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,94 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>inline.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 4"><span class="line"><span><span class="code even" style="--layer: 1" title="6:18-6:34: @0[4]: _6 = const main::promoted[0]
-6:18-6:34: @0[5]: _4 = &amp;(*_6)
-6:18-6:34: @0[6]: _3 = &amp;(*_4)
-6:18-6:34: @0[7]: _2 = move _3 as &amp;[char] (Pointer(Unsize))
-6:5-6:35: @0.Call: _1 = permutations::&lt;char&gt;(move _2) -&gt; [return: bb1, unwind: bb2]
-5:11-7:2: @1[3]: _0 = const ()
-7:2-7:2: @1.Return: return"><span class="annotation">@0,1⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:18-6:34: @0[4]: _6 = const main::promoted[0]
-6:18-6:34: @0[5]: _4 = &amp;(*_6)
-6:18-6:34: @0[6]: _3 = &amp;(*_4)
-6:18-6:34: @0[7]: _2 = move _3 as &amp;[char] (Pointer(Unsize))
-6:5-6:35: @0.Call: _1 = permutations::&lt;char&gt;(move _2) -&gt; [return: bb1, unwind: bb2]
-5:11-7:2: @1[3]: _0 = const ()
-7:2-7:2: @1.Return: return">    permutations(&amp;['a', 'b', 'c']);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:18-6:34: @0[4]: _6 = const main::promoted[0]
-6:18-6:34: @0[5]: _4 = &amp;(*_6)
-6:18-6:34: @0[6]: _3 = &amp;(*_4)
-6:18-6:34: @0[7]: _2 = move _3 as &amp;[char] (Pointer(Unsize))
-6:5-6:35: @0.Call: _1 = permutations::&lt;char&gt;(move _2) -&gt; [return: bb1, unwind: bb2]
-5:11-7:2: @1[3]: _0 = const ()
-7:2-7: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/expected_mir_dump.inline/inline.permutate.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutate.-------.InstrumentCoverage.0.html
deleted file mode 100644
index fd72973ccd076..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutate.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,183 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutate.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>inline.permutate - 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 14"><span class="line"><span><span class="code even" style="--layer: 1" title="16:20-16:22: @0[2]: _4 = &amp;(*_1)
-16:13-16:23: @0.Call: _3 = length::&lt;T&gt;(move _4) -&gt; [return: bb1, unwind: bb22]
-16:9-16:10: @1[1]: FakeRead(ForLet, _3)
-17:8-17:9: @1[4]: _6 = _2
-17:13-17:14: @1[6]: _7 = _3
-17:8-17:14: @1[7]: _5 = Eq(move _6, move _7)"><span class="annotation">@0,1⦊</span>fn permutate&lt;T: Copy + Display&gt;(xs: &amp;mut [T], k: usize) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="16:20-16:22: @0[2]: _4 = &amp;(*_1)
-16:13-16:23: @0.Call: _3 = length::&lt;T&gt;(move _4) -&gt; [return: bb1, unwind: bb22]
-16:9-16:10: @1[1]: FakeRead(ForLet, _3)
-17:8-17:9: @1[4]: _6 = _2
-17:13-17:14: @1[6]: _7 = _3
-17:8-17:14: @1[7]: _5 = Eq(move _6, move _7)">    let n = length(xs);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="16:20-16:22: @0[2]: _4 = &amp;(*_1)
-16:13-16:23: @0.Call: _3 = length::&lt;T&gt;(move _4) -&gt; [return: bb1, unwind: bb22]
-16:9-16:10: @1[1]: FakeRead(ForLet, _3)
-17:8-17:9: @1[4]: _6 = _2
-17:13-17:14: @1[6]: _7 = _3
-17:8-17:14: @1[7]: _5 = Eq(move _6, move _7)">    if k == n<span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="18:17-18:19: @2[2]: _9 = &amp;(*_1)
-18:9-18:20: @2.Call: _8 = display::&lt;T&gt;(move _9) -&gt; [return: bb4, unwind: bb22]
-17:15-19:6: @4[2]: _0 = const ()"><span class="annotation">@2,4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="18:17-18:19: @2[2]: _9 = &amp;(*_1)
-18:9-18:20: @2.Call: _8 = display::&lt;T&gt;(move _9) -&gt; [return: bb4, unwind: bb22]
-17:15-19:6: @4[2]: _0 = const ()">        display(xs);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="18:17-18:19: @2[2]: _9 = &amp;(*_1)
-18:9-18:20: @2.Call: _8 = display::&lt;T&gt;(move _9) -&gt; [return: bb4, unwind: bb22]
-17:15-19:6: @4[2]: _0 = const ()">    }<span class="annotation">⦉@2,4</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code even" style="--layer: 1" title="19:15-19:16: @3[2]: _11 = _2
-19:19-19:20: @3[4]: _12 = _3
-19:15-19:20: @3[5]: _10 = Lt(move _11, move _12)"><span class="annotation">@3⦊</span>k &lt; n<span class="annotation">⦉@3</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        for </span><span><span class="code odd" style="--layer: 1" title="20:13-20:14: @14[1]: _25 = ((_21 as Some).0: usize)
-20:13-20:14: @14[3]: _26 = _25
-20:13-20:14: @14[4]: _19 = move _26
-20:13-20:14: @14[5]: _20 = const ()
-20:13-20:14: @14[13]: FakeRead(ForLet, _28)"><span class="annotation">@12,14,15,16,17,18⦊</span>i<span class="annotation">⦉@12,14,15,16,17,18</span></span></span><span class="code" style="--layer: 0"> in </span><span><span class="code even" style="--layer: 1" title="20:18-20:19: @5[3]: _15 = _2
-20:21-20:22: @5[5]: _16 = _3"><span class="annotation">@5,7⦊</span>k..n<span class="annotation">⦉@5,7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="21:18-21:20: @14[17]: _31 = &amp;mut (*_1)
-21:22-21:23: @14[19]: _32 = _28
-21:25-21:26: @14[21]: _33 = _2
-21:13-21:27: @14.Call: _30 = swap::&lt;T&gt;(move _31, move _32, move _33) -&gt; [return: bb15, unwind: bb22]
-22:23-22:25: @15[6]: _35 = &amp;mut (*_1)
-22:27-22:28: @15[9]: _37 = _2
-22:27-22:32: @15[10]: _38 = CheckedAdd(_37, const 1_usize)
-22:27-22:32: @16[0]: _36 = move (_38.0: usize)
-22:13-22:33: @16.Call: _34 = permutate::&lt;T&gt;(move _35, move _36) -&gt; [return: bb17, unwind: bb22]
-23:18-23:20: @17[5]: _40 = &amp;mut (*_1)
-23:22-23:23: @17[7]: _41 = _28
-23:25-23:26: @17[9]: _42 = _2
-23:13-23:27: @17.Call: _39 = swap::&lt;T&gt;(move _40, move _41, move _42) -&gt; [return: bb18, unwind: bb22]
-20:23-24:10: @18[4]: _29 = const ()"><span class="annotation">@12,14,15,16,17,18⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="21:18-21:20: @14[17]: _31 = &amp;mut (*_1)
-21:22-21:23: @14[19]: _32 = _28
-21:25-21:26: @14[21]: _33 = _2
-21:13-21:27: @14.Call: _30 = swap::&lt;T&gt;(move _31, move _32, move _33) -&gt; [return: bb15, unwind: bb22]
-22:23-22:25: @15[6]: _35 = &amp;mut (*_1)
-22:27-22:28: @15[9]: _37 = _2
-22:27-22:32: @15[10]: _38 = CheckedAdd(_37, const 1_usize)
-22:27-22:32: @16[0]: _36 = move (_38.0: usize)
-22:13-22:33: @16.Call: _34 = permutate::&lt;T&gt;(move _35, move _36) -&gt; [return: bb17, unwind: bb22]
-23:18-23:20: @17[5]: _40 = &amp;mut (*_1)
-23:22-23:23: @17[7]: _41 = _28
-23:25-23:26: @17[9]: _42 = _2
-23:13-23:27: @17.Call: _39 = swap::&lt;T&gt;(move _40, move _41, move _42) -&gt; [return: bb18, unwind: bb22]
-20:23-24:10: @18[4]: _29 = const ()">            swap(xs, i, k);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="21:18-21:20: @14[17]: _31 = &amp;mut (*_1)
-21:22-21:23: @14[19]: _32 = _28
-21:25-21:26: @14[21]: _33 = _2
-21:13-21:27: @14.Call: _30 = swap::&lt;T&gt;(move _31, move _32, move _33) -&gt; [return: bb15, unwind: bb22]
-22:23-22:25: @15[6]: _35 = &amp;mut (*_1)
-22:27-22:28: @15[9]: _37 = _2
-22:27-22:32: @15[10]: _38 = CheckedAdd(_37, const 1_usize)
-22:27-22:32: @16[0]: _36 = move (_38.0: usize)
-22:13-22:33: @16.Call: _34 = permutate::&lt;T&gt;(move _35, move _36) -&gt; [return: bb17, unwind: bb22]
-23:18-23:20: @17[5]: _40 = &amp;mut (*_1)
-23:22-23:23: @17[7]: _41 = _28
-23:25-23:26: @17[9]: _42 = _2
-23:13-23:27: @17.Call: _39 = swap::&lt;T&gt;(move _40, move _41, move _42) -&gt; [return: bb18, unwind: bb22]
-20:23-24:10: @18[4]: _29 = const ()">            permutate(xs, k + 1);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="21:18-21:20: @14[17]: _31 = &amp;mut (*_1)
-21:22-21:23: @14[19]: _32 = _28
-21:25-21:26: @14[21]: _33 = _2
-21:13-21:27: @14.Call: _30 = swap::&lt;T&gt;(move _31, move _32, move _33) -&gt; [return: bb15, unwind: bb22]
-22:23-22:25: @15[6]: _35 = &amp;mut (*_1)
-22:27-22:28: @15[9]: _37 = _2
-22:27-22:32: @15[10]: _38 = CheckedAdd(_37, const 1_usize)
-22:27-22:32: @16[0]: _36 = move (_38.0: usize)
-22:13-22:33: @16.Call: _34 = permutate::&lt;T&gt;(move _35, move _36) -&gt; [return: bb17, unwind: bb22]
-23:18-23:20: @17[5]: _40 = &amp;mut (*_1)
-23:22-23:23: @17[7]: _41 = _28
-23:25-23:26: @17[9]: _42 = _2
-23:13-23:27: @17.Call: _39 = swap::&lt;T&gt;(move _40, move _41, move _42) -&gt; [return: bb18, unwind: bb22]
-20:23-24:10: @18[4]: _29 = const ()">            swap(xs, i, k);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="21:18-21:20: @14[17]: _31 = &amp;mut (*_1)
-21:22-21:23: @14[19]: _32 = _28
-21:25-21:26: @14[21]: _33 = _2
-21:13-21:27: @14.Call: _30 = swap::&lt;T&gt;(move _31, move _32, move _33) -&gt; [return: bb15, unwind: bb22]
-22:23-22:25: @15[6]: _35 = &amp;mut (*_1)
-22:27-22:28: @15[9]: _37 = _2
-22:27-22:32: @15[10]: _38 = CheckedAdd(_37, const 1_usize)
-22:27-22:32: @16[0]: _36 = move (_38.0: usize)
-22:13-22:33: @16.Call: _34 = permutate::&lt;T&gt;(move _35, move _36) -&gt; [return: bb17, unwind: bb22]
-23:18-23:20: @17[5]: _40 = &amp;mut (*_1)
-23:22-23:23: @17[7]: _41 = _28
-23:25-23:26: @17[9]: _42 = _2
-23:13-23:27: @17.Call: _39 = swap::&lt;T&gt;(move _40, move _41, move _42) -&gt; [return: bb18, unwind: bb22]
-20:23-24:10: @18[4]: _29 = const ()">        }<span class="annotation">⦉@12,14,15,16,17,18</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else </span><span><span class="code even" style="--layer: 1" title="26:9-26:16: @6.Call: _43 = error() -&gt; [return: bb19, unwind: bb22]
-25:12-27:6: @19[1]: _0 = const ()"><span class="annotation">@6,19⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="26:9-26:16: @6.Call: _43 = error() -&gt; [return: bb19, unwind: bb22]
-25:12-27:6: @19[1]: _0 = const ()">        error();</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="26:9-26:16: @6.Call: _43 = error() -&gt; [return: bb19, unwind: bb22]
-25:12-27:6: @19[1]: _0 = const ()">    }<span class="annotation">⦉@6,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="code odd" style="--layer: 1" title="28:2-28:2: @21.Return: return"><span class="annotation">@21⦊</span>‸<span class="annotation">⦉@21</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutations.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutations.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4bfd22f3cd903..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutations.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,113 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutations.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>inline.permutations - 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 9"><span class="line"><span><span class="code even" style="--layer: 1" title="11:18-11:20: @0[2]: _3 = &amp;(*_1)
-11:18-11:31: @0.Call: _2 = &lt;[T] as std::borrow::ToOwned&gt;::to_owned(move _3) -&gt; [return: bb1, unwind: bb6]
-11:9-11:15: @1[1]: FakeRead(ForLet, _2)
-12:15-12:22: @1[7]: _8 = &amp;mut _2
-12:15-12:22: @1[8]: _7 = &amp;mut (*_8)
-12:15-12:22: @1.Call: _6 = &lt;std::vec::Vec&lt;T&gt; as std::ops::DerefMut&gt;::deref_mut(move _7) -&gt; [return: bb2, unwind: bb5]
-12:15-12:22: @2[0]: _5 = &amp;mut (*_6)
-12:5-12:26: @2.Call: _4 = permutate::&lt;T&gt;(move _5, const 0_usize) -&gt; [return: bb3, unwind: bb5]
-10:46-13:2: @3[4]: _0 = const ()
-13:2-13:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>fn permutations&lt;T: Copy + Display&gt;(xs: &amp;[T]) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="11:18-11:20: @0[2]: _3 = &amp;(*_1)
-11:18-11:31: @0.Call: _2 = &lt;[T] as std::borrow::ToOwned&gt;::to_owned(move _3) -&gt; [return: bb1, unwind: bb6]
-11:9-11:15: @1[1]: FakeRead(ForLet, _2)
-12:15-12:22: @1[7]: _8 = &amp;mut _2
-12:15-12:22: @1[8]: _7 = &amp;mut (*_8)
-12:15-12:22: @1.Call: _6 = &lt;std::vec::Vec&lt;T&gt; as std::ops::DerefMut&gt;::deref_mut(move _7) -&gt; [return: bb2, unwind: bb5]
-12:15-12:22: @2[0]: _5 = &amp;mut (*_6)
-12:5-12:26: @2.Call: _4 = permutate::&lt;T&gt;(move _5, const 0_usize) -&gt; [return: bb3, unwind: bb5]
-10:46-13:2: @3[4]: _0 = const ()
-13:2-13:2: @4.Return: return">    let mut ys = xs.to_owned();</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="11:18-11:20: @0[2]: _3 = &amp;(*_1)
-11:18-11:31: @0.Call: _2 = &lt;[T] as std::borrow::ToOwned&gt;::to_owned(move _3) -&gt; [return: bb1, unwind: bb6]
-11:9-11:15: @1[1]: FakeRead(ForLet, _2)
-12:15-12:22: @1[7]: _8 = &amp;mut _2
-12:15-12:22: @1[8]: _7 = &amp;mut (*_8)
-12:15-12:22: @1.Call: _6 = &lt;std::vec::Vec&lt;T&gt; as std::ops::DerefMut&gt;::deref_mut(move _7) -&gt; [return: bb2, unwind: bb5]
-12:15-12:22: @2[0]: _5 = &amp;mut (*_6)
-12:5-12:26: @2.Call: _4 = permutate::&lt;T&gt;(move _5, const 0_usize) -&gt; [return: bb3, unwind: bb5]
-10:46-13:2: @3[4]: _0 = const ()
-13:2-13:2: @4.Return: return">    permutate(&amp;mut ys, 0);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="11:18-11:20: @0[2]: _3 = &amp;(*_1)
-11:18-11:31: @0.Call: _2 = &lt;[T] as std::borrow::ToOwned&gt;::to_owned(move _3) -&gt; [return: bb1, unwind: bb6]
-11:9-11:15: @1[1]: FakeRead(ForLet, _2)
-12:15-12:22: @1[7]: _8 = &amp;mut _2
-12:15-12:22: @1[8]: _7 = &amp;mut (*_8)
-12:15-12:22: @1.Call: _6 = &lt;std::vec::Vec&lt;T&gt; as std::ops::DerefMut&gt;::deref_mut(move _7) -&gt; [return: bb2, unwind: bb5]
-12:15-12:22: @2[0]: _5 = &amp;mut (*_6)
-12:5-12:26: @2.Call: _4 = permutate::&lt;T&gt;(move _5, const 0_usize) -&gt; [return: bb3, unwind: bb5]
-10:46-13:2: @3[4]: _0 = const ()
-13:2-13:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.swap.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.swap.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4c3f63093d30e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.swap.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,173 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.swap.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>inline.swap - 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 34"><span class="line"><span><span class="code even" style="--layer: 1" title="36:16-36:17: @0[2]: _5 = _2
-36:13-36:18: @0[3]: _6 = Len((*_1))
-36:13-36:18: @0[4]: _7 = Lt(_5, _6)
-36:13-36:18: @1[0]: _4 = (*_1)[_5]
-36:9-36:10: @1[1]: FakeRead(ForLet, _4)
-37:16-37:17: @1[5]: _9 = _3
-37:13-37:18: @1[6]: _10 = Len((*_1))
-37:13-37:18: @1[7]: _11 = Lt(_9, _10)
-37:13-37:18: @2[0]: _8 = (*_1)[_9]
-37:8-37:9: @2[2]: _12 = _2
-37:5-37:10: @2[3]: _13 = Len((*_1))
-37:5-37:10: @2[4]: _14 = Lt(_12, _13)
-37:5-37:18: @3[0]: (*_1)[_12] = move _8
-38:13-38:14: @3[5]: _15 = _4
-38:8-38:9: @3[7]: _16 = _3
-38:5-38:10: @3[8]: _17 = Len((*_1))
-38:5-38:10: @3[9]: _18 = Lt(_16, _17)
-38:5-38:14: @4[0]: (*_1)[_16] = move _15
-35:52-39:2: @4[3]: _0 = const ()
-39:2-39:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>fn swap&lt;T: Copy&gt;(xs: &amp;mut [T], i: usize, j: usize) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:16-36:17: @0[2]: _5 = _2
-36:13-36:18: @0[3]: _6 = Len((*_1))
-36:13-36:18: @0[4]: _7 = Lt(_5, _6)
-36:13-36:18: @1[0]: _4 = (*_1)[_5]
-36:9-36:10: @1[1]: FakeRead(ForLet, _4)
-37:16-37:17: @1[5]: _9 = _3
-37:13-37:18: @1[6]: _10 = Len((*_1))
-37:13-37:18: @1[7]: _11 = Lt(_9, _10)
-37:13-37:18: @2[0]: _8 = (*_1)[_9]
-37:8-37:9: @2[2]: _12 = _2
-37:5-37:10: @2[3]: _13 = Len((*_1))
-37:5-37:10: @2[4]: _14 = Lt(_12, _13)
-37:5-37:18: @3[0]: (*_1)[_12] = move _8
-38:13-38:14: @3[5]: _15 = _4
-38:8-38:9: @3[7]: _16 = _3
-38:5-38:10: @3[8]: _17 = Len((*_1))
-38:5-38:10: @3[9]: _18 = Lt(_16, _17)
-38:5-38:14: @4[0]: (*_1)[_16] = move _15
-35:52-39:2: @4[3]: _0 = const ()
-39:2-39:2: @4.Return: return">    let t = xs[i];</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:16-36:17: @0[2]: _5 = _2
-36:13-36:18: @0[3]: _6 = Len((*_1))
-36:13-36:18: @0[4]: _7 = Lt(_5, _6)
-36:13-36:18: @1[0]: _4 = (*_1)[_5]
-36:9-36:10: @1[1]: FakeRead(ForLet, _4)
-37:16-37:17: @1[5]: _9 = _3
-37:13-37:18: @1[6]: _10 = Len((*_1))
-37:13-37:18: @1[7]: _11 = Lt(_9, _10)
-37:13-37:18: @2[0]: _8 = (*_1)[_9]
-37:8-37:9: @2[2]: _12 = _2
-37:5-37:10: @2[3]: _13 = Len((*_1))
-37:5-37:10: @2[4]: _14 = Lt(_12, _13)
-37:5-37:18: @3[0]: (*_1)[_12] = move _8
-38:13-38:14: @3[5]: _15 = _4
-38:8-38:9: @3[7]: _16 = _3
-38:5-38:10: @3[8]: _17 = Len((*_1))
-38:5-38:10: @3[9]: _18 = Lt(_16, _17)
-38:5-38:14: @4[0]: (*_1)[_16] = move _15
-35:52-39:2: @4[3]: _0 = const ()
-39:2-39:2: @4.Return: return">    xs[i] = xs[j];</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:16-36:17: @0[2]: _5 = _2
-36:13-36:18: @0[3]: _6 = Len((*_1))
-36:13-36:18: @0[4]: _7 = Lt(_5, _6)
-36:13-36:18: @1[0]: _4 = (*_1)[_5]
-36:9-36:10: @1[1]: FakeRead(ForLet, _4)
-37:16-37:17: @1[5]: _9 = _3
-37:13-37:18: @1[6]: _10 = Len((*_1))
-37:13-37:18: @1[7]: _11 = Lt(_9, _10)
-37:13-37:18: @2[0]: _8 = (*_1)[_9]
-37:8-37:9: @2[2]: _12 = _2
-37:5-37:10: @2[3]: _13 = Len((*_1))
-37:5-37:10: @2[4]: _14 = Lt(_12, _13)
-37:5-37:18: @3[0]: (*_1)[_12] = move _8
-38:13-38:14: @3[5]: _15 = _4
-38:8-38:9: @3[7]: _16 = _3
-38:5-38:10: @3[8]: _17 = Len((*_1))
-38:5-38:10: @3[9]: _18 = Lt(_16, _17)
-38:5-38:14: @4[0]: (*_1)[_16] = move _15
-35:52-39:2: @4[3]: _0 = const ()
-39:2-39:2: @4.Return: return">    xs[j] = t;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:16-36:17: @0[2]: _5 = _2
-36:13-36:18: @0[3]: _6 = Len((*_1))
-36:13-36:18: @0[4]: _7 = Lt(_5, _6)
-36:13-36:18: @1[0]: _4 = (*_1)[_5]
-36:9-36:10: @1[1]: FakeRead(ForLet, _4)
-37:16-37:17: @1[5]: _9 = _3
-37:13-37:18: @1[6]: _10 = Len((*_1))
-37:13-37:18: @1[7]: _11 = Lt(_9, _10)
-37:13-37:18: @2[0]: _8 = (*_1)[_9]
-37:8-37:9: @2[2]: _12 = _2
-37:5-37:10: @2[3]: _13 = Len((*_1))
-37:5-37:10: @2[4]: _14 = Lt(_12, _13)
-37:5-37:18: @3[0]: (*_1)[_12] = move _8
-38:13-38:14: @3[5]: _15 = _4
-38:8-38:9: @3[7]: _16 = _3
-38:5-38:10: @3[8]: _17 = Len((*_1))
-38:5-38:10: @3[9]: _18 = Lt(_16, _17)
-38:5-38:14: @4[0]: (*_1)[_16] = move _15
-35:52-39:2: @4[3]: _0 = const ()
-39:2-39:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 1dc5bb64e0bc3..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,93 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = main::in_func(const main::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 main::InTrait&gt;::trait_func(move _4, const main::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>fn default_trait_func(&amp;mut self) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="34:13-34:30: @0.Call: _2 = main::in_func(const main::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 main::InTrait&gt;::trait_func(move _4, const main::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 = main::in_func(const main::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 main::InTrait&gt;::trait_func(move _4, const main::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 = main::in_func(const main::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 main::InTrait&gt;::trait_func(move _4, const main::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/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 82724e5e86517..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,203 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><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)
-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)
-20:17-20:22: @1[0]: _3 = move (_6.0: u32)
-20:13-20:14: @1[3]: FakeRead(ForLet, _3)
-21:18-21:26: @1[9]: _23 = const main::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
-21:9-21:30: @3.Call: _7 = std::io::_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">@0,1,2,3,4⦊</span>fn in_func(a: u32) {</span></span>
-<span class="line"><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)
-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)
-20:17-20:22: @1[0]: _3 = move (_6.0: u32)
-20:13-20:14: @1[3]: FakeRead(ForLet, _3)
-21:18-21:26: @1[9]: _23 = const main::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
-21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -&gt; [return: bb4, unwind: bb5]
-21:9-21:30: @4[6]: _0 = const ()
-22:6-22:6: @4.Return: return">        let b = 1;</span></span>
-<span class="line"><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)
-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)
-20:17-20:22: @1[0]: _3 = move (_6.0: u32)
-20:13-20:14: @1[3]: FakeRead(ForLet, _3)
-21:18-21:26: @1[9]: _23 = const main::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
-21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -&gt; [return: bb4, unwind: bb5]
-21:9-21:30: @4[6]: _0 = const ()
-22:6-22:6: @4.Return: return">        let c = a + b;</span></span>
-<span class="line"><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)
-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)
-20:17-20:22: @1[0]: _3 = move (_6.0: u32)
-20:13-20:14: @1[3]: FakeRead(ForLet, _3)
-21:18-21:26: @1[9]: _23 = const main::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
-21:9-21:30: @3.Call: _7 = std::io::_print(move _8) -&gt; [return: bb4, unwind: bb5]
-21:9-21:30: @4[6]: _0 = const ()
-22:6-22:6: @4.Return: return">        println!("c = {}", c)</span></span>
-<span class="line"><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)
-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)
-20:17-20:22: @1[0]: _3 = move (_6.0: u32)
-20:13-20:14: @1[3]: FakeRead(ForLet, _3)
-21:18-21:26: @1[9]: _23 = const main::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 = std::fmt::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 = std::fmt::Arguments::new_v1(move _9, move _13) -&gt; [return: bb3, unwind: bb5]
-21:9-21:30: @3.Call: _7 = std::io::_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">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
deleted file mode 100644
index b00a781a0a74c..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,101 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-%7Bimpl%230%7D-trait_func.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><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)
-41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32)
-42:21-42:41: @1[4]: _6 = ((*_1).0: u32)
-42:13-42:42: @1.Call: _5 = main::in_func(move _6) -&gt; [return: bb2, unwind: bb3]
-40:45-43:10: @2[2]: _0 = const ()
-43:10-43:10: @2.Return: return"><span class="annotation">@0,1,2⦊</span>fn trait_func(&amp;mut self, incr: u32) {</span></span>
-<span class="line"><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)
-41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32)
-42:21-42:41: @1[4]: _6 = ((*_1).0: u32)
-42:13-42:42: @1.Call: _5 = main::in_func(move _6) -&gt; [return: bb2, unwind: bb3]
-40:45-43:10: @2[2]: _0 = const ()
-43:10-43:10: @2.Return: return">            self.in_struct_field += incr;</span></span>
-<span class="line"><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)
-41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32)
-42:21-42:41: @1[4]: _6 = ((*_1).0: u32)
-42:13-42:42: @1.Call: _5 = main::in_func(move _6) -&gt; [return: bb2, unwind: bb3]
-40:45-43:10: @2[2]: _0 = const ()
-43:10-43:10: @2.Return: return">            in_func(self.in_struct_field);</span></span>
-<span class="line"><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)
-41:13-41:41: @1[0]: ((*_1).0: u32) = move (_4.0: u32)
-42:21-42:41: @1[4]: _6 = ((*_1).0: u32)
-42:13-42:42: @1.Call: _5 = main::in_func(move _6) -&gt; [return: bb2, unwind: bb3]
-40:45-43:10: @2[2]: _0 = const ()
-43:10-43: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/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4a1003dfbed32..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,189 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1"><span class="annotation">@0,1,2,3⦊</span>fn main() <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">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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_u32
-9:9-9:22: @3[3]: FakeRead(ForLet, _5)
-10:8-10:15: @3[6]: _7 = _1"><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 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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_u32
-9:9-9:22: @3[3]: FakeRead(ForLet, _5)
-10:8-10:15: @3[6]: _7 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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_u32
-9:9-9:22: @3[3]: FakeRead(ForLet, _5)
-10:8-10:15: @3[6]: _7 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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_u32
-9:9-9:22: @3[3]: FakeRead(ForLet, _5)
-10:8-10:15: @3[6]: _7 = _1">    if 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: @4[0]: _5 = const 10_u32
-10:16-12:6: @4[1]: _6 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @4[0]: _5 = const 10_u32
-10:16-12:6: @4[1]: _6 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:23: @4[0]: _5 = const 10_u32
-10:16-12:6: @4[1]: _6 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="12:6-12:6: @5[0]: _6 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    mod in_mod {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        const IN_MOD_CONST: u32 = 1000;</span></span>
-<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 odd" style="--layer: 1" title="48:8-48:15: @6[4]: _9 = _1"><span class="annotation">@6⦊</span>is_true<span class="annotation">⦉@6</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="49:17-49:26: @7[2]: _11 = _5
-49:9-49:27: @7.Call: _10 = main::in_func(move _11) -&gt; [return: bb9, unwind: bb13]
-48:16-50:6: @9[2]: _8 = const ()"><span class="annotation">@7,9⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @7[2]: _11 = _5
-49:9-49:27: @7.Call: _10 = main::in_func(move _11) -&gt; [return: bb9, unwind: bb13]
-48:16-50:6: @9[2]: _8 = const ()">        in_func(countdown);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="49:17-49:26: @7[2]: _11 = _5
-49:9-49:27: @7.Call: _10 = main::in_func(move _11) -&gt; [return: bb9, unwind: bb13]
-48:16-50:6: @9[2]: _8 = const ()">    }<span class="annotation">⦉@7,9</span></span></span><span><span class="code odd" style="--layer: 1" title="50:6-50:6: @8[0]: _8 = const ()"><span class="annotation">@8⦊</span>‸<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 }
-52:9-52:16: @10[4]: FakeRead(ForLet, _12)
-56:5-56:8: @10[7]: _14 = &amp;mut _12
-56:5-56:29: @10.Call: _13 = &lt;main::InStruct as main::InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb11, unwind: bb13]
-57:2-57:2: @11.Return: return"><span class="annotation">@10,11⦊</span>mut val = InStruct {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 }
-52:9-52:16: @10[4]: FakeRead(ForLet, _12)
-56:5-56:8: @10[7]: _14 = &amp;mut _12
-56:5-56:29: @10.Call: _13 = &lt;main::InStruct as main::InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb11, unwind: bb13]
-57:2-57:2: @11.Return: return">        in_struct_field: 101,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 }
-52:9-52:16: @10[4]: FakeRead(ForLet, _12)
-56:5-56:8: @10[7]: _14 = &amp;mut _12
-56:5-56:29: @10.Call: _13 = &lt;main::InStruct as main::InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb11, unwind: bb13]
-57:2-57:2: @11.Return: return">    };</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 }
-52:9-52:16: @10[4]: FakeRead(ForLet, _12)
-56:5-56:8: @10[7]: _14 = &amp;mut _12
-56:5-56:29: @10.Call: _13 = &lt;main::InStruct as main::InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb11, unwind: bb13]
-57:2-57:2: @11.Return: return"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 }
-52:9-52:16: @10[4]: FakeRead(ForLet, _12)
-56:5-56:8: @10[7]: _14 = &amp;mut _12
-56:5-56:29: @10.Call: _13 = &lt;main::InStruct as main::InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb11, unwind: bb13]
-57:2-57:2: @11.Return: return">    val.default_trait_func();</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="52:19-54:6: @10[3]: _12 = main::InStruct { in_struct_field: const 101_u32 }
-52:9-52:16: @10[4]: FakeRead(ForLet, _12)
-56:5-56:8: @10[7]: _14 = &amp;mut _12
-56:5-56:29: @10.Call: _13 = &lt;main::InStruct as main::InTrait&gt;::default_trait_func(move _14) -&gt; [return: bb11, unwind: bb13]
-57:2-57:2: @11.Return: return">}<span class="annotation">⦉@10,11</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index a6f8d500065fa..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1">    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 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1">    let (mut a, mut b, mut c) = (0, 0, 0);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-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)
-10:8-10:15: @3[12]: _10 = _1">    if 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: @4[0]: _5 = const 1_i32
-12:9-12:15: @4[1]: _6 = const 10_i32
-13:9-13:16: @4[2]: _7 = const 100_i32
-10:16-14:6: @4[3]: _9 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @4[0]: _5 = const 1_i32
-12:9-12:15: @4[1]: _6 = const 10_i32
-13:9-13:16: @4[2]: _7 = const 100_i32
-10:16-14:6: @4[3]: _9 = const ()">        a = 1;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @4[0]: _5 = const 1_i32
-12:9-12:15: @4[1]: _6 = const 10_i32
-13:9-13:16: @4[2]: _7 = const 100_i32
-10:16-14:6: @4[3]: _9 = const ()">        b = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @4[0]: _5 = const 1_i32
-12:9-12:15: @4[1]: _6 = const 10_i32
-13:9-13:16: @4[2]: _7 = const 100_i32
-10:16-14:6: @4[3]: _9 = const ()">        c = 100;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:14: @4[0]: _5 = const 1_i32
-12:9-12:15: @4[1]: _6 = const 10_i32
-13:9-13:16: @4[2]: _7 = const 100_i32
-10:16-14:6: @4[3]: _9 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="14:6-14:6: @5[0]: _9 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    let</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="16:9-16:17: @9[2]: FakeRead(ForLet, _11)"><span class="annotation">@9⦊</span>somebool<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 even" style="--layer: 1" title="18:13-18:14: @6[5]: _13 = _5
-18:17-18:18: @6[7]: _14 = _6
-18:13-18:18: @6[8]: _12 = Lt(move _13, move _14)"><span class="annotation">@6⦊</span>a &lt; b<span class="annotation">⦉@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 odd" style="--layer: 1" title="20:13-20:14: @8[2]: _16 = _6
-20:17-20:18: @8[4]: _17 = _7
-20:13-20:18: @8[5]: _15 = Lt(move _16, move _17)"><span class="annotation">@8⦊</span>b &lt; c<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    ;</span></span>
-<span class="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="23:9-23:17: @12[2]: FakeRead(ForLet, _18)"><span class="annotation">@12⦊</span>somebool<span class="annotation">⦉@12</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        =</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="25:13-25:14: @9[6]: _20 = _6
-25:17-25:18: @9[8]: _21 = _5
-25:13-25:18: @9[9]: _19 = Lt(move _20, move _21)"><span class="annotation">@9⦊</span>b &lt; a<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 even" style="--layer: 1" title="27:13-27:14: @11[2]: _23 = _6
-27:17-27:18: @11[4]: _24 = _7
-27:13-27:18: @11[5]: _22 = Lt(move _23, move _24)"><span class="annotation">@11⦊</span>b &lt; c<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">    let </span><span><span class="code odd" style="--layer: 1" title="29:9-29:17: @15[2]: FakeRead(ForLet, _25)"><span class="annotation">@15⦊</span>somebool<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code even" style="--layer: 1" title="29:20-29:21: @12[6]: _27 = _5
-29:24-29:25: @12[8]: _28 = _6
-29:20-29:25: @12[9]: _26 = Lt(move _27, move _28)"><span class="annotation">@12⦊</span>a &lt; b<span class="annotation">⦉@12</span></span></span><span class="code" style="--layer: 0"> &amp;&amp; </span><span><span class="code odd" style="--layer: 1" title="29:29-29:30: @14[2]: _30 = _6
-29:33-29:34: @14[4]: _31 = _7
-29:29-29:34: @14[5]: _29 = Lt(move _30, move _31)"><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">    let </span><span><span class="code even" style="--layer: 1" title="30:9-30:17: @18[2]: FakeRead(ForLet, _32)"><span class="annotation">@18⦊</span>somebool<span class="annotation">⦉@18</span></span></span><span class="code" style="--layer: 0"> = </span><span><span class="code odd" style="--layer: 1" title="30:20-30:21: @15[6]: _34 = _6
-30:24-30:25: @15[8]: _35 = _5
-30:20-30:25: @15[9]: _33 = Lt(move _34, move _35)"><span class="annotation">@15⦊</span>b &lt; a<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"> &amp;&amp; </span><span><span class="code even" style="--layer: 1" title="30:29-30:30: @17[2]: _37 = _6
-30:33-30:34: @17[4]: _38 = _7
-30:29-30:34: @17[5]: _36 = Lt(move _37, move _38)"><span class="annotation">@17⦊</span>b &lt; c<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    if</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="34:9-34:16: @18[6]: _41 = _1
-33:9-34:16: @18[7]: _40 = Not(move _41)"><span class="annotation">@18⦊</span>!</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="34:9-34:16: @18[6]: _41 = _1
-33:9-34:16: @18[7]: _40 = Not(move _41)">        is_true<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="code even" style="--layer: 1" title="36:9-36:14: @19[0]: _5 = const 2_i32
-35:5-38:6: @19[1]: _39 = const ()"><span class="annotation">@19⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @19[0]: _5 = const 2_i32
-35:5-38:6: @19[1]: _39 = const ()">        a = 2</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @19[0]: _5 = const 2_i32
-35:5-38:6: @19[1]: _39 = const ()">        ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:9-36:14: @19[0]: _5 = const 2_i32
-35:5-38:6: @19[1]: _39 = const ()">    }<span class="annotation">⦉@19</span></span></span><span><span class="code odd" style="--layer: 1" title="38:6-38:6: @20[0]: _39 = const ()"><span class="annotation">@20⦊</span>‸<span class="annotation">⦉@20</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    if</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="41:9-41:16: @21[4]: _43 = _1"><span class="annotation">@21⦊</span>is_true<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="43:9-43:15: @22[0]: _6 = const 30_i32
-42:5-45:6: @22[1]: _42 = const ()"><span class="annotation">@22⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @22[0]: _6 = const 30_i32
-42:5-45:6: @22[1]: _42 = const ()">        b = 30</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @22[0]: _6 = const 30_i32
-42:5-45:6: @22[1]: _42 = const ()">        ;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="43:9-43:15: @22[0]: _6 = const 30_i32
-42:5-45:6: @22[1]: _42 = const ()">    }<span class="annotation">⦉@22</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    else</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="48:9-48:16: @23[0]: _7 = const 400_i32
-47:5-50:6: @23[1]: _42 = const ()"><span class="annotation">@23⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @23[0]: _7 = const 400_i32
-47:5-50:6: @23[1]: _42 = const ()">        c = 400</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @23[0]: _7 = const 400_i32
-47:5-50:6: @23[1]: _42 = const ()">        ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="48:9-48:16: @23[0]: _7 = const 400_i32
-47:5-50:6: @23[1]: _42 = const ()">    }<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">    if </span><span><span class="code odd" style="--layer: 1" title="52:9-52:16: @24[5]: _46 = _1
-52:8-52:16: @24[6]: _45 = Not(move _46)"><span class="annotation">@24⦊</span>!is_true<span class="annotation">⦉@24</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="53:9-53:14: @25[0]: _5 = const 2_i32
-52:17-54:6: @25[1]: _44 = const ()"><span class="annotation">@25⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="53:9-53:14: @25[0]: _5 = const 2_i32
-52:17-54:6: @25[1]: _44 = const ()">        a = 2;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="53:9-53:14: @25[0]: _5 = const 2_i32
-52:17-54:6: @25[1]: _44 = const ()">    }<span class="annotation">⦉@25</span></span></span><span><span class="code odd" style="--layer: 1" title="54:6-54:6: @26[0]: _44 = const ()"><span class="annotation">@26⦊</span>‸<span class="annotation">⦉@26</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="56:8-56:15: @27[3]: _47 = _1"><span class="annotation">@27⦊</span>is_true<span class="annotation">⦉@27</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="57:9-57:15: @28[0]: _6 = const 30_i32
-56:16-58:6: @28[1]: _0 = const ()"><span class="annotation">@28⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="57:9-57:15: @28[0]: _6 = const 30_i32
-56:16-58:6: @28[1]: _0 = const ()">        b = 30;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="57:9-57:15: @28[0]: _6 = const 30_i32
-56:16-58:6: @28[1]: _0 = const ()">    }<span class="annotation">⦉@28</span></span></span><span class="code" style="--layer: 0"> else </span><span><span class="code even" style="--layer: 1" title="59:9-59:16: @29[0]: _7 = const 400_i32
-58:12-60:6: @29[1]: _0 = const ()"><span class="annotation">@29⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="59:9-59:16: @29[0]: _7 = const 400_i32
-58:12-60:6: @29[1]: _0 = const ()">        c = 400;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="59:9-59:16: @29[0]: _7 = const 400_i32
-58:12-60:6: @29[1]: _0 = const ()">    }<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="61:2-61:2: @30.Return: return"><span class="annotation">@30⦊</span>‸<span class="annotation">⦉@30</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 076d036c2aff7..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,128 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><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>fn main() {</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/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 95e8f0b71eab8..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,161 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>loops_branches.main - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 21"><span class="line"><span><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
-23:9-23:19: @0[2]: FakeRead(ForLet, _1)
-24:14-24:20: @0[9]: _19 = const main::promoted[0]
-24:14-24:20: @0[10]: _7 = &amp;(*_19)
-24:14-24:20: @0[11]: _6 = &amp;(*_7)
-24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-24:22-24:32: @0[20]: _14 = &amp;_1
-24:5-24:34: @0[21]: _13 = (move _14,)
-24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
-24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
-24:5-24:34: @0[28]: _17 = &amp;(*_15)
-24:5-24:34: @0[30]: _18 = &lt;DebugTest as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
-24:5-24:34: @1[2]: _12 = [move _16]
-24:5-24:34: @1[5]: _11 = &amp;_12
-24:5-24:34: @1[6]: _10 = &amp;(*_11)
-24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb4]
-24:5-24:34: @3[6]: _2 = const ()
-22:11-25:2: @3[8]: _0 = const ()
-25:2-25:2: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
-23:9-23:19: @0[2]: FakeRead(ForLet, _1)
-24:14-24:20: @0[9]: _19 = const main::promoted[0]
-24:14-24:20: @0[10]: _7 = &amp;(*_19)
-24:14-24:20: @0[11]: _6 = &amp;(*_7)
-24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-24:22-24:32: @0[20]: _14 = &amp;_1
-24:5-24:34: @0[21]: _13 = (move _14,)
-24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
-24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
-24:5-24:34: @0[28]: _17 = &amp;(*_15)
-24:5-24:34: @0[30]: _18 = &lt;DebugTest as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
-24:5-24:34: @1[2]: _12 = [move _16]
-24:5-24:34: @1[5]: _11 = &amp;_12
-24:5-24:34: @1[6]: _10 = &amp;(*_11)
-24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb4]
-24:5-24:34: @3[6]: _2 = const ()
-22:11-25:2: @3[8]: _0 = const ()
-25:2-25:2: @3.Return: return">    let debug_test = DebugTest;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
-23:9-23:19: @0[2]: FakeRead(ForLet, _1)
-24:14-24:20: @0[9]: _19 = const main::promoted[0]
-24:14-24:20: @0[10]: _7 = &amp;(*_19)
-24:14-24:20: @0[11]: _6 = &amp;(*_7)
-24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-24:22-24:32: @0[20]: _14 = &amp;_1
-24:5-24:34: @0[21]: _13 = (move _14,)
-24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
-24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
-24:5-24:34: @0[28]: _17 = &amp;(*_15)
-24:5-24:34: @0[30]: _18 = &lt;DebugTest as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
-24:5-24:34: @1[2]: _12 = [move _16]
-24:5-24:34: @1[5]: _11 = &amp;_12
-24:5-24:34: @1[6]: _10 = &amp;(*_11)
-24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb4]
-24:5-24:34: @3[6]: _2 = const ()
-22:11-25:2: @3[8]: _0 = const ()
-25:2-25:2: @3.Return: return">    println!("{:?}", debug_test);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:22-23:31: @0[1]: _1 = DebugTest
-23:9-23:19: @0[2]: FakeRead(ForLet, _1)
-24:14-24:20: @0[9]: _19 = const main::promoted[0]
-24:14-24:20: @0[10]: _7 = &amp;(*_19)
-24:14-24:20: @0[11]: _6 = &amp;(*_7)
-24:14-24:20: @0[12]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-24:22-24:32: @0[20]: _14 = &amp;_1
-24:5-24:34: @0[21]: _13 = (move _14,)
-24:5-24:34: @0[23]: FakeRead(ForMatchedPlace, _13)
-24:5-24:34: @0[25]: _15 = (_13.0: &amp;DebugTest)
-24:5-24:34: @0[28]: _17 = &amp;(*_15)
-24:5-24:34: @0[30]: _18 = &lt;DebugTest as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r DebugTest, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-24:5-24:34: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;DebugTest&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb4]
-24:5-24:34: @1[2]: _12 = [move _16]
-24:5-24:34: @1[5]: _11 = &amp;_12
-24:5-24:34: @1[6]: _10 = &amp;(*_11)
-24:5-24:34: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-24:5-24:34: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb4]
-24:5-24:34: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb4]
-24:5-24:34: @3[6]: _2 = const ()
-22:11-25:2: @3[8]: _0 = const ()
-25:2-25:2: @3.Return: return">}<span class="annotation">⦉@0,1,2,3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html
deleted file mode 100644
index f6f08b6a7704b..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,100 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.%7Bimpl%230%7D-fmt.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>loops_branches.{impl#0}-fmt - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 8"><span class="line">    <span><span class="code even" style="--layer: 1" title="10:12-10:16: @0[2]: _4 = const true"><span class="annotation">@0⦊</span>fn fmt(&amp;self, f: &amp;mut std::fmt::Formatter) -&gt; std::fmt::Result {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:12-10:16: @0[2]: _4 = const true">        if true<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code odd" style="--layer: 1" title="11:16-11:21: @1[2]: _6 = const false"><span class="annotation">@1⦊</span>false<span class="annotation">⦉@1</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">                while </span><span><span class="code even" style="--layer: 1" title="12:23-12:27: @5[1]: _8 = const true
-12:23-12:27: @5[2]: FakeRead(ForMatchedPlace, _8)"><span class="annotation">@4,5⦊</span>true<span class="annotation">⦉@4,5</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="12:28-13:18: @8[0]: _7 = const ()"><span class="annotation">@6,8⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="12:28-13:18: @8[0]: _7 = const ()">                }<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="code even" style="--layer: 1" title="14:14-14:14: @3[0]: _5 = const ()"><span class="annotation">@3⦊</span>‸<span class="annotation">⦉@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="15:20-15:21: @9[6]: _13 = &amp;mut (*_2)
-15:23-15:30: @9[11]: _32 = const &lt;DebugTest as std::fmt::Debug&gt;::fmt::promoted[1]
-15:23-15:30: @9[12]: _17 = &amp;(*_32)
-15:23-15:30: @9[13]: _16 = &amp;(*_17)
-15:23-15:30: @9[14]: _15 = move _16 as &amp;[&amp;str] (Pointer(Unsize))
-15:13-15:31: @9[20]: _23 = ()
-15:13-15:31: @9[21]: FakeRead(ForMatchedPlace, _23)
-15:13-15:31: @9[22]: _31 = const &lt;DebugTest as std::fmt::Debug&gt;::fmt::promoted[0]
-15:13-15:31: @9[23]: _21 = &amp;(*_31)
-15:13-15:31: @9[24]: _20 = &amp;(*_21)
-15:13-15:31: @9[25]: _19 = move _20 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-15:13-15:31: @9.Call: _14 = std::fmt::Arguments::new_v1(move _15, move _19) -&gt; [return: bb10, unwind: bb21]
-15:13-15:31: @10.Call: _12 = std::fmt::Formatter::write_fmt(move _13, move _14) -&gt; [return: bb11, unwind: bb21]"><span class="annotation">@9,10,11,12⦊</span>write!(f, "error")<span class="annotation">⦉@9,10,11,12</span></span></span><span><span class="code even" style="--layer: 1" title="15:31-15:32: @16[1]: _25 = ((_11 as Err).0: std::fmt::Error)
-15:31-15:32: @16[4]: _28 = _25
-15:31-15:32: @16.Call: _27 = &lt;std::fmt::Error as std::convert::From&lt;std::fmt::Error&gt;&gt;::from(move _28) -&gt; [return: bb17, unwind: bb21]"><span class="annotation">@14,16,17,18⦊</span>?<span class="annotation">⦉@14,16,17,18</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        } else </span><span><span class="code odd" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()"><span class="annotation">@2⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="16:16-17:10: @2[0]: _3 = const ()">        }<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code even" style="--layer: 1" title="18:12-18:14: @19[3]: _30 = ()
-18:9-18:15: @19[4]: _0 = std::result::Result::&lt;(), std::fmt::Error&gt;::Ok(move _30)"><span class="annotation">@19⦊</span>Ok(())<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="code odd" style="--layer: 1" title="19:6-19:6: @20.Return: return"><span class="annotation">@20⦊</span>‸<span class="annotation">⦉@20</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 013c292ce9a43..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,259 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>match_or_pattern.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><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1">    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 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1">    let mut a: u8 = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1">    let mut b: u8 = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb37]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb36]
-7:19-7:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-7:9-7:16: @2[3]: FakeRead(ForLet, _1)
-9:21-9:22: @3[2]: _5 = const 0_u8
-9:9-9:14: @3[3]: FakeRead(ForLet, _5)
-9:16-9:18: @3[4]: AscribeUserType(_5, o, UserTypeProjection { base: UserType(1), projs: [] })
-10:21-10:22: @3[6]: _6 = const 0_u8
-10:9-10:14: @3[7]: FakeRead(ForLet, _6)
-10:16-10:18: @3[8]: AscribeUserType(_6, o, UserTypeProjection { base: UserType(3), projs: [] })
-11:8-11:15: @3[11]: _8 = _1">    if 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="12:9-12:14: @4[0]: _5 = const 2_u8
-13:9-13:14: @4[1]: _6 = const 0_u8
-11:16-14:6: @4[2]: _7 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="12:9-12:14: @4[0]: _5 = const 2_u8
-13:9-13:14: @4[1]: _6 = const 0_u8
-11:16-14:6: @4[2]: _7 = const ()">        a = 2;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="12:9-12:14: @4[0]: _5 = const 2_u8
-13:9-13:14: @4[1]: _6 = const 0_u8
-11:16-14:6: @4[2]: _7 = const ()">        b = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="12:9-12:14: @4[0]: _5 = const 2_u8
-13:9-13:14: @4[1]: _6 = const 0_u8
-11:16-14:6: @4[2]: _7 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="14:6-14:6: @5[0]: _7 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    match </span><span><span class="code odd" style="--layer: 1" title="15:12-15:13: @6[5]: _11 = _5
-15:15-15:16: @6[7]: _12 = _6
-15:11-15:17: @6[8]: _10 = (move _11, move _12)
-15:11-15:17: @6[11]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@6⦊</span>(a, b)<span class="annotation">⦉@6</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        // Or patterns generate MIR `SwitchInt` with multiple targets to the same `BasicBlock`.</span></span>
-<span class="line"><span class="code" style="--layer: 0">        // This test confirms a fix for Issue #79569.</span></span>
-<span class="line"><span class="code" style="--layer: 0">        (0 | 1, 2 | 3) =&gt; </span><span><span class="code even" style="--layer: 1" title="18:27-18:29: @10[0]: _9 = const ()"><span class="annotation">@9,10⦊</span>{}<span class="annotation">⦉@9,10</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="code odd" style="--layer: 1" title="19:14-19:16: @7[0]: _9 = const ()"><span class="annotation">@7⦊</span>{}<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="21:8-21:15: @11[4]: _14 = _1"><span class="annotation">@11⦊</span>is_true<span class="annotation">⦉@11</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="22:9-22:14: @12[0]: _5 = const 0_u8
-23:9-23:14: @12[1]: _6 = const 0_u8
-21:16-24:6: @12[2]: _13 = const ()"><span class="annotation">@12⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:9-22:14: @12[0]: _5 = const 0_u8
-23:9-23:14: @12[1]: _6 = const 0_u8
-21:16-24:6: @12[2]: _13 = const ()">        a = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:9-22:14: @12[0]: _5 = const 0_u8
-23:9-23:14: @12[1]: _6 = const 0_u8
-21:16-24:6: @12[2]: _13 = const ()">        b = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:9-22:14: @12[0]: _5 = const 0_u8
-23:9-23:14: @12[1]: _6 = const 0_u8
-21:16-24:6: @12[2]: _13 = const ()">    }<span class="annotation">⦉@12</span></span></span><span><span class="code even" style="--layer: 1" title="24:6-24:6: @13[0]: _13 = const ()"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    match </span><span><span class="code odd" style="--layer: 1" title="25:12-25:13: @14[5]: _17 = _5
-25:15-25:16: @14[7]: _18 = _6
-25:11-25:17: @14[8]: _16 = (move _17, move _18)
-25:11-25:17: @14[11]: FakeRead(ForMatchedPlace, _16)"><span class="annotation">@14⦊</span>(a, b)<span class="annotation">⦉@14</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        (0 | 1, 2 | 3) =&gt; </span><span><span class="code even" style="--layer: 1" title="26:27-26:29: @18[0]: _15 = const ()"><span class="annotation">@17,18⦊</span>{}<span class="annotation">⦉@17,18</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="code odd" style="--layer: 1" title="27:14-27:16: @15[0]: _15 = const ()"><span class="annotation">@15⦊</span>{}<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="29:8-29:15: @19[4]: _20 = _1"><span class="annotation">@19⦊</span>is_true<span class="annotation">⦉@19</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="30:9-30:14: @20[0]: _5 = const 2_u8
-31:9-31:14: @20[1]: _6 = const 2_u8
-29:16-32:6: @20[2]: _19 = const ()"><span class="annotation">@20⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="30:9-30:14: @20[0]: _5 = const 2_u8
-31:9-31:14: @20[1]: _6 = const 2_u8
-29:16-32:6: @20[2]: _19 = const ()">        a = 2;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="30:9-30:14: @20[0]: _5 = const 2_u8
-31:9-31:14: @20[1]: _6 = const 2_u8
-29:16-32:6: @20[2]: _19 = const ()">        b = 2;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="30:9-30:14: @20[0]: _5 = const 2_u8
-31:9-31:14: @20[1]: _6 = const 2_u8
-29:16-32:6: @20[2]: _19 = const ()">    }<span class="annotation">⦉@20</span></span></span><span><span class="code even" style="--layer: 1" title="32:6-32:6: @21[0]: _19 = const ()"><span class="annotation">@21⦊</span>‸<span class="annotation">⦉@21</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    match </span><span><span class="code odd" style="--layer: 1" title="33:12-33:13: @22[5]: _23 = _5
-33:15-33:16: @22[7]: _24 = _6
-33:11-33:17: @22[8]: _22 = (move _23, move _24)
-33:11-33:17: @22[11]: FakeRead(ForMatchedPlace, _22)"><span class="annotation">@22⦊</span>(a, b)<span class="annotation">⦉@22</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        (0 | 1, 2 | 3) =&gt; </span><span><span class="code even" style="--layer: 1" title="34:27-34:29: @26[0]: _21 = const ()"><span class="annotation">@25,26⦊</span>{}<span class="annotation">⦉@25,26</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="code odd" style="--layer: 1" title="35:14-35:16: @23[0]: _21 = const ()"><span class="annotation">@23⦊</span>{}<span class="annotation">⦉@23</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    if </span><span><span class="code even" style="--layer: 1" title="37:8-37:15: @27[4]: _26 = _1"><span class="annotation">@27⦊</span>is_true<span class="annotation">⦉@27</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="38:9-38:14: @28[0]: _5 = const 0_u8
-39:9-39:14: @28[1]: _6 = const 2_u8
-37:16-40:6: @28[2]: _25 = const ()"><span class="annotation">@28⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="38:9-38:14: @28[0]: _5 = const 0_u8
-39:9-39:14: @28[1]: _6 = const 2_u8
-37:16-40:6: @28[2]: _25 = const ()">        a = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="38:9-38:14: @28[0]: _5 = const 0_u8
-39:9-39:14: @28[1]: _6 = const 2_u8
-37:16-40:6: @28[2]: _25 = const ()">        b = 2;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="38:9-38:14: @28[0]: _5 = const 0_u8
-39:9-39:14: @28[1]: _6 = const 2_u8
-37:16-40:6: @28[2]: _25 = const ()">    }<span class="annotation">⦉@28</span></span></span><span><span class="code even" style="--layer: 1" title="40:6-40:6: @29[0]: _25 = const ()"><span class="annotation">@29⦊</span>‸<span class="annotation">⦉@29</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    match </span><span><span class="code odd" style="--layer: 1" title="41:12-41:13: @30[4]: _28 = _5
-41:15-41:16: @30[6]: _29 = _6
-41:11-41:17: @30[7]: _27 = (move _28, move _29)
-41:11-41:17: @30[10]: FakeRead(ForMatchedPlace, _27)"><span class="annotation">@30⦊</span>(a, b)<span class="annotation">⦉@30</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        (0 | 1, 2 | 3) =&gt; </span><span><span class="code even" style="--layer: 1" title="42:27-42:29: @34[0]: _0 = const ()"><span class="annotation">@33,34⦊</span>{}<span class="annotation">⦉@33,34</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="code odd" style="--layer: 1" title="43:14-43:16: @31[0]: _0 = const ()"><span class="annotation">@31⦊</span>{}<span class="annotation">⦉@31</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="45:2-45:2: @35.Return: return"><span class="annotation">@35⦊</span>‸<span class="annotation">⦉@35</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 1abc24156d9c3..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,166 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>nested_loops.main - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 0"><span class="line"><span><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-2:19-2:35: @1[0]: _3 = &amp;_4
-2:19-2:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-2:9-2:16: @2[3]: FakeRead(ForLet, _1)
-3:25-3:27: @3[2]: _5 = const 10_i32
-3:9-3:22: @3[3]: FakeRead(ForLet, _5)"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-2:19-2:35: @1[0]: _3 = &amp;_4
-2:19-2:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-2:9-2:16: @2[3]: FakeRead(ForLet, _1)
-3:25-3:27: @3[2]: _5 = const 10_i32
-3:9-3:22: @3[3]: FakeRead(ForLet, _5)">    let is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="2:19-2:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb32]
-2:19-2:35: @1[0]: _3 = &amp;_4
-2:19-2:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb31]
-2:19-2:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-2:9-2:16: @2[3]: FakeRead(ForLet, _1)
-3:25-3:27: @3[2]: _5 = const 10_i32
-3:9-3:22: @3[3]: FakeRead(ForLet, _5)">    let mut countdown = 10<span class="annotation">⦉@0,1,2,3</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    'outer: while </span><span><span class="code odd" style="--layer: 1" title="5:19-5:28: @5[2]: _8 = _5
-5:19-5:32: @5[3]: _7 = Gt(move _8, const 0_i32)
-5:19-5:32: @5[5]: FakeRead(ForMatchedPlace, _7)"><span class="annotation">@4,5⦊</span>countdown &gt; 0<span class="annotation">⦉@4,5</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        let </span><span><span class="code even" style="--layer: 1" title="6:21-6:24: @8[1]: _9 = const 100_i32
-6:13-6:18: @8[2]: FakeRead(ForLet, _9)
-7:21-7:24: @8[4]: _10 = const 100_i32
-7:13-7:18: @8[5]: FakeRead(ForLet, _10)"><span class="annotation">@6,8,9⦊</span>mut a = 100;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:21-6:24: @8[1]: _9 = const 100_i32
-6:13-6:18: @8[2]: FakeRead(ForLet, _9)
-7:21-7:24: @8[4]: _10 = const 100_i32
-7:13-7:18: @8[5]: FakeRead(ForLet, _10)">        let mut b = 100<span class="annotation">⦉@6,8,9</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        for </span><span><span class="code odd" style="--layer: 1" title="8:13-8:14: @16[1]: _21 = ((_17 as Some).0: i32)
-8:13-8:14: @16[3]: _22 = _21
-8:13-8:14: @16[4]: _15 = move _22
-8:13-8:14: @16[5]: _16 = const ()"><span class="annotation">@14,16⦊</span>_<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> in </span><span><span class="code even" style="--layer: 1" title="8:18-8:23: @11[5]: _19 = &amp;mut _14
-8:18-8:23: @11[6]: _18 = &amp;mut (*_19)
-8:18-8:23: @11.Call: _17 = &lt;std::ops::Range&lt;i32&gt; as std::iter::Iterator&gt;::next(move _18) -&gt; [return: bb12, unwind: bb32]
-8:18-8:23: @12[1]: FakeRead(ForMatchedPlace, _17)"><span class="annotation">@10,11,12⦊</span>0..50<span class="annotation">⦉@10,11,12</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            if </span><span><span class="code odd" style="--layer: 1" title="9:16-9:17: @16[15]: _27 = _9
-9:16-9:22: @16[16]: _26 = Lt(move _27, const 30_i32)"><span class="annotation">@14,16⦊</span>a &lt; 30<span class="annotation">⦉@14,16</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="10:17-10:22: @17[0]: _11 = const ()"><span class="annotation">@17⦊</span>break<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">            }</span><span><span class="code odd" style="--layer: 1" title="11:14-11:14: @18[0]: _25 = const ()
-12:13-12:19: @18[3]: _29 = CheckedSub(_9, const 5_i32)
-12:13-12:19: @19[0]: _9 = move (_29.0: i32)
-13:13-13:19: @19[1]: _30 = CheckedSub(_10, const 5_i32)
-13:13-13:19: @20[0]: _10 = move (_30.0: i32)
-14:16-14:17: @20[3]: _32 = _10
-14:16-14:22: @20[4]: _31 = Lt(move _32, const 90_i32)"><span class="annotation">@18,19,20⦊</span></span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:14-11:14: @18[0]: _25 = const ()
-12:13-12:19: @18[3]: _29 = CheckedSub(_9, const 5_i32)
-12:13-12:19: @19[0]: _9 = move (_29.0: i32)
-13:13-13:19: @19[1]: _30 = CheckedSub(_10, const 5_i32)
-13:13-13:19: @20[0]: _10 = move (_30.0: i32)
-14:16-14:17: @20[3]: _32 = _10
-14:16-14:22: @20[4]: _31 = Lt(move _32, const 90_i32)">            a -= 5;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:14-11:14: @18[0]: _25 = const ()
-12:13-12:19: @18[3]: _29 = CheckedSub(_9, const 5_i32)
-12:13-12:19: @19[0]: _9 = move (_29.0: i32)
-13:13-13:19: @19[1]: _30 = CheckedSub(_10, const 5_i32)
-13:13-13:19: @20[0]: _10 = move (_30.0: i32)
-14:16-14:17: @20[3]: _32 = _10
-14:16-14:22: @20[4]: _31 = Lt(move _32, const 90_i32)">            b -= 5;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:14-11:14: @18[0]: _25 = const ()
-12:13-12:19: @18[3]: _29 = CheckedSub(_9, const 5_i32)
-12:13-12:19: @19[0]: _9 = move (_29.0: i32)
-13:13-13:19: @19[1]: _30 = CheckedSub(_10, const 5_i32)
-13:13-13:19: @20[0]: _10 = move (_30.0: i32)
-14:16-14:17: @20[3]: _32 = _10
-14:16-14:22: @20[4]: _31 = Lt(move _32, const 90_i32)">            if b &lt; 90<span class="annotation">⦉@18,19,20</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code even" style="--layer: 1" title="15:17-15:24: @21[0]: _33 = CheckedSub(_9, const 10_i32)
-15:17-15:24: @23[0]: _9 = move (_33.0: i32)
-16:20-16:27: @23[2]: _34 = _1"><span class="annotation">@21,23⦊</span>a -= 10;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="15:17-15:24: @21[0]: _33 = CheckedSub(_9, const 10_i32)
-15:17-15:24: @23[0]: _9 = move (_33.0: i32)
-16:20-16:27: @23[2]: _34 = _1">                if is_true<span class="annotation">⦉@21,23</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">                    </span><span><span class="code odd" style="--layer: 1" title="17:21-17:33: @24[0]: _0 = const ()"><span class="annotation">@24⦊</span>break 'outer<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="code even" style="--layer: 1" title="19:21-19:27: @25[0]: _36 = CheckedSub(_9, const 2_i32)
-19:21-19:27: @26[0]: _9 = move (_36.0: i32)
-18:24-20:18: @26[1]: _24 = const ()"><span class="annotation">@25,26⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:21-19:27: @25[0]: _36 = CheckedSub(_9, const 2_i32)
-19:21-19:27: @26[0]: _9 = move (_36.0: i32)
-18:24-20:18: @26[1]: _24 = const ()">                    a -= 2;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="19:21-19:27: @25[0]: _36 = CheckedSub(_9, const 2_i32)
-19:21-19:27: @26[0]: _9 = move (_36.0: i32)
-18:24-20:18: @26[1]: _24 = const ()">                }<span class="annotation">⦉@25,26</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:14-21:14: @22[0]: _24 = const ()"><span class="annotation">@22⦊</span>‸<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="23:9-23:23: @28[4]: _37 = CheckedSub(_5, const 1_i32)
-23:9-23:23: @29[0]: _5 = move (_37.0: i32)"><span class="annotation">@28,29⦊</span>countdown -= 1<span class="annotation">⦉@28,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="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="25:2-25:2: @30.Return: return"><span class="annotation">@30⦊</span>‸<span class="annotation">⦉@30</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 2a9b1b10efcd2..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,258 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>overflow.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 14"><span class="line"><span><span class="code even" style="--layer: 1" title="16:25-16:27: @0[1]: _1 = const 10_i32
-16:9-16:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>fn main() -&gt; Result&lt;(),u8&gt; {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="16:25-16:27: @0[1]: _1 = const 10_i32
-16:9-16:22: @0[2]: FakeRead(ForLet, _1)">    let 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">    while </span><span><span class="code odd" style="--layer: 1" title="17:11-17:20: @2[2]: _5 = _1
-17:11-17:24: @2[3]: _4 = Gt(move _5, const 0_i32)
-17:11-17:24: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>countdown &gt; 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">        if </span><span><span class="code even" style="--layer: 1" title="18:12-18:21: @5[3]: _8 = _1
-18:12-18:26: @5[4]: _7 = Eq(move _8, const 1_i32)"><span class="annotation">@3,5⦊</span>countdown == 1<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="19:26-19:44: @6.Call: _9 = might_overflow(const 10_u32) -&gt; [return: bb8, unwind: bb21]
-19:17-19:23: @8[0]: FakeRead(ForLet, _9)
-20:22-20:34: @8[7]: _51 = const main::promoted[1]
-20:22-20:34: @8[8]: _15 = &amp;(*_51)
-20:22-20:34: @8[9]: _14 = &amp;(*_15)
-20:22-20:34: @8[10]: _13 = move _14 as &amp;[&amp;str] (Pointer(Unsize))
-20:36-20:42: @8[18]: _22 = &amp;_9
-20:13-20:44: @8[19]: _21 = (move _22,)
-20:13-20:44: @8[21]: FakeRead(ForMatchedPlace, _21)
-20:13-20:44: @8[23]: _23 = (_21.0: &amp;u32)
-20:13-20:44: @8[26]: _25 = &amp;(*_23)
-20:13-20:44: @8[28]: _26 = &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))
-20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _25, move _26) -&gt; [return: bb9, unwind: bb21]
-20:13-20:44: @9[2]: _20 = [move _24]
-20:13-20:44: @9[5]: _19 = &amp;_20
-20:13-20:44: @9[6]: _18 = &amp;(*_19)
-20:13-20:44: @9[7]: _17 = move _18 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -&gt; [return: bb10, unwind: bb21]
-20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -&gt; [return: bb11, unwind: bb21]
-20:13-20:44: @11[6]: _10 = const ()
-18:27-21:10: @11[8]: _6 = const ()"><span class="annotation">@6,8,9,10,11⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="19:26-19:44: @6.Call: _9 = might_overflow(const 10_u32) -&gt; [return: bb8, unwind: bb21]
-19:17-19:23: @8[0]: FakeRead(ForLet, _9)
-20:22-20:34: @8[7]: _51 = const main::promoted[1]
-20:22-20:34: @8[8]: _15 = &amp;(*_51)
-20:22-20:34: @8[9]: _14 = &amp;(*_15)
-20:22-20:34: @8[10]: _13 = move _14 as &amp;[&amp;str] (Pointer(Unsize))
-20:36-20:42: @8[18]: _22 = &amp;_9
-20:13-20:44: @8[19]: _21 = (move _22,)
-20:13-20:44: @8[21]: FakeRead(ForMatchedPlace, _21)
-20:13-20:44: @8[23]: _23 = (_21.0: &amp;u32)
-20:13-20:44: @8[26]: _25 = &amp;(*_23)
-20:13-20:44: @8[28]: _26 = &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))
-20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _25, move _26) -&gt; [return: bb9, unwind: bb21]
-20:13-20:44: @9[2]: _20 = [move _24]
-20:13-20:44: @9[5]: _19 = &amp;_20
-20:13-20:44: @9[6]: _18 = &amp;(*_19)
-20:13-20:44: @9[7]: _17 = move _18 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -&gt; [return: bb10, unwind: bb21]
-20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -&gt; [return: bb11, unwind: bb21]
-20:13-20:44: @11[6]: _10 = const ()
-18:27-21:10: @11[8]: _6 = const ()">            let result = might_overflow(10);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="19:26-19:44: @6.Call: _9 = might_overflow(const 10_u32) -&gt; [return: bb8, unwind: bb21]
-19:17-19:23: @8[0]: FakeRead(ForLet, _9)
-20:22-20:34: @8[7]: _51 = const main::promoted[1]
-20:22-20:34: @8[8]: _15 = &amp;(*_51)
-20:22-20:34: @8[9]: _14 = &amp;(*_15)
-20:22-20:34: @8[10]: _13 = move _14 as &amp;[&amp;str] (Pointer(Unsize))
-20:36-20:42: @8[18]: _22 = &amp;_9
-20:13-20:44: @8[19]: _21 = (move _22,)
-20:13-20:44: @8[21]: FakeRead(ForMatchedPlace, _21)
-20:13-20:44: @8[23]: _23 = (_21.0: &amp;u32)
-20:13-20:44: @8[26]: _25 = &amp;(*_23)
-20:13-20:44: @8[28]: _26 = &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))
-20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _25, move _26) -&gt; [return: bb9, unwind: bb21]
-20:13-20:44: @9[2]: _20 = [move _24]
-20:13-20:44: @9[5]: _19 = &amp;_20
-20:13-20:44: @9[6]: _18 = &amp;(*_19)
-20:13-20:44: @9[7]: _17 = move _18 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -&gt; [return: bb10, unwind: bb21]
-20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -&gt; [return: bb11, unwind: bb21]
-20:13-20:44: @11[6]: _10 = const ()
-18:27-21:10: @11[8]: _6 = const ()">            println!("Result: {}", result);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="19:26-19:44: @6.Call: _9 = might_overflow(const 10_u32) -&gt; [return: bb8, unwind: bb21]
-19:17-19:23: @8[0]: FakeRead(ForLet, _9)
-20:22-20:34: @8[7]: _51 = const main::promoted[1]
-20:22-20:34: @8[8]: _15 = &amp;(*_51)
-20:22-20:34: @8[9]: _14 = &amp;(*_15)
-20:22-20:34: @8[10]: _13 = move _14 as &amp;[&amp;str] (Pointer(Unsize))
-20:36-20:42: @8[18]: _22 = &amp;_9
-20:13-20:44: @8[19]: _21 = (move _22,)
-20:13-20:44: @8[21]: FakeRead(ForMatchedPlace, _21)
-20:13-20:44: @8[23]: _23 = (_21.0: &amp;u32)
-20:13-20:44: @8[26]: _25 = &amp;(*_23)
-20:13-20:44: @8[28]: _26 = &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))
-20:13-20:44: @8.Call: _24 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _25, move _26) -&gt; [return: bb9, unwind: bb21]
-20:13-20:44: @9[2]: _20 = [move _24]
-20:13-20:44: @9[5]: _19 = &amp;_20
-20:13-20:44: @9[6]: _18 = &amp;(*_19)
-20:13-20:44: @9[7]: _17 = move _18 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-20:13-20:44: @9.Call: _12 = std::fmt::Arguments::new_v1(move _13, move _17) -&gt; [return: bb10, unwind: bb21]
-20:13-20:44: @10.Call: _11 = std::io::_print(move _12) -&gt; [return: bb11, unwind: bb21]
-20:13-20:44: @11[6]: _10 = const ()
-18:27-21:10: @11[8]: _6 = const ()">        }<span class="annotation">⦉@6,8,9,10,11</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code even" style="--layer: 1" title="21:19-21:28: @7[2]: _28 = _1
-21:19-21:32: @7[3]: _27 = Lt(move _28, const 5_i32)"><span class="annotation">@7⦊</span>countdown &lt; 5<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -&gt; [return: bb14, unwind: bb21]
-22:17-22:23: @14[0]: FakeRead(ForLet, _29)
-23:22-23:34: @14[7]: _50 = const main::promoted[0]
-23:22-23:34: @14[8]: _35 = &amp;(*_50)
-23:22-23:34: @14[9]: _34 = &amp;(*_35)
-23:22-23:34: @14[10]: _33 = move _34 as &amp;[&amp;str] (Pointer(Unsize))
-23:36-23:42: @14[18]: _42 = &amp;_29
-23:13-23:44: @14[19]: _41 = (move _42,)
-23:13-23:44: @14[21]: FakeRead(ForMatchedPlace, _41)
-23:13-23:44: @14[23]: _43 = (_41.0: &amp;u32)
-23:13-23:44: @14[26]: _45 = &amp;(*_43)
-23:13-23:44: @14[28]: _46 = &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))
-23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _45, move _46) -&gt; [return: bb15, unwind: bb21]
-23:13-23:44: @15[2]: _40 = [move _44]
-23:13-23:44: @15[5]: _39 = &amp;_40
-23:13-23:44: @15[6]: _38 = &amp;(*_39)
-23:13-23:44: @15[7]: _37 = move _38 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -&gt; [return: bb16, unwind: bb21]
-23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -&gt; [return: bb17, unwind: bb21]
-23:13-23:44: @17[6]: _30 = const ()
-21:33-24:10: @17[8]: _6 = const ()"><span class="annotation">@12,14,15,16,17⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -&gt; [return: bb14, unwind: bb21]
-22:17-22:23: @14[0]: FakeRead(ForLet, _29)
-23:22-23:34: @14[7]: _50 = const main::promoted[0]
-23:22-23:34: @14[8]: _35 = &amp;(*_50)
-23:22-23:34: @14[9]: _34 = &amp;(*_35)
-23:22-23:34: @14[10]: _33 = move _34 as &amp;[&amp;str] (Pointer(Unsize))
-23:36-23:42: @14[18]: _42 = &amp;_29
-23:13-23:44: @14[19]: _41 = (move _42,)
-23:13-23:44: @14[21]: FakeRead(ForMatchedPlace, _41)
-23:13-23:44: @14[23]: _43 = (_41.0: &amp;u32)
-23:13-23:44: @14[26]: _45 = &amp;(*_43)
-23:13-23:44: @14[28]: _46 = &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))
-23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _45, move _46) -&gt; [return: bb15, unwind: bb21]
-23:13-23:44: @15[2]: _40 = [move _44]
-23:13-23:44: @15[5]: _39 = &amp;_40
-23:13-23:44: @15[6]: _38 = &amp;(*_39)
-23:13-23:44: @15[7]: _37 = move _38 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -&gt; [return: bb16, unwind: bb21]
-23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -&gt; [return: bb17, unwind: bb21]
-23:13-23:44: @17[6]: _30 = const ()
-21:33-24:10: @17[8]: _6 = const ()">            let result = might_overflow(1);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -&gt; [return: bb14, unwind: bb21]
-22:17-22:23: @14[0]: FakeRead(ForLet, _29)
-23:22-23:34: @14[7]: _50 = const main::promoted[0]
-23:22-23:34: @14[8]: _35 = &amp;(*_50)
-23:22-23:34: @14[9]: _34 = &amp;(*_35)
-23:22-23:34: @14[10]: _33 = move _34 as &amp;[&amp;str] (Pointer(Unsize))
-23:36-23:42: @14[18]: _42 = &amp;_29
-23:13-23:44: @14[19]: _41 = (move _42,)
-23:13-23:44: @14[21]: FakeRead(ForMatchedPlace, _41)
-23:13-23:44: @14[23]: _43 = (_41.0: &amp;u32)
-23:13-23:44: @14[26]: _45 = &amp;(*_43)
-23:13-23:44: @14[28]: _46 = &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))
-23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _45, move _46) -&gt; [return: bb15, unwind: bb21]
-23:13-23:44: @15[2]: _40 = [move _44]
-23:13-23:44: @15[5]: _39 = &amp;_40
-23:13-23:44: @15[6]: _38 = &amp;(*_39)
-23:13-23:44: @15[7]: _37 = move _38 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -&gt; [return: bb16, unwind: bb21]
-23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -&gt; [return: bb17, unwind: bb21]
-23:13-23:44: @17[6]: _30 = const ()
-21:33-24:10: @17[8]: _6 = const ()">            println!("Result: {}", result);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="22:26-22:43: @12.Call: _29 = might_overflow(const 1_u32) -&gt; [return: bb14, unwind: bb21]
-22:17-22:23: @14[0]: FakeRead(ForLet, _29)
-23:22-23:34: @14[7]: _50 = const main::promoted[0]
-23:22-23:34: @14[8]: _35 = &amp;(*_50)
-23:22-23:34: @14[9]: _34 = &amp;(*_35)
-23:22-23:34: @14[10]: _33 = move _34 as &amp;[&amp;str] (Pointer(Unsize))
-23:36-23:42: @14[18]: _42 = &amp;_29
-23:13-23:44: @14[19]: _41 = (move _42,)
-23:13-23:44: @14[21]: FakeRead(ForMatchedPlace, _41)
-23:13-23:44: @14[23]: _43 = (_41.0: &amp;u32)
-23:13-23:44: @14[26]: _45 = &amp;(*_43)
-23:13-23:44: @14[28]: _46 = &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))
-23:13-23:44: @14.Call: _44 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _45, move _46) -&gt; [return: bb15, unwind: bb21]
-23:13-23:44: @15[2]: _40 = [move _44]
-23:13-23:44: @15[5]: _39 = &amp;_40
-23:13-23:44: @15[6]: _38 = &amp;(*_39)
-23:13-23:44: @15[7]: _37 = move _38 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-23:13-23:44: @15.Call: _32 = std::fmt::Arguments::new_v1(move _33, move _37) -&gt; [return: bb16, unwind: bb21]
-23:13-23:44: @16.Call: _31 = std::io::_print(move _32) -&gt; [return: bb17, unwind: bb21]
-23:13-23:44: @17[6]: _30 = const ()
-21:33-24:10: @17[8]: _6 = const ()">        }<span class="annotation">⦉@12,14,15,16,17</span></span></span><span><span class="code even" style="--layer: 1" title="24:10-24:10: @13[0]: _6 = const ()"><span class="annotation">@13⦊</span>‸<span class="annotation">⦉@13</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="25:9-25:23: @19[2]: _47 = CheckedSub(_1, const 1_i32)
-25:9-25:23: @20[0]: _1 = move (_47.0: i32)"><span class="annotation">@19,20⦊</span>countdown -= 1<span class="annotation">⦉@19,20</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code even" style="--layer: 1" title="27:8-27:10: @4[4]: _49 = ()
-27:5-27:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _49)
-28:2-28:2: @4.Return: return"><span class="annotation">@4⦊</span>Ok(())</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="27:8-27:10: @4[4]: _49 = ()
-27:5-27:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _49)
-28:2-28:2: @4.Return: return">}<span class="annotation">⦉@4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html
deleted file mode 100644
index c6043f0bd07fe..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,394 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>overflow.might_overflow - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line"><span><span class="code even" style="--layer: 1" title="5:8-5:14: @0[3]: _4 = _1
-5:8-5:18: @0[4]: _3 = Gt(move _4, const 5_u32)"><span class="annotation">@0⦊</span>fn might_overflow(to_add: u32) -&gt; u32 {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="5:8-5:14: @0[3]: _4 = _1
-5:8-5:18: @0[4]: _3 = Gt(move _4, const 5_u32)">    if to_add &gt; 5<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="6:18-6:47: @1[6]: _61 = const might_overflow::promoted[4]
-6:18-6:47: @1[7]: _10 = &amp;(*_61)
-6:18-6:47: @1[8]: _9 = &amp;(*_10)
-6:18-6:47: @1[9]: _8 = move _9 as &amp;[&amp;str] (Pointer(Unsize))
-6:9-6:49: @1[15]: _16 = ()
-6:9-6:49: @1[16]: FakeRead(ForMatchedPlace, _16)
-6:9-6:49: @1[17]: _60 = const might_overflow::promoted[3]
-6:9-6:49: @1[18]: _14 = &amp;(*_60)
-6:9-6:49: @1[19]: _13 = &amp;(*_14)
-6:9-6:49: @1[20]: _12 = move _13 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-6:9-6:49: @1.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -&gt; [return: bb3, unwind: bb14]
-6:9-6:49: @3.Call: _6 = std::io::_print(move _7) -&gt; [return: bb4, unwind: bb14]
-6:9-6:49: @4[5]: _5 = const ()
-5:19-7:6: @4[7]: _2 = const ()"><span class="annotation">@1,3,4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="6:18-6:47: @1[6]: _61 = const might_overflow::promoted[4]
-6:18-6:47: @1[7]: _10 = &amp;(*_61)
-6:18-6:47: @1[8]: _9 = &amp;(*_10)
-6:18-6:47: @1[9]: _8 = move _9 as &amp;[&amp;str] (Pointer(Unsize))
-6:9-6:49: @1[15]: _16 = ()
-6:9-6:49: @1[16]: FakeRead(ForMatchedPlace, _16)
-6:9-6:49: @1[17]: _60 = const might_overflow::promoted[3]
-6:9-6:49: @1[18]: _14 = &amp;(*_60)
-6:9-6:49: @1[19]: _13 = &amp;(*_14)
-6:9-6:49: @1[20]: _12 = move _13 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-6:9-6:49: @1.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -&gt; [return: bb3, unwind: bb14]
-6:9-6:49: @3.Call: _6 = std::io::_print(move _7) -&gt; [return: bb4, unwind: bb14]
-6:9-6:49: @4[5]: _5 = const ()
-5:19-7:6: @4[7]: _2 = const ()">        println!("this will probably overflow");</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="6:18-6:47: @1[6]: _61 = const might_overflow::promoted[4]
-6:18-6:47: @1[7]: _10 = &amp;(*_61)
-6:18-6:47: @1[8]: _9 = &amp;(*_10)
-6:18-6:47: @1[9]: _8 = move _9 as &amp;[&amp;str] (Pointer(Unsize))
-6:9-6:49: @1[15]: _16 = ()
-6:9-6:49: @1[16]: FakeRead(ForMatchedPlace, _16)
-6:9-6:49: @1[17]: _60 = const might_overflow::promoted[3]
-6:9-6:49: @1[18]: _14 = &amp;(*_60)
-6:9-6:49: @1[19]: _13 = &amp;(*_14)
-6:9-6:49: @1[20]: _12 = move _13 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-6:9-6:49: @1.Call: _7 = std::fmt::Arguments::new_v1(move _8, move _12) -&gt; [return: bb3, unwind: bb14]
-6:9-6:49: @3.Call: _6 = std::io::_print(move _7) -&gt; [return: bb4, unwind: bb14]
-6:9-6:49: @4[5]: _5 = const ()
-5:19-7:6: @4[7]: _2 = const ()">    }<span class="annotation">⦉@1,3,4</span></span></span><span><span class="code even" style="--layer: 1" title="7:6-7:6: @2[0]: _2 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="8:18-8:30: @5[3]: _18 = CheckedSub(const core::num::&lt;impl u32&gt;::MAX, const 5_u32)
-8:18-8:30: @6[0]: _17 = move (_18.0: u32)
-8:9-8:15: @6[1]: FakeRead(ForLet, _17)
-9:14-9:38: @6[8]: _59 = const might_overflow::promoted[2]
-9:14-9:38: @6[9]: _24 = &amp;(*_59)
-9:14-9:38: @6[10]: _23 = &amp;(*_24)
-9:14-9:38: @6[11]: _22 = move _23 as &amp;[&amp;str] (Pointer(Unsize))
-9:40-9:46: @6[19]: _31 = &amp;_17
-9:48-9:54: @6[21]: _32 = &amp;_1
-9:5-9:56: @6[22]: _30 = (move _31, move _32)
-9:5-9:56: @6[25]: FakeRead(ForMatchedPlace, _30)
-9:5-9:56: @6[27]: _33 = (_30.0: &amp;u32)
-9:5-9:56: @6[29]: _34 = (_30.1: &amp;u32)
-9:5-9:56: @6[32]: _36 = &amp;(*_33)
-9:5-9:56: @6[34]: _37 = &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))
-9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _36, move _37) -&gt; [return: bb7, unwind: bb14]
-9:5-9:56: @7[4]: _39 = &amp;(*_34)
-9:5-9:56: @7[6]: _40 = &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))
-9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _39, move _40) -&gt; [return: bb8, unwind: bb14]
-9:5-9:56: @8[2]: _29 = [move _35, move _38]
-9:5-9:56: @8[7]: _28 = &amp;_29
-9:5-9:56: @8[8]: _27 = &amp;(*_28)
-9:5-9:56: @8[9]: _26 = move _27 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -&gt; [return: bb9, unwind: bb14]
-9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -&gt; [return: bb10, unwind: bb14]
-9:5-9:56: @10[6]: _19 = const ()
-10:18-10:24: @10[10]: _42 = _1
-10:27-10:33: @10[12]: _43 = _17
-10:18-10:33: @10[13]: _44 = CheckedAdd(_42, _43)
-10:18-10:33: @11[0]: _41 = move (_44.0: u32)
-10:9-10:15: @11[3]: FakeRead(ForLet, _41)
-11:14-11:47: @11[10]: _58 = const might_overflow::promoted[1]
-11:14-11:47: @11[11]: _50 = &amp;(*_58)
-11:14-11:47: @11[12]: _49 = &amp;(*_50)
-11:14-11:47: @11[13]: _48 = move _49 as &amp;[&amp;str] (Pointer(Unsize))
-11:5-11:49: @11[19]: _56 = ()
-11:5-11:49: @11[20]: FakeRead(ForMatchedPlace, _56)
-11:5-11:49: @11[21]: _57 = const might_overflow::promoted[0]
-11:5-11:49: @11[22]: _54 = &amp;(*_57)
-11:5-11:49: @11[23]: _53 = &amp;(*_54)
-11:5-11:49: @11[24]: _52 = move _53 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -&gt; [return: bb12, unwind: bb14]
-11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -&gt; [return: bb13, unwind: bb14]
-11:5-11:49: @13[5]: _45 = const ()
-12:5-12:11: @13[7]: _0 = _41
-13:2-13:2: @13.Return: return"><span class="annotation">@5,6,7,8,9,10,11,12,13⦊</span>add_to = u32::MAX - 5;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="8:18-8:30: @5[3]: _18 = CheckedSub(const core::num::&lt;impl u32&gt;::MAX, const 5_u32)
-8:18-8:30: @6[0]: _17 = move (_18.0: u32)
-8:9-8:15: @6[1]: FakeRead(ForLet, _17)
-9:14-9:38: @6[8]: _59 = const might_overflow::promoted[2]
-9:14-9:38: @6[9]: _24 = &amp;(*_59)
-9:14-9:38: @6[10]: _23 = &amp;(*_24)
-9:14-9:38: @6[11]: _22 = move _23 as &amp;[&amp;str] (Pointer(Unsize))
-9:40-9:46: @6[19]: _31 = &amp;_17
-9:48-9:54: @6[21]: _32 = &amp;_1
-9:5-9:56: @6[22]: _30 = (move _31, move _32)
-9:5-9:56: @6[25]: FakeRead(ForMatchedPlace, _30)
-9:5-9:56: @6[27]: _33 = (_30.0: &amp;u32)
-9:5-9:56: @6[29]: _34 = (_30.1: &amp;u32)
-9:5-9:56: @6[32]: _36 = &amp;(*_33)
-9:5-9:56: @6[34]: _37 = &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))
-9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _36, move _37) -&gt; [return: bb7, unwind: bb14]
-9:5-9:56: @7[4]: _39 = &amp;(*_34)
-9:5-9:56: @7[6]: _40 = &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))
-9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _39, move _40) -&gt; [return: bb8, unwind: bb14]
-9:5-9:56: @8[2]: _29 = [move _35, move _38]
-9:5-9:56: @8[7]: _28 = &amp;_29
-9:5-9:56: @8[8]: _27 = &amp;(*_28)
-9:5-9:56: @8[9]: _26 = move _27 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -&gt; [return: bb9, unwind: bb14]
-9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -&gt; [return: bb10, unwind: bb14]
-9:5-9:56: @10[6]: _19 = const ()
-10:18-10:24: @10[10]: _42 = _1
-10:27-10:33: @10[12]: _43 = _17
-10:18-10:33: @10[13]: _44 = CheckedAdd(_42, _43)
-10:18-10:33: @11[0]: _41 = move (_44.0: u32)
-10:9-10:15: @11[3]: FakeRead(ForLet, _41)
-11:14-11:47: @11[10]: _58 = const might_overflow::promoted[1]
-11:14-11:47: @11[11]: _50 = &amp;(*_58)
-11:14-11:47: @11[12]: _49 = &amp;(*_50)
-11:14-11:47: @11[13]: _48 = move _49 as &amp;[&amp;str] (Pointer(Unsize))
-11:5-11:49: @11[19]: _56 = ()
-11:5-11:49: @11[20]: FakeRead(ForMatchedPlace, _56)
-11:5-11:49: @11[21]: _57 = const might_overflow::promoted[0]
-11:5-11:49: @11[22]: _54 = &amp;(*_57)
-11:5-11:49: @11[23]: _53 = &amp;(*_54)
-11:5-11:49: @11[24]: _52 = move _53 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -&gt; [return: bb12, unwind: bb14]
-11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -&gt; [return: bb13, unwind: bb14]
-11:5-11:49: @13[5]: _45 = const ()
-12:5-12:11: @13[7]: _0 = _41
-13:2-13:2: @13.Return: return">    println!("does {} + {} overflow?", add_to, to_add);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="8:18-8:30: @5[3]: _18 = CheckedSub(const core::num::&lt;impl u32&gt;::MAX, const 5_u32)
-8:18-8:30: @6[0]: _17 = move (_18.0: u32)
-8:9-8:15: @6[1]: FakeRead(ForLet, _17)
-9:14-9:38: @6[8]: _59 = const might_overflow::promoted[2]
-9:14-9:38: @6[9]: _24 = &amp;(*_59)
-9:14-9:38: @6[10]: _23 = &amp;(*_24)
-9:14-9:38: @6[11]: _22 = move _23 as &amp;[&amp;str] (Pointer(Unsize))
-9:40-9:46: @6[19]: _31 = &amp;_17
-9:48-9:54: @6[21]: _32 = &amp;_1
-9:5-9:56: @6[22]: _30 = (move _31, move _32)
-9:5-9:56: @6[25]: FakeRead(ForMatchedPlace, _30)
-9:5-9:56: @6[27]: _33 = (_30.0: &amp;u32)
-9:5-9:56: @6[29]: _34 = (_30.1: &amp;u32)
-9:5-9:56: @6[32]: _36 = &amp;(*_33)
-9:5-9:56: @6[34]: _37 = &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))
-9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _36, move _37) -&gt; [return: bb7, unwind: bb14]
-9:5-9:56: @7[4]: _39 = &amp;(*_34)
-9:5-9:56: @7[6]: _40 = &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))
-9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _39, move _40) -&gt; [return: bb8, unwind: bb14]
-9:5-9:56: @8[2]: _29 = [move _35, move _38]
-9:5-9:56: @8[7]: _28 = &amp;_29
-9:5-9:56: @8[8]: _27 = &amp;(*_28)
-9:5-9:56: @8[9]: _26 = move _27 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -&gt; [return: bb9, unwind: bb14]
-9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -&gt; [return: bb10, unwind: bb14]
-9:5-9:56: @10[6]: _19 = const ()
-10:18-10:24: @10[10]: _42 = _1
-10:27-10:33: @10[12]: _43 = _17
-10:18-10:33: @10[13]: _44 = CheckedAdd(_42, _43)
-10:18-10:33: @11[0]: _41 = move (_44.0: u32)
-10:9-10:15: @11[3]: FakeRead(ForLet, _41)
-11:14-11:47: @11[10]: _58 = const might_overflow::promoted[1]
-11:14-11:47: @11[11]: _50 = &amp;(*_58)
-11:14-11:47: @11[12]: _49 = &amp;(*_50)
-11:14-11:47: @11[13]: _48 = move _49 as &amp;[&amp;str] (Pointer(Unsize))
-11:5-11:49: @11[19]: _56 = ()
-11:5-11:49: @11[20]: FakeRead(ForMatchedPlace, _56)
-11:5-11:49: @11[21]: _57 = const might_overflow::promoted[0]
-11:5-11:49: @11[22]: _54 = &amp;(*_57)
-11:5-11:49: @11[23]: _53 = &amp;(*_54)
-11:5-11:49: @11[24]: _52 = move _53 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -&gt; [return: bb12, unwind: bb14]
-11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -&gt; [return: bb13, unwind: bb14]
-11:5-11:49: @13[5]: _45 = const ()
-12:5-12:11: @13[7]: _0 = _41
-13:2-13:2: @13.Return: return">    let result = to_add + add_to;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="8:18-8:30: @5[3]: _18 = CheckedSub(const core::num::&lt;impl u32&gt;::MAX, const 5_u32)
-8:18-8:30: @6[0]: _17 = move (_18.0: u32)
-8:9-8:15: @6[1]: FakeRead(ForLet, _17)
-9:14-9:38: @6[8]: _59 = const might_overflow::promoted[2]
-9:14-9:38: @6[9]: _24 = &amp;(*_59)
-9:14-9:38: @6[10]: _23 = &amp;(*_24)
-9:14-9:38: @6[11]: _22 = move _23 as &amp;[&amp;str] (Pointer(Unsize))
-9:40-9:46: @6[19]: _31 = &amp;_17
-9:48-9:54: @6[21]: _32 = &amp;_1
-9:5-9:56: @6[22]: _30 = (move _31, move _32)
-9:5-9:56: @6[25]: FakeRead(ForMatchedPlace, _30)
-9:5-9:56: @6[27]: _33 = (_30.0: &amp;u32)
-9:5-9:56: @6[29]: _34 = (_30.1: &amp;u32)
-9:5-9:56: @6[32]: _36 = &amp;(*_33)
-9:5-9:56: @6[34]: _37 = &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))
-9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _36, move _37) -&gt; [return: bb7, unwind: bb14]
-9:5-9:56: @7[4]: _39 = &amp;(*_34)
-9:5-9:56: @7[6]: _40 = &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))
-9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _39, move _40) -&gt; [return: bb8, unwind: bb14]
-9:5-9:56: @8[2]: _29 = [move _35, move _38]
-9:5-9:56: @8[7]: _28 = &amp;_29
-9:5-9:56: @8[8]: _27 = &amp;(*_28)
-9:5-9:56: @8[9]: _26 = move _27 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -&gt; [return: bb9, unwind: bb14]
-9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -&gt; [return: bb10, unwind: bb14]
-9:5-9:56: @10[6]: _19 = const ()
-10:18-10:24: @10[10]: _42 = _1
-10:27-10:33: @10[12]: _43 = _17
-10:18-10:33: @10[13]: _44 = CheckedAdd(_42, _43)
-10:18-10:33: @11[0]: _41 = move (_44.0: u32)
-10:9-10:15: @11[3]: FakeRead(ForLet, _41)
-11:14-11:47: @11[10]: _58 = const might_overflow::promoted[1]
-11:14-11:47: @11[11]: _50 = &amp;(*_58)
-11:14-11:47: @11[12]: _49 = &amp;(*_50)
-11:14-11:47: @11[13]: _48 = move _49 as &amp;[&amp;str] (Pointer(Unsize))
-11:5-11:49: @11[19]: _56 = ()
-11:5-11:49: @11[20]: FakeRead(ForMatchedPlace, _56)
-11:5-11:49: @11[21]: _57 = const might_overflow::promoted[0]
-11:5-11:49: @11[22]: _54 = &amp;(*_57)
-11:5-11:49: @11[23]: _53 = &amp;(*_54)
-11:5-11:49: @11[24]: _52 = move _53 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -&gt; [return: bb12, unwind: bb14]
-11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -&gt; [return: bb13, unwind: bb14]
-11:5-11:49: @13[5]: _45 = const ()
-12:5-12:11: @13[7]: _0 = _41
-13:2-13:2: @13.Return: return">    println!("continuing after overflow check");</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="8:18-8:30: @5[3]: _18 = CheckedSub(const core::num::&lt;impl u32&gt;::MAX, const 5_u32)
-8:18-8:30: @6[0]: _17 = move (_18.0: u32)
-8:9-8:15: @6[1]: FakeRead(ForLet, _17)
-9:14-9:38: @6[8]: _59 = const might_overflow::promoted[2]
-9:14-9:38: @6[9]: _24 = &amp;(*_59)
-9:14-9:38: @6[10]: _23 = &amp;(*_24)
-9:14-9:38: @6[11]: _22 = move _23 as &amp;[&amp;str] (Pointer(Unsize))
-9:40-9:46: @6[19]: _31 = &amp;_17
-9:48-9:54: @6[21]: _32 = &amp;_1
-9:5-9:56: @6[22]: _30 = (move _31, move _32)
-9:5-9:56: @6[25]: FakeRead(ForMatchedPlace, _30)
-9:5-9:56: @6[27]: _33 = (_30.0: &amp;u32)
-9:5-9:56: @6[29]: _34 = (_30.1: &amp;u32)
-9:5-9:56: @6[32]: _36 = &amp;(*_33)
-9:5-9:56: @6[34]: _37 = &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))
-9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _36, move _37) -&gt; [return: bb7, unwind: bb14]
-9:5-9:56: @7[4]: _39 = &amp;(*_34)
-9:5-9:56: @7[6]: _40 = &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))
-9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _39, move _40) -&gt; [return: bb8, unwind: bb14]
-9:5-9:56: @8[2]: _29 = [move _35, move _38]
-9:5-9:56: @8[7]: _28 = &amp;_29
-9:5-9:56: @8[8]: _27 = &amp;(*_28)
-9:5-9:56: @8[9]: _26 = move _27 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -&gt; [return: bb9, unwind: bb14]
-9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -&gt; [return: bb10, unwind: bb14]
-9:5-9:56: @10[6]: _19 = const ()
-10:18-10:24: @10[10]: _42 = _1
-10:27-10:33: @10[12]: _43 = _17
-10:18-10:33: @10[13]: _44 = CheckedAdd(_42, _43)
-10:18-10:33: @11[0]: _41 = move (_44.0: u32)
-10:9-10:15: @11[3]: FakeRead(ForLet, _41)
-11:14-11:47: @11[10]: _58 = const might_overflow::promoted[1]
-11:14-11:47: @11[11]: _50 = &amp;(*_58)
-11:14-11:47: @11[12]: _49 = &amp;(*_50)
-11:14-11:47: @11[13]: _48 = move _49 as &amp;[&amp;str] (Pointer(Unsize))
-11:5-11:49: @11[19]: _56 = ()
-11:5-11:49: @11[20]: FakeRead(ForMatchedPlace, _56)
-11:5-11:49: @11[21]: _57 = const might_overflow::promoted[0]
-11:5-11:49: @11[22]: _54 = &amp;(*_57)
-11:5-11:49: @11[23]: _53 = &amp;(*_54)
-11:5-11:49: @11[24]: _52 = move _53 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -&gt; [return: bb12, unwind: bb14]
-11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -&gt; [return: bb13, unwind: bb14]
-11:5-11:49: @13[5]: _45 = const ()
-12:5-12:11: @13[7]: _0 = _41
-13:2-13:2: @13.Return: return">    result</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="8:18-8:30: @5[3]: _18 = CheckedSub(const core::num::&lt;impl u32&gt;::MAX, const 5_u32)
-8:18-8:30: @6[0]: _17 = move (_18.0: u32)
-8:9-8:15: @6[1]: FakeRead(ForLet, _17)
-9:14-9:38: @6[8]: _59 = const might_overflow::promoted[2]
-9:14-9:38: @6[9]: _24 = &amp;(*_59)
-9:14-9:38: @6[10]: _23 = &amp;(*_24)
-9:14-9:38: @6[11]: _22 = move _23 as &amp;[&amp;str] (Pointer(Unsize))
-9:40-9:46: @6[19]: _31 = &amp;_17
-9:48-9:54: @6[21]: _32 = &amp;_1
-9:5-9:56: @6[22]: _30 = (move _31, move _32)
-9:5-9:56: @6[25]: FakeRead(ForMatchedPlace, _30)
-9:5-9:56: @6[27]: _33 = (_30.0: &amp;u32)
-9:5-9:56: @6[29]: _34 = (_30.1: &amp;u32)
-9:5-9:56: @6[32]: _36 = &amp;(*_33)
-9:5-9:56: @6[34]: _37 = &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))
-9:5-9:56: @6.Call: _35 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _36, move _37) -&gt; [return: bb7, unwind: bb14]
-9:5-9:56: @7[4]: _39 = &amp;(*_34)
-9:5-9:56: @7[6]: _40 = &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))
-9:5-9:56: @7.Call: _38 = std::fmt::ArgumentV1::new::&lt;u32&gt;(move _39, move _40) -&gt; [return: bb8, unwind: bb14]
-9:5-9:56: @8[2]: _29 = [move _35, move _38]
-9:5-9:56: @8[7]: _28 = &amp;_29
-9:5-9:56: @8[8]: _27 = &amp;(*_28)
-9:5-9:56: @8[9]: _26 = move _27 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:5-9:56: @8.Call: _21 = std::fmt::Arguments::new_v1(move _22, move _26) -&gt; [return: bb9, unwind: bb14]
-9:5-9:56: @9.Call: _20 = std::io::_print(move _21) -&gt; [return: bb10, unwind: bb14]
-9:5-9:56: @10[6]: _19 = const ()
-10:18-10:24: @10[10]: _42 = _1
-10:27-10:33: @10[12]: _43 = _17
-10:18-10:33: @10[13]: _44 = CheckedAdd(_42, _43)
-10:18-10:33: @11[0]: _41 = move (_44.0: u32)
-10:9-10:15: @11[3]: FakeRead(ForLet, _41)
-11:14-11:47: @11[10]: _58 = const might_overflow::promoted[1]
-11:14-11:47: @11[11]: _50 = &amp;(*_58)
-11:14-11:47: @11[12]: _49 = &amp;(*_50)
-11:14-11:47: @11[13]: _48 = move _49 as &amp;[&amp;str] (Pointer(Unsize))
-11:5-11:49: @11[19]: _56 = ()
-11:5-11:49: @11[20]: FakeRead(ForMatchedPlace, _56)
-11:5-11:49: @11[21]: _57 = const might_overflow::promoted[0]
-11:5-11:49: @11[22]: _54 = &amp;(*_57)
-11:5-11:49: @11[23]: _53 = &amp;(*_54)
-11:5-11:49: @11[24]: _52 = move _53 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-11:5-11:49: @11.Call: _47 = std::fmt::Arguments::new_v1(move _48, move _52) -&gt; [return: bb12, unwind: bb14]
-11:5-11:49: @12.Call: _46 = std::io::_print(move _47) -&gt; [return: bb13, unwind: bb14]
-11:5-11:49: @13[5]: _45 = const ()
-12:5-12:11: @13[7]: _0 = _41
-13:2-13:2: @13.Return: return">}<span class="annotation">⦉@5,6,7,8,9,10,11,12,13</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 5b097f118e3a8..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,102 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>panic_unwind.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 12"><span class="line"><span><span class="code even" style="--layer: 1" title="14:25-14:27: @0[1]: _1 = const 10_i32
-14:9-14:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>fn main() -&gt; Result&lt;(), u8&gt; {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="14:25-14:27: @0[1]: _1 = const 10_i32
-14:9-14:22: @0[2]: FakeRead(ForLet, _1)">    let 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">    while </span><span><span class="code odd" style="--layer: 1" title="15:11-15:20: @2[2]: _5 = _1
-15:11-15:24: @2[3]: _4 = Gt(move _5, const 0_i32)
-15:11-15:24: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>countdown &gt; 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">        if </span><span><span class="code even" style="--layer: 1" title="16:12-16:21: @5[3]: _8 = _1
-16:12-16:26: @5[4]: _7 = Eq(move _8, const 1_i32)"><span class="annotation">@3,5⦊</span>countdown == 1<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="17:13-17:30: @6.Call: _9 = might_panic(const true) -&gt; [return: bb8, unwind: bb15]
-16:27-18:10: @8[1]: _6 = const ()"><span class="annotation">@6,8⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="17:13-17:30: @6.Call: _9 = might_panic(const true) -&gt; [return: bb8, unwind: bb15]
-16:27-18:10: @8[1]: _6 = const ()">            might_panic(true);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="17:13-17:30: @6.Call: _9 = might_panic(const true) -&gt; [return: bb8, unwind: bb15]
-16:27-18:10: @8[1]: _6 = const ()">        }<span class="annotation">⦉@6,8</span></span></span><span class="code" style="--layer: 0"> else if </span><span><span class="code even" style="--layer: 1" title="18:19-18:28: @7[2]: _11 = _1
-18:19-18:32: @7[3]: _10 = Lt(move _11, const 5_i32)"><span class="annotation">@7⦊</span>countdown &lt; 5<span class="annotation">⦉@7</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="19:13-19:31: @9.Call: _12 = might_panic(const false) -&gt; [return: bb11, unwind: bb15]
-18:33-20:10: @11[1]: _6 = const ()"><span class="annotation">@9,11⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="19:13-19:31: @9.Call: _12 = might_panic(const false) -&gt; [return: bb11, unwind: bb15]
-18:33-20:10: @11[1]: _6 = const ()">            might_panic(false);</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="19:13-19:31: @9.Call: _12 = might_panic(const false) -&gt; [return: bb11, unwind: bb15]
-18:33-20:10: @11[1]: _6 = const ()">        }<span class="annotation">⦉@9,11</span></span></span><span><span class="code even" style="--layer: 1" title="20:10-20:10: @10[0]: _6 = const ()"><span class="annotation">@10⦊</span>‸<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="code odd" style="--layer: 1" title="21:9-21:23: @13[2]: _13 = CheckedSub(_1, const 1_i32)
-21:9-21:23: @14[0]: _1 = move (_13.0: i32)"><span class="annotation">@13,14⦊</span>countdown -= 1<span class="annotation">⦉@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">    </span><span><span class="code even" style="--layer: 1" title="23:8-23:10: @4[4]: _15 = ()
-23:5-23:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _15)
-24:2-24:2: @4.Return: return"><span class="annotation">@4⦊</span>Ok(())</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:8-23:10: @4[4]: _15 = ()
-23:5-23:11: @4[5]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _15)
-24:2-24:2: @4.Return: return">}<span class="annotation">⦉@4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 32988629ba0eb..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,163 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>panic_unwind.might_panic - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0⦊</span>fn might_panic(should_panic: bool) <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:20: @0[1]: _2 = _1"><span class="annotation">@0⦊</span>should_panic<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:18-6:32: @1[6]: _33 = const might_panic::promoted[3]
-6:18-6:32: @1[7]: _9 = &amp;(*_33)
-6:18-6:32: @1[8]: _8 = &amp;(*_9)
-6:18-6:32: @1[9]: _7 = move _8 as &amp;[&amp;str] (Pointer(Unsize))
-6:9-6:34: @1[15]: _15 = ()
-6:9-6:34: @1[16]: FakeRead(ForMatchedPlace, _15)
-6:9-6:34: @1[17]: _32 = const might_panic::promoted[2]
-6:9-6:34: @1[18]: _13 = &amp;(*_32)
-6:9-6:34: @1[19]: _12 = &amp;(*_13)
-6:9-6:34: @1[20]: _11 = move _12 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-6:9-6:34: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -&gt; [return: bb3, unwind: bb7]
-6:9-6:34: @3.Call: _5 = std::io::_print(move _6) -&gt; [return: bb4, unwind: bb7]
-6:9-6:34: @4[5]: _4 = const ()
-7:9-7:26: @4.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;panics&quot;) -&gt; bb7"><span class="annotation">@1,3,4⦊</span>println!("panicking...");</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="6:18-6:32: @1[6]: _33 = const might_panic::promoted[3]
-6:18-6:32: @1[7]: _9 = &amp;(*_33)
-6:18-6:32: @1[8]: _8 = &amp;(*_9)
-6:18-6:32: @1[9]: _7 = move _8 as &amp;[&amp;str] (Pointer(Unsize))
-6:9-6:34: @1[15]: _15 = ()
-6:9-6:34: @1[16]: FakeRead(ForMatchedPlace, _15)
-6:9-6:34: @1[17]: _32 = const might_panic::promoted[2]
-6:9-6:34: @1[18]: _13 = &amp;(*_32)
-6:9-6:34: @1[19]: _12 = &amp;(*_13)
-6:9-6:34: @1[20]: _11 = move _12 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-6:9-6:34: @1.Call: _6 = std::fmt::Arguments::new_v1(move _7, move _11) -&gt; [return: bb3, unwind: bb7]
-6:9-6:34: @3.Call: _5 = std::io::_print(move _6) -&gt; [return: bb4, unwind: bb7]
-6:9-6:34: @4[5]: _4 = const ()
-7:9-7:26: @4.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;panics&quot;) -&gt; bb7">        panic!("panics");<span class="annotation">⦉@1,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    } else </span><span><span class="code even" style="--layer: 1" title="9:18-9:31: @2[6]: _31 = const might_panic::promoted[1]
-9:18-9:31: @2[7]: _23 = &amp;(*_31)
-9:18-9:31: @2[8]: _22 = &amp;(*_23)
-9:18-9:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-9:9-9:33: @2[15]: _29 = ()
-9:9-9:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-9:9-9:33: @2[17]: _30 = const might_panic::promoted[0]
-9:9-9:33: @2[18]: _27 = &amp;(*_30)
-9:9-9:33: @2[19]: _26 = &amp;(*_27)
-9:9-9:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-9:9-9:33: @6[5]: _18 = const ()
-8:12-10:6: @6[7]: _0 = const ()
-11:2-11:2: @6.Return: return"><span class="annotation">@2,5,6⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="9:18-9:31: @2[6]: _31 = const might_panic::promoted[1]
-9:18-9:31: @2[7]: _23 = &amp;(*_31)
-9:18-9:31: @2[8]: _22 = &amp;(*_23)
-9:18-9:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-9:9-9:33: @2[15]: _29 = ()
-9:9-9:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-9:9-9:33: @2[17]: _30 = const might_panic::promoted[0]
-9:9-9:33: @2[18]: _27 = &amp;(*_30)
-9:9-9:33: @2[19]: _26 = &amp;(*_27)
-9:9-9:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-9:9-9:33: @6[5]: _18 = const ()
-8:12-10:6: @6[7]: _0 = const ()
-11:2-11:2: @6.Return: return">        println!("Don't Panic");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="9:18-9:31: @2[6]: _31 = const might_panic::promoted[1]
-9:18-9:31: @2[7]: _23 = &amp;(*_31)
-9:18-9:31: @2[8]: _22 = &amp;(*_23)
-9:18-9:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-9:9-9:33: @2[15]: _29 = ()
-9:9-9:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-9:9-9:33: @2[17]: _30 = const might_panic::promoted[0]
-9:9-9:33: @2[18]: _27 = &amp;(*_30)
-9:9-9:33: @2[19]: _26 = &amp;(*_27)
-9:9-9:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-9:9-9:33: @6[5]: _18 = const ()
-8:12-10:6: @6[7]: _0 = const ()
-11:2-11:2: @6.Return: return">    }</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="9:18-9:31: @2[6]: _31 = const might_panic::promoted[1]
-9:18-9:31: @2[7]: _23 = &amp;(*_31)
-9:18-9:31: @2[8]: _22 = &amp;(*_23)
-9:18-9:31: @2[9]: _21 = move _22 as &amp;[&amp;str] (Pointer(Unsize))
-9:9-9:33: @2[15]: _29 = ()
-9:9-9:33: @2[16]: FakeRead(ForMatchedPlace, _29)
-9:9-9:33: @2[17]: _30 = const might_panic::promoted[0]
-9:9-9:33: @2[18]: _27 = &amp;(*_30)
-9:9-9:33: @2[19]: _26 = &amp;(*_27)
-9:9-9:33: @2[20]: _25 = move _26 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-9:9-9:33: @2.Call: _20 = std::fmt::Arguments::new_v1(move _21, move _25) -&gt; [return: bb5, unwind: bb7]
-9:9-9:33: @5.Call: _19 = std::io::_print(move _20) -&gt; [return: bb6, unwind: bb7]
-9:9-9:33: @6[5]: _18 = const ()
-8:12-10:6: @6[7]: _0 = const ()
-11:2-11:2: @6.Return: return">}<span class="annotation">⦉@2,5,6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 3e307c4f460d5..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,295 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.main - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 20"><span class="line"><span><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
-22:9-22:22: @1[0]: FakeRead(ForLet, _1)
-23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
-23:9-23:22: @2[0]: FakeRead(ForLet, _2)
-25:14-25:32: @2[7]: _33 = const main::promoted[0]
-25:14-25:32: @2[8]: _8 = &amp;(*_33)
-25:14-25:32: @2[9]: _7 = &amp;(*_8)
-25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
-25:34-25:47: @2[18]: _15 = &amp;_1
-25:49-25:62: @2[20]: _16 = &amp;_2
-25:64-25:77: @2[24]: _19 = &amp;_1
-25:80-25:93: @2[26]: _20 = &amp;_2
-25:64-25:93: @2.Call: _18 = &lt;Version as std::cmp::PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
-25:64-25:93: @3[2]: _17 = &amp;_18
-25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
-25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
-25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
-25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
-25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
-25:5-25:95: @3[16]: _25 = &amp;(*_21)
-25:5-25:95: @3[18]: _26 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
-25:5-25:95: @4[4]: _28 = &amp;(*_22)
-25:5-25:95: @4[6]: _29 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
-25:5-25:95: @5[4]: _31 = &amp;(*_23)
-25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
-25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
-25:5-25:95: @6[9]: _12 = &amp;_13
-25:5-25:95: @6[10]: _11 = &amp;(*_12)
-25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
-25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -&gt; [return: bb8, unwind: bb9]
-25:5-25:95: @8[7]: _3 = const ()
-21:11-26:2: @8[9]: _0 = const ()
-26:2-26:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
-22:9-22:22: @1[0]: FakeRead(ForLet, _1)
-23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
-23:9-23:22: @2[0]: FakeRead(ForLet, _2)
-25:14-25:32: @2[7]: _33 = const main::promoted[0]
-25:14-25:32: @2[8]: _8 = &amp;(*_33)
-25:14-25:32: @2[9]: _7 = &amp;(*_8)
-25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
-25:34-25:47: @2[18]: _15 = &amp;_1
-25:49-25:62: @2[20]: _16 = &amp;_2
-25:64-25:77: @2[24]: _19 = &amp;_1
-25:80-25:93: @2[26]: _20 = &amp;_2
-25:64-25:93: @2.Call: _18 = &lt;Version as std::cmp::PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
-25:64-25:93: @3[2]: _17 = &amp;_18
-25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
-25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
-25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
-25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
-25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
-25:5-25:95: @3[16]: _25 = &amp;(*_21)
-25:5-25:95: @3[18]: _26 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
-25:5-25:95: @4[4]: _28 = &amp;(*_22)
-25:5-25:95: @4[6]: _29 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
-25:5-25:95: @5[4]: _31 = &amp;(*_23)
-25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
-25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
-25:5-25:95: @6[9]: _12 = &amp;_13
-25:5-25:95: @6[10]: _11 = &amp;(*_12)
-25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
-25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -&gt; [return: bb8, unwind: bb9]
-25:5-25:95: @8[7]: _3 = const ()
-21:11-26:2: @8[9]: _0 = const ()
-26:2-26:2: @8.Return: return">    let version_3_2_1 = Version::new(3, 2, 1);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
-22:9-22:22: @1[0]: FakeRead(ForLet, _1)
-23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
-23:9-23:22: @2[0]: FakeRead(ForLet, _2)
-25:14-25:32: @2[7]: _33 = const main::promoted[0]
-25:14-25:32: @2[8]: _8 = &amp;(*_33)
-25:14-25:32: @2[9]: _7 = &amp;(*_8)
-25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
-25:34-25:47: @2[18]: _15 = &amp;_1
-25:49-25:62: @2[20]: _16 = &amp;_2
-25:64-25:77: @2[24]: _19 = &amp;_1
-25:80-25:93: @2[26]: _20 = &amp;_2
-25:64-25:93: @2.Call: _18 = &lt;Version as std::cmp::PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
-25:64-25:93: @3[2]: _17 = &amp;_18
-25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
-25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
-25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
-25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
-25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
-25:5-25:95: @3[16]: _25 = &amp;(*_21)
-25:5-25:95: @3[18]: _26 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
-25:5-25:95: @4[4]: _28 = &amp;(*_22)
-25:5-25:95: @4[6]: _29 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
-25:5-25:95: @5[4]: _31 = &amp;(*_23)
-25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
-25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
-25:5-25:95: @6[9]: _12 = &amp;_13
-25:5-25:95: @6[10]: _11 = &amp;(*_12)
-25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
-25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -&gt; [return: bb8, unwind: bb9]
-25:5-25:95: @8[7]: _3 = const ()
-21:11-26:2: @8[9]: _0 = const ()
-26:2-26:2: @8.Return: return">    let version_3_3_0 = Version::new(3, 3, 0);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
-22:9-22:22: @1[0]: FakeRead(ForLet, _1)
-23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
-23:9-23:22: @2[0]: FakeRead(ForLet, _2)
-25:14-25:32: @2[7]: _33 = const main::promoted[0]
-25:14-25:32: @2[8]: _8 = &amp;(*_33)
-25:14-25:32: @2[9]: _7 = &amp;(*_8)
-25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
-25:34-25:47: @2[18]: _15 = &amp;_1
-25:49-25:62: @2[20]: _16 = &amp;_2
-25:64-25:77: @2[24]: _19 = &amp;_1
-25:80-25:93: @2[26]: _20 = &amp;_2
-25:64-25:93: @2.Call: _18 = &lt;Version as std::cmp::PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
-25:64-25:93: @3[2]: _17 = &amp;_18
-25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
-25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
-25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
-25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
-25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
-25:5-25:95: @3[16]: _25 = &amp;(*_21)
-25:5-25:95: @3[18]: _26 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
-25:5-25:95: @4[4]: _28 = &amp;(*_22)
-25:5-25:95: @4[6]: _29 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
-25:5-25:95: @5[4]: _31 = &amp;(*_23)
-25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
-25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
-25:5-25:95: @6[9]: _12 = &amp;_13
-25:5-25:95: @6[10]: _11 = &amp;(*_12)
-25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
-25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -&gt; [return: bb8, unwind: bb9]
-25:5-25:95: @8[7]: _3 = const ()
-21:11-26:2: @8[9]: _0 = const ()
-26:2-26:2: @8.Return: return"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
-22:9-22:22: @1[0]: FakeRead(ForLet, _1)
-23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
-23:9-23:22: @2[0]: FakeRead(ForLet, _2)
-25:14-25:32: @2[7]: _33 = const main::promoted[0]
-25:14-25:32: @2[8]: _8 = &amp;(*_33)
-25:14-25:32: @2[9]: _7 = &amp;(*_8)
-25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
-25:34-25:47: @2[18]: _15 = &amp;_1
-25:49-25:62: @2[20]: _16 = &amp;_2
-25:64-25:77: @2[24]: _19 = &amp;_1
-25:80-25:93: @2[26]: _20 = &amp;_2
-25:64-25:93: @2.Call: _18 = &lt;Version as std::cmp::PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
-25:64-25:93: @3[2]: _17 = &amp;_18
-25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
-25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
-25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
-25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
-25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
-25:5-25:95: @3[16]: _25 = &amp;(*_21)
-25:5-25:95: @3[18]: _26 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
-25:5-25:95: @4[4]: _28 = &amp;(*_22)
-25:5-25:95: @4[6]: _29 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
-25:5-25:95: @5[4]: _31 = &amp;(*_23)
-25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
-25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
-25:5-25:95: @6[9]: _12 = &amp;_13
-25:5-25:95: @6[10]: _11 = &amp;(*_12)
-25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
-25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -&gt; [return: bb8, unwind: bb9]
-25:5-25:95: @8[7]: _3 = const ()
-21:11-26:2: @8[9]: _0 = const ()
-26:2-26:2: @8.Return: return">    println!("{:?} &lt; {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 &lt; version_3_3_0);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:25-22:46: @0.Call: _1 = Version::new(const 3_usize, const 2_usize, const 1_usize) -&gt; [return: bb1, unwind: bb9]
-22:9-22:22: @1[0]: FakeRead(ForLet, _1)
-23:25-23:46: @1.Call: _2 = Version::new(const 3_usize, const 3_usize, const 0_usize) -&gt; [return: bb2, unwind: bb9]
-23:9-23:22: @2[0]: FakeRead(ForLet, _2)
-25:14-25:32: @2[7]: _33 = const main::promoted[0]
-25:14-25:32: @2[8]: _8 = &amp;(*_33)
-25:14-25:32: @2[9]: _7 = &amp;(*_8)
-25:14-25:32: @2[10]: _6 = move _7 as &amp;[&amp;str] (Pointer(Unsize))
-25:34-25:47: @2[18]: _15 = &amp;_1
-25:49-25:62: @2[20]: _16 = &amp;_2
-25:64-25:77: @2[24]: _19 = &amp;_1
-25:80-25:93: @2[26]: _20 = &amp;_2
-25:64-25:93: @2.Call: _18 = &lt;Version as std::cmp::PartialOrd&gt;::lt(move _19, move _20) -&gt; [return: bb3, unwind: bb9]
-25:64-25:93: @3[2]: _17 = &amp;_18
-25:5-25:95: @3[3]: _14 = (move _15, move _16, move _17)
-25:5-25:95: @3[7]: FakeRead(ForMatchedPlace, _14)
-25:5-25:95: @3[9]: _21 = (_14.0: &amp;Version)
-25:5-25:95: @3[11]: _22 = (_14.1: &amp;Version)
-25:5-25:95: @3[13]: _23 = (_14.2: &amp;bool)
-25:5-25:95: @3[16]: _25 = &amp;(*_21)
-25:5-25:95: @3[18]: _26 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @3.Call: _24 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _25, move _26) -&gt; [return: bb4, unwind: bb9]
-25:5-25:95: @4[4]: _28 = &amp;(*_22)
-25:5-25:95: @4[6]: _29 = &lt;Version as std::fmt::Debug&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r Version, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @4.Call: _27 = std::fmt::ArgumentV1::new::&lt;Version&gt;(move _28, move _29) -&gt; [return: bb5, unwind: bb9]
-25:5-25:95: @5[4]: _31 = &amp;(*_23)
-25:5-25:95: @5[6]: _32 = &lt;bool as std::fmt::Display&gt;::fmt as for&lt;&#39;r, &#39;s, &#39;t0&gt; fn(&amp;&#39;r bool, &amp;&#39;s mut std::fmt::Formatter&lt;&#39;t0&gt;) -&gt; std::result::Result&lt;(), std::fmt::Error&gt; (Pointer(ReifyFnPointer))
-25:5-25:95: @5.Call: _30 = std::fmt::ArgumentV1::new::&lt;bool&gt;(move _31, move _32) -&gt; [return: bb6, unwind: bb9]
-25:5-25:95: @6[2]: _13 = [move _24, move _27, move _30]
-25:5-25:95: @6[9]: _12 = &amp;_13
-25:5-25:95: @6[10]: _11 = &amp;(*_12)
-25:5-25:95: @6[11]: _10 = move _11 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-25:5-25:95: @6.Call: _5 = std::fmt::Arguments::new_v1(move _6, move _10) -&gt; [return: bb7, unwind: bb9]
-25:5-25:95: @7.Call: _4 = std::io::_print(move _5) -&gt; [return: bb8, unwind: bb9]
-25:5-25:95: @8[7]: _3 = const ()
-21:11-26:2: @8[9]: _0 = const ()
-26:2-26:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#0}-new.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#0}-new.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 820ccf74d1b9e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#0}-new.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,108 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%230%7D-new.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#0}-new - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 11"><span class="line">    <span><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
-15:13-15:18: @0[3]: _5 = _2
-16:13-16:18: @0[5]: _6 = _3
-13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
-18:6-18:6: @0.Return: return"><span class="annotation">@0⦊</span>pub fn new(major: usize, minor: usize, patch: usize) -&gt; Self {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
-15:13-15:18: @0[3]: _5 = _2
-16:13-16:18: @0[5]: _6 = _3
-13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
-18:6-18:6: @0.Return: return">        Self {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
-15:13-15:18: @0[3]: _5 = _2
-16:13-16:18: @0[5]: _6 = _3
-13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
-18:6-18:6: @0.Return: return">            major,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
-15:13-15:18: @0[3]: _5 = _2
-16:13-16:18: @0[5]: _6 = _3
-13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
-18:6-18:6: @0.Return: return">            minor,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
-15:13-15:18: @0[3]: _5 = _2
-16:13-16:18: @0[5]: _6 = _3
-13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
-18:6-18:6: @0.Return: return">            patch,</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
-15:13-15:18: @0[3]: _5 = _2
-16:13-16:18: @0[5]: _6 = _3
-13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
-18:6-18:6: @0.Return: return">        }</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="14:13-14:18: @0[1]: _4 = _1
-15:13-15:18: @0[3]: _5 = _2
-16:13-16:18: @0[5]: _6 = _3
-13:9-17:10: @0[6]: _0 = Version { major: move _4, minor: move _5, patch: move _6 }
-18:6-18:6: @0.Return: return">    }<span class="annotation">⦉@0</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#1}-cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#1}-cmp.-------.InstrumentCoverage.0.html
deleted file mode 100644
index ee4c10afd8b89..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#1}-cmp.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%231%7D-cmp.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#1}-cmp - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line">                                                  <span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>‸<span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">Ord</span><span><span class="code odd" style="--layer: 1" title="4:54-4:54: @15.Return: return"><span class="annotation">@15⦊</span>‸<span class="annotation">⦉@15</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 2f5092bd51f0a..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#2}-partial_cmp.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%232%7D-partial_cmp.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#2}-partial_cmp - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line">                                      <span><span class="code even" style="--layer: 1"><span class="annotation">@0,1⦊</span>‸<span class="annotation">⦉@0,1</span></span></span><span class="code" style="--layer: 0">PartialOrd</span><span><span class="code odd" style="--layer: 1" title="4:49-4:49: @18.Return: return"><span class="annotation">@18⦊</span>‸<span class="annotation">⦉@18</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html
deleted file mode 100644
index ebb8b1c15ce08..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#4}-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,75 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%234%7D-assert_receiver_is_total_eq.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#4}-assert_receiver_is_total_eq - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line">                                  <span><span class="code even" style="--layer: 1" title="4:35-4:37: @0[0]: _0 = const ()
-4:37-4:37: @0.Return: return"><span class="annotation">@0⦊</span>‸<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">Eq</span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#6}-eq.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#6}-eq.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 9858b270d7ef9..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#6}-eq.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%236%7D-eq.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#6}-eq - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line">                       <span><span class="code even" style="--layer: 1"><span class="annotation">@0⦊</span>‸<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">PartialEq</span><span><span class="code odd" style="--layer: 1" title="4:33-4:33: @3.Return: return"><span class="annotation">@3⦊</span>‸<span class="annotation">⦉@3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#6}-ne.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#6}-ne.-------.InstrumentCoverage.0.html
deleted file mode 100644
index bf94e5cbf739b..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#6}-ne.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,74 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%236%7D-ne.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#6}-ne - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line">                       <span><span class="code even" style="--layer: 1"><span class="annotation">@0⦊</span>‸<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">PartialEq</span><span><span class="code odd" style="--layer: 1" title="4:33-4:33: @3.Return: return"><span class="annotation">@3⦊</span>‸<span class="annotation">⦉@3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#7}-fmt.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#7}-fmt.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 930492f24841f..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#7}-fmt.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,110 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%237%7D-fmt.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#7}-fmt - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line">                <span><span class="code even" style="--layer: 1" title="4:17-4:22: @0[0]: FakeRead(ForMatchedPlace, (*_1))
-4:17-4:22: @0[2]: _3 = &amp;((*_1).0: usize)
-4:17-4:22: @0[4]: _4 = &amp;((*_1).1: usize)
-4:17-4:22: @0[6]: _5 = &amp;((*_1).2: usize)
-4:17-4:22: @0[10]: _8 = &amp;mut (*_2)
-4:17-4:22: @0[13]: _10 = const &quot;Version&quot;
-4:17-4:22: @0[14]: _9 = &amp;(*_10)
-4:17-4:22: @0.Call: _7 = std::fmt::Formatter::debug_struct(move _8, move _9) -&gt; [return: bb1, unwind: bb6]
-4:17-4:22: @1[2]: _6 = &amp;mut _7
-4:17-4:22: @1[3]: FakeRead(ForLet, _6)
-4:17-4:22: @1[7]: _12 = &amp;mut (*_6)
-4:17-4:22: @1[10]: _14 = const &quot;major&quot;
-4:17-4:22: @1[11]: _13 = &amp;(*_14)
-4:17-4:22: @1[16]: _18 = &amp;(*_3)
-4:17-4:22: @1[17]: _17 = &amp;_18
-4:17-4:22: @1[18]: _16 = &amp;(*_17)
-4:17-4:22: @1[19]: _15 = move _16 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
-4:17-4:22: @1.Call: _11 = std::fmt::DebugStruct::field(move _12, move _13, move _15) -&gt; [return: bb2, unwind: bb6]
-4:17-4:22: @2[9]: _20 = &amp;mut (*_6)
-4:17-4:22: @2[12]: _22 = const &quot;minor&quot;
-4:17-4:22: @2[13]: _21 = &amp;(*_22)
-4:17-4:22: @2[18]: _26 = &amp;(*_4)
-4:17-4:22: @2[19]: _25 = &amp;_26
-4:17-4:22: @2[20]: _24 = &amp;(*_25)
-4:17-4:22: @2[21]: _23 = move _24 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
-4:17-4:22: @2.Call: _19 = std::fmt::DebugStruct::field(move _20, move _21, move _23) -&gt; [return: bb3, unwind: bb6]
-4:17-4:22: @3[9]: _28 = &amp;mut (*_6)
-4:17-4:22: @3[12]: _30 = const &quot;patch&quot;
-4:17-4:22: @3[13]: _29 = &amp;(*_30)
-4:17-4:22: @3[18]: _34 = &amp;(*_5)
-4:17-4:22: @3[19]: _33 = &amp;_34
-4:17-4:22: @3[20]: _32 = &amp;(*_33)
-4:17-4:22: @3[21]: _31 = move _32 as &amp;dyn std::fmt::Debug (Pointer(Unsize))
-4:17-4:22: @3.Call: _27 = std::fmt::DebugStruct::field(move _28, move _29, move _31) -&gt; [return: bb4, unwind: bb6]
-4:17-4:22: @4[8]: _35 = &amp;mut (*_6)
-4:17-4:22: @4.Call: _0 = std::fmt::DebugStruct::finish(move _35) -&gt; [return: bb5, unwind: bb6]
-4:22-4:22: @5.Return: return"><span class="annotation">@0,1,2,3,4,5⦊</span>Debug<span class="annotation">⦉@0,1,2,3,4,5</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#8}-clone.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#8}-clone.-------.InstrumentCoverage.0.html
deleted file mode 100644
index f1c983933432c..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#8}-clone.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,88 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.%7Bimpl%238%7D-clone.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>partial_eq.{impl#8}-clone - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 3"><span class="line">         <span><span class="code even" style="--layer: 1" title="4:10-4:15: @0[0]: FakeRead(ForMatchedPlace, (*_1))
-4:10-4:15: @0[2]: _2 = &amp;((*_1).0: usize)
-4:10-4:15: @0[4]: _3 = &amp;((*_1).1: usize)
-4:10-4:15: @0[6]: _4 = &amp;((*_1).2: usize)
-4:10-4:15: @0[10]: _7 = &amp;(*_2)
-4:10-4:15: @0[11]: _6 = &amp;(*_7)
-4:10-4:15: @0.Call: _5 = &lt;usize as std::clone::Clone&gt;::clone(move _6) -&gt; [return: bb1, unwind: bb4]
-4:10-4:15: @1[4]: _10 = &amp;(*_3)
-4:10-4:15: @1[5]: _9 = &amp;(*_10)
-4:10-4:15: @1.Call: _8 = &lt;usize as std::clone::Clone&gt;::clone(move _9) -&gt; [return: bb2, unwind: bb4]
-4:10-4:15: @2[4]: _13 = &amp;(*_4)
-4:10-4:15: @2[5]: _12 = &amp;(*_13)
-4:10-4:15: @2.Call: _11 = &lt;usize as std::clone::Clone&gt;::clone(move _12) -&gt; [return: bb3, unwind: bb4]
-4:10-4:15: @3[1]: _0 = Version { major: move _5, minor: move _8, patch: move _11 }
-4:15-4:15: @3.Return: return"><span class="annotation">@0,1,2,3⦊</span>Clone<span class="annotation">⦉@0,1,2,3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 6b911eea34121..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,193 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_loop/simple_loop.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1">    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 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1">    if</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb13]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::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)
-12:9-12:16: @3[6]: _7 = _1">        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: @4[0]: _5 = const 10_i32
-13:5-18:6: @4[1]: _6 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @4[0]: _5 = const 10_i32
-13:5-18:6: @4[1]: _6 = const ()">        countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @4[0]: _5 = const 10_i32
-13:5-18:6: @4[1]: _6 = const ()">        =</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @4[0]: _5 = const 10_i32
-13:5-18:6: @4[1]: _6 = const ()">            10</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @4[0]: _5 = const 10_i32
-13:5-18:6: @4[1]: _6 = const ()">        ;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:9-16:15: @4[0]: _5 = const 10_i32
-13:5-18:6: @4[1]: _6 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="18:6-18:6: @5[0]: _6 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    loop</span></span>
-<span class="line"><span class="code" style="--layer: 0">    {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        if</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="23:13-23:22: @8[3]: _11 = _5
-23:13-25:14: @8[4]: _10 = Eq(move _11, const 0_i32)"><span class="annotation">@7,8⦊</span>countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:13-23:22: @8[3]: _11 = _5
-23:13-25:14: @8[4]: _10 = Eq(move _11, const 0_i32)">                ==</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="23:13-23:22: @8[3]: _11 = _5
-23:13-25:14: @8[4]: _10 = Eq(move _11, const 0_i32)">            0<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">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:18: @9[0]: _0 = const ()"><span class="annotation">@9⦊</span>break<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="29:10-29:10: @10[0]: _9 = const ()
-30:9-32:10: @10[3]: _13 = CheckedSub(_5, const 1_i32)
-30:9-32:10: @11[0]: _5 = move (_13.0: i32)"><span class="annotation">@10,11⦊</span></span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="29:10-29:10: @10[0]: _9 = const ()
-30:9-32:10: @10[3]: _13 = CheckedSub(_5, const 1_i32)
-30:9-32:10: @11[0]: _5 = move (_13.0: i32)">        countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="29:10-29:10: @10[0]: _9 = const ()
-30:9-32:10: @10[3]: _13 = CheckedSub(_5, const 1_i32)
-30:9-32:10: @11[0]: _5 = move (_13.0: i32)">        -=</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="29:10-29:10: @10[0]: _9 = const ()
-30:9-32:10: @10[3]: _13 = CheckedSub(_5, const 1_i32)
-30:9-32:10: @11[0]: _5 = move (_13.0: i32)">        1<span class="annotation">⦉@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">    }</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: @9.Return: return"><span class="annotation">@9⦊</span>‸<span class="annotation">⦉@9</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index a56692d9c2a48..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,222 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.simple_match/simple_match.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1"><span class="annotation">@0,1,2,3⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1">    // 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 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1">    // dependent conditions.</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1">    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 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1"></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1">    let mut countdown = 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="7:19-7:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb21]
-7:19-7:35: @1[0]: _3 = &amp;_4
-7:19-7:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb20]
-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)
-10:8-10:15: @3[6]: _7 = _1">    if 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: @4[0]: _5 = const 0_i32
-10:16-12:6: @4[1]: _6 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:22: @4[0]: _5 = const 0_i32
-10:16-12:6: @4[1]: _6 = const ()">        countdown = 0;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="11:9-11:22: @4[0]: _5 = const 0_i32
-10:16-12:6: @4[1]: _6 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="12:6-12:6: @5[0]: _6 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    for</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="15:9-15:10: @14[1]: _18 = ((_14 as Some).0: i32)
-15:9-15:10: @14[3]: _19 = _18
-15:9-15:10: @14[4]: _12 = move _19
-15:9-15:10: @14[5]: _13 = const ()"><span class="annotation">@12,14,16⦊</span>_<span class="annotation">⦉@12,14,16</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="17:9-17:13: @9[5]: _16 = &amp;mut _10
-17:9-17:13: @9[6]: _15 = &amp;mut (*_16)
-17:9-17:13: @9.Call: _14 = &lt;std::ops::Range&lt;i32&gt; as std::iter::Iterator&gt;::next(move _15) -&gt; [return: bb10, unwind: bb21]
-17:9-17:13: @10[1]: FakeRead(ForMatchedPlace, _14)"><span class="annotation">@8,9,10⦊</span>0..2<span class="annotation">⦉@8,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">        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 odd" style="--layer: 1" title="22:13-22:22: @14[13]: FakeRead(ForMatchedPlace, _5)"><span class="annotation">@12,14,16⦊</span>countdown<span class="annotation">⦉@12,14,16</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="24:13-24:14: @17[3]: _23 = _5"><span class="annotation">@17⦊</span>x<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">            if</span></span>
-<span class="line"><span class="code" style="--layer: 0">                </span><span><span class="code odd" style="--layer: 1" title="26:17-26:18: @16[4]: _26 = (*_24)
-26:17-28:18: @16[5]: _25 = Lt(move _26, const 1_i32)"><span class="annotation">@12,14,16⦊</span>x</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="26:17-26:18: @16[4]: _26 = (*_24)
-26:17-28:18: @16[5]: _25 = Lt(move _26, const 1_i32)">                    &lt;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="26:17-26:18: @16[4]: _26 = (*_24)
-26:17-28:18: @16[5]: _25 = Lt(move _26, const 1_i32)">                1<span class="annotation">⦉@12,14,16</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 even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()"><span class="annotation">@17⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()">                z = countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()">                ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()">                let y = countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()">                ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()">                countdown = 10</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()">                ;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="31:21-31:30: @17[5]: _27 = _5
-31:17-31:30: @17[6]: _22 = move _27
-33:25-33:34: @17[9]: _28 = _5
-33:21-33:22: @17[10]: FakeRead(ForLet, _28)
-35:17-35:31: @17[11]: _5 = const 10_i32
-30:13-37:14: @17[12]: _21 = const ()">            }<span class="annotation">⦉@17</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">            _</span></span>
-<span class="line"><span class="code" style="--layer: 0">            =&gt;</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code odd" style="--layer: 1" title="40:13-40:15: @15[0]: _21 = const ()"><span class="annotation">@15⦊</span>{}<span class="annotation">⦉@15</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        }</span></span>
-<span class="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: @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/expected_mir_dump.tight_inf_loop/tight_inf_loop.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.tight_inf_loop/tight_inf_loop.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 8cbd265c6a01c..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.tight_inf_loop/tight_inf_loop.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,81 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.tight_inf_loop/tight_inf_loop.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>tight_inf_loop.main - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 0"><span class="line"><span><span class="code even" style="--layer: 1" title="2:8-2:13: @0[1]: _1 = const false"><span class="annotation">@0⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="2:8-2:13: @0[1]: _1 = const false">    if false<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="3:9-3:16: @3.FalseUnwind: falseUnwind -&gt; [real: bb4, cleanup: bb5]
-3:14-3:16: @4[0]: _3 = const ()"><span class="annotation">@3,4⦊</span>loop {}<span class="annotation">⦉@3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    }</span><span><span class="code even" style="--layer: 1" title="4:6-4:6: @2[0]: _0 = const ()
-5:2-5:2: @2.Return: return"><span class="annotation">@2⦊</span></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="4:6-4:6: @2[0]: _0 = const ()
-5:2-5:2: @2.Return: return">}<span class="annotation">⦉@2</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
deleted file mode 100644
index a8a3139334c96..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.call.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><span class="code even" style="--layer: 1" title="5:8-5:20: @0[1]: _2 = _1"><span class="annotation">@0⦊</span>fn call(return_error: bool) -&gt; Result&lt;(),()&gt; {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="5:8-5:20: @0[1]: _2 = _1">    if 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: @1[1]: _3 = ()
-6:9-6:16: @1[2]: _0 = std::result::Result::&lt;(), ()&gt;::Err(move _3)"><span class="annotation">@1⦊</span>Err(())<span class="annotation">⦉@1</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: @3.Return: return"><span class="annotation">@3⦊</span>‸<span class="annotation">⦉@3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 5b0c5cb072f04..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,129 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.try_error_result/try_error_result.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<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><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>fn main() -&gt; Result&lt;(),()&gt; {</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)">    let 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">    for</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="17:9-17:10: @8[1]: _13 = ((_9 as Some).0: i32)
-17:9-17:10: @8[3]: _14 = _13
-17:9-17:10: @8[4]: _7 = move _14
-17:9-17:10: @8[5]: _8 = const ()"><span class="annotation">@6,8,9⦊</span>_<span class="annotation">⦉@6,8,9</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    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: @3[5]: _11 = &amp;mut _5
-19:9-19:14: @3[6]: _10 = &amp;mut (*_11)
-19:9-19:14: @3.Call: _9 = &lt;std::ops::Range&lt;i32&gt; as std::iter::Iterator&gt;::next(move _10) -&gt; [return: bb4, unwind: bb39]
-19:9-19:14: @4[1]: FakeRead(ForMatchedPlace, _9)"><span class="annotation">@2,3,4⦊</span>0..10<span class="annotation">⦉@2,3,4</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="21:9-22:17: @8[12]: _17 = CheckedSub(_1, const 1_i32)
-21:9-22:17: @9[0]: _1 = move (_17.0: i32)
-25:13-25:22: @9[3]: _19 = _1
-25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)"><span class="annotation">@6,8,9⦊</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)
-21:9-22:17: @9[0]: _1 = move (_17.0: i32)
-25:13-25:22: @9[3]: _19 = _1
-25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)">            -= 1</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)
-21:9-22:17: @9[0]: _1 = move (_17.0: i32)
-25:13-25:22: @9[3]: _19 = _1
-25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)">        ;</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)
-21:9-22:17: @9[0]: _1 = move (_17.0: i32)
-25:13-25:22: @9[3]: _19 = _1
-25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)">        if</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)
-21:9-22:17: @9[0]: _1 = move (_17.0: i32)
-25:13-25:22: @9[3]: _19 = _1
-25:13-25:26: @9[4]: _18 = Lt(move _19, const 5_i32)">            countdown &lt; 5<span class="annotation">⦉@6,8,9</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">        {</span></span>
-<span class="line"><span class="code" style="--layer: 0">            </span><span><span class="code even" style="--layer: 1" title="27:13-27:41: @10.Call: _22 = call(const true) -&gt; [return: bb12, unwind: bb39]"><span class="annotation">@10,12,13⦊</span>call(/*return_error=*/ true)<span class="annotation">⦉@10,12,13</span></span></span><span><span class="code odd" style="--layer: 1" title="27:41-27:42: @17[1]: _24 = ((_21 as Err).0: ())
-27:41-27:42: @17[4]: _27 = _24
-27:41-27:42: @17.Call: _26 = &lt;() as std::convert::From&lt;()&gt;&gt;::from(move _27) -&gt; [return: bb18, unwind: bb39]"><span class="annotation">@15,17,18,19⦊</span>?<span class="annotation">⦉@15,17,18,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="code even" style="--layer: 1" title="28:13-28:42: @14.Call: _31 = call(const false) -&gt; [return: bb20, unwind: bb39]"><span class="annotation">@14,20,21⦊</span>call(/*return_error=*/ false)<span class="annotation">⦉@14,20,21</span></span></span><span><span class="code odd" style="--layer: 1" title="28:42-28:43: @25[1]: _33 = ((_30 as Err).0: ())
-28:42-28:43: @25[4]: _36 = _33
-28:42-28:43: @25.Call: _35 = &lt;() as std::convert::From&lt;()&gt;&gt;::from(move _36) -&gt; [return: bb26, unwind: bb39]"><span class="annotation">@23,25,26,27⦊</span>?<span class="annotation">⦉@23,25,26,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">        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="32:13-32:42: @11.Call: _40 = call(const false) -&gt; [return: bb28, unwind: bb39]"><span class="annotation">@11,28,29⦊</span>call(/*return_error=*/ false)<span class="annotation">⦉@11,28,29</span></span></span><span><span class="code odd" style="--layer: 1" title="32:42-32:43: @33[1]: _42 = ((_39 as Err).0: ())
-32:42-32:43: @33[4]: _45 = _42
-32:42-32:43: @33.Call: _44 = &lt;() as std::convert::From&lt;()&gt;&gt;::from(move _45) -&gt; [return: bb34, unwind: bb39]"><span class="annotation">@31,33,34,35⦊</span>?<span class="annotation">⦉@31,33,34,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">    </span><span><span class="code even" style="--layer: 1" title="35:8-35:10: @5[9]: _47 = ()
-35:5-35:11: @5[10]: _0 = std::result::Result::&lt;(), ()&gt;::Ok(move _47)"><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 odd" style="--layer: 1" title="36:2-36:2: @38.Return: return"><span class="annotation">@38⦊</span>‸<span class="annotation">⦉@38</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.foo.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.foo.-------.InstrumentCoverage.0.html
deleted file mode 100644
index ef431a356c250..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.foo.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,87 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.foo.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>unused.foo - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 0"><span class="line"><span><span class="code even" style="--layer: 1" title="2:17-2:18: @0[1]: _2 = const 0_i32
-2:9-2:14: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>fn foo&lt;T&gt;(x: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="2:17-2:18: @0[1]: _2 = const 0_i32
-2:9-2:14: @0[2]: FakeRead(ForLet, _2)">    let mut i = 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">    while </span><span><span class="code odd" style="--layer: 1" title="3:11-3:12: @2[2]: _5 = _2
-3:11-3:17: @2[3]: _4 = Lt(move _5, const 10_i32)
-3:11-3:17: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>i &lt; 10<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="code even" style="--layer: 1" title="4:9-4:10: @5[3]: _8 = _2
-4:9-4:15: @5[4]: _7 = Ne(move _8, const 0_i32)"><span class="annotation">@3,5⦊</span>i != 0<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="4:19-4:20: @7[2]: _10 = _2
-4:19-4:25: @7[3]: _9 = Ne(move _10, const 0_i32)"><span class="annotation">@7⦊</span>i != 0<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="5:9-5:15: @8[3]: _11 = CheckedAdd(_2, const 1_i32)
-5:9-5:15: @9[0]: _2 = move (_11.0: i32)"><span class="annotation">@8,9⦊</span>i += 1<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="7:2-7:2: @10.Return: return"><span class="annotation">@4,10⦊</span>‸<span class="annotation">⦉@4,10</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 864f6c4feb152..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,98 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>unused.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 34"><span class="line"><span><span class="code even" style="--layer: 1" title="36:5-36:18: @0.Call: _1 = foo::&lt;u32&gt;(const 0_u32) -&gt; [return: bb1, unwind: bb3]
-37:5-37:20: @1.Call: _2 = foo::&lt;f32&gt;(const 0f32) -&gt; [return: bb2, unwind: bb3]
-38:8-38:10: @2[2]: _3 = ()
-38:5-38:11: @2[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _3)
-39:2-39:2: @2.Return: return"><span class="annotation">@0,1,2⦊</span>fn main() -&gt; Result&lt;(), u8&gt; {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:5-36:18: @0.Call: _1 = foo::&lt;u32&gt;(const 0_u32) -&gt; [return: bb1, unwind: bb3]
-37:5-37:20: @1.Call: _2 = foo::&lt;f32&gt;(const 0f32) -&gt; [return: bb2, unwind: bb3]
-38:8-38:10: @2[2]: _3 = ()
-38:5-38:11: @2[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _3)
-39:2-39:2: @2.Return: return">    foo::&lt;u32&gt;(0);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:5-36:18: @0.Call: _1 = foo::&lt;u32&gt;(const 0_u32) -&gt; [return: bb1, unwind: bb3]
-37:5-37:20: @1.Call: _2 = foo::&lt;f32&gt;(const 0f32) -&gt; [return: bb2, unwind: bb3]
-38:8-38:10: @2[2]: _3 = ()
-38:5-38:11: @2[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _3)
-39:2-39:2: @2.Return: return">    foo::&lt;f32&gt;(0.0);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:5-36:18: @0.Call: _1 = foo::&lt;u32&gt;(const 0_u32) -&gt; [return: bb1, unwind: bb3]
-37:5-37:20: @1.Call: _2 = foo::&lt;f32&gt;(const 0f32) -&gt; [return: bb2, unwind: bb3]
-38:8-38:10: @2[2]: _3 = ()
-38:5-38:11: @2[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _3)
-39:2-39:2: @2.Return: return">    Ok(())</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="36:5-36:18: @0.Call: _1 = foo::&lt;u32&gt;(const 0_u32) -&gt; [return: bb1, unwind: bb3]
-37:5-37:20: @1.Call: _2 = foo::&lt;f32&gt;(const 0f32) -&gt; [return: bb2, unwind: bb3]
-38:8-38:10: @2[2]: _3 = ()
-38:5-38:11: @2[3]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _3)
-39:2-39:2: @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/expected_mir_dump.unused/unused.unused_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 52beea080232e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,86 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>unused.unused_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 16"><span class="line"><span><span class="code even" style="--layer: 1" title="18:8-18:9: @0[2]: _3 = _1
-18:8-18:14: @0[3]: _2 = Ne(move _3, const 0_u32)"><span class="annotation">@0⦊</span>fn unused_func(mut a: u32) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="18:8-18:9: @0[2]: _3 = _1
-18:8-18:14: @0[3]: _2 = Ne(move _3, const 0_u32)">    if a != 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="19:9-19:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-19:9-19:15: @3[0]: _1 = move (_4.0: u32)
-18:15-20:6: @3[1]: _0 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="19:9-19:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-19:9-19:15: @3[0]: _1 = move (_4.0: u32)
-18:15-20:6: @3[1]: _0 = const ()">        a += 1;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="19:9-19:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-19:9-19:15: @3[0]: _1 = move (_4.0: u32)
-18:15-20:6: @3[1]: _0 = const ()">    }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="20:6-20:6: @2[0]: _0 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="21:2-21: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/expected_mir_dump.unused/unused.unused_func2.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func2.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 816ef73ea6b06..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func2.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,86 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func2.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>unused.unused_func2 - 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 22"><span class="line"><span><span class="code even" style="--layer: 1" title="24:8-24:9: @0[2]: _3 = _1
-24:8-24:14: @0[3]: _2 = Ne(move _3, const 0_u32)"><span class="annotation">@0⦊</span>fn unused_func2(mut a: u32) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="24:8-24:9: @0[2]: _3 = _1
-24:8-24:14: @0[3]: _2 = Ne(move _3, const 0_u32)">    if a != 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="25:9-25:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-25:9-25:15: @3[0]: _1 = move (_4.0: u32)
-24:15-26:6: @3[1]: _0 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-25:9-25:15: @3[0]: _1 = move (_4.0: u32)
-24:15-26:6: @3[1]: _0 = const ()">        a += 1;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="25:9-25:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-25:9-25:15: @3[0]: _1 = move (_4.0: u32)
-24:15-26:6: @3[1]: _0 = const ()">    }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="26:6-26:6: @2[0]: _0 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="27:2-27: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/expected_mir_dump.unused/unused.unused_func3.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func3.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 739f9f42db359..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func3.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,86 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_func3.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>unused.unused_func3 - 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 28"><span class="line"><span><span class="code even" style="--layer: 1" title="30:8-30:9: @0[2]: _3 = _1
-30:8-30:14: @0[3]: _2 = Ne(move _3, const 0_u32)"><span class="annotation">@0⦊</span>fn unused_func3(mut a: u32) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:8-30:9: @0[2]: _3 = _1
-30:8-30:14: @0[3]: _2 = Ne(move _3, const 0_u32)">    if a != 0<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code odd" style="--layer: 1" title="31:9-31:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-31:9-31:15: @3[0]: _1 = move (_4.0: u32)
-30:15-32:6: @3[1]: _0 = const ()"><span class="annotation">@1,3⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="31:9-31:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-31:9-31:15: @3[0]: _1 = move (_4.0: u32)
-30:15-32:6: @3[1]: _0 = const ()">        a += 1;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="31:9-31:15: @1[0]: _4 = CheckedAdd(_1, const 1_u32)
-31:9-31:15: @3[0]: _1 = move (_4.0: u32)
-30:15-32:6: @3[1]: _0 = const ()">    }<span class="annotation">⦉@1,3</span></span></span><span><span class="code even" style="--layer: 1" title="32:6-32:6: @2[0]: _0 = const ()"><span class="annotation">@2⦊</span>‸<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="33:2-33: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/expected_mir_dump.unused/unused.unused_template_func.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_template_func.-------.InstrumentCoverage.0.html
deleted file mode 100644
index be4f5efc5dbf1..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_template_func.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,87 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.unused/unused.unused_template_func.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>unused.unused_template_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 8"><span class="line"><span><span class="code even" style="--layer: 1" title="10:17-10:18: @0[1]: _2 = const 0_i32
-10:9-10:14: @0[2]: FakeRead(ForLet, _2)"><span class="annotation">@0⦊</span>fn unused_template_func&lt;T&gt;(x: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="10:17-10:18: @0[1]: _2 = const 0_i32
-10:9-10:14: @0[2]: FakeRead(ForLet, _2)">    let mut i = 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">    while </span><span><span class="code odd" style="--layer: 1" title="11:11-11:12: @2[2]: _5 = _2
-11:11-11:17: @2[3]: _4 = Lt(move _5, const 10_i32)
-11:11-11:17: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>i &lt; 10<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="code even" style="--layer: 1" title="12:9-12:10: @5[3]: _8 = _2
-12:9-12:15: @5[4]: _7 = Ne(move _8, const 0_i32)"><span class="annotation">@3,5⦊</span>i != 0<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"> || </span><span><span class="code odd" style="--layer: 1" title="12:19-12:20: @7[2]: _10 = _2
-12:19-12:25: @7[3]: _9 = Ne(move _10, const 0_i32)"><span class="annotation">@7⦊</span>i != 0<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="13:9-13:15: @8[3]: _11 = CheckedAdd(_2, const 1_i32)
-13:9-13:15: @9[0]: _2 = move (_11.0: i32)"><span class="annotation">@8,9⦊</span>i += 1<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="15:2-15:2: @10.Return: return"><span class="annotation">@4,10⦊</span>‸<span class="annotation">⦉@4,10</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 65e21ecef13bd..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,115 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.unused_function - 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 36"><span class="line"><span><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-38:19-38:35: @1[0]: _3 = &amp;_4
-38:19-38:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-38:9-38:16: @2[3]: FakeRead(ForLet, _1)
-39:25-39:26: @3[2]: _5 = const 2_i32
-39:9-39:22: @3[3]: FakeRead(ForLet, _5)
-40:9-40:16: @3[6]: _7 = _1
-40:8-40:16: @3[7]: _6 = Not(move _7)"><span class="annotation">@0,1,2,3⦊</span>pub fn unused_function() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-38:19-38:35: @1[0]: _3 = &amp;_4
-38:19-38:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-38:9-38:16: @2[3]: FakeRead(ForLet, _1)
-39:25-39:26: @3[2]: _5 = const 2_i32
-39:9-39:22: @3[3]: FakeRead(ForLet, _5)
-40:9-40:16: @3[6]: _7 = _1
-40:8-40:16: @3[7]: _6 = Not(move _7)">    let is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-38:19-38:35: @1[0]: _3 = &amp;_4
-38:19-38:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-38:9-38:16: @2[3]: FakeRead(ForLet, _1)
-39:25-39:26: @3[2]: _5 = const 2_i32
-39:9-39:22: @3[3]: FakeRead(ForLet, _5)
-40:9-40:16: @3[6]: _7 = _1
-40:8-40:16: @3[7]: _6 = Not(move _7)">    let mut countdown = 2;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="38:19-38:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-38:19-38:35: @1[0]: _3 = &amp;_4
-38:19-38:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-38:19-38:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-38:9-38:16: @2[3]: FakeRead(ForLet, _1)
-39:25-39:26: @3[2]: _5 = const 2_i32
-39:9-39:22: @3[3]: FakeRead(ForLet, _5)
-40:9-40:16: @3[6]: _7 = _1
-40:8-40:16: @3[7]: _6 = Not(move _7)">    if !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="41:9-41:23: @4[0]: _5 = const 20_i32
-40:17-42:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="41:9-41:23: @4[0]: _5 = const 20_i32
-40:17-42:6: @4[1]: _0 = const ()">        countdown = 20;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="41:9-41:23: @4[0]: _5 = const 20_i32
-40:17-42:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="42:6-42:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="43:2-43:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 02154a2268b75..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.unused_generic_function - 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><span class="code even" style="--layer: 1" title="34:14-34:49: @0[6]: _19 = const unused_generic_function::&lt;T&gt;::promoted[0]
-34:14-34:49: @0[7]: _7 = &amp;(*_19)
-34:14-34:49: @0[8]: _6 = &amp;(*_7)
-34:14-34:49: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-34:51-34:54: @0[17]: _14 = &amp;_1
-34:5-34:56: @0[18]: _13 = (move _14,)
-34:5-34:56: @0[20]: FakeRead(ForMatchedPlace, _13)
-34:5-34:56: @0[22]: _15 = (_13.0: &amp;T)
-34:5-34:56: @0[25]: _17 = &amp;(*_15)
-34:5-34:56: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-34:5-34:56: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-34:5-34:56: @1[2]: _12 = [move _16]
-34:5-34:56: @1[5]: _11 = &amp;_12
-34:5-34:56: @1[6]: _10 = &amp;(*_11)
-34:5-34:56: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-34:5-34:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-34:5-34:56: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-34:5-34:56: @3[6]: _2 = const ()
-33:50-35:2: @3[8]: _0 = const ()
-35:2-35:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn unused_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="34:14-34:49: @0[6]: _19 = const unused_generic_function::&lt;T&gt;::promoted[0]
-34:14-34:49: @0[7]: _7 = &amp;(*_19)
-34:14-34:49: @0[8]: _6 = &amp;(*_7)
-34:14-34:49: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-34:51-34:54: @0[17]: _14 = &amp;_1
-34:5-34:56: @0[18]: _13 = (move _14,)
-34:5-34:56: @0[20]: FakeRead(ForMatchedPlace, _13)
-34:5-34:56: @0[22]: _15 = (_13.0: &amp;T)
-34:5-34:56: @0[25]: _17 = &amp;(*_15)
-34:5-34:56: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-34:5-34:56: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-34:5-34:56: @1[2]: _12 = [move _16]
-34:5-34:56: @1[5]: _11 = &amp;_12
-34:5-34:56: @1[6]: _10 = &amp;(*_11)
-34:5-34:56: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-34:5-34:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-34:5-34:56: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-34:5-34:56: @3[6]: _2 = const ()
-33:50-35:2: @3[8]: _0 = const ()
-35:2-35:2: @4.Return: return">    println!("unused_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="34:14-34:49: @0[6]: _19 = const unused_generic_function::&lt;T&gt;::promoted[0]
-34:14-34:49: @0[7]: _7 = &amp;(*_19)
-34:14-34:49: @0[8]: _6 = &amp;(*_7)
-34:14-34:49: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-34:51-34:54: @0[17]: _14 = &amp;_1
-34:5-34:56: @0[18]: _13 = (move _14,)
-34:5-34:56: @0[20]: FakeRead(ForMatchedPlace, _13)
-34:5-34:56: @0[22]: _15 = (_13.0: &amp;T)
-34:5-34:56: @0[25]: _17 = &amp;(*_15)
-34:5-34:56: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-34:5-34:56: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-34:5-34:56: @1[2]: _12 = [move _16]
-34:5-34:56: @1[5]: _11 = &amp;_12
-34:5-34:56: @1[6]: _10 = &amp;(*_11)
-34:5-34:56: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-34:5-34:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-34:5-34:56: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-34:5-34:56: @3[6]: _2 = const ()
-33:50-35:2: @3[8]: _0 = const ()
-35:2-35:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 78228594e3753..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,115 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.unused_private_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.unused_private_function - 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 44"><span class="line"><span><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-46:19-46:35: @1[0]: _3 = &amp;_4
-46:19-46:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-46:9-46:16: @2[3]: FakeRead(ForLet, _1)
-47:25-47:26: @3[2]: _5 = const 2_i32
-47:9-47:22: @3[3]: FakeRead(ForLet, _5)
-48:9-48:16: @3[6]: _7 = _1
-48:8-48:16: @3[7]: _6 = Not(move _7)"><span class="annotation">@0,1,2,3⦊</span>fn unused_private_function() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-46:19-46:35: @1[0]: _3 = &amp;_4
-46:19-46:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-46:9-46:16: @2[3]: FakeRead(ForLet, _1)
-47:25-47:26: @3[2]: _5 = const 2_i32
-47:9-47:22: @3[3]: FakeRead(ForLet, _5)
-48:9-48:16: @3[6]: _7 = _1
-48:8-48:16: @3[7]: _6 = Not(move _7)">    let is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-46:19-46:35: @1[0]: _3 = &amp;_4
-46:19-46:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-46:9-46:16: @2[3]: FakeRead(ForLet, _1)
-47:25-47:26: @3[2]: _5 = const 2_i32
-47:9-47:22: @3[3]: FakeRead(ForLet, _5)
-48:9-48:16: @3[6]: _7 = _1
-48:8-48:16: @3[7]: _6 = Not(move _7)">    let mut countdown = 2;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="46:19-46:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-46:19-46:35: @1[0]: _3 = &amp;_4
-46:19-46:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-46:19-46:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-46:9-46:16: @2[3]: FakeRead(ForLet, _1)
-47:25-47:26: @3[2]: _5 = const 2_i32
-47:9-47:22: @3[3]: FakeRead(ForLet, _5)
-48:9-48:16: @3[6]: _7 = _1
-48:8-48:16: @3[7]: _6 = Not(move _7)">    if !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="49:9-49:23: @4[0]: _5 = const 20_i32
-48:17-50:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="49:9-49:23: @4[0]: _5 = const 20_i32
-48:17-50:6: @4[1]: _0 = const ()">        countdown = 20;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="49:9-49:23: @4[0]: _5 = const 20_i32
-48:17-50:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="50:6-50:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="51:2-51:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 8f618d2e24954..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,190 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.use_this_lib_crate - 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 52"><span class="line"><span><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>fn use_this_lib_crate() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">    used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">    used_with_same_type_from_bin_crate_and_lib_crate_generic_function(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">        "used from library used_crate.rs",</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">    let some_vec = vec![5, 6, 7, 8];</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">    used_only_from_this_lib_crate_generic_function(some_vec);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">    used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="54:5-54:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-55:5-57:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-58:20-58:36: @2[5]: _6 = Box([i32; 4])
-58:20-58:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-58:20-58:36: @2[7]: _5 = move _6
-58:20-58:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-58:20-58:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-58:9-58:17: @5[1]: FakeRead(ForLet, _3)
-59:52-59:60: @5[4]: _8 = move _3
-59:5-59:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-60:5-60:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-53:25-61:2: @7[1]: _0 = const ()
-61:2-61:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 61a709c4729f2..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.used_from_bin_crate_and_lib_crate_generic_function - 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 24"><span class="line"><span><span class="code even" style="--layer: 1" title="26:14-26:76: @0[6]: _19 = const used_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-26:14-26:76: @0[7]: _7 = &amp;(*_19)
-26:14-26:76: @0[8]: _6 = &amp;(*_7)
-26:14-26:76: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-26:78-26:81: @0[17]: _14 = &amp;_1
-26:5-26:83: @0[18]: _13 = (move _14,)
-26:5-26:83: @0[20]: FakeRead(ForMatchedPlace, _13)
-26:5-26:83: @0[22]: _15 = (_13.0: &amp;T)
-26:5-26:83: @0[25]: _17 = &amp;(*_15)
-26:5-26:83: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-26:5-26:83: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-26:5-26:83: @1[2]: _12 = [move _16]
-26:5-26:83: @1[5]: _11 = &amp;_12
-26:5-26:83: @1[6]: _10 = &amp;(*_11)
-26:5-26:83: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-26:5-26:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-26:5-26:83: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-26:5-26:83: @3[6]: _2 = const ()
-25:77-27:2: @3[8]: _0 = const ()
-27:2-27:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_from_bin_crate_and_lib_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="26:14-26:76: @0[6]: _19 = const used_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-26:14-26:76: @0[7]: _7 = &amp;(*_19)
-26:14-26:76: @0[8]: _6 = &amp;(*_7)
-26:14-26:76: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-26:78-26:81: @0[17]: _14 = &amp;_1
-26:5-26:83: @0[18]: _13 = (move _14,)
-26:5-26:83: @0[20]: FakeRead(ForMatchedPlace, _13)
-26:5-26:83: @0[22]: _15 = (_13.0: &amp;T)
-26:5-26:83: @0[25]: _17 = &amp;(*_15)
-26:5-26:83: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-26:5-26:83: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-26:5-26:83: @1[2]: _12 = [move _16]
-26:5-26:83: @1[5]: _11 = &amp;_12
-26:5-26:83: @1[6]: _10 = &amp;(*_11)
-26:5-26:83: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-26:5-26:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-26:5-26:83: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-26:5-26:83: @3[6]: _2 = const ()
-25:77-27:2: @3[8]: _0 = const ()
-27:2-27:2: @4.Return: return">    println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="26:14-26:76: @0[6]: _19 = const used_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-26:14-26:76: @0[7]: _7 = &amp;(*_19)
-26:14-26:76: @0[8]: _6 = &amp;(*_7)
-26:14-26:76: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-26:78-26:81: @0[17]: _14 = &amp;_1
-26:5-26:83: @0[18]: _13 = (move _14,)
-26:5-26:83: @0[20]: FakeRead(ForMatchedPlace, _13)
-26:5-26:83: @0[22]: _15 = (_13.0: &amp;T)
-26:5-26:83: @0[25]: _17 = &amp;(*_15)
-26:5-26:83: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-26:5-26:83: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-26:5-26:83: @1[2]: _12 = [move _16]
-26:5-26:83: @1[5]: _11 = &amp;_12
-26:5-26:83: @1[6]: _10 = &amp;(*_11)
-26:5-26:83: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-26:5-26:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-26:5-26:83: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-26:5-26:83: @3[6]: _2 = const ()
-25:77-27:2: @3[8]: _0 = const ()
-27:2-27:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 974a24b2c6d44..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,110 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.used_function - 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 4"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1,2,3⦊</span>pub fn used_function() <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">    // 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="9:19-9:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-9:19-9:35: @1[0]: _3 = &amp;_4
-9:19-9:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-9:19-9:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-9:9-9:16: @2[3]: FakeRead(ForLet, _1)
-10:25-10:26: @3[2]: _5 = const 0_i32
-10:9-10:22: @3[3]: FakeRead(ForLet, _5)
-11:8-11:15: @3[6]: _7 = _1"><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="9:19-9:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-9:19-9:35: @1[0]: _3 = &amp;_4
-9:19-9:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-9:19-9:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-9:9-9:16: @2[3]: FakeRead(ForLet, _1)
-10:25-10:26: @3[2]: _5 = const 0_i32
-10:9-10:22: @3[3]: FakeRead(ForLet, _5)
-11:8-11:15: @3[6]: _7 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="9:19-9:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-9:19-9:35: @1[0]: _3 = &amp;_4
-9:19-9:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-9:19-9:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-9:9-9:16: @2[3]: FakeRead(ForLet, _1)
-10:25-10:26: @3[2]: _5 = const 0_i32
-10:9-10:22: @3[3]: FakeRead(ForLet, _5)
-11:8-11:15: @3[6]: _7 = _1">    if 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="12:9-12:23: @4[0]: _5 = const 10_i32
-11:16-13:6: @4[1]: _6 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="12:9-12:23: @4[0]: _5 = const 10_i32
-11:16-13:6: @4[1]: _6 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="12:9-12:23: @4[0]: _5 = const 10_i32
-11:16-13:6: @4[1]: _6 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="13:6-13:6: @5[0]: _6 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="14:5-14:25: @6.Call: _8 = use_this_lib_crate() -&gt; [return: bb7, unwind: bb9]
-15:2-15:2: @7.Return: return"><span class="annotation">@6,7⦊</span>use_this_lib_crate();</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:5-14:25: @6.Call: _8 = use_this_lib_crate() -&gt; [return: bb7, unwind: bb9]
-15:2-15:2: @7.Return: return">}<span class="annotation">⦉@6,7</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 68035339fe4a8..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.used_only_from_bin_crate_generic_function - 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><span class="code even" style="--layer: 1" title="18:14-18:67: @0[6]: _19 = const used_only_from_bin_crate_generic_function::&lt;T&gt;::promoted[0]
-18:14-18:67: @0[7]: _7 = &amp;(*_19)
-18:14-18:67: @0[8]: _6 = &amp;(*_7)
-18:14-18:67: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-18:69-18:72: @0[17]: _14 = &amp;_1
-18:5-18:74: @0[18]: _13 = (move _14,)
-18:5-18:74: @0[20]: FakeRead(ForMatchedPlace, _13)
-18:5-18:74: @0[22]: _15 = (_13.0: &amp;T)
-18:5-18:74: @0[25]: _17 = &amp;(*_15)
-18:5-18:74: @0[27]: _18 = &lt;T as std::fmt::Debug&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:5-18:74: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-18:5-18:74: @1[2]: _12 = [move _16]
-18:5-18:74: @1[5]: _11 = &amp;_12
-18:5-18:74: @1[6]: _10 = &amp;(*_11)
-18:5-18:74: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-18:5-18:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-18:5-18:74: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-18:5-18:74: @3[6]: _2 = const ()
-17:68-19:2: @3[8]: _0 = const ()
-19:2-19:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_only_from_bin_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="18:14-18:67: @0[6]: _19 = const used_only_from_bin_crate_generic_function::&lt;T&gt;::promoted[0]
-18:14-18:67: @0[7]: _7 = &amp;(*_19)
-18:14-18:67: @0[8]: _6 = &amp;(*_7)
-18:14-18:67: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-18:69-18:72: @0[17]: _14 = &amp;_1
-18:5-18:74: @0[18]: _13 = (move _14,)
-18:5-18:74: @0[20]: FakeRead(ForMatchedPlace, _13)
-18:5-18:74: @0[22]: _15 = (_13.0: &amp;T)
-18:5-18:74: @0[25]: _17 = &amp;(*_15)
-18:5-18:74: @0[27]: _18 = &lt;T as std::fmt::Debug&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:5-18:74: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-18:5-18:74: @1[2]: _12 = [move _16]
-18:5-18:74: @1[5]: _11 = &amp;_12
-18:5-18:74: @1[6]: _10 = &amp;(*_11)
-18:5-18:74: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-18:5-18:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-18:5-18:74: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-18:5-18:74: @3[6]: _2 = const ()
-17:68-19:2: @3[8]: _0 = const ()
-19:2-19:2: @4.Return: return">    println!("used_only_from_bin_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="18:14-18:67: @0[6]: _19 = const used_only_from_bin_crate_generic_function::&lt;T&gt;::promoted[0]
-18:14-18:67: @0[7]: _7 = &amp;(*_19)
-18:14-18:67: @0[8]: _6 = &amp;(*_7)
-18:14-18:67: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-18:69-18:72: @0[17]: _14 = &amp;_1
-18:5-18:74: @0[18]: _13 = (move _14,)
-18:5-18:74: @0[20]: FakeRead(ForMatchedPlace, _13)
-18:5-18:74: @0[22]: _15 = (_13.0: &amp;T)
-18:5-18:74: @0[25]: _17 = &amp;(*_15)
-18:5-18:74: @0[27]: _18 = &lt;T as std::fmt::Debug&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:5-18:74: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-18:5-18:74: @1[2]: _12 = [move _16]
-18:5-18:74: @1[5]: _11 = &amp;_12
-18:5-18:74: @1[6]: _10 = &amp;(*_11)
-18:5-18:74: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-18:5-18:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-18:5-18:74: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-18:5-18:74: @3[6]: _2 = const ()
-17:68-19:2: @3[8]: _0 = const ()
-19:2-19:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 63944eb9ab38e..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.used_only_from_this_lib_crate_generic_function - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 20"><span class="line"><span><span class="code even" style="--layer: 1" title="22:14-22:72: @0[6]: _19 = const used_only_from_this_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-22:14-22:72: @0[7]: _7 = &amp;(*_19)
-22:14-22:72: @0[8]: _6 = &amp;(*_7)
-22:14-22:72: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-22:74-22:77: @0[17]: _14 = &amp;_1
-22:5-22:79: @0[18]: _13 = (move _14,)
-22:5-22:79: @0[20]: FakeRead(ForMatchedPlace, _13)
-22:5-22:79: @0[22]: _15 = (_13.0: &amp;T)
-22:5-22:79: @0[25]: _17 = &amp;(*_15)
-22:5-22:79: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-22:5-22:79: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-22:5-22:79: @1[2]: _12 = [move _16]
-22:5-22:79: @1[5]: _11 = &amp;_12
-22:5-22:79: @1[6]: _10 = &amp;(*_11)
-22:5-22:79: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-22:5-22:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-22:5-22:79: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-22:5-22:79: @3[6]: _2 = const ()
-21:73-23:2: @3[8]: _0 = const ()
-23:2-23:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_only_from_this_lib_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:14-22:72: @0[6]: _19 = const used_only_from_this_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-22:14-22:72: @0[7]: _7 = &amp;(*_19)
-22:14-22:72: @0[8]: _6 = &amp;(*_7)
-22:14-22:72: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-22:74-22:77: @0[17]: _14 = &amp;_1
-22:5-22:79: @0[18]: _13 = (move _14,)
-22:5-22:79: @0[20]: FakeRead(ForMatchedPlace, _13)
-22:5-22:79: @0[22]: _15 = (_13.0: &amp;T)
-22:5-22:79: @0[25]: _17 = &amp;(*_15)
-22:5-22:79: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-22:5-22:79: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-22:5-22:79: @1[2]: _12 = [move _16]
-22:5-22:79: @1[5]: _11 = &amp;_12
-22:5-22:79: @1[6]: _10 = &amp;(*_11)
-22:5-22:79: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-22:5-22:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-22:5-22:79: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-22:5-22:79: @3[6]: _2 = const ()
-21:73-23:2: @3[8]: _0 = const ()
-23:2-23:2: @4.Return: return">    println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="22:14-22:72: @0[6]: _19 = const used_only_from_this_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-22:14-22:72: @0[7]: _7 = &amp;(*_19)
-22:14-22:72: @0[8]: _6 = &amp;(*_7)
-22:14-22:72: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-22:74-22:77: @0[17]: _14 = &amp;_1
-22:5-22:79: @0[18]: _13 = (move _14,)
-22:5-22:79: @0[20]: FakeRead(ForMatchedPlace, _13)
-22:5-22:79: @0[22]: _15 = (_13.0: &amp;T)
-22:5-22:79: @0[25]: _17 = &amp;(*_15)
-22:5-22:79: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-22:5-22:79: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-22:5-22:79: @1[2]: _12 = [move _16]
-22:5-22:79: @1[5]: _11 = &amp;_12
-22:5-22:79: @1[6]: _10 = &amp;(*_11)
-22:5-22:79: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-22:5-22:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-22:5-22:79: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-22:5-22:79: @3[6]: _2 = const ()
-21:73-23:2: @3[8]: _0 = const ()
-23:2-23:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index b146180fbd155..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_crate/used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function - 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 28"><span class="line"><span><span class="code even" style="--layer: 1" title="30:14-30:91: @0[6]: _19 = const used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-30:14-30:91: @0[7]: _7 = &amp;(*_19)
-30:14-30:91: @0[8]: _6 = &amp;(*_7)
-30:14-30:91: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-30:93-30:96: @0[17]: _14 = &amp;_1
-30:5-30:98: @0[18]: _13 = (move _14,)
-30:5-30:98: @0[20]: FakeRead(ForMatchedPlace, _13)
-30:5-30:98: @0[22]: _15 = (_13.0: &amp;T)
-30:5-30:98: @0[25]: _17 = &amp;(*_15)
-30:5-30:98: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-30:5-30:98: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-30:5-30:98: @1[2]: _12 = [move _16]
-30:5-30:98: @1[5]: _11 = &amp;_12
-30:5-30:98: @1[6]: _10 = &amp;(*_11)
-30:5-30:98: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-30:5-30:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-30:5-30:98: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-30:5-30:98: @3[6]: _2 = const ()
-29:92-31:2: @3[8]: _0 = const ()
-31:2-31:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:14-30:91: @0[6]: _19 = const used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-30:14-30:91: @0[7]: _7 = &amp;(*_19)
-30:14-30:91: @0[8]: _6 = &amp;(*_7)
-30:14-30:91: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-30:93-30:96: @0[17]: _14 = &amp;_1
-30:5-30:98: @0[18]: _13 = (move _14,)
-30:5-30:98: @0[20]: FakeRead(ForMatchedPlace, _13)
-30:5-30:98: @0[22]: _15 = (_13.0: &amp;T)
-30:5-30:98: @0[25]: _17 = &amp;(*_15)
-30:5-30:98: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-30:5-30:98: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-30:5-30:98: @1[2]: _12 = [move _16]
-30:5-30:98: @1[5]: _11 = &amp;_12
-30:5-30:98: @1[6]: _10 = &amp;(*_11)
-30:5-30:98: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-30:5-30:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-30:5-30:98: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-30:5-30:98: @3[6]: _2 = const ()
-29:92-31:2: @3[8]: _0 = const ()
-31:2-31:2: @4.Return: return">    println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="30:14-30:91: @0[6]: _19 = const used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-30:14-30:91: @0[7]: _7 = &amp;(*_19)
-30:14-30:91: @0[8]: _6 = &amp;(*_7)
-30:14-30:91: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-30:93-30:96: @0[17]: _14 = &amp;_1
-30:5-30:98: @0[18]: _13 = (move _14,)
-30:5-30:98: @0[20]: FakeRead(ForMatchedPlace, _13)
-30:5-30:98: @0[22]: _15 = (_13.0: &amp;T)
-30:5-30:98: @0[25]: _17 = &amp;(*_15)
-30:5-30:98: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-30:5-30:98: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-30:5-30:98: @1[2]: _12 = [move _16]
-30:5-30:98: @1[5]: _11 = &amp;_12
-30:5-30:98: @1[6]: _10 = &amp;(*_11)
-30:5-30:98: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-30:5-30:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-30:5-30:98: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-30:5-30:98: @3[6]: _2 = const ()
-29:92-31:2: @3[8]: _0 = const ()
-31:2-31:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 322eaf07677f4..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,115 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.unused_function - 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 64"><span class="line"><span><span class="code even" style="--layer: 1" title="66:19-66:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-66:19-66:35: @1[0]: _3 = &amp;_4
-66:19-66:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-66:19-66:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-66:9-66:16: @2[3]: FakeRead(ForLet, _1)
-67:25-67:26: @3[2]: _5 = const 2_i32
-67:9-67:22: @3[3]: FakeRead(ForLet, _5)
-68:9-68:16: @3[6]: _7 = _1
-68:8-68:16: @3[7]: _6 = Not(move _7)"><span class="annotation">@0,1,2,3⦊</span>pub fn unused_function() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="66:19-66:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-66:19-66:35: @1[0]: _3 = &amp;_4
-66:19-66:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-66:19-66:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-66:9-66:16: @2[3]: FakeRead(ForLet, _1)
-67:25-67:26: @3[2]: _5 = const 2_i32
-67:9-67:22: @3[3]: FakeRead(ForLet, _5)
-68:9-68:16: @3[6]: _7 = _1
-68:8-68:16: @3[7]: _6 = Not(move _7)">    let is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="66:19-66:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-66:19-66:35: @1[0]: _3 = &amp;_4
-66:19-66:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-66:19-66:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-66:9-66:16: @2[3]: FakeRead(ForLet, _1)
-67:25-67:26: @3[2]: _5 = const 2_i32
-67:9-67:22: @3[3]: FakeRead(ForLet, _5)
-68:9-68:16: @3[6]: _7 = _1
-68:8-68:16: @3[7]: _6 = Not(move _7)">    let mut countdown = 2;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="66:19-66:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-66:19-66:35: @1[0]: _3 = &amp;_4
-66:19-66:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-66:19-66:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-66:9-66:16: @2[3]: FakeRead(ForLet, _1)
-67:25-67:26: @3[2]: _5 = const 2_i32
-67:9-67:22: @3[3]: FakeRead(ForLet, _5)
-68:9-68:16: @3[6]: _7 = _1
-68:8-68:16: @3[7]: _6 = Not(move _7)">    if !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="69:9-69:23: @4[0]: _5 = const 20_i32
-68:17-70:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="69:9-69:23: @4[0]: _5 = const 20_i32
-68:17-70:6: @4[1]: _0 = const ()">        countdown = 20;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="69:9-69:23: @4[0]: _5 = const 20_i32
-68:17-70:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="70:6-70:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="71:2-71:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 9e3052ccac155..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.unused_generic_function - 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><span class="code even" style="--layer: 1" title="61:14-61:49: @0[6]: _19 = const unused_generic_function::&lt;T&gt;::promoted[0]
-61:14-61:49: @0[7]: _7 = &amp;(*_19)
-61:14-61:49: @0[8]: _6 = &amp;(*_7)
-61:14-61:49: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-61:51-61:54: @0[17]: _14 = &amp;_1
-61:5-61:56: @0[18]: _13 = (move _14,)
-61:5-61:56: @0[20]: FakeRead(ForMatchedPlace, _13)
-61:5-61:56: @0[22]: _15 = (_13.0: &amp;T)
-61:5-61:56: @0[25]: _17 = &amp;(*_15)
-61:5-61:56: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-61:5-61:56: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-61:5-61:56: @1[2]: _12 = [move _16]
-61:5-61:56: @1[5]: _11 = &amp;_12
-61:5-61:56: @1[6]: _10 = &amp;(*_11)
-61:5-61:56: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-61:5-61:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-61:5-61:56: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-61:5-61:56: @3[6]: _2 = const ()
-60:50-62:2: @3[8]: _0 = const ()
-62:2-62:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn unused_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="61:14-61:49: @0[6]: _19 = const unused_generic_function::&lt;T&gt;::promoted[0]
-61:14-61:49: @0[7]: _7 = &amp;(*_19)
-61:14-61:49: @0[8]: _6 = &amp;(*_7)
-61:14-61:49: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-61:51-61:54: @0[17]: _14 = &amp;_1
-61:5-61:56: @0[18]: _13 = (move _14,)
-61:5-61:56: @0[20]: FakeRead(ForMatchedPlace, _13)
-61:5-61:56: @0[22]: _15 = (_13.0: &amp;T)
-61:5-61:56: @0[25]: _17 = &amp;(*_15)
-61:5-61:56: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-61:5-61:56: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-61:5-61:56: @1[2]: _12 = [move _16]
-61:5-61:56: @1[5]: _11 = &amp;_12
-61:5-61:56: @1[6]: _10 = &amp;(*_11)
-61:5-61:56: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-61:5-61:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-61:5-61:56: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-61:5-61:56: @3[6]: _2 = const ()
-60:50-62:2: @3[8]: _0 = const ()
-62:2-62:2: @4.Return: return">    println!("unused_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="61:14-61:49: @0[6]: _19 = const unused_generic_function::&lt;T&gt;::promoted[0]
-61:14-61:49: @0[7]: _7 = &amp;(*_19)
-61:14-61:49: @0[8]: _6 = &amp;(*_7)
-61:14-61:49: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-61:51-61:54: @0[17]: _14 = &amp;_1
-61:5-61:56: @0[18]: _13 = (move _14,)
-61:5-61:56: @0[20]: FakeRead(ForMatchedPlace, _13)
-61:5-61:56: @0[22]: _15 = (_13.0: &amp;T)
-61:5-61:56: @0[25]: _17 = &amp;(*_15)
-61:5-61:56: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-61:5-61:56: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-61:5-61:56: @1[2]: _12 = [move _16]
-61:5-61:56: @1[5]: _11 = &amp;_12
-61:5-61:56: @1[6]: _10 = &amp;(*_11)
-61:5-61:56: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-61:5-61:56: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-61:5-61:56: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-61:5-61:56: @3[6]: _2 = const ()
-60:50-62:2: @3[8]: _0 = const ()
-62:2-62:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_private_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_private_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index e9c381db94025..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_private_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,115 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.unused_private_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.unused_private_function - 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 73"><span class="line"><span><span class="code even" style="--layer: 1" title="75:19-75:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-75:19-75:35: @1[0]: _3 = &amp;_4
-75:19-75:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-75:19-75:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-75:9-75:16: @2[3]: FakeRead(ForLet, _1)
-76:25-76:26: @3[2]: _5 = const 2_i32
-76:9-76:22: @3[3]: FakeRead(ForLet, _5)
-77:9-77:16: @3[6]: _7 = _1
-77:8-77:16: @3[7]: _6 = Not(move _7)"><span class="annotation">@0,1,2,3⦊</span>fn unused_private_function() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="75:19-75:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-75:19-75:35: @1[0]: _3 = &amp;_4
-75:19-75:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-75:19-75:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-75:9-75:16: @2[3]: FakeRead(ForLet, _1)
-76:25-76:26: @3[2]: _5 = const 2_i32
-76:9-76:22: @3[3]: FakeRead(ForLet, _5)
-77:9-77:16: @3[6]: _7 = _1
-77:8-77:16: @3[7]: _6 = Not(move _7)">    let is_true = std::env::args().len() == 1;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="75:19-75:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-75:19-75:35: @1[0]: _3 = &amp;_4
-75:19-75:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-75:19-75:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-75:9-75:16: @2[3]: FakeRead(ForLet, _1)
-76:25-76:26: @3[2]: _5 = const 2_i32
-76:9-76:22: @3[3]: FakeRead(ForLet, _5)
-77:9-77:16: @3[6]: _7 = _1
-77:8-77:16: @3[7]: _6 = Not(move _7)">    let mut countdown = 2;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="75:19-75:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb8]
-75:19-75:35: @1[0]: _3 = &amp;_4
-75:19-75:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb7]
-75:19-75:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-75:9-75:16: @2[3]: FakeRead(ForLet, _1)
-76:25-76:26: @3[2]: _5 = const 2_i32
-76:9-76:22: @3[3]: FakeRead(ForLet, _5)
-77:9-77:16: @3[6]: _7 = _1
-77:8-77:16: @3[7]: _6 = Not(move _7)">    if !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="78:9-78:23: @4[0]: _5 = const 20_i32
-77:17-79:6: @4[1]: _0 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="78:9-78:23: @4[0]: _5 = const 20_i32
-77:17-79:6: @4[1]: _0 = const ()">        countdown = 20;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="78:9-78:23: @4[0]: _5 = const 20_i32
-77:17-79:6: @4[1]: _0 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="79:6-79:6: @5[0]: _0 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="80:2-80:2: @6.Return: return"><span class="annotation">@6⦊</span>‸<span class="annotation">⦉@6</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 056f618a403c9..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,190 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.use_this_lib_crate.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.use_this_lib_crate - 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 81"><span class="line"><span><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8⦊</span>fn use_this_lib_crate() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">    used_from_bin_crate_and_lib_crate_generic_function("used from library used_crate.rs");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">    used_with_same_type_from_bin_crate_and_lib_crate_generic_function(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">        "used from library used_crate.rs",</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">    let some_vec = vec![5, 6, 7, 8];</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">    used_only_from_this_lib_crate_generic_function(some_vec);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">    used_only_from_this_lib_crate_generic_function("used ONLY from library used_crate.rs");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="83:5-83:90: @0.Call: _1 = used_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb1, unwind: bb13]
-84:5-86:6: @1.Call: _2 = used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from library used_crate.rs&quot;) -&gt; [return: bb2, unwind: bb13]
-87:20-87:36: @2[5]: _6 = Box([i32; 4])
-87:20-87:36: @2[6]: (*_6) = [const 5_i32, const 6_i32, const 7_i32, const 8_i32]
-87:20-87:36: @2[7]: _5 = move _6
-87:20-87:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-87:20-87:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb12]
-87:9-87:17: @5[1]: FakeRead(ForLet, _3)
-88:52-88:60: @5[4]: _8 = move _3
-88:5-88:61: @5.Call: _7 = used_only_from_this_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb9]
-89:5-89:91: @6.Call: _9 = used_only_from_this_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;used ONLY from library used_crate.rs&quot;) -&gt; [return: bb7, unwind: bb10]
-82:25-90:2: @7[1]: _0 = const ()
-90:2-90:2: @8.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 0d88b0bc60e34..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.used_from_bin_crate_and_lib_crate_generic_function - 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 49"><span class="line"><span><span class="code even" style="--layer: 1" title="51:14-51:76: @0[6]: _19 = const used_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-51:14-51:76: @0[7]: _7 = &amp;(*_19)
-51:14-51:76: @0[8]: _6 = &amp;(*_7)
-51:14-51:76: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-51:78-51:81: @0[17]: _14 = &amp;_1
-51:5-51:83: @0[18]: _13 = (move _14,)
-51:5-51:83: @0[20]: FakeRead(ForMatchedPlace, _13)
-51:5-51:83: @0[22]: _15 = (_13.0: &amp;T)
-51:5-51:83: @0[25]: _17 = &amp;(*_15)
-51:5-51:83: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-51:5-51:83: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-51:5-51:83: @1[2]: _12 = [move _16]
-51:5-51:83: @1[5]: _11 = &amp;_12
-51:5-51:83: @1[6]: _10 = &amp;(*_11)
-51:5-51:83: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-51:5-51:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-51:5-51:83: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-51:5-51:83: @3[6]: _2 = const ()
-50:77-52:2: @3[8]: _0 = const ()
-52:2-52:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_from_bin_crate_and_lib_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="51:14-51:76: @0[6]: _19 = const used_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-51:14-51:76: @0[7]: _7 = &amp;(*_19)
-51:14-51:76: @0[8]: _6 = &amp;(*_7)
-51:14-51:76: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-51:78-51:81: @0[17]: _14 = &amp;_1
-51:5-51:83: @0[18]: _13 = (move _14,)
-51:5-51:83: @0[20]: FakeRead(ForMatchedPlace, _13)
-51:5-51:83: @0[22]: _15 = (_13.0: &amp;T)
-51:5-51:83: @0[25]: _17 = &amp;(*_15)
-51:5-51:83: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-51:5-51:83: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-51:5-51:83: @1[2]: _12 = [move _16]
-51:5-51:83: @1[5]: _11 = &amp;_12
-51:5-51:83: @1[6]: _10 = &amp;(*_11)
-51:5-51:83: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-51:5-51:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-51:5-51:83: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-51:5-51:83: @3[6]: _2 = const ()
-50:77-52:2: @3[8]: _0 = const ()
-52:2-52:2: @4.Return: return">    println!("used_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="51:14-51:76: @0[6]: _19 = const used_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-51:14-51:76: @0[7]: _7 = &amp;(*_19)
-51:14-51:76: @0[8]: _6 = &amp;(*_7)
-51:14-51:76: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-51:78-51:81: @0[17]: _14 = &amp;_1
-51:5-51:83: @0[18]: _13 = (move _14,)
-51:5-51:83: @0[20]: FakeRead(ForMatchedPlace, _13)
-51:5-51:83: @0[22]: _15 = (_13.0: &amp;T)
-51:5-51:83: @0[25]: _17 = &amp;(*_15)
-51:5-51:83: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-51:5-51:83: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-51:5-51:83: @1[2]: _12 = [move _16]
-51:5-51:83: @1[5]: _11 = &amp;_12
-51:5-51:83: @1[6]: _10 = &amp;(*_11)
-51:5-51:83: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-51:5-51:83: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-51:5-51:83: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-51:5-51:83: @3[6]: _2 = const ()
-50:77-52:2: @3[8]: _0 = const ()
-52:2-52:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index d722d9f46ecff..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,110 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.used_function - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 6"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1,2,3⦊</span>pub fn used_function() <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">    // 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="11:19-11:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-11:19-11:35: @1[0]: _3 = &amp;_4
-11:19-11:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-11:19-11:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-11:9-11:16: @2[3]: FakeRead(ForLet, _1)
-12:25-12:26: @3[2]: _5 = const 0_i32
-12:9-12:22: @3[3]: FakeRead(ForLet, _5)
-13:8-13:15: @3[6]: _7 = _1"><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="11:19-11:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-11:19-11:35: @1[0]: _3 = &amp;_4
-11:19-11:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-11:19-11:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-11:9-11:16: @2[3]: FakeRead(ForLet, _1)
-12:25-12:26: @3[2]: _5 = const 0_i32
-12:9-12:22: @3[3]: FakeRead(ForLet, _5)
-13:8-13:15: @3[6]: _7 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="11:19-11:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-11:19-11:35: @1[0]: _3 = &amp;_4
-11:19-11:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-11:19-11:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-11:9-11:16: @2[3]: FakeRead(ForLet, _1)
-12:25-12:26: @3[2]: _5 = const 0_i32
-12:9-12:22: @3[3]: FakeRead(ForLet, _5)
-13:8-13:15: @3[6]: _7 = _1">    if 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="14:9-14:23: @4[0]: _5 = const 10_i32
-13:16-15:6: @4[1]: _6 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:9-14:23: @4[0]: _5 = const 10_i32
-13:16-15:6: @4[1]: _6 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="14:9-14:23: @4[0]: _5 = const 10_i32
-13:16-15:6: @4[1]: _6 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="15:6-15:6: @5[0]: _6 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="16:5-16:25: @6.Call: _8 = use_this_lib_crate() -&gt; [return: bb7, unwind: bb9]
-17:2-17:2: @7.Return: return"><span class="annotation">@6,7⦊</span>use_this_lib_crate();</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="16:5-16:25: @6.Call: _8 = use_this_lib_crate() -&gt; [return: bb7, unwind: bb9]
-17:2-17:2: @7.Return: return">}<span class="annotation">⦉@6,7</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_inline_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_inline_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index a15c31bb13fd0..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_inline_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,110 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_inline_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.used_inline_function - 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 19"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1,2,3⦊</span>pub fn used_inline_function() <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">    // 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="24:19-24:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-24:19-24:35: @1[0]: _3 = &amp;_4
-24:19-24:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-24:19-24:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-24:9-24:16: @2[3]: FakeRead(ForLet, _1)
-25:25-25:26: @3[2]: _5 = const 0_i32
-25:9-25:22: @3[3]: FakeRead(ForLet, _5)
-26:8-26:15: @3[6]: _7 = _1"><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="24:19-24:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-24:19-24:35: @1[0]: _3 = &amp;_4
-24:19-24:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-24:19-24:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-24:9-24:16: @2[3]: FakeRead(ForLet, _1)
-25:25-25:26: @3[2]: _5 = const 0_i32
-25:9-25:22: @3[3]: FakeRead(ForLet, _5)
-26:8-26:15: @3[6]: _7 = _1">    let mut countdown = 0;</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="24:19-24:35: @0.Call: _4 = std::env::args() -&gt; [return: bb1, unwind: bb9]
-24:19-24:35: @1[0]: _3 = &amp;_4
-24:19-24:41: @1.Call: _2 = &lt;std::env::Args as std::iter::ExactSizeIterator&gt;::len(move _3) -&gt; [return: bb2, unwind: bb8]
-24:19-24:46: @2[1]: _1 = Eq(move _2, const 1_usize)
-24:9-24:16: @2[3]: FakeRead(ForLet, _1)
-25:25-25:26: @3[2]: _5 = const 0_i32
-25:9-25:22: @3[3]: FakeRead(ForLet, _5)
-26:8-26:15: @3[6]: _7 = _1">    if 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="27:9-27:23: @4[0]: _5 = const 10_i32
-26:16-28:6: @4[1]: _6 = const ()"><span class="annotation">@4⦊</span>{</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="27:9-27:23: @4[0]: _5 = const 10_i32
-26:16-28:6: @4[1]: _6 = const ()">        countdown = 10;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="27:9-27:23: @4[0]: _5 = const 10_i32
-26:16-28:6: @4[1]: _6 = const ()">    }<span class="annotation">⦉@4</span></span></span><span><span class="code even" style="--layer: 1" title="28:6-28:6: @5[0]: _6 = const ()"><span class="annotation">@5⦊</span>‸<span class="annotation">⦉@5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">    </span><span><span class="code odd" style="--layer: 1" title="29:5-29:25: @6.Call: _8 = use_this_lib_crate() -&gt; [return: bb7, unwind: bb9]
-30:2-30:2: @7.Return: return"><span class="annotation">@6,7⦊</span>use_this_lib_crate();</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="29:5-29:25: @6.Call: _8 = use_this_lib_crate() -&gt; [return: bb7, unwind: bb9]
-30:2-30:2: @7.Return: return">}<span class="annotation">⦉@6,7</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 252ff76d41696..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_bin_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.used_only_from_bin_crate_generic_function - 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 38"><span class="line"><span><span class="code even" style="--layer: 1" title="40:14-40:67: @0[6]: _19 = const used_only_from_bin_crate_generic_function::&lt;T&gt;::promoted[0]
-40:14-40:67: @0[7]: _7 = &amp;(*_19)
-40:14-40:67: @0[8]: _6 = &amp;(*_7)
-40:14-40:67: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-40:69-40:72: @0[17]: _14 = &amp;_1
-40:5-40:74: @0[18]: _13 = (move _14,)
-40:5-40:74: @0[20]: FakeRead(ForMatchedPlace, _13)
-40:5-40:74: @0[22]: _15 = (_13.0: &amp;T)
-40:5-40:74: @0[25]: _17 = &amp;(*_15)
-40:5-40:74: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-40:5-40:74: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-40:5-40:74: @1[2]: _12 = [move _16]
-40:5-40:74: @1[5]: _11 = &amp;_12
-40:5-40:74: @1[6]: _10 = &amp;(*_11)
-40:5-40:74: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-40:5-40:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-40:5-40:74: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-40:5-40:74: @3[6]: _2 = const ()
-39:68-41:2: @3[8]: _0 = const ()
-41:2-41:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_only_from_bin_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="40:14-40:67: @0[6]: _19 = const used_only_from_bin_crate_generic_function::&lt;T&gt;::promoted[0]
-40:14-40:67: @0[7]: _7 = &amp;(*_19)
-40:14-40:67: @0[8]: _6 = &amp;(*_7)
-40:14-40:67: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-40:69-40:72: @0[17]: _14 = &amp;_1
-40:5-40:74: @0[18]: _13 = (move _14,)
-40:5-40:74: @0[20]: FakeRead(ForMatchedPlace, _13)
-40:5-40:74: @0[22]: _15 = (_13.0: &amp;T)
-40:5-40:74: @0[25]: _17 = &amp;(*_15)
-40:5-40:74: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-40:5-40:74: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-40:5-40:74: @1[2]: _12 = [move _16]
-40:5-40:74: @1[5]: _11 = &amp;_12
-40:5-40:74: @1[6]: _10 = &amp;(*_11)
-40:5-40:74: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-40:5-40:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-40:5-40:74: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-40:5-40:74: @3[6]: _2 = const ()
-39:68-41:2: @3[8]: _0 = const ()
-41:2-41:2: @4.Return: return">    println!("used_only_from_bin_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="40:14-40:67: @0[6]: _19 = const used_only_from_bin_crate_generic_function::&lt;T&gt;::promoted[0]
-40:14-40:67: @0[7]: _7 = &amp;(*_19)
-40:14-40:67: @0[8]: _6 = &amp;(*_7)
-40:14-40:67: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-40:69-40:72: @0[17]: _14 = &amp;_1
-40:5-40:74: @0[18]: _13 = (move _14,)
-40:5-40:74: @0[20]: FakeRead(ForMatchedPlace, _13)
-40:5-40:74: @0[22]: _15 = (_13.0: &amp;T)
-40:5-40:74: @0[25]: _17 = &amp;(*_15)
-40:5-40:74: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-40:5-40:74: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-40:5-40:74: @1[2]: _12 = [move _16]
-40:5-40:74: @1[5]: _11 = &amp;_12
-40:5-40:74: @1[6]: _10 = &amp;(*_11)
-40:5-40:74: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-40:5-40:74: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-40:5-40:74: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-40:5-40:74: @3[6]: _2 = const ()
-39:68-41:2: @3[8]: _0 = const ()
-41:2-41:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index f8fb4990ad9a6..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_only_from_this_lib_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.used_only_from_this_lib_crate_generic_function - 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 44"><span class="line"><span><span class="code even" style="--layer: 1" title="46:14-46:72: @0[6]: _19 = const used_only_from_this_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-46:14-46:72: @0[7]: _7 = &amp;(*_19)
-46:14-46:72: @0[8]: _6 = &amp;(*_7)
-46:14-46:72: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-46:74-46:77: @0[17]: _14 = &amp;_1
-46:5-46:79: @0[18]: _13 = (move _14,)
-46:5-46:79: @0[20]: FakeRead(ForMatchedPlace, _13)
-46:5-46:79: @0[22]: _15 = (_13.0: &amp;T)
-46:5-46:79: @0[25]: _17 = &amp;(*_15)
-46:5-46:79: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-46:5-46:79: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-46:5-46:79: @1[2]: _12 = [move _16]
-46:5-46:79: @1[5]: _11 = &amp;_12
-46:5-46:79: @1[6]: _10 = &amp;(*_11)
-46:5-46:79: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-46:5-46:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-46:5-46:79: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-46:5-46:79: @3[6]: _2 = const ()
-45:73-47:2: @3[8]: _0 = const ()
-47:2-47:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_only_from_this_lib_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="46:14-46:72: @0[6]: _19 = const used_only_from_this_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-46:14-46:72: @0[7]: _7 = &amp;(*_19)
-46:14-46:72: @0[8]: _6 = &amp;(*_7)
-46:14-46:72: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-46:74-46:77: @0[17]: _14 = &amp;_1
-46:5-46:79: @0[18]: _13 = (move _14,)
-46:5-46:79: @0[20]: FakeRead(ForMatchedPlace, _13)
-46:5-46:79: @0[22]: _15 = (_13.0: &amp;T)
-46:5-46:79: @0[25]: _17 = &amp;(*_15)
-46:5-46:79: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-46:5-46:79: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-46:5-46:79: @1[2]: _12 = [move _16]
-46:5-46:79: @1[5]: _11 = &amp;_12
-46:5-46:79: @1[6]: _10 = &amp;(*_11)
-46:5-46:79: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-46:5-46:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-46:5-46:79: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-46:5-46:79: @3[6]: _2 = const ()
-45:73-47:2: @3[8]: _0 = const ()
-47:2-47:2: @4.Return: return">    println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="46:14-46:72: @0[6]: _19 = const used_only_from_this_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-46:14-46:72: @0[7]: _7 = &amp;(*_19)
-46:14-46:72: @0[8]: _6 = &amp;(*_7)
-46:14-46:72: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-46:74-46:77: @0[17]: _14 = &amp;_1
-46:5-46:79: @0[18]: _13 = (move _14,)
-46:5-46:79: @0[20]: FakeRead(ForMatchedPlace, _13)
-46:5-46:79: @0[22]: _15 = (_13.0: &amp;T)
-46:5-46:79: @0[25]: _17 = &amp;(*_15)
-46:5-46:79: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-46:5-46:79: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-46:5-46:79: @1[2]: _12 = [move _16]
-46:5-46:79: @1[5]: _11 = &amp;_12
-46:5-46:79: @1[6]: _10 = &amp;(*_11)
-46:5-46:79: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-46:5-46:79: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-46:5-46:79: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-46:5-46:79: @3[6]: _2 = const ()
-45:73-47:2: @3[8]: _0 = const ()
-47:2-47:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
deleted file mode 100644
index db5e24d9b1dd6..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,133 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.used_inline_crate/used_inline_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>used_inline_crate.used_with_same_type_from_bin_crate_and_lib_crate_generic_function - 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 54"><span class="line"><span><span class="code even" style="--layer: 1" title="56:14-56:91: @0[6]: _19 = const used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-56:14-56:91: @0[7]: _7 = &amp;(*_19)
-56:14-56:91: @0[8]: _6 = &amp;(*_7)
-56:14-56:91: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-56:93-56:96: @0[17]: _14 = &amp;_1
-56:5-56:98: @0[18]: _13 = (move _14,)
-56:5-56:98: @0[20]: FakeRead(ForMatchedPlace, _13)
-56:5-56:98: @0[22]: _15 = (_13.0: &amp;T)
-56:5-56:98: @0[25]: _17 = &amp;(*_15)
-56:5-56:98: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-56:5-56:98: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-56:5-56:98: @1[2]: _12 = [move _16]
-56:5-56:98: @1[5]: _11 = &amp;_12
-56:5-56:98: @1[6]: _10 = &amp;(*_11)
-56:5-56:98: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-56:5-56:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-56:5-56:98: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-56:5-56:98: @3[6]: _2 = const ()
-55:92-57:2: @3[8]: _0 = const ()
-57:2-57:2: @4.Return: return"><span class="annotation">@0,1,2,3,4⦊</span>pub fn used_with_same_type_from_bin_crate_and_lib_crate_generic_function&lt;T: Debug&gt;(arg: T) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="56:14-56:91: @0[6]: _19 = const used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-56:14-56:91: @0[7]: _7 = &amp;(*_19)
-56:14-56:91: @0[8]: _6 = &amp;(*_7)
-56:14-56:91: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-56:93-56:96: @0[17]: _14 = &amp;_1
-56:5-56:98: @0[18]: _13 = (move _14,)
-56:5-56:98: @0[20]: FakeRead(ForMatchedPlace, _13)
-56:5-56:98: @0[22]: _15 = (_13.0: &amp;T)
-56:5-56:98: @0[25]: _17 = &amp;(*_15)
-56:5-56:98: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-56:5-56:98: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-56:5-56:98: @1[2]: _12 = [move _16]
-56:5-56:98: @1[5]: _11 = &amp;_12
-56:5-56:98: @1[6]: _10 = &amp;(*_11)
-56:5-56:98: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-56:5-56:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-56:5-56:98: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-56:5-56:98: @3[6]: _2 = const ()
-55:92-57:2: @3[8]: _0 = const ()
-57:2-57:2: @4.Return: return">    println!("used_with_same_type_from_bin_crate_and_lib_crate_generic_function with {:?}", arg);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="56:14-56:91: @0[6]: _19 = const used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;T&gt;::promoted[0]
-56:14-56:91: @0[7]: _7 = &amp;(*_19)
-56:14-56:91: @0[8]: _6 = &amp;(*_7)
-56:14-56:91: @0[9]: _5 = move _6 as &amp;[&amp;str] (Pointer(Unsize))
-56:93-56:96: @0[17]: _14 = &amp;_1
-56:5-56:98: @0[18]: _13 = (move _14,)
-56:5-56:98: @0[20]: FakeRead(ForMatchedPlace, _13)
-56:5-56:98: @0[22]: _15 = (_13.0: &amp;T)
-56:5-56:98: @0[25]: _17 = &amp;(*_15)
-56:5-56:98: @0[27]: _18 = &lt;T as std::fmt::Debug&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))
-56:5-56:98: @0.Call: _16 = std::fmt::ArgumentV1::new::&lt;T&gt;(move _17, move _18) -&gt; [return: bb1, unwind: bb5]
-56:5-56:98: @1[2]: _12 = [move _16]
-56:5-56:98: @1[5]: _11 = &amp;_12
-56:5-56:98: @1[6]: _10 = &amp;(*_11)
-56:5-56:98: @1[7]: _9 = move _10 as &amp;[std::fmt::ArgumentV1] (Pointer(Unsize))
-56:5-56:98: @1.Call: _4 = std::fmt::Arguments::new_v1(move _5, move _9) -&gt; [return: bb2, unwind: bb5]
-56:5-56:98: @2.Call: _3 = std::io::_print(move _4) -&gt; [return: bb3, unwind: bb5]
-56:5-56:98: @3[6]: _2 = const ()
-55:92-57:2: @3[8]: _0 = const ()
-57:2-57:2: @4.Return: return">}<span class="annotation">⦉@0,1,2,3,4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 28cf051ecf873..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,193 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_crate/uses_crate.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>uses_crate.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 4"><span class="line"><span><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return">    used_crate::used_function();</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return">    let some_vec = vec![1, 2, 3, 4];</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return">    used_crate::used_only_from_bin_crate_generic_function(&amp;some_vec);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return">    used_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return">    used_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return">    used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function("interesting?");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="6:5-6:32: @0.Call: _1 = used_crate::used_function() -&gt; [return: bb1, unwind: bb14]
-7:20-7:36: @1[5]: _5 = Box([i32; 4])
-7:20-7:36: @1[6]: (*_5) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-7:20-7:36: @1[7]: _4 = move _5
-7:20-7:36: @1[8]: _3 = move _4 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-7:20-7:36: @3.Call: _2 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _3) -&gt; [return: bb4, unwind: bb13]
-7:9-7:17: @4[1]: FakeRead(ForLet, _2)
-8:59-8:68: @4[4]: _7 = &amp;_2
-8:5-8:69: @4.Call: _6 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _7) -&gt; [return: bb5, unwind: bb11]
-9:5-9:89: @5.Call: _8 = used_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb6, unwind: bb11]
-10:68-10:76: @6[3]: _10 = move _2
-10:5-10:77: @6.Call: _9 = used_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _10) -&gt; [return: bb7, unwind: bb10]
-11:5-11:98: @7.Call: _11 = used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb8, unwind: bb11]
-5:11-12:2: @8[1]: _0 = const ()
-12:2-12:2: @9.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_inline_crate/uses_inline_crate.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_inline_crate/uses_inline_crate.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 179940f6bd5b7..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_inline_crate/uses_inline_crate.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,249 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.uses_inline_crate/uses_inline_crate.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>uses_inline_crate.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 6"><span class="line"><span><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return"><span class="annotation">@0,1,2,3,4,5,6,7,8,9,10⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    used_inline_crate::used_function();</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    used_inline_crate::used_inline_function();</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    let some_vec = vec![1, 2, 3, 4];</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    used_inline_crate::used_only_from_bin_crate_generic_function(&amp;some_vec);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    used_inline_crate::used_only_from_bin_crate_generic_function("used from bin uses_crate.rs");</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function(some_vec);</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function(</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">        "interesting?",</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">    );</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="8:5-8:39: @0.Call: _1 = used_inline_crate::used_function() -&gt; [return: bb1, unwind: bb15]
-9:5-9:46: @1.Call: _2 = used_inline_crate::used_inline_function() -&gt; [return: bb2, unwind: bb15]
-10:20-10:36: @2[5]: _6 = Box([i32; 4])
-10:20-10:36: @2[6]: (*_6) = [const 1_i32, const 2_i32, const 3_i32, const 4_i32]
-10:20-10:36: @2[7]: _5 = move _6
-10:20-10:36: @2[8]: _4 = move _5 as std::boxed::Box&lt;[i32]&gt; (Pointer(Unsize))
-10:20-10:36: @4.Call: _3 = std::slice::&lt;impl [i32]&gt;::into_vec::&lt;std::alloc::Global&gt;(move _4) -&gt; [return: bb5, unwind: bb14]
-10:9-10:17: @5[1]: FakeRead(ForLet, _3)
-11:66-11:75: @5[4]: _8 = &amp;_3
-11:5-11:76: @5.Call: _7 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;std::vec::Vec&lt;i32&gt;&gt;(move _8) -&gt; [return: bb6, unwind: bb12]
-12:5-12:96: @6.Call: _9 = used_inline_crate::used_only_from_bin_crate_generic_function::&lt;&amp;str&gt;(const &quot;used from bin uses_crate.rs&quot;) -&gt; [return: bb7, unwind: bb12]
-13:75-13:83: @7[3]: _11 = move _3
-13:5-13:84: @7.Call: _10 = used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::&lt;std::vec::Vec&lt;i32&gt;&gt;(move _11) -&gt; [return: bb8, unwind: bb11]
-14:5-16:6: @8.Call: _12 = used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::&lt;&amp;str&gt;(const &quot;interesting?&quot;) -&gt; [return: bb9, unwind: bb12]
-7:11-17:2: @9[1]: _0 = const ()
-17:2-17:2: @10.Return: return">}<span class="annotation">⦉@0,1,2,3,4,5,6,7,8,9,10</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index f037a8ee5c52f..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,82 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while/while.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>while.main - Coverage Spans</title>
-<style>
-    .line {
-        counter-increment: line;
-    }
-    .line:before {
-        content: counter(line) ": ";
-        font-family: Menlo, Monaco, monospace;
-        font-style: italic;
-        width: 3.8em;
-        display: inline-block;
-        text-align: right;
-        filter: opacity(50%);
-        -webkit-user-select: none;
-    }
-    .code {
-        color: #dddddd;
-        background-color: #222222;
-        font-family: Menlo, Monaco, monospace;
-        line-height: 1.4em;
-        border-bottom: 2px solid #222222;
-        white-space: pre;
-        display: inline-block;
-    }
-    .odd {
-        background-color: #55bbff;
-        color: #223311;
-    }
-    .even {
-        background-color: #ee7756;
-        color: #551133;
-    }
-    .code {
-        --index: calc(var(--layer) - 1);
-        padding-top: calc(var(--index) * 0.15em);
-        filter:
-            hue-rotate(calc(var(--index) * 25deg))
-            saturate(calc(100% - (var(--index) * 2%)))
-            brightness(calc(100% - (var(--index) * 1.5%)));
-    }
-    .annotation {
-        color: #4444ff;
-        font-family: monospace;
-        font-style: italic;
-        display: none;
-        -webkit-user-select: none;
-    }
-    body:active .annotation {
-        /* requires holding mouse down anywhere on the page */
-        display: inline-block;
-    }
-    span:hover .annotation {
-        /* requires hover over a span ONLY on its first line */
-        display: inline-block;
-    }
-</style>
-</head>
-<body>
-<div class="code" style="counter-reset: line 0"><span class="line"><span><span class="code even" style="--layer: 1" title="2:15-2:16: @0[1]: _1 = const 9_i32
-2:9-2:12: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0⦊</span>fn main() {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="2:15-2:16: @0[1]: _1 = const 9_i32
-2:9-2:12: @0[2]: FakeRead(ForLet, _1)">    let num = 9<span class="annotation">⦉@0</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">    while </span><span><span class="code odd" style="--layer: 1" title="3:11-3:14: @2[2]: _4 = _1
-3:11-3:20: @2[3]: _3 = Ge(move _4, const 10_i32)
-3:11-3:20: @2[5]: FakeRead(ForMatchedPlace, _3)"><span class="annotation">@1,2⦊</span>num &gt;= 10<span class="annotation">⦉@1,2</span></span></span><span class="code" style="--layer: 0"> </span><span><span class="code even" style="--layer: 1" title="3:21-4:6: @5[0]: _2 = const ()"><span class="annotation">@3,5⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="3:21-4:6: @5[0]: _2 = const ()">    }<span class="annotation">⦉@3,5</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">}</span><span><span class="code odd" style="--layer: 1" title="5:2-5:2: @4.Return: return"><span class="annotation">@4⦊</span>‸<span class="annotation">⦉@4</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while_early_ret/while_early_ret.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while_early_ret/while_early_ret.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index fcb5418e1d0cf..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while_early_ret/while_early_ret.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,130 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.while_early_ret/while_early_ret.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>while_early_ret.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><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>fn main() -&gt; Result&lt;(),u8&gt; {</span></span>
-<span class="line"><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)">    let 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">    while</span></span>
-<span class="line"><span class="code" style="--layer: 0">        </span><span><span class="code odd" style="--layer: 1" title="7:9-7:18: @2[2]: _5 = _1
-7:9-9:10: @2[3]: _4 = Gt(move _5, const 0_i32)
-7:9-9:10: @2[5]: FakeRead(ForMatchedPlace, _4)"><span class="annotation">@1,2⦊</span>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)"><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)">                &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)">            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: @6[2]: _11 = _1
-18:21-20:22: @6[3]: _10 = Gt(move _11, const 8_i32)"><span class="annotation">@6⦊</span>countdown</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="18:21-18:30: @6[2]: _11 = _1
-18:21-20:22: @6[3]: _10 = Gt(move _11, const 8_i32)">                        &gt;</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="18:21-18:30: @6[2]: _11 = _1
-18:21-20:22: @6[3]: _10 = Gt(move _11, const 8_i32)">                    8<span class="annotation">⦉@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="22:24-22:26: @8[1]: _12 = ()
-22:21-22:27: @8[2]: _0 = std::result::Result::&lt;(), u8&gt;::Ok(move _12)"><span class="annotation">@8⦊</span>Ok(())<span class="annotation">⦉@8</span></span></span><span class="code" style="--layer: 0"></span></span>
-<span class="line"><span class="code" style="--layer: 0">                }</span></span>
-<span class="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: @9[0]: _0 = std::result::Result::&lt;(), u8&gt;::Err(const 1_u8)"><span class="annotation">@9⦊</span>Err(1)<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="line"><span class="code" style="--layer: 0">        }</span><span><span class="code even" style="--layer: 1" title="29:10-29:10: @7[0]: _6 = const ()
-30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)
-30:9-32:10: @11[0]: _1 = move (_13.0: i32)"><span class="annotation">@7,11⦊</span></span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="29:10-29:10: @7[0]: _6 = const ()
-30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)
-30:9-32:10: @11[0]: _1 = move (_13.0: i32)">        countdown</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="29:10-29:10: @7[0]: _6 = const ()
-30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)
-30:9-32:10: @11[0]: _1 = move (_13.0: i32)">            -=</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="29:10-29:10: @7[0]: _6 = const ()
-30:9-32:10: @7[3]: _13 = CheckedSub(_1, const 1_i32)
-30:9-32:10: @11[0]: _1 = move (_13.0: i32)">        1<span class="annotation">⦉@7,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: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: @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/expected_mir_dump.yield/yield.main-{closure#0}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main-{closure#0}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 1e68c345f849b..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main-{closure#0}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,79 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main-%7Bclosure%230%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>yield.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 7"><span class="line">                        <span class="code" style="--layer: 0">|| </span><span><span class="code even" style="--layer: 1" title="9:9-9:16: @0.Yield: _3 = yield(const 1_i32) -&gt; [resume: bb1, drop: bb2]"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="9:9-9:16: @0.Yield: _3 = yield(const 1_i32) -&gt; [resume: bb1, drop: bb2]">        yield 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">        return </span><span><span class="code odd" style="--layer: 1" title="10:16-10:21: @1[1]: _0 = const &quot;foo&quot;
-11:6-11:6: @1.Return: return"><span class="annotation">@1⦊</span>"foo"</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="10:16-10:21: @1[1]: _0 = const &quot;foo&quot;
-11:6-11:6: @1.Return: return">    }<span class="annotation">⦉@1</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main-{closure#1}.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main-{closure#1}.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 842d7823bfd12..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main-{closure#1}.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,81 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main-%7Bclosure%231%7D.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>yield.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 21"><span class="line">                        <span class="code" style="--layer: 0">|| </span><span><span class="code even" style="--layer: 1" title="23:9-23:16: @0.Yield: _3 = yield(const 1_i32) -&gt; [resume: bb1, drop: bb6]"><span class="annotation">@0⦊</span>{</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="23:9-23:16: @0.Yield: _3 = yield(const 1_i32) -&gt; [resume: bb1, drop: bb6]">        yield 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">        </span><span><span class="code odd" style="--layer: 1" title="24:9-24:16: @1.Yield: _4 = yield(const 2_i32) -&gt; [resume: bb2, drop: bb5]"><span class="annotation">@1⦊</span>yield 2<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="code even" style="--layer: 1" title="25:9-25:16: @2.Yield: _5 = yield(const 3_i32) -&gt; [resume: bb3, drop: bb4]"><span class="annotation">@2⦊</span>yield 3<span class="annotation">⦉@2</span></span></span><span class="code" style="--layer: 0">;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        return </span><span><span class="code odd" style="--layer: 1" title="26:16-26:21: @3[1]: _0 = const &quot;foo&quot;
-27:6-27:6: @3.Return: return"><span class="annotation">@3⦊</span>"foo"</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="26:16-26:21: @3[1]: _0 = const &quot;foo&quot;
-27:6-27:6: @3.Return: return">    }<span class="annotation">⦉@3</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html b/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html
deleted file mode 100644
index 4c0c0d562b840..0000000000000
--- a/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html
+++ /dev/null
@@ -1,138 +0,0 @@
-<!DOCTYPE html>
-<!--
-
-Preview this file as rendered HTML from the github source at:
-https://htmlpreview.github.io/?https://github.com/rust-lang/rust/blob/master/src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.yield/yield.main.-------.InstrumentCoverage.0.html
-
-For revisions in Pull Requests (PR):
-  * Replace "rust-lang" with the github PR author
-  * Replace "master" with the PR branch name
-
--->
-<html>
-<head>
-<title>yield.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 6"><span class="line"><span><span class="code even" style="--layer: 1"><span class="annotation">@0,1,2⦊</span>fn main() <span class="annotation">⦉@0,1,2</span></span></span><span class="code" style="--layer: 0">{</span></span>
-<span class="line"><span class="code" style="--layer: 0">    let </span><span><span class="code even" style="--layer: 1" title="8:9-8:22: @0[2]: FakeRead(ForLet, _1)"><span class="annotation">@0,1,2⦊</span>mut generator<span class="annotation">⦉@0,1,2</span></span></span><span class="code" style="--layer: 0"> = || {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        yield 1;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        return "foo"</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">    match </span><span><span class="code even" style="--layer: 1" title="13:20-13:34: @0[7]: _5 = &amp;mut _1
-13:11-13:35: @0.Call: _4 = std::pin::Pin::&lt;&amp;mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]&gt;::new(move _5) -&gt; [return: bb1, unwind: bb26]
-13:43-13:45: @1[2]: _6 = ()
-13:11-13:46: @1.Call: _3 = &lt;[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as std::ops::Generator&gt;::resume(move _4, move _6) -&gt; [return: bb2, unwind: bb26]
-13:11-13:46: @2[2]: FakeRead(ForMatchedPlace, _3)
-14:9-14:35: @2[3]: _7 = discriminant(_3)"><span class="annotation">@0,1,2⦊</span>Pin::new(&amp;mut generator).resume(()) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="13:20-13:34: @0[7]: _5 = &amp;mut _1
-13:11-13:35: @0.Call: _4 = std::pin::Pin::&lt;&amp;mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]&gt;::new(move _5) -&gt; [return: bb1, unwind: bb26]
-13:43-13:45: @1[2]: _6 = ()
-13:11-13:46: @1.Call: _3 = &lt;[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as std::ops::Generator&gt;::resume(move _4, move _6) -&gt; [return: bb2, unwind: bb26]
-13:11-13:46: @2[2]: FakeRead(ForMatchedPlace, _3)
-14:9-14:35: @2[3]: _7 = discriminant(_3)">        GeneratorState::Yielded(1)<span class="annotation">⦉@0,1,2</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code odd" style="--layer: 1" title="14:39-14:41: @6[0]: _2 = const ()"><span class="annotation">@4,6,7,8⦊</span>{}<span class="annotation">⦉@4,6,7,8</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="code even" style="--layer: 1" title="15:14-15:52: @5.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;unexpected value from resume&quot;) -&gt; bb26"><span class="annotation">@5⦊</span>panic!("unexpected value from resume")<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">    match </span><span><span class="code odd" style="--layer: 1" title="17:20-17:34: @6[7]: _12 = &amp;mut _1
-17:11-17:35: @6.Call: _11 = std::pin::Pin::&lt;&amp;mut [generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}]&gt;::new(move _12) -&gt; [return: bb7, unwind: bb26]
-17:43-17:45: @7[2]: _13 = ()
-17:11-17:46: @7.Call: _10 = &lt;[generator@../coverage/yield.rs:8:25: 11:6 {i32, ()}] as std::ops::Generator&gt;::resume(move _11, move _13) -&gt; [return: bb8, unwind: bb26]
-17:11-17:46: @8[2]: FakeRead(ForMatchedPlace, _10)"><span class="annotation">@4,6,7,8⦊</span>Pin::new(&amp;mut generator).resume(())<span class="annotation">⦉@4,6,7,8</span></span></span><span class="code" style="--layer: 0"> {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        GeneratorState::Complete(</span><span><span class="code even" style="--layer: 1" title="18:34-18:39: @10.Call: _14 = &lt;str as std::cmp::PartialEq&gt;::eq(((_10 as Complete).0: &amp;str), const &quot;foo&quot;) -&gt; [return: bb11, unwind: bb26]"><span class="annotation">@10,11⦊</span>"foo"<span class="annotation">⦉@10,11</span></span></span><span class="code" style="--layer: 0">) =&gt; </span><span><span class="code odd" style="--layer: 1" title="18:44-18:46: @13[0]: _9 = const ()"><span class="annotation">@12,13,14,15⦊</span>{}<span class="annotation">⦉@12,13,14,15</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="code even" style="--layer: 1" title="19:14-19:52: @9.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;unexpected value from resume&quot;) -&gt; bb26"><span class="annotation">@9⦊</span>panic!("unexpected value from resume")<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="line"><span class="code" style="--layer: 0">    let </span><span><span class="code odd" style="--layer: 1" title="22:9-22:22: @13[5]: FakeRead(ForLet, _17)"><span class="annotation">@12,13,14,15⦊</span>mut generator<span class="annotation">⦉@12,13,14,15</span></span></span><span class="code" style="--layer: 0"> = || {</span></span>
-<span class="line"><span class="code" style="--layer: 0">        yield 1;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        yield 2;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        yield 3;</span></span>
-<span class="line"><span class="code" style="--layer: 0">        return "foo"</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">    match </span><span><span class="code odd" style="--layer: 1" title="29:20-29:34: @13[10]: _21 = &amp;mut _17
-29:11-29:35: @13.Call: _20 = std::pin::Pin::&lt;&amp;mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]&gt;::new(move _21) -&gt; [return: bb14, unwind: bb26]
-29:43-29:45: @14[2]: _22 = ()
-29:11-29:46: @14.Call: _19 = &lt;[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator&gt;::resume(move _20, move _22) -&gt; [return: bb15, unwind: bb26]
-29:11-29:46: @15[2]: FakeRead(ForMatchedPlace, _19)
-30:9-30:35: @15[3]: _23 = discriminant(_19)"><span class="annotation">@12,13,14,15⦊</span>Pin::new(&amp;mut generator).resume(()) {</span></span>
-<span class="line"><span class="code odd" style="--layer: 1" title="29:20-29:34: @13[10]: _21 = &amp;mut _17
-29:11-29:35: @13.Call: _20 = std::pin::Pin::&lt;&amp;mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]&gt;::new(move _21) -&gt; [return: bb14, unwind: bb26]
-29:43-29:45: @14[2]: _22 = ()
-29:11-29:46: @14.Call: _19 = &lt;[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator&gt;::resume(move _20, move _22) -&gt; [return: bb15, unwind: bb26]
-29:11-29:46: @15[2]: FakeRead(ForMatchedPlace, _19)
-30:9-30:35: @15[3]: _23 = discriminant(_19)">        GeneratorState::Yielded(1)<span class="annotation">⦉@12,13,14,15</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code even" style="--layer: 1" title="30:39-30:41: @19[0]: _18 = const ()"><span class="annotation">@17,19,20,21⦊</span>{}<span class="annotation">⦉@17,19,20,21</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="code odd" style="--layer: 1" title="31:14-31:52: @18.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;unexpected value from resume&quot;) -&gt; bb26"><span class="annotation">@18⦊</span>panic!("unexpected value from resume")<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">    match </span><span><span class="code even" style="--layer: 1" title="33:20-33:34: @19[6]: _27 = &amp;mut _17
-33:11-33:35: @19.Call: _26 = std::pin::Pin::&lt;&amp;mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]&gt;::new(move _27) -&gt; [return: bb20, unwind: bb26]
-33:43-33:45: @20[2]: _28 = ()
-33:11-33:46: @20.Call: _25 = &lt;[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator&gt;::resume(move _26, move _28) -&gt; [return: bb21, unwind: bb26]
-33:11-33:46: @21[2]: FakeRead(ForMatchedPlace, _25)
-34:9-34:35: @21[3]: _29 = discriminant(_25)"><span class="annotation">@17,19,20,21⦊</span>Pin::new(&amp;mut generator).resume(()) {</span></span>
-<span class="line"><span class="code even" style="--layer: 1" title="33:20-33:34: @19[6]: _27 = &amp;mut _17
-33:11-33:35: @19.Call: _26 = std::pin::Pin::&lt;&amp;mut [generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}]&gt;::new(move _27) -&gt; [return: bb20, unwind: bb26]
-33:43-33:45: @20[2]: _28 = ()
-33:11-33:46: @20.Call: _25 = &lt;[generator@../coverage/yield.rs:22:25: 27:6 {i32, ()}] as std::ops::Generator&gt;::resume(move _26, move _28) -&gt; [return: bb21, unwind: bb26]
-33:11-33:46: @21[2]: FakeRead(ForMatchedPlace, _25)
-34:9-34:35: @21[3]: _29 = discriminant(_25)">        GeneratorState::Yielded(2)<span class="annotation">⦉@17,19,20,21</span></span></span><span class="code" style="--layer: 0"> =&gt; </span><span><span class="code odd" style="--layer: 1" title="34:39-34:41: @25[0]: _0 = const ()"><span class="annotation">@23,25⦊</span>{}<span class="annotation">⦉@23,25</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="code even" style="--layer: 1" title="35:14-35:52: @24.Call: std::rt::begin_panic::&lt;&amp;str&gt;(const &quot;unexpected value from resume&quot;) -&gt; bb26"><span class="annotation">@24⦊</span>panic!("unexpected value from resume")<span class="annotation">⦉@24</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="37:2-37:2: @25.Return: return"><span class="annotation">@23,25⦊</span>‸<span class="annotation">⦉@23,25</span></span></span></span></div>
-</body>
-</html>
diff --git a/src/test/run-make-fulldeps/coverage/coverage_tools.mk b/src/test/run-make-fulldeps/coverage/coverage_tools.mk
index 38643aaf9021e..aa1dc7b91ce94 100644
--- a/src/test/run-make-fulldeps/coverage/coverage_tools.mk
+++ b/src/test/run-make-fulldeps/coverage/coverage_tools.mk
@@ -4,11 +4,3 @@
 # -include ../coverage/coverage_tools.mk
 
 -include ../tools.mk
-
-# 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`
-# file, required for coverage reports.
-#
-# Enabling `-C link-dead-code` is not necessary when compiling with `-Z instrument-coverage`,
-# due to improvements in the coverage map generation, to add unreachable functions known to Rust.
-# Therefore, `-C link-dead-code` is no longer automatically enabled.
diff --git a/src/test/run-make/emit-shared-files/Makefile b/src/test/run-make/emit-shared-files/Makefile
new file mode 100644
index 0000000000000..5c4825ae66c87
--- /dev/null
+++ b/src/test/run-make/emit-shared-files/Makefile
@@ -0,0 +1,46 @@
+-include ../../run-make-fulldeps/tools.mk
+
+INVOCATION_ONLY = $(TMPDIR)/invocation-only
+TOOLCHAIN_ONLY = $(TMPDIR)/toolchain-only
+ALL_SHARED = $(TMPDIR)/all-shared
+
+all: invocation-only toolchain-only all-shared
+
+invocation-only:
+	$(RUSTDOC) -Z unstable-options --emit=invocation-specific --output $(INVOCATION_ONLY) --resource-suffix=-xxx --theme y.css --extend-css z.css x.rs
+	[ -e $(INVOCATION_ONLY)/search-index-xxx.js ]
+	[ -e $(INVOCATION_ONLY)/settings.html ]
+	[ -e $(INVOCATION_ONLY)/x/all.html ]
+	[ -e $(INVOCATION_ONLY)/x/index.html ]
+	[ -e $(INVOCATION_ONLY)/theme-xxx.css ] # generated from z.css
+	! [ -e $(INVOCATION_ONLY)/storage-xxx.js ]
+	! [ -e $(INVOCATION_ONLY)/SourceSerifPro-It.ttf.woff ]
+
+	# FIXME: this probably shouldn't have a suffix
+	[ -e $(INVOCATION_ONLY)/y-xxx.css ]
+	# FIXME: this is technically incorrect (see `write_shared`)
+	! [ -e $(INVOCATION_ONLY)/main-xxx.js ]
+
+toolchain-only:
+	$(RUSTDOC) -Z unstable-options --emit=toolchain-shared-resources --output $(TOOLCHAIN_ONLY) --resource-suffix=-xxx --extend-css z.css x.rs
+	[ -e $(TOOLCHAIN_ONLY)/storage-xxx.js ]
+	! [ -e $(TOOLCHAIN_ONLY)/SourceSerifPro-It.ttf.woff ]
+	! [ -e $(TOOLCHAIN_ONLY)/search-index-xxx.js ]
+	! [ -e $(TOOLCHAIN_ONLY)/x/index.html ]
+	! [ -e $(TOOLCHAIN_ONLY)/theme.css ]
+
+	[ -e $(TOOLCHAIN_ONLY)/main-xxx.js ]
+	! [ -e $(TOOLCHAIN_ONLY)/y-xxx.css ]
+
+all-shared:
+	$(RUSTDOC) -Z unstable-options --emit=toolchain-shared-resources,unversioned-shared-resources --output $(ALL_SHARED) --resource-suffix=-xxx --extend-css z.css x.rs
+	[ -e $(ALL_SHARED)/storage-xxx.js ]
+	[ -e $(ALL_SHARED)/SourceSerifPro-It.ttf.woff ]
+	! [ -e $(ALL_SHARED)/search-index-xxx.js ]
+	! [ -e $(ALL_SHARED)/settings.html ]
+	! [ -e $(ALL_SHARED)/x ]
+	! [ -e $(ALL_SHARED)/src ]
+	! [ -e $(ALL_SHARED)/theme.css ]
+
+	[ -e $(ALL_SHARED)/main-xxx.js ]
+	! [ -e $(ALL_SHARED)/y-xxx.css ]
diff --git a/src/test/run-make/emit-shared-files/x.rs b/src/test/run-make/emit-shared-files/x.rs
new file mode 100644
index 0000000000000..5df7576133a68
--- /dev/null
+++ b/src/test/run-make/emit-shared-files/x.rs
@@ -0,0 +1 @@
+// nothing to see here
diff --git a/src/test/run-make/emit-shared-files/y.css b/src/test/run-make/emit-shared-files/y.css
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/src/test/run-make/emit-shared-files/z.css b/src/test/run-make/emit-shared-files/z.css
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/src/test/ui/associated-types/defaults-suitability.stderr b/src/test/ui/associated-types/defaults-suitability.stderr
index 274d09fd09c86..af4e6f0a5c161 100644
--- a/src/test/ui/associated-types/defaults-suitability.stderr
+++ b/src/test/ui/associated-types/defaults-suitability.stderr
@@ -31,8 +31,8 @@ LL |     type Bar: Clone = Vec<T>;
    = note: required because of the requirements on the impl of `Clone` for `Vec<T>`
 help: consider restricting type parameter `T`
    |
-LL | trait Foo<T: Clone> {
-   |            ^^^^^^^
+LL | trait Foo<T: std::clone::Clone> {
+   |            ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `(): Foo<Self>` is not satisfied
   --> $DIR/defaults-suitability.rs:34:5
@@ -99,8 +99,8 @@ LL |     type Baz = T;
    |
 help: consider further restricting type parameter `T`
    |
-LL |     Self::Baz: Clone, T: Clone
-   |                     ^^^^^^^^^^
+LL |     Self::Baz: Clone, T: std::clone::Clone
+   |                     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 8 previous errors
 
diff --git a/src/test/ui/associated-types/issue-27675-unchecked-bounds.stderr b/src/test/ui/associated-types/issue-27675-unchecked-bounds.stderr
index 02396bd00a59d..b6122bd54d162 100644
--- a/src/test/ui/associated-types/issue-27675-unchecked-bounds.stderr
+++ b/src/test/ui/associated-types/issue-27675-unchecked-bounds.stderr
@@ -9,8 +9,8 @@ LL |     copy::<dyn Setup<From=T>>(t)
    |
 help: consider restricting type parameter `T`
    |
-LL | pub fn copy_any<T: Copy>(t: &T) -> T {
-   |                  ^^^^^^
+LL | pub fn copy_any<T: std::marker::Copy>(t: &T) -> T {
+   |                  ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/associated-types/issue-43784-associated-type.stderr b/src/test/ui/associated-types/issue-43784-associated-type.stderr
index d5105ae3b5815..0e653a7d3b22f 100644
--- a/src/test/ui/associated-types/issue-43784-associated-type.stderr
+++ b/src/test/ui/associated-types/issue-43784-associated-type.stderr
@@ -9,8 +9,8 @@ LL |     type Assoc = T;
    |
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Copy> Complete for T {
-   |       ^^^^^^
+LL | impl<T: std::marker::Copy> Complete for T {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/async-await/issue-70818.stderr b/src/test/ui/async-await/issue-70818.stderr
index 11fca2dd8ef4c..5f39cf6dde125 100644
--- a/src/test/ui/async-await/issue-70818.stderr
+++ b/src/test/ui/async-await/issue-70818.stderr
@@ -11,8 +11,8 @@ LL |     async { (ty, ty1) }
    |                  ^^^ has type `U` which is not `Send`
 help: consider restricting type parameter `U`
    |
-LL | fn foo<T: Send, U: Send>(ty: T, ty1: U) -> impl Future<Output = (T, U)> + Send {
-   |                  ^^^^^^
+LL | fn foo<T: Send, U: std::marker::Send>(ty: T, ty1: U) -> impl Future<Output = (T, U)> + Send {
+   |                  ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/bad/bad-method-typaram-kind.stderr b/src/test/ui/bad/bad-method-typaram-kind.stderr
index 5b68d97a9ea55..fd3999ae6fbec 100644
--- a/src/test/ui/bad/bad-method-typaram-kind.stderr
+++ b/src/test/ui/bad/bad-method-typaram-kind.stderr
@@ -6,8 +6,8 @@ LL |     1.bar::<T>();
    |
 help: consider further restricting this bound
    |
-LL | fn foo<T:'static + Send>() {
-   |                  ^^^^^^
+LL | fn foo<T:'static + std::marker::Send>() {
+   |                  ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/bound-suggestions.fixed b/src/test/ui/bound-suggestions.fixed
index be61b7dda256a..31fdd2b67e294 100644
--- a/src/test/ui/bound-suggestions.fixed
+++ b/src/test/ui/bound-suggestions.fixed
@@ -5,37 +5,37 @@ use std::fmt::Debug;
 // Rustfix should add this, or use `std::fmt::Debug` instead.
 
 #[allow(dead_code)]
-fn test_impl(t: impl Sized + Debug) {
+fn test_impl(t: impl Sized + std::fmt::Debug) {
     println!("{:?}", t);
     //~^ ERROR doesn't implement
 }
 
 #[allow(dead_code)]
-fn test_no_bounds<T: Debug>(t: T) {
+fn test_no_bounds<T: std::fmt::Debug>(t: T) {
     println!("{:?}", t);
     //~^ ERROR doesn't implement
 }
 
 #[allow(dead_code)]
-fn test_one_bound<T: Sized + Debug>(t: T) {
+fn test_one_bound<T: Sized + std::fmt::Debug>(t: T) {
     println!("{:?}", t);
     //~^ ERROR doesn't implement
 }
 
 #[allow(dead_code)]
-fn test_no_bounds_where<X, Y>(x: X, y: Y) where X: std::fmt::Debug, Y: Debug {
+fn test_no_bounds_where<X, Y>(x: X, y: Y) where X: std::fmt::Debug, Y: std::fmt::Debug {
     println!("{:?} {:?}", x, y);
     //~^ ERROR doesn't implement
 }
 
 #[allow(dead_code)]
-fn test_one_bound_where<X>(x: X) where X: Sized + Debug {
+fn test_one_bound_where<X>(x: X) where X: Sized + std::fmt::Debug {
     println!("{:?}", x);
     //~^ ERROR doesn't implement
 }
 
 #[allow(dead_code)]
-fn test_many_bounds_where<X>(x: X) where X: Sized, X: Sized, X: Debug {
+fn test_many_bounds_where<X>(x: X) where X: Sized, X: Sized, X: std::fmt::Debug {
     println!("{:?}", x);
     //~^ ERROR doesn't implement
 }
diff --git a/src/test/ui/bound-suggestions.stderr b/src/test/ui/bound-suggestions.stderr
index 12e67e90265ab..ebf43bdb2717c 100644
--- a/src/test/ui/bound-suggestions.stderr
+++ b/src/test/ui/bound-suggestions.stderr
@@ -8,8 +8,8 @@ LL |     println!("{:?}", t);
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 help: consider further restricting this bound
    |
-LL | fn test_impl(t: impl Sized + Debug) {
-   |                            ^^^^^^^
+LL | fn test_impl(t: impl Sized + std::fmt::Debug) {
+   |                            ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `T` doesn't implement `Debug`
   --> $DIR/bound-suggestions.rs:15:22
@@ -21,8 +21,8 @@ LL |     println!("{:?}", t);
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 help: consider restricting type parameter `T`
    |
-LL | fn test_no_bounds<T: Debug>(t: T) {
-   |                    ^^^^^^^
+LL | fn test_no_bounds<T: std::fmt::Debug>(t: T) {
+   |                    ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `T` doesn't implement `Debug`
   --> $DIR/bound-suggestions.rs:21:22
@@ -34,8 +34,8 @@ LL |     println!("{:?}", t);
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 help: consider further restricting this bound
    |
-LL | fn test_one_bound<T: Sized + Debug>(t: T) {
-   |                            ^^^^^^^
+LL | fn test_one_bound<T: Sized + std::fmt::Debug>(t: T) {
+   |                            ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `Y` doesn't implement `Debug`
   --> $DIR/bound-suggestions.rs:27:30
@@ -47,8 +47,8 @@ LL |     println!("{:?} {:?}", x, y);
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 help: consider further restricting type parameter `Y`
    |
-LL | fn test_no_bounds_where<X, Y>(x: X, y: Y) where X: std::fmt::Debug, Y: Debug {
-   |                                                                   ^^^^^^^^^^
+LL | fn test_no_bounds_where<X, Y>(x: X, y: Y) where X: std::fmt::Debug, Y: std::fmt::Debug {
+   |                                                                   ^^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `X` doesn't implement `Debug`
   --> $DIR/bound-suggestions.rs:33:22
@@ -60,8 +60,8 @@ LL |     println!("{:?}", x);
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 help: consider further restricting this bound
    |
-LL | fn test_one_bound_where<X>(x: X) where X: Sized + Debug {
-   |                                                 ^^^^^^^
+LL | fn test_one_bound_where<X>(x: X) where X: Sized + std::fmt::Debug {
+   |                                                 ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `X` doesn't implement `Debug`
   --> $DIR/bound-suggestions.rs:39:22
@@ -73,8 +73,8 @@ LL |     println!("{:?}", x);
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
 help: consider further restricting type parameter `X`
    |
-LL | fn test_many_bounds_where<X>(x: X) where X: Sized, X: Sized, X: Debug {
-   |                                                            ^^^^^^^^^^
+LL | fn test_many_bounds_where<X>(x: X) where X: Sized, X: Sized, X: std::fmt::Debug {
+   |                                                            ^^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the size for values of type `Self` cannot be known at compilation time
   --> $DIR/bound-suggestions.rs:44:46
diff --git a/src/test/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr b/src/test/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
index 7e8ac113b4871..7ff986ec38109 100644
--- a/src/test/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
+++ b/src/test/ui/builtin-superkinds/builtin-superkinds-double-superkind.stderr
@@ -10,8 +10,8 @@ LL | impl <T: Sync+'static> Foo for (T,) { }
    = note: required because it appears within the type `(T,)`
 help: consider further restricting this bound
    |
-LL | impl <T: Sync+'static + Send> Foo for (T,) { }
-   |                       ^^^^^^
+LL | impl <T: Sync+'static + std::marker::Send> Foo for (T,) { }
+   |                       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `T` cannot be shared between threads safely
   --> $DIR/builtin-superkinds-double-superkind.rs:9:16
@@ -25,8 +25,8 @@ LL | impl <T: Send> Foo for (T,T) { }
    = note: required because it appears within the type `(T, T)`
 help: consider further restricting this bound
    |
-LL | impl <T: Send + Sync> Foo for (T,T) { }
-   |               ^^^^^^
+LL | impl <T: Send + std::marker::Sync> Foo for (T,T) { }
+   |               ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr b/src/test/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
index 2b4b6e548b881..133508d39c105 100644
--- a/src/test/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
+++ b/src/test/ui/builtin-superkinds/builtin-superkinds-in-metadata.stderr
@@ -12,8 +12,8 @@ LL | pub trait RequiresRequiresShareAndSend : RequiresShare + Send { }
    = note: required because it appears within the type `X<T>`
 help: consider further restricting this bound
    |
-LL | impl <T:Sync+'static + Send> RequiresRequiresShareAndSend for X<T> { }
-   |                      ^^^^^^
+LL | impl <T:Sync+'static + std::marker::Send> RequiresRequiresShareAndSend for X<T> { }
+   |                      ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr b/src/test/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
index ff2cd1c4c8c75..ad80b3fa8d11f 100644
--- a/src/test/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
+++ b/src/test/ui/builtin-superkinds/builtin-superkinds-typaram-not-send.stderr
@@ -9,8 +9,8 @@ LL | impl <T: Sync+'static> Foo for T { }
    |
 help: consider further restricting this bound
    |
-LL | impl <T: Sync+'static + Send> Foo for T { }
-   |                       ^^^^^^
+LL | impl <T: Sync+'static + std::marker::Send> Foo for T { }
+   |                       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed
new file mode 100644
index 0000000000000..300f67e8b1e81
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed
@@ -0,0 +1,133 @@
+// run-rustfix
+
+#![deny(disjoint_capture_drop_reorder)]
+//~^ NOTE: the lint level is defined here
+
+// Test cases for types that implement a insignificant drop (stlib defined)
+
+// `t` needs Drop because one of its elements needs drop,
+// therefore precise capture might affect drop ordering
+fn test1_all_need_migration() {
+    let t = (String::new(), String::new());
+    let t1 = (String::new(), String::new());
+    let t2 = (String::new(), String::new());
+
+    let c = || { let _ = (&t, &t1, &t2); 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+
+        let _t = t.0;
+        let _t1 = t1.0;
+        let _t2 = t2.0;
+    };
+
+    c();
+}
+
+// String implements drop and therefore should be migrated.
+// But in this test cases, `t2` is completely captured and when it is dropped won't be affected
+fn test2_only_precise_paths_need_migration() {
+    let t = (String::new(), String::new());
+    let t1 = (String::new(), String::new());
+    let t2 = (String::new(), String::new());
+
+    let c = || { let _ = (&t, &t1); 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
+        let _t = t.0;
+        let _t1 = t1.0;
+        let _t2 = t2;
+    };
+
+    c();
+}
+
+// If a variable would've not been captured by value then it would've not been
+// dropped with the closure and therefore doesn't need migration.
+fn test3_only_by_value_need_migration() {
+    let t = (String::new(), String::new());
+    let t1 = (String::new(), String::new());
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+        println!("{}", t1.1);
+    };
+
+    c();
+}
+
+// Copy types get copied into the closure instead of move. Therefore we don't need to
+// migrate then as their drop order isn't tied to the closure.
+fn test4_only_non_copy_types_need_migration() {
+    let t = (String::new(), String::new());
+
+    // `t1` is Copy because all of its elements are Copy
+    let t1 = (0i32, 0i32);
+
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+        let _t1 = t1.0;
+    };
+
+    c();
+}
+
+fn test5_only_drop_types_need_migration() {
+    struct S(i32, i32);
+
+    let t = (String::new(), String::new());
+
+    // `s` doesn't implement Drop or any elements within it, and doesn't need migration
+    let s = S(0i32, 0i32);
+
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+        let _s = s.0;
+    };
+
+    c();
+}
+
+// Since we are using a move closure here, both `t` and `t1` get moved
+// even though they are being used by ref inside the closure.
+fn test6_move_closures_non_copy_types_might_need_migration() {
+    let t = (String::new(), String::new());
+    let t1 = (String::new(), String::new());
+    let c = move || { let _ = (&t1, &t); 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
+        println!("{} {}", t1.1, t.1);
+    };
+
+    c();
+}
+
+// Test migration analysis in case of Drop + Non Drop aggregates.
+// Note we need migration here only because the non-copy (because Drop type) is captured,
+// otherwise we won't need to, since we can get away with just by ref capture in that case.
+fn test7_drop_non_drop_aggregate_need_migration() {
+    let t = (String::new(), String::new(), 0i32);
+
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+    };
+
+    c();
+}
+
+fn main() {
+    test1_all_need_migration();
+    test2_only_precise_paths_need_migration();
+    test3_only_by_value_need_migration();
+    test4_only_non_copy_types_need_migration();
+    test5_only_drop_types_need_migration();
+    test6_move_closures_non_copy_types_might_need_migration();
+    test7_drop_non_drop_aggregate_need_migration();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs
index 02b373620966e..a17c70d3e2877 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs
@@ -1,3 +1,5 @@
+// run-rustfix
+
 #![deny(disjoint_capture_drop_reorder)]
 //~^ NOTE: the lint level is defined here
 
@@ -11,8 +13,9 @@ fn test1_all_need_migration() {
     let t2 = (String::new(), String::new());
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t, t1, t2));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+
         let _t = t.0;
         let _t1 = t1.0;
         let _t2 = t2.0;
@@ -29,8 +32,8 @@ fn test2_only_precise_paths_need_migration() {
     let t2 = (String::new(), String::new());
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t, t1));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
         let _t = t.0;
         let _t1 = t1.0;
         let _t2 = t2;
@@ -45,8 +48,8 @@ fn test3_only_by_value_need_migration() {
     let t = (String::new(), String::new());
     let t1 = (String::new(), String::new());
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
         println!("{}", t1.1);
     };
@@ -63,8 +66,8 @@ fn test4_only_non_copy_types_need_migration() {
     let t1 = (0i32, 0i32);
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
         let _t1 = t1.0;
     };
@@ -81,8 +84,8 @@ fn test5_only_drop_types_need_migration() {
     let s = S(0i32, 0i32);
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
         let _s = s.0;
     };
@@ -96,8 +99,8 @@ fn test6_move_closures_non_copy_types_might_need_migration() {
     let t = (String::new(), String::new());
     let t1 = (String::new(), String::new());
     let c = move || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t1, t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
         println!("{} {}", t1.1, t.1);
     };
 
@@ -111,8 +114,8 @@ fn test7_drop_non_drop_aggregate_need_migration() {
     let t = (String::new(), String::new(), 0i32);
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
     };
 
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr
index 656c132c12dee..69c12d2bb56c0 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr
@@ -1,25 +1,33 @@
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/insignificant_drop.rs:13:13
+  --> $DIR/insignificant_drop.rs:15:13
    |
 LL |       let c = || {
    |  _____________^
 LL | |
 LL | |
-LL | |         let _t = t.0;
-LL | |         let _t1 = t1.0;
+LL | |
+...  |
 LL | |         let _t2 = t2.0;
 LL | |     };
    | |_____^
    |
 note: the lint level is defined here
-  --> $DIR/insignificant_drop.rs:1:9
+  --> $DIR/insignificant_drop.rs:3:9
    |
 LL | #![deny(disjoint_capture_drop_reorder)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: drop(&(t, t1, t2));
+help: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+   |
+LL |     let c = || { let _ = (&t, &t1, &t2); 
+LL |
+LL |
+LL | 
+LL |         let _t = t.0;
+LL |         let _t1 = t1.0;
+ ...
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/insignificant_drop.rs:31:13
+  --> $DIR/insignificant_drop.rs:34:13
    |
 LL |       let c = || {
    |  _____________^
@@ -31,10 +39,18 @@ LL | |         let _t2 = t2;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t, t1));
+help: add a dummy let to cause `t`, `t1` to be fully captured
+   |
+LL |     let c = || { let _ = (&t, &t1); 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         let _t1 = t1.0;
+LL |         let _t2 = t2;
+ ...
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/insignificant_drop.rs:47:13
+  --> $DIR/insignificant_drop.rs:50:13
    |
 LL |       let c = || {
    |  _____________^
@@ -45,10 +61,18 @@ LL | |         println!("{}", t1.1);
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         println!("{}", t1.1);
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/insignificant_drop.rs:65:13
+  --> $DIR/insignificant_drop.rs:68:13
    |
 LL |       let c = || {
    |  _____________^
@@ -59,10 +83,18 @@ LL | |         let _t1 = t1.0;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         let _t1 = t1.0;
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/insignificant_drop.rs:83:13
+  --> $DIR/insignificant_drop.rs:86:13
    |
 LL |       let c = || {
    |  _____________^
@@ -73,10 +105,18 @@ LL | |         let _s = s.0;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         let _s = s.0;
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/insignificant_drop.rs:98:13
+  --> $DIR/insignificant_drop.rs:101:13
    |
 LL |       let c = move || {
    |  _____________^
@@ -86,10 +126,17 @@ LL | |         println!("{} {}", t1.1, t.1);
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t1, t));
+help: add a dummy let to cause `t1`, `t` to be fully captured
+   |
+LL |     let c = move || { let _ = (&t1, &t); 
+LL |
+LL |
+LL |         println!("{} {}", t1.1, t.1);
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/insignificant_drop.rs:113:13
+  --> $DIR/insignificant_drop.rs:116:13
    |
 LL |       let c = || {
    |  _____________^
@@ -99,7 +146,14 @@ LL | |         let _t = t.0;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |     };
+   |
 
 error: aborting due to 7 previous errors
 
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.fixed
new file mode 100644
index 0000000000000..a3e51a2b8e91a
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.fixed
@@ -0,0 +1,40 @@
+// run-rustfix
+#![deny(disjoint_capture_drop_reorder)]
+//~^ NOTE: the lint level is defined here
+
+// Test the two possible cases for automated migartion using rustfix
+// - Closure contains a block i.e.  `|| { .. };`
+// - Closure contains just an expr `|| ..;`
+
+#[derive(Debug)]
+struct Foo(i32);
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!("{:?} dropped", self.0);
+    }
+}
+
+fn closure_contains_block() {
+    let t = (Foo(0), Foo(0));
+    let c = || { let _ = &t; 
+        //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+        //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+    };
+
+    c();
+}
+
+fn closure_doesnt_contain_block() {
+    let t = (Foo(0), Foo(0));
+    let c = || { let _ = &t; t.0 };
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+
+    c();
+}
+
+fn main() {
+    closure_contains_block();
+    closure_doesnt_contain_block();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.rs b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.rs
new file mode 100644
index 0000000000000..0eb837b688835
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.rs
@@ -0,0 +1,40 @@
+// run-rustfix
+#![deny(disjoint_capture_drop_reorder)]
+//~^ NOTE: the lint level is defined here
+
+// Test the two possible cases for automated migartion using rustfix
+// - Closure contains a block i.e.  `|| { .. };`
+// - Closure contains just an expr `|| ..;`
+
+#[derive(Debug)]
+struct Foo(i32);
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!("{:?} dropped", self.0);
+    }
+}
+
+fn closure_contains_block() {
+    let t = (Foo(0), Foo(0));
+    let c = || {
+        //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+        //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+    };
+
+    c();
+}
+
+fn closure_doesnt_contain_block() {
+    let t = (Foo(0), Foo(0));
+    let c = || t.0;
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+
+    c();
+}
+
+fn main() {
+    closure_contains_block();
+    closure_doesnt_contain_block();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.stderr
new file mode 100644
index 0000000000000..e6173217edc2f
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.stderr
@@ -0,0 +1,38 @@
+error: drop order affected for closure because of `capture_disjoint_fields`
+  --> $DIR/migrations_rustfix.rs:19:13
+   |
+LL |       let c = || {
+   |  _____________^
+LL | |
+LL | |
+LL | |         let _t = t.0;
+LL | |     };
+   | |_____^
+   |
+note: the lint level is defined here
+  --> $DIR/migrations_rustfix.rs:2:9
+   |
+LL | #![deny(disjoint_capture_drop_reorder)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |     };
+   |
+
+error: drop order affected for closure because of `capture_disjoint_fields`
+  --> $DIR/migrations_rustfix.rs:30:13
+   |
+LL |     let c = || t.0;
+   |             ^^^^^^
+   |
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; t.0 };
+   |                ^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/precise.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/precise.fixed
new file mode 100644
index 0000000000000..b739035c78422
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/precise.fixed
@@ -0,0 +1,56 @@
+// run-rustfix
+
+#![deny(disjoint_capture_drop_reorder)]
+
+#[derive(Debug)]
+struct Foo(i32);
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!("{:?} dropped", self.0);
+    }
+}
+
+struct ConstainsDropField(Foo, Foo);
+
+// Test that lint is triggered if a path that implements Drop is not captured by move
+fn test_precise_analysis_drop_paths_not_captured_by_move() {
+    let t = ConstainsDropField(Foo(10), Foo(20));
+
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+        let _t = &t.1;
+    };
+
+    c();
+}
+
+struct S;
+impl Drop for S {
+    fn drop(&mut self) {
+    }
+}
+
+struct T(S, S);
+struct U(T, T);
+
+// Test precise analysis for the lint works with paths longer than one.
+fn test_precise_analysis_long_path_missing() {
+    let u = U(T(S, S), T(S, S));
+
+    let c = || { let _ = &u; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `u` to be fully captured
+        let _x = u.0.0;
+        let _x = u.0.1;
+        let _x = u.1.0;
+    };
+
+    c();
+}
+
+fn main() {
+    test_precise_analysis_drop_paths_not_captured_by_move();
+    test_precise_analysis_long_path_missing();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs b/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs
index 79702cc6b56f3..e1f29c9d0e9d8 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs
@@ -1,5 +1,6 @@
+// run-rustfix
+
 #![deny(disjoint_capture_drop_reorder)]
-//~^ NOTE: the lint level is defined here
 
 #[derive(Debug)]
 struct Foo(i32);
@@ -11,35 +12,13 @@ impl Drop for Foo {
 
 struct ConstainsDropField(Foo, Foo);
 
-#[derive(Debug)]
-struct ContainsAndImplsDrop(Foo);
-impl Drop for ContainsAndImplsDrop {
-    fn drop(&mut self) {
-        println!("{:?} dropped", self.0);
-    }
-}
-
-// Test that even if all paths starting at root variable that implement Drop are captured,
-// the lint is triggered if the root variable implements drop and isn't captured.
-fn test_precise_analysis_parent_root_impl_drop_not_captured() {
-    let t = ContainsAndImplsDrop(Foo(10));
-
-    let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
-        let _t = t.0;
-    };
-
-    c();
-}
-
 // Test that lint is triggered if a path that implements Drop is not captured by move
 fn test_precise_analysis_drop_paths_not_captured_by_move() {
     let t = ConstainsDropField(Foo(10), Foo(20));
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
         let _t = &t.1;
     };
@@ -61,8 +40,8 @@ fn test_precise_analysis_long_path_missing() {
     let u = U(T(S, S), T(S, S));
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(u));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `u` to be fully captured
         let _x = u.0.0;
         let _x = u.0.1;
         let _x = u.1.0;
@@ -72,7 +51,6 @@ fn test_precise_analysis_long_path_missing() {
 }
 
 fn main() {
-    test_precise_analysis_parent_root_impl_drop_not_captured();
     test_precise_analysis_drop_paths_not_captured_by_move();
     test_precise_analysis_long_path_missing();
 }
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr
index 968ca395f946e..7135ded13c256 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr
@@ -1,37 +1,32 @@
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/precise.rs:27:13
+  --> $DIR/precise.rs:19:13
    |
 LL |       let c = || {
    |  _____________^
 LL | |
 LL | |
 LL | |         let _t = t.0;
+LL | |         let _t = &t.1;
 LL | |     };
    | |_____^
    |
 note: the lint level is defined here
-  --> $DIR/precise.rs:1:9
+  --> $DIR/precise.rs:3:9
    |
 LL | #![deny(disjoint_capture_drop_reorder)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: drop(&(t));
-
-error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/precise.rs:40:13
+help: add a dummy let to cause `t` to be fully captured
    |
-LL |       let c = || {
-   |  _____________^
-LL | |
-LL | |
-LL | |         let _t = t.0;
-LL | |         let _t = &t.1;
-LL | |     };
-   | |_____^
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         let _t = &t.1;
+LL |     };
    |
-   = note: drop(&(t));
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/precise.rs:63:13
+  --> $DIR/precise.rs:42:13
    |
 LL |       let c = || {
    |  _____________^
@@ -43,7 +38,15 @@ LL | |         let _x = u.1.0;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(u));
+help: add a dummy let to cause `u` to be fully captured
+   |
+LL |     let c = || { let _ = &u; 
+LL |
+LL |
+LL |         let _x = u.0.0;
+LL |         let _x = u.0.1;
+LL |         let _x = u.1.0;
+ ...
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.fixed
new file mode 100644
index 0000000000000..e1b212153f431
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.fixed
@@ -0,0 +1,136 @@
+// run-rustfix
+#![deny(disjoint_capture_drop_reorder)]
+//~^ NOTE: the lint level is defined here
+
+// Test cases for types that implement a significant drop (user defined)
+
+#[derive(Debug)]
+struct Foo(i32);
+impl Drop for Foo {
+    fn drop(&mut self) {
+        println!("{:?} dropped", self.0);
+    }
+}
+
+#[derive(Debug)]
+struct ConstainsDropField(Foo, Foo);
+
+// `t` needs Drop because one of its elements needs drop,
+// therefore precise capture might affect drop ordering
+fn test1_all_need_migration() {
+    let t = (Foo(0), Foo(0));
+    let t1 = (Foo(0), Foo(0));
+    let t2 = (Foo(0), Foo(0));
+
+    let c = || { let _ = (&t, &t1, &t2); 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+        let _t = t.0;
+        let _t1 = t1.0;
+        let _t2 = t2.0;
+    };
+
+    c();
+}
+
+// String implements drop and therefore should be migrated.
+// But in this test cases, `t2` is completely captured and when it is dropped won't be affected
+fn test2_only_precise_paths_need_migration() {
+    let t = (Foo(0), Foo(0));
+    let t1 = (Foo(0), Foo(0));
+    let t2 = (Foo(0), Foo(0));
+
+    let c = || { let _ = (&t, &t1); 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
+        let _t = t.0;
+        let _t1 = t1.0;
+        let _t2 = t2;
+    };
+
+    c();
+}
+
+// If a variable would've not been captured by value then it would've not been
+// dropped with the closure and therefore doesn't need migration.
+fn test3_only_by_value_need_migration() {
+    let t = (Foo(0), Foo(0));
+    let t1 = (Foo(0), Foo(0));
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+        println!("{:?}", t1.1);
+    };
+
+    c();
+}
+
+// The root variable might not implement drop themselves but some path starting
+// at the root variable might implement Drop.
+//
+// If this path isn't captured we need to migrate for the root variable.
+fn test4_type_contains_drop_need_migration() {
+    let t = ConstainsDropField(Foo(0), Foo(0));
+
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+    };
+
+    c();
+}
+
+// Test migration analysis in case of Drop + Non Drop aggregates.
+// Note we need migration here only because the non-copy (because Drop type) is captured,
+// otherwise we won't need to, since we can get away with just by ref capture in that case.
+fn test5_drop_non_drop_aggregate_need_migration() {
+    let t = (Foo(0), Foo(0), 0i32);
+
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.0;
+    };
+
+    c();
+}
+
+// Test migration analysis in case of Significant and Insignificant Drop aggregates.
+fn test6_significant_insignificant_drop_aggregate_need_migration() {
+    let t = (Foo(0), String::new());
+
+    let c = || { let _ = &t; 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
+        let _t = t.1;
+    };
+
+    c();
+}
+
+// Since we are using a move closure here, both `t` and `t1` get moved
+// even though they are being used by ref inside the closure.
+fn test7_move_closures_non_copy_types_might_need_migration() {
+    let t = (Foo(0), Foo(0));
+    let t1 = (Foo(0), Foo(0), Foo(0));
+
+    let c = move || { let _ = (&t1, &t); 
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
+        println!("{:?} {:?}", t1.1, t.1);
+    };
+
+    c();
+}
+
+fn main() {
+    test1_all_need_migration();
+    test2_only_precise_paths_need_migration();
+    test3_only_by_value_need_migration();
+    test4_type_contains_drop_need_migration();
+    test5_drop_non_drop_aggregate_need_migration();
+    test6_significant_insignificant_drop_aggregate_need_migration();
+    test7_move_closures_non_copy_types_might_need_migration();
+}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs
index ed5e4ea8be011..106b293351515 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs
@@ -1,3 +1,4 @@
+// run-rustfix
 #![deny(disjoint_capture_drop_reorder)]
 //~^ NOTE: the lint level is defined here
 
@@ -22,8 +23,8 @@ fn test1_all_need_migration() {
     let t2 = (Foo(0), Foo(0));
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t, t1, t2));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
         let _t = t.0;
         let _t1 = t1.0;
         let _t2 = t2.0;
@@ -40,8 +41,8 @@ fn test2_only_precise_paths_need_migration() {
     let t2 = (Foo(0), Foo(0));
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t, t1));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
         let _t = t.0;
         let _t1 = t1.0;
         let _t2 = t2;
@@ -56,8 +57,8 @@ fn test3_only_by_value_need_migration() {
     let t = (Foo(0), Foo(0));
     let t1 = (Foo(0), Foo(0));
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
         println!("{:?}", t1.1);
     };
@@ -73,8 +74,8 @@ fn test4_type_contains_drop_need_migration() {
     let t = ConstainsDropField(Foo(0), Foo(0));
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
     };
 
@@ -88,8 +89,8 @@ fn test5_drop_non_drop_aggregate_need_migration() {
     let t = (Foo(0), Foo(0), 0i32);
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.0;
     };
 
@@ -98,13 +99,11 @@ fn test5_drop_non_drop_aggregate_need_migration() {
 
 // Test migration analysis in case of Significant and Insignificant Drop aggregates.
 fn test6_significant_insignificant_drop_aggregate_need_migration() {
-    struct S(i32, i32);
-
     let t = (Foo(0), String::new());
 
     let c = || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t` to be fully captured
         let _t = t.1;
     };
 
@@ -118,8 +117,8 @@ fn test7_move_closures_non_copy_types_might_need_migration() {
     let t1 = (Foo(0), Foo(0), Foo(0));
 
     let c = move || {
-    //~^ERROR: drop order affected for closure because of `capture_disjoint_fields`
-    //~| NOTE: drop(&(t1, t));
+    //~^ ERROR: drop order affected for closure because of `capture_disjoint_fields`
+    //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
         println!("{:?} {:?}", t1.1, t.1);
     };
 
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr
index 6c21b27b493ba..ee29fe1306059 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr
@@ -1,5 +1,5 @@
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/significant_drop.rs:24:13
+  --> $DIR/significant_drop.rs:25:13
    |
 LL |       let c = || {
    |  _____________^
@@ -12,14 +12,22 @@ LL | |     };
    | |_____^
    |
 note: the lint level is defined here
-  --> $DIR/significant_drop.rs:1:9
+  --> $DIR/significant_drop.rs:2:9
    |
 LL | #![deny(disjoint_capture_drop_reorder)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: drop(&(t, t1, t2));
+help: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+   |
+LL |     let c = || { let _ = (&t, &t1, &t2); 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         let _t1 = t1.0;
+LL |         let _t2 = t2.0;
+ ...
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/significant_drop.rs:42:13
+  --> $DIR/significant_drop.rs:43:13
    |
 LL |       let c = || {
    |  _____________^
@@ -31,10 +39,18 @@ LL | |         let _t2 = t2;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t, t1));
+help: add a dummy let to cause `t`, `t1` to be fully captured
+   |
+LL |     let c = || { let _ = (&t, &t1); 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         let _t1 = t1.0;
+LL |         let _t2 = t2;
+ ...
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/significant_drop.rs:58:13
+  --> $DIR/significant_drop.rs:59:13
    |
 LL |       let c = || {
    |  _____________^
@@ -45,10 +61,18 @@ LL | |         println!("{:?}", t1.1);
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |         println!("{:?}", t1.1);
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/significant_drop.rs:75:13
+  --> $DIR/significant_drop.rs:76:13
    |
 LL |       let c = || {
    |  _____________^
@@ -58,10 +82,17 @@ LL | |         let _t = t.0;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/significant_drop.rs:90:13
+  --> $DIR/significant_drop.rs:91:13
    |
 LL |       let c = || {
    |  _____________^
@@ -71,10 +102,17 @@ LL | |         let _t = t.0;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.0;
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/significant_drop.rs:105:13
+  --> $DIR/significant_drop.rs:104:13
    |
 LL |       let c = || {
    |  _____________^
@@ -84,10 +122,17 @@ LL | |         let _t = t.1;
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t));
+help: add a dummy let to cause `t` to be fully captured
+   |
+LL |     let c = || { let _ = &t; 
+LL |
+LL |
+LL |         let _t = t.1;
+LL |     };
+   |
 
 error: drop order affected for closure because of `capture_disjoint_fields`
-  --> $DIR/significant_drop.rs:120:13
+  --> $DIR/significant_drop.rs:119:13
    |
 LL |       let c = move || {
    |  _____________^
@@ -97,7 +142,14 @@ LL | |         println!("{:?} {:?}", t1.1, t.1);
 LL | |     };
    | |_____^
    |
-   = note: drop(&(t1, t));
+help: add a dummy let to cause `t1`, `t` to be fully captured
+   |
+LL |     let c = move || { let _ = (&t1, &t); 
+LL |
+LL |
+LL |         println!("{:?} {:?}", t1.1, t.1);
+LL |     };
+   |
 
 error: aborting due to 7 previous errors
 
diff --git a/src/test/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr b/src/test/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
index 48f18b1ebe957..273eae995538a 100644
--- a/src/test/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
+++ b/src/test/ui/closures/closure-bounds-cant-promote-superkind-in-struct.stderr
@@ -9,8 +9,8 @@ LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static {
    |
 help: consider further restricting this bound
    |
-LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + Send {
-   |                                                       ^^^^^^
+LL | fn foo<F>(blk: F) -> X<F> where F: FnOnce() + 'static + std::marker::Send {
+   |                                                       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/closures/closure-bounds-subtype.stderr b/src/test/ui/closures/closure-bounds-subtype.stderr
index d649eeccb8cc9..7df29d5a098a0 100644
--- a/src/test/ui/closures/closure-bounds-subtype.stderr
+++ b/src/test/ui/closures/closure-bounds-subtype.stderr
@@ -9,8 +9,8 @@ LL |     take_const_owned(f);
    |
 help: consider further restricting this bound
    |
-LL | fn give_owned<F>(f: F) where F: FnOnce() + Send + Sync {
-   |                                                 ^^^^^^
+LL | fn give_owned<F>(f: F) where F: FnOnce() + Send + std::marker::Sync {
+   |                                                 ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/const-generics/const-argument-if-length.full.stderr b/src/test/ui/const-generics/const-argument-if-length.full.stderr
index 5dca01f0dc078..c6088e665a232 100644
--- a/src/test/ui/const-generics/const-argument-if-length.full.stderr
+++ b/src/test/ui/const-generics/const-argument-if-length.full.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/const-argument-if-length.rs:7:28
    |
 LL | pub const fn is_zst<T: ?Sized>() -> usize {
-   |                     - this type parameter needs to be `Sized`
+   |                     - this type parameter needs to be `std::marker::Sized`
 LL |     if std::mem::size_of::<T>() == 0 {
    |                            ^ doesn't have a size known at compile-time
    | 
@@ -15,7 +15,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/const-argument-if-length.rs:16:12
    |
 LL | pub struct AtLeastByte<T: ?Sized> {
-   |                        - this type parameter needs to be `Sized`
+   |                        - this type parameter needs to be `std::marker::Sized`
 LL |     value: T,
    |            ^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/const-generics/const-argument-if-length.min.stderr b/src/test/ui/const-generics/const-argument-if-length.min.stderr
index ea177c1974619..bc06e8d7fb123 100644
--- a/src/test/ui/const-generics/const-argument-if-length.min.stderr
+++ b/src/test/ui/const-generics/const-argument-if-length.min.stderr
@@ -11,7 +11,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/const-argument-if-length.rs:16:12
    |
 LL | pub struct AtLeastByte<T: ?Sized> {
-   |                        - this type parameter needs to be `Sized`
+   |                        - this type parameter needs to be `std::marker::Sized`
 LL |     value: T,
    |            ^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/const-generics/issues/issue-61336-2.full.stderr b/src/test/ui/const-generics/issues/issue-61336-2.full.stderr
index 9f8e68d211dec..ef0cafcb9bb7c 100644
--- a/src/test/ui/const-generics/issues/issue-61336-2.full.stderr
+++ b/src/test/ui/const-generics/issues/issue-61336-2.full.stderr
@@ -16,8 +16,8 @@ LL |     [x; { N }]
    = note: the `Copy` trait is required because the repeated element will be copied
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Copy, const N: usize>(x: T) -> [T; N] {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/const-generics/issues/issue-61336-2.min.stderr b/src/test/ui/const-generics/issues/issue-61336-2.min.stderr
index 82d17a87e0af8..e5fe50513aaf7 100644
--- a/src/test/ui/const-generics/issues/issue-61336-2.min.stderr
+++ b/src/test/ui/const-generics/issues/issue-61336-2.min.stderr
@@ -7,8 +7,8 @@ LL |     [x; { N }]
    = note: the `Copy` trait is required because the repeated element will be copied
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Copy, const N: usize>(x: T) -> [T; N] {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/const-generics/issues/issue-61336.full.stderr b/src/test/ui/const-generics/issues/issue-61336.full.stderr
index 974e2af6fd2cf..fcfd39387c293 100644
--- a/src/test/ui/const-generics/issues/issue-61336.full.stderr
+++ b/src/test/ui/const-generics/issues/issue-61336.full.stderr
@@ -16,8 +16,8 @@ LL |     [x; N]
    = note: the `Copy` trait is required because the repeated element will be copied
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Copy, const N: usize>(x: T) -> [T; N] {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/const-generics/issues/issue-61336.min.stderr b/src/test/ui/const-generics/issues/issue-61336.min.stderr
index 19c7153582cb9..91580313e1e83 100644
--- a/src/test/ui/const-generics/issues/issue-61336.min.stderr
+++ b/src/test/ui/const-generics/issues/issue-61336.min.stderr
@@ -7,8 +7,8 @@ LL |     [x; N]
    = note: the `Copy` trait is required because the repeated element will be copied
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Copy, const N: usize>(x: T) -> [T; N] {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Copy, const N: usize>(x: T) -> [T; N] {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/dst/dst-object-from-unsized-type.stderr b/src/test/ui/dst/dst-object-from-unsized-type.stderr
index 49940112a9f63..2d12265df98ed 100644
--- a/src/test/ui/dst/dst-object-from-unsized-type.stderr
+++ b/src/test/ui/dst/dst-object-from-unsized-type.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/dst-object-from-unsized-type.rs:8:23
    |
 LL | fn test1<T: ?Sized + Foo>(t: &T) {
-   |          - this type parameter needs to be `Sized`
+   |          - this type parameter needs to be `std::marker::Sized`
 LL |     let u: &dyn Foo = t;
    |                       ^ doesn't have a size known at compile-time
    |
@@ -12,7 +12,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/dst-object-from-unsized-type.rs:13:23
    |
 LL | fn test2<T: ?Sized + Foo>(t: &T) {
-   |          - this type parameter needs to be `Sized`
+   |          - this type parameter needs to be `std::marker::Sized`
 LL |     let v: &dyn Foo = t as &dyn Foo;
    |                       ^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr b/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr
index 266008cc0def4..4afbde5021f91 100644
--- a/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr
+++ b/src/test/ui/feature-gates/feature-gate-generic_associated_types.stderr
@@ -69,8 +69,8 @@ LL |     type Pointer2<U32> = Box<U32>;
    |
 help: consider restricting type parameter `U32`
    |
-LL |     type Pointer2<U32: Clone> = Box<U32>;
-   |                      ^^^^^^^
+LL |     type Pointer2<U32: std::clone::Clone> = Box<U32>;
+   |                      ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 8 previous errors
 
diff --git a/src/test/ui/generic-associated-types/impl_bounds.stderr b/src/test/ui/generic-associated-types/impl_bounds.stderr
index 645d292714562..e3d3de8bf9417 100644
--- a/src/test/ui/generic-associated-types/impl_bounds.stderr
+++ b/src/test/ui/generic-associated-types/impl_bounds.stderr
@@ -51,8 +51,8 @@ LL |     type C where Self: Copy = String;
    = note: the requirement `Fooy<T>: Copy` appears on the associated impl type but not on the corresponding associated trait type
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Copy> Foo for Fooy<T> {
-   |       ^^^^^^
+LL | impl<T: std::marker::Copy> Foo for Fooy<T> {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
diff --git a/src/test/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr b/src/test/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
index b380f0da2ea40..c92800c3746ad 100644
--- a/src/test/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
+++ b/src/test/ui/generic-associated-types/issue-68641-check-gat-bounds.stderr
@@ -18,8 +18,8 @@ LL |     type Item<'a> = T;
    |
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Copy> UnsafeCopy for T {
-   |       ^^^^^^
+LL | impl<T: std::marker::Copy> UnsafeCopy for T {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr b/src/test/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
index 61950478c32a8..e44547b10c17b 100644
--- a/src/test/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
+++ b/src/test/ui/generic-associated-types/issue-68642-broken-llvm-ir.stderr
@@ -19,8 +19,8 @@ LL |     type F<'a> = Self;
    = note: wrap the `T` in a closure with no arguments: `|| { /* code */ }`
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Fn<()>> Fun for T {
-   |       ^^^^^^^^
+LL | impl<T: std::ops::Fn<()>> Fun for T {
+   |       ^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/generic-associated-types/issue-68643-broken-mir.stderr b/src/test/ui/generic-associated-types/issue-68643-broken-mir.stderr
index 13980618987be..fd0b4733d9359 100644
--- a/src/test/ui/generic-associated-types/issue-68643-broken-mir.stderr
+++ b/src/test/ui/generic-associated-types/issue-68643-broken-mir.stderr
@@ -19,8 +19,8 @@ LL |     type F<'a> = Self;
    = note: wrap the `T` in a closure with no arguments: `|| { /* code */ }`
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Fn<()>> Fun for T {
-   |       ^^^^^^^^
+LL | impl<T: std::ops::Fn<()>> Fun for T {
+   |       ^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/generic-associated-types/issue-68644-codegen-selection.stderr b/src/test/ui/generic-associated-types/issue-68644-codegen-selection.stderr
index 8112425146959..0c23c870f0106 100644
--- a/src/test/ui/generic-associated-types/issue-68644-codegen-selection.stderr
+++ b/src/test/ui/generic-associated-types/issue-68644-codegen-selection.stderr
@@ -19,8 +19,8 @@ LL |     type F<'a> = Self;
    = note: wrap the `T` in a closure with no arguments: `|| { /* code */ }`
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Fn<()>> Fun for T {
-   |       ^^^^^^^^
+LL | impl<T: std::ops::Fn<()>> Fun for T {
+   |       ^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr b/src/test/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
index 22f50b3949828..85d8d3f8e936e 100644
--- a/src/test/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
+++ b/src/test/ui/generic-associated-types/issue-68645-codegen-fulfillment.stderr
@@ -19,8 +19,8 @@ LL |     type F<'a> = Self;
    = note: wrap the `T` in a closure with no arguments: `|| { /* code */ }`
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Fn<()>> Fun for T {
-   |       ^^^^^^^^
+LL | impl<T: std::ops::Fn<()>> Fun for T {
+   |       ^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/generic-associated-types/issue-74824.stderr b/src/test/ui/generic-associated-types/issue-74824.stderr
index 34a2c1932ebcc..7a7b5fd4f1c55 100644
--- a/src/test/ui/generic-associated-types/issue-74824.stderr
+++ b/src/test/ui/generic-associated-types/issue-74824.stderr
@@ -19,8 +19,8 @@ LL |     type Copy<T>: Copy = Box<T>;
    = note: required because of the requirements on the impl of `Clone` for `Box<T>`
 help: consider restricting type parameter `T`
    |
-LL |     type Copy<T: Clone>: Copy = Box<T>;
-   |                ^^^^^^^
+LL |     type Copy<T: std::clone::Clone>: Copy = Box<T>;
+   |                ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/impl-trait/issue-55872-1.full_tait.stderr b/src/test/ui/impl-trait/issue-55872-1.full_tait.stderr
index 5195333884a83..67a500f34d8e7 100644
--- a/src/test/ui/impl-trait/issue-55872-1.full_tait.stderr
+++ b/src/test/ui/impl-trait/issue-55872-1.full_tait.stderr
@@ -25,8 +25,8 @@ LL |     type E = impl Copy;
    = note: required because it appears within the type `(S, T)`
 help: consider further restricting this bound
    |
-LL | impl<S: Default + Copy> Bar for S {
-   |                 ^^^^^^
+LL | impl<S: Default + std::marker::Copy> Bar for S {
+   |                 ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `T: Copy` is not satisfied in `(S, T)`
   --> $DIR/issue-55872-1.rs:14:14
@@ -37,8 +37,8 @@ LL |     type E = impl Copy;
    = note: required because it appears within the type `(S, T)`
 help: consider further restricting this bound
    |
-LL |     fn foo<T: Default + Copy>() -> Self::E {
-   |                       ^^^^^^
+LL |     fn foo<T: Default + std::marker::Copy>() -> Self::E {
+   |                       ^^^^^^^^^^^^^^^^^^^
 
 error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias
   --> $DIR/issue-55872-1.rs:18:37
diff --git a/src/test/ui/impl-trait/issue-55872-1.min_tait.stderr b/src/test/ui/impl-trait/issue-55872-1.min_tait.stderr
index 26fc200c2a2d5..90225d249d759 100644
--- a/src/test/ui/impl-trait/issue-55872-1.min_tait.stderr
+++ b/src/test/ui/impl-trait/issue-55872-1.min_tait.stderr
@@ -16,8 +16,8 @@ LL |     type E = impl Copy;
    = note: required because it appears within the type `(S, T)`
 help: consider further restricting this bound
    |
-LL | impl<S: Default + Copy> Bar for S {
-   |                 ^^^^^^
+LL | impl<S: Default + std::marker::Copy> Bar for S {
+   |                 ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `T: Copy` is not satisfied in `(S, T)`
   --> $DIR/issue-55872-1.rs:14:14
@@ -28,8 +28,8 @@ LL |     type E = impl Copy;
    = note: required because it appears within the type `(S, T)`
 help: consider further restricting this bound
    |
-LL |     fn foo<T: Default + Copy>() -> Self::E {
-   |                       ^^^^^^
+LL |     fn foo<T: Default + std::marker::Copy>() -> Self::E {
+   |                       ^^^^^^^^^^^^^^^^^^^
 
 error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias
   --> $DIR/issue-55872-1.rs:18:37
diff --git a/src/test/ui/issues/issue-27060-2.stderr b/src/test/ui/issues/issue-27060-2.stderr
index c4faecbdf2f9e..5dbcc96e87488 100644
--- a/src/test/ui/issues/issue-27060-2.stderr
+++ b/src/test/ui/issues/issue-27060-2.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/issue-27060-2.rs:3:11
    |
 LL | pub struct Bad<T: ?Sized> {
-   |                - this type parameter needs to be `Sized`
+   |                - this type parameter needs to be `std::marker::Sized`
 LL |     data: T,
    |           ^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/issues/issue-43784-supertrait.stderr b/src/test/ui/issues/issue-43784-supertrait.stderr
index c73536ba97332..45a2350ddfd0e 100644
--- a/src/test/ui/issues/issue-43784-supertrait.stderr
+++ b/src/test/ui/issues/issue-43784-supertrait.stderr
@@ -9,8 +9,8 @@ LL | impl<T> Complete for T {}
    |
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Copy> Complete for T {}
-   |       ^^^^^^
+LL | impl<T: std::marker::Copy> Complete for T {}
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/kindck/kindck-impl-type-params.nll.stderr b/src/test/ui/kindck/kindck-impl-type-params.nll.stderr
index b01b8258e735f..e9002ec36f43d 100644
--- a/src/test/ui/kindck/kindck-impl-type-params.nll.stderr
+++ b/src/test/ui/kindck/kindck-impl-type-params.nll.stderr
@@ -8,8 +8,8 @@ LL |     let a = &t as &dyn Gettable<T>;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn f<T: Send>(val: T) {
-   |       ^^^^^^
+LL | fn f<T: std::marker::Send>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
   --> $DIR/kindck-impl-type-params.rs:18:13
@@ -21,8 +21,8 @@ LL |     let a = &t as &dyn Gettable<T>;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn f<T: Copy>(val: T) {
-   |       ^^^^^^
+LL | fn f<T: std::marker::Copy>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `T` cannot be sent between threads safely
   --> $DIR/kindck-impl-type-params.rs:25:31
@@ -34,8 +34,8 @@ LL |     let a: &dyn Gettable<T> = &t;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Send>(val: T) {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Send>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
   --> $DIR/kindck-impl-type-params.rs:25:31
@@ -47,8 +47,8 @@ LL |     let a: &dyn Gettable<T> = &t;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Copy>(val: T) {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Copy>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `String: Copy` is not satisfied
   --> $DIR/kindck-impl-type-params.rs:38:13
diff --git a/src/test/ui/kindck/kindck-impl-type-params.stderr b/src/test/ui/kindck/kindck-impl-type-params.stderr
index ddf8adf3637b3..472a6bcafa273 100644
--- a/src/test/ui/kindck/kindck-impl-type-params.stderr
+++ b/src/test/ui/kindck/kindck-impl-type-params.stderr
@@ -8,8 +8,8 @@ LL |     let a = &t as &dyn Gettable<T>;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn f<T: Send>(val: T) {
-   |       ^^^^^^
+LL | fn f<T: std::marker::Send>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
   --> $DIR/kindck-impl-type-params.rs:18:13
@@ -21,8 +21,8 @@ LL |     let a = &t as &dyn Gettable<T>;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn f<T: Copy>(val: T) {
-   |       ^^^^^^
+LL | fn f<T: std::marker::Copy>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `T` cannot be sent between threads safely
   --> $DIR/kindck-impl-type-params.rs:25:31
@@ -34,8 +34,8 @@ LL |     let a: &dyn Gettable<T> = &t;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Send>(val: T) {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Send>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `T: Copy` is not satisfied
   --> $DIR/kindck-impl-type-params.rs:25:31
@@ -47,8 +47,8 @@ LL |     let a: &dyn Gettable<T> = &t;
    = note: required for the cast to the object type `dyn Gettable<T>`
 help: consider restricting type parameter `T`
    |
-LL | fn g<T: Copy>(val: T) {
-   |       ^^^^^^
+LL | fn g<T: std::marker::Copy>(val: T) {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error[E0477]: the type `&'a isize` does not fulfill the required lifetime
   --> $DIR/kindck-impl-type-params.rs:32:13
diff --git a/src/test/ui/phantom-auto-trait.stderr b/src/test/ui/phantom-auto-trait.stderr
index 779919f9d643f..5a2ad637e4204 100644
--- a/src/test/ui/phantom-auto-trait.stderr
+++ b/src/test/ui/phantom-auto-trait.stderr
@@ -12,8 +12,8 @@ LL |     is_zen(x)
    = note: required because it appears within the type `Guard<'_, T>`
 help: consider restricting type parameter `T`
    |
-LL | fn not_sync<T: Sync>(x: Guard<T>) {
-   |              ^^^^^^
+LL | fn not_sync<T: std::marker::Sync>(x: Guard<T>) {
+   |              ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `T` cannot be shared between threads safely
   --> $DIR/phantom-auto-trait.rs:26:12
@@ -30,8 +30,8 @@ LL |     is_zen(x)
    = note: required because it appears within the type `Nested<Guard<'_, T>>`
 help: consider restricting type parameter `T`
    |
-LL | fn nested_not_sync<T: Sync>(x: Nested<Guard<T>>) {
-   |                     ^^^^^^
+LL | fn nested_not_sync<T: std::marker::Sync>(x: Nested<Guard<T>>) {
+   |                     ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/specialization/deafult-generic-associated-type-bound.stderr b/src/test/ui/specialization/deafult-generic-associated-type-bound.stderr
index b5a1877ea1931..eb5d80bc4dda6 100644
--- a/src/test/ui/specialization/deafult-generic-associated-type-bound.stderr
+++ b/src/test/ui/specialization/deafult-generic-associated-type-bound.stderr
@@ -28,8 +28,8 @@ LL |     default type U<'a> = &'a T;
    = note: required because of the requirements on the impl of `PartialEq` for `&'a T`
 help: consider further restricting this bound
    |
-LL | impl<T: 'static + PartialEq> X for T {
-   |                 ^^^^^^^^^^^
+LL | impl<T: 'static + std::cmp::PartialEq> X for T {
+   |                 ^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 2 warnings emitted
 
diff --git a/src/test/ui/specialization/defaultimpl/specialization-wfcheck.stderr b/src/test/ui/specialization/defaultimpl/specialization-wfcheck.stderr
index 57b90c457cb77..e416f30cb415d 100644
--- a/src/test/ui/specialization/defaultimpl/specialization-wfcheck.stderr
+++ b/src/test/ui/specialization/defaultimpl/specialization-wfcheck.stderr
@@ -19,8 +19,8 @@ LL | default impl<U> Foo<'static, U> for () {}
    |
 help: consider restricting type parameter `U`
    |
-LL | default impl<U: Eq> Foo<'static, U> for () {}
-   |               ^^^^
+LL | default impl<U: std::cmp::Eq> Foo<'static, U> for () {}
+   |               ^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr b/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr
index 9437fbe61cc7e..5cb3a404037a7 100644
--- a/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr
+++ b/src/test/ui/suggestions/adt-param-with-implicit-sized-bound.stderr
@@ -5,7 +5,7 @@ LL | struct X<T>(T);
    |          - required by this bound in `X`
 ...
 LL | struct Struct5<T: ?Sized>{
-   |                - this type parameter needs to be `Sized`
+   |                - this type parameter needs to be `std::marker::Sized`
 LL |     _t: X<T>,
    |         ^^^^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/suggestions/restrict-type-argument.stderr b/src/test/ui/suggestions/restrict-type-argument.stderr
index 7a7242a6369df..33af13d943f74 100644
--- a/src/test/ui/suggestions/restrict-type-argument.stderr
+++ b/src/test/ui/suggestions/restrict-type-argument.stderr
@@ -9,8 +9,8 @@ LL |     is_send(val);
    |
 help: consider further restricting this bound
    |
-LL | fn use_impl_sync(val: impl Sync + Send) {
-   |                                 ^^^^^^
+LL | fn use_impl_sync(val: impl Sync + std::marker::Send) {
+   |                                 ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `S` cannot be sent between threads safely
   --> $DIR/restrict-type-argument.rs:8:13
@@ -23,8 +23,8 @@ LL |     is_send(val);
    |
 help: consider further restricting this bound
    |
-LL | fn use_where<S>(val: S) where S: Sync + Send {
-   |                                       ^^^^^^
+LL | fn use_where<S>(val: S) where S: Sync + std::marker::Send {
+   |                                       ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `S` cannot be sent between threads safely
   --> $DIR/restrict-type-argument.rs:12:13
@@ -37,8 +37,8 @@ LL |     is_send(val);
    |
 help: consider further restricting this bound
    |
-LL | fn use_bound<S: Sync + Send>(val: S) {
-   |                      ^^^^^^
+LL | fn use_bound<S: Sync + std::marker::Send>(val: S) {
+   |                      ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `S` cannot be sent between threads safely
   --> $DIR/restrict-type-argument.rs:20:13
@@ -51,8 +51,8 @@ LL |     is_send(val);
    |
 help: consider further restricting this bound
    |
-LL |     Sync + Send
-   |          ^^^^^^
+LL |     Sync + std::marker::Send
+   |          ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `S` cannot be sent between threads safely
   --> $DIR/restrict-type-argument.rs:24:13
@@ -65,8 +65,8 @@ LL |     is_send(val);
    |
 help: consider further restricting this bound
    |
-LL | fn use_bound_and_where<S: Sync>(val: S) where S: std::fmt::Debug + Send {
-   |                                                                  ^^^^^^
+LL | fn use_bound_and_where<S: Sync>(val: S) where S: std::fmt::Debug + std::marker::Send {
+   |                                                                  ^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: `S` cannot be sent between threads safely
   --> $DIR/restrict-type-argument.rs:28:13
@@ -79,8 +79,8 @@ LL |     is_send(val);
    |
 help: consider restricting type parameter `S`
    |
-LL | fn use_unbound<S: Send>(val: S) {
-   |                 ^^^^^^
+LL | fn use_unbound<S: std::marker::Send>(val: S) {
+   |                 ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 6 previous errors
 
diff --git a/src/test/ui/trait-impl-bound-suggestions.fixed b/src/test/ui/trait-impl-bound-suggestions.fixed
index db3a95f5c4f61..744e7bef04e97 100644
--- a/src/test/ui/trait-impl-bound-suggestions.fixed
+++ b/src/test/ui/trait-impl-bound-suggestions.fixed
@@ -10,7 +10,7 @@ struct ConstrainedStruct<X: Copy> {
 }
 
 #[allow(dead_code)]
-trait InsufficientlyConstrainedGeneric<X=()> where X: Copy {
+trait InsufficientlyConstrainedGeneric<X=()> where X: std::marker::Copy {
     fn return_the_constrained_type(&self, x: X) -> ConstrainedStruct<X> {
         //~^ ERROR the trait bound `X: Copy` is not satisfied
         ConstrainedStruct { x }
diff --git a/src/test/ui/trait-impl-bound-suggestions.stderr b/src/test/ui/trait-impl-bound-suggestions.stderr
index 3a21e9c6b2ad4..110ca79908079 100644
--- a/src/test/ui/trait-impl-bound-suggestions.stderr
+++ b/src/test/ui/trait-impl-bound-suggestions.stderr
@@ -9,8 +9,8 @@ LL |     fn return_the_constrained_type(&self, x: X) -> ConstrainedStruct<X> {
    |
 help: consider further restricting type parameter `X`
    |
-LL | trait InsufficientlyConstrainedGeneric<X=()> where X: Copy {
-   |                                              ^^^^^^^^^^^^^
+LL | trait InsufficientlyConstrainedGeneric<X=()> where X: std::marker::Copy {
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/traits/inductive-overflow/two-traits.stderr b/src/test/ui/traits/inductive-overflow/two-traits.stderr
index d3f2931f25d47..508a12d859a62 100644
--- a/src/test/ui/traits/inductive-overflow/two-traits.stderr
+++ b/src/test/ui/traits/inductive-overflow/two-traits.stderr
@@ -9,8 +9,8 @@ LL |     type X = Self;
    |
 help: consider further restricting this bound
    |
-LL | impl<T: Magic + Sync> Magic for T {
-   |               ^^^^^^
+LL | impl<T: Magic + std::marker::Sync> Magic for T {
+   |               ^^^^^^^^^^^^^^^^^^^
 
 error[E0275]: overflow evaluating the requirement `*mut (): Magic`
   --> $DIR/two-traits.rs:20:5
diff --git a/src/test/ui/traits/suggest-where-clause.stderr b/src/test/ui/traits/suggest-where-clause.stderr
index 86d589ffa9e31..efab64205f3af 100644
--- a/src/test/ui/traits/suggest-where-clause.stderr
+++ b/src/test/ui/traits/suggest-where-clause.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `U` cannot be known at compilation tim
   --> $DIR/suggest-where-clause.rs:7:20
    |
 LL | fn check<T: Iterator, U: ?Sized>() {
-   |                       - this type parameter needs to be `Sized`
+   |                       - this type parameter needs to be `std::marker::Sized`
 LL |     // suggest a where-clause, if needed
 LL |     mem::size_of::<U>();
    |                    ^ doesn't have a size known at compile-time
@@ -16,7 +16,7 @@ error[E0277]: the size for values of type `U` cannot be known at compilation tim
   --> $DIR/suggest-where-clause.rs:10:5
    |
 LL | fn check<T: Iterator, U: ?Sized>() {
-   |                       - this type parameter needs to be `Sized`
+   |                       - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     mem::size_of::<Misc<U>>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
diff --git a/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.full_tait.stderr b/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.full_tait.stderr
index 871ef22f3ebcf..cfb1fe9c19a8b 100644
--- a/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.full_tait.stderr
@@ -15,8 +15,8 @@ LL | type X<T> = impl Clone;
    |
 help: consider restricting type parameter `T`
    |
-LL | type X<T: Clone> = impl Clone;
-   |         ^^^^^^^
+LL | type X<T: std::clone::Clone> = impl Clone;
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.min_tait.stderr b/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.min_tait.stderr
index 20656e5e55320..735b96d5df98e 100644
--- a/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/bounds-are-checked-2.min_tait.stderr
@@ -6,8 +6,8 @@ LL | type X<T> = impl Clone;
    |
 help: consider restricting type parameter `T`
    |
-LL | type X<T: Clone> = impl Clone;
-   |         ^^^^^^^
+LL | type X<T: std::clone::Clone> = impl Clone;
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.full_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.full_tait.stderr
index 8a0c411c7754a..aab64e72b7bca 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.full_tait.stderr
@@ -28,8 +28,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, U)`
 help: consider restricting type parameter `T`
    |
-LL | type Two<T: Debug, U> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<T: std::fmt::Debug, U> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `U` doesn't implement `Debug`
   --> $DIR/generic_duplicate_param_use5.rs:11:18
@@ -40,8 +40,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, U)`
 help: consider restricting type parameter `U`
    |
-LL | type Two<T, U: Debug> = impl Debug;
-   |              ^^^^^^^
+LL | type Two<T, U: std::fmt::Debug> = impl Debug;
+   |              ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.min_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.min_tait.stderr
index 35115ccb2d678..5c8c5b8977906 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.min_tait.stderr
@@ -19,8 +19,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, U)`
 help: consider restricting type parameter `T`
    |
-LL | type Two<T: Debug, U> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<T: std::fmt::Debug, U> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `U` doesn't implement `Debug`
   --> $DIR/generic_duplicate_param_use5.rs:11:18
@@ -31,8 +31,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, U)`
 help: consider restricting type parameter `U`
    |
-LL | type Two<T, U: Debug> = impl Debug;
-   |              ^^^^^^^
+LL | type Two<T, U: std::fmt::Debug> = impl Debug;
+   |              ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.full_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.full_tait.stderr
index 8f72c333e817c..a69e99bf8b05f 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.full_tait.stderr
@@ -28,8 +28,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, T)`
 help: consider restricting type parameter `T`
    |
-LL | type Two<T: Debug, U> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<T: std::fmt::Debug, U> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.min_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.min_tait.stderr
index 922c9a7420848..a377ef2d87322 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.min_tait.stderr
@@ -19,8 +19,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, T)`
 help: consider restricting type parameter `T`
    |
-LL | type Two<T: Debug, U> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<T: std::fmt::Debug, U> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.full_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.full_tait.stderr
index a93321d4d0508..e73ac88500e03 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.full_tait.stderr
@@ -28,8 +28,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, u32)`
 help: consider restricting type parameter `T`
    |
-LL | type Two<T: Debug, U> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<T: std::fmt::Debug, U> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.min_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.min_tait.stderr
index 25ac60799f668..d7edce7a491de 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.min_tait.stderr
@@ -19,8 +19,8 @@ LL | type Two<T, U> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(T, u32)`
 help: consider restricting type parameter `T`
    |
-LL | type Two<T: Debug, U> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<T: std::fmt::Debug, U> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.full_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.full_tait.stderr
index 098be7929d6f2..0b3d72d67b242 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.full_tait.stderr
@@ -40,8 +40,8 @@ LL | type Two<A, B> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(A, B, <A as Foo>::Bar)`
 help: consider restricting type parameter `A`
    |
-LL | type Two<A: Debug, B> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<A: std::fmt::Debug, B> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `B` doesn't implement `Debug`
   --> $DIR/generic_duplicate_param_use9.rs:10:18
@@ -52,8 +52,8 @@ LL | type Two<A, B> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(A, B, <A as Foo>::Bar)`
 help: consider restricting type parameter `B`
    |
-LL | type Two<A, B: Debug> = impl Debug;
-   |              ^^^^^^^
+LL | type Two<A, B: std::fmt::Debug> = impl Debug;
+   |              ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.min_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.min_tait.stderr
index b59e10c1b06f1..fd1081d7b71de 100644
--- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.min_tait.stderr
@@ -31,8 +31,8 @@ LL | type Two<A, B> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(A, B, <A as Foo>::Bar)`
 help: consider restricting type parameter `A`
    |
-LL | type Two<A: Debug, B> = impl Debug;
-   |           ^^^^^^^
+LL | type Two<A: std::fmt::Debug, B> = impl Debug;
+   |           ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `B` doesn't implement `Debug`
   --> $DIR/generic_duplicate_param_use9.rs:10:18
@@ -43,8 +43,8 @@ LL | type Two<A, B> = impl Debug;
    = note: required because of the requirements on the impl of `Debug` for `(A, B, <A as Foo>::Bar)`
 help: consider restricting type parameter `B`
    |
-LL | type Two<A, B: Debug> = impl Debug;
-   |              ^^^^^^^
+LL | type Two<A, B: std::fmt::Debug> = impl Debug;
+   |              ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_underconstrained2.full_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.full_tait.stderr
index ca263ba4f5b41..7ab73d24274ce 100644
--- a/src/test/ui/type-alias-impl-trait/generic_underconstrained2.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.full_tait.stderr
@@ -30,8 +30,8 @@ LL | fn underconstrained<U>(_: U) -> Underconstrained<U> {
    |
 help: consider restricting type parameter `U`
    |
-LL | fn underconstrained<U: Debug>(_: U) -> Underconstrained<U> {
-   |                      ^^^^^^^
+LL | fn underconstrained<U: std::fmt::Debug>(_: U) -> Underconstrained<U> {
+   |                      ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `V` doesn't implement `Debug`
   --> $DIR/generic_underconstrained2.rs:21:43
@@ -44,8 +44,8 @@ LL | fn underconstrained2<U, V>(_: U, _: V) -> Underconstrained2<V> {
    |
 help: consider restricting type parameter `V`
    |
-LL | fn underconstrained2<U, V: Debug>(_: U, _: V) -> Underconstrained2<V> {
-   |                          ^^^^^^^
+LL | fn underconstrained2<U, V: std::fmt::Debug>(_: U, _: V) -> Underconstrained2<V> {
+   |                          ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/generic_underconstrained2.min_tait.stderr b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.min_tait.stderr
index 6ce32f457e3ec..a4f5f4b8645b1 100644
--- a/src/test/ui/type-alias-impl-trait/generic_underconstrained2.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/generic_underconstrained2.min_tait.stderr
@@ -21,8 +21,8 @@ LL | fn underconstrained<U>(_: U) -> Underconstrained<U> {
    |
 help: consider restricting type parameter `U`
    |
-LL | fn underconstrained<U: Debug>(_: U) -> Underconstrained<U> {
-   |                      ^^^^^^^
+LL | fn underconstrained<U: std::fmt::Debug>(_: U) -> Underconstrained<U> {
+   |                      ^^^^^^^^^^^^^^^^^
 
 error[E0277]: `V` doesn't implement `Debug`
   --> $DIR/generic_underconstrained2.rs:21:43
@@ -35,8 +35,8 @@ LL | fn underconstrained2<U, V>(_: U, _: V) -> Underconstrained2<V> {
    |
 help: consider restricting type parameter `V`
    |
-LL | fn underconstrained2<U, V: Debug>(_: U, _: V) -> Underconstrained2<V> {
-   |                          ^^^^^^^
+LL | fn underconstrained2<U, V: std::fmt::Debug>(_: U, _: V) -> Underconstrained2<V> {
+   |                          ^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 
diff --git a/src/test/ui/type-alias-impl-trait/issue-52843.full_tait.stderr b/src/test/ui/type-alias-impl-trait/issue-52843.full_tait.stderr
index 14f4f62d7a5f7..35ac0993b29ca 100644
--- a/src/test/ui/type-alias-impl-trait/issue-52843.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/issue-52843.full_tait.stderr
@@ -15,8 +15,8 @@ LL | type Foo<T> = impl Default;
    |
 help: consider restricting type parameter `T`
    |
-LL | type Foo<T: Default> = impl Default;
-   |           ^^^^^^^^^
+LL | type Foo<T: std::default::Default> = impl Default;
+   |           ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error; 1 warning emitted
 
diff --git a/src/test/ui/type-alias-impl-trait/issue-52843.min_tait.stderr b/src/test/ui/type-alias-impl-trait/issue-52843.min_tait.stderr
index 6dda27f515e79..9fb760f34c19a 100644
--- a/src/test/ui/type-alias-impl-trait/issue-52843.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/issue-52843.min_tait.stderr
@@ -6,8 +6,8 @@ LL | type Foo<T> = impl Default;
    |
 help: consider restricting type parameter `T`
    |
-LL | type Foo<T: Default> = impl Default;
-   |           ^^^^^^^^^
+LL | type Foo<T: std::default::Default> = impl Default;
+   |           ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/type/type-check-defaults.stderr b/src/test/ui/type/type-check-defaults.stderr
index d8c7f595e62ef..ddfa31cf62448 100644
--- a/src/test/ui/type/type-check-defaults.stderr
+++ b/src/test/ui/type/type-check-defaults.stderr
@@ -56,8 +56,8 @@ LL | trait Base<T = String>: Super<T> { }
    |
 help: consider further restricting type parameter `T`
    |
-LL | trait Base<T = String>: Super<T> where T: Copy { }
-   |                                  ^^^^^^^^^^^^^
+LL | trait Base<T = String>: Super<T> where T: std::marker::Copy { }
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: cannot add `u8` to `i32`
   --> $DIR/type-check-defaults.rs:24:66
diff --git a/src/test/ui/typeck/typeck-default-trait-impl-send-param.stderr b/src/test/ui/typeck/typeck-default-trait-impl-send-param.stderr
index 4fb423b9a2c38..7398b48a238d1 100644
--- a/src/test/ui/typeck/typeck-default-trait-impl-send-param.stderr
+++ b/src/test/ui/typeck/typeck-default-trait-impl-send-param.stderr
@@ -9,8 +9,8 @@ LL | fn is_send<T:Send>() {
    |
 help: consider restricting type parameter `T`
    |
-LL | fn foo<T: Send>() {
-   |         ^^^^^^
+LL | fn foo<T: std::marker::Send>() {
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/union/union-sized-field.stderr b/src/test/ui/union/union-sized-field.stderr
index cebeeb59a7829..b916bbe8ad10a 100644
--- a/src/test/ui/union/union-sized-field.stderr
+++ b/src/test/ui/union/union-sized-field.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/union-sized-field.rs:4:12
    |
 LL | union Foo<T: ?Sized> {
-   |           - this type parameter needs to be `Sized`
+   |           - this type parameter needs to be `std::marker::Sized`
 LL |     value: T,
    |            ^ doesn't have a size known at compile-time
    |
@@ -21,7 +21,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/union-sized-field.rs:9:12
    |
 LL | struct Foo2<T: ?Sized> {
-   |             - this type parameter needs to be `Sized`
+   |             - this type parameter needs to be `std::marker::Sized`
 LL |     value: T,
    |            ^ doesn't have a size known at compile-time
    |
@@ -40,7 +40,7 @@ error[E0277]: the size for values of type `T` cannot be known at compilation tim
   --> $DIR/union-sized-field.rs:15:11
    |
 LL | enum Foo3<T: ?Sized> {
-   |           - this type parameter needs to be `Sized`
+   |           - this type parameter needs to be `std::marker::Sized`
 LL |     Value(T),
    |           ^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/unsized/unsized-bare-typaram.stderr b/src/test/ui/unsized/unsized-bare-typaram.stderr
index b2ff3159c9591..19978ae24cacb 100644
--- a/src/test/ui/unsized/unsized-bare-typaram.stderr
+++ b/src/test/ui/unsized/unsized-bare-typaram.stderr
@@ -6,7 +6,7 @@ LL | fn bar<T: Sized>() { }
 LL | fn foo<T: ?Sized>() { bar::<T>() }
    |        -                    ^ doesn't have a size known at compile-time
    |        |
-   |        this type parameter needs to be `Sized`
+   |        this type parameter needs to be `std::marker::Sized`
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/unsized/unsized-enum.stderr b/src/test/ui/unsized/unsized-enum.stderr
index 3057d4789bd81..601db7d1cd983 100644
--- a/src/test/ui/unsized/unsized-enum.stderr
+++ b/src/test/ui/unsized/unsized-enum.stderr
@@ -7,7 +7,7 @@ LL | fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
 LL | fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
    |         -                          ^^^^^^ doesn't have a size known at compile-time
    |         |
-   |         this type parameter needs to be `Sized`
+   |         this type parameter needs to be `std::marker::Sized`
    |
 help: you could relax the implicit `Sized` bound on `U` if it were used through indirection like `&U` or `Box<U>`
   --> $DIR/unsized-enum.rs:4:10
diff --git a/src/test/ui/unsized/unsized-enum2.stderr b/src/test/ui/unsized/unsized-enum2.stderr
index 0a0896638e072..79f690e8d1a83 100644
--- a/src/test/ui/unsized/unsized-enum2.stderr
+++ b/src/test/ui/unsized/unsized-enum2.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `W` cannot be known at compilation tim
   --> $DIR/unsized-enum2.rs:23:8
    |
 LL | enum E<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized> {
-   |        - this type parameter needs to be `Sized`
+   |        - this type parameter needs to be `std::marker::Sized`
 LL |     // parameter
 LL |     VA(W),
    |        ^ doesn't have a size known at compile-time
@@ -22,7 +22,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized-enum2.rs:25:11
    |
 LL | enum E<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized> {
-   |                   - this type parameter needs to be `Sized`
+   |                   - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     VB{x: X},
    |           ^ doesn't have a size known at compile-time
@@ -42,7 +42,7 @@ error[E0277]: the size for values of type `Y` cannot be known at compilation tim
   --> $DIR/unsized-enum2.rs:27:15
    |
 LL | enum E<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized> {
-   |                              - this type parameter needs to be `Sized`
+   |                              - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     VC(isize, Y),
    |               ^ doesn't have a size known at compile-time
@@ -62,7 +62,7 @@ error[E0277]: the size for values of type `Z` cannot be known at compilation tim
   --> $DIR/unsized-enum2.rs:29:21
    |
 LL | enum E<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized> {
-   |                                         - this type parameter needs to be `Sized`
+   |                                         - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     VD{u: isize, x: Z},
    |                     ^ doesn't have a size known at compile-time
diff --git a/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr b/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr
index 9d8a1c67734a4..9d072eda4e81c 100644
--- a/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr
+++ b/src/test/ui/unsized/unsized-inherent-impl-self-type.stderr
@@ -7,7 +7,7 @@ LL |
 LL | impl<X: ?Sized> S5<X> {
    |      -          ^^^^^ doesn't have a size known at compile-time
    |      |
-   |      this type parameter needs to be `Sized`
+   |      this type parameter needs to be `std::marker::Sized`
    |
 help: you could relax the implicit `Sized` bound on `Y` if it were used through indirection like `&Y` or `Box<Y>`
   --> $DIR/unsized-inherent-impl-self-type.rs:5:11
diff --git a/src/test/ui/unsized/unsized-struct.stderr b/src/test/ui/unsized/unsized-struct.stderr
index 6661cf358b3ab..52cf1cbb81d7f 100644
--- a/src/test/ui/unsized/unsized-struct.stderr
+++ b/src/test/ui/unsized/unsized-struct.stderr
@@ -7,7 +7,7 @@ LL | fn foo1<T>() { not_sized::<Foo<T>>() } // Hunky dory.
 LL | fn foo2<T: ?Sized>() { not_sized::<Foo<T>>() }
    |         -                          ^^^^^^ doesn't have a size known at compile-time
    |         |
-   |         this type parameter needs to be `Sized`
+   |         this type parameter needs to be `std::marker::Sized`
    |
 help: you could relax the implicit `Sized` bound on `T` if it were used through indirection like `&T` or `Box<T>`
   --> $DIR/unsized-struct.rs:4:12
@@ -26,7 +26,7 @@ LL | fn is_sized<T:Sized>() { }
 LL | fn bar2<T: ?Sized>() { is_sized::<Bar<T>>() }
    |         -              ^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |         |
-   |         this type parameter needs to be `Sized`
+   |         this type parameter needs to be `std::marker::Sized`
    |
    = note: required because it appears within the type `Bar<T>`
 
diff --git a/src/test/ui/unsized/unsized-trait-impl-self-type.stderr b/src/test/ui/unsized/unsized-trait-impl-self-type.stderr
index d1b590d813307..aef0d0cbb8395 100644
--- a/src/test/ui/unsized/unsized-trait-impl-self-type.stderr
+++ b/src/test/ui/unsized/unsized-trait-impl-self-type.stderr
@@ -7,7 +7,7 @@ LL |
 LL | impl<X: ?Sized> T3<X> for S5<X> {
    |      -                    ^^^^^ doesn't have a size known at compile-time
    |      |
-   |      this type parameter needs to be `Sized`
+   |      this type parameter needs to be `std::marker::Sized`
    |
 help: you could relax the implicit `Sized` bound on `Y` if it were used through indirection like `&Y` or `Box<Y>`
   --> $DIR/unsized-trait-impl-self-type.rs:8:11
diff --git a/src/test/ui/unsized/unsized-trait-impl-trait-arg.stderr b/src/test/ui/unsized/unsized-trait-impl-trait-arg.stderr
index 17fe16ed4fc05..f48d4ef9f1461 100644
--- a/src/test/ui/unsized/unsized-trait-impl-trait-arg.stderr
+++ b/src/test/ui/unsized/unsized-trait-impl-trait-arg.stderr
@@ -7,7 +7,7 @@ LL | trait T2<Z> {
 LL | impl<X: ?Sized> T2<X> for S4<X> {
    |      -          ^^^^^ doesn't have a size known at compile-time
    |      |
-   |      this type parameter needs to be `Sized`
+   |      this type parameter needs to be `std::marker::Sized`
    |
 help: consider relaxing the implicit `Sized` restriction
    |
diff --git a/src/test/ui/unsized3.stderr b/src/test/ui/unsized3.stderr
index 7ed43c38f1d38..ddddae4eaba57 100644
--- a/src/test/ui/unsized3.stderr
+++ b/src/test/ui/unsized3.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized3.rs:7:13
    |
 LL | fn f1<X: ?Sized>(x: &X) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 LL |     f2::<X>(x);
    |             ^ doesn't have a size known at compile-time
 ...
@@ -18,7 +18,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized3.rs:18:13
    |
 LL | fn f3<X: ?Sized + T>(x: &X) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 LL |     f4::<X>(x);
    |             ^ doesn't have a size known at compile-time
 ...
@@ -37,7 +37,7 @@ LL | fn f5<Y>(x: &Y) {}
    |       - required by this bound in `f5`
 ...
 LL | fn f8<X: ?Sized>(x1: &S<X>, x2: &S<X>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 LL |     f5(x1);
    |        ^^ doesn't have a size known at compile-time
    |
@@ -51,7 +51,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized3.rs:40:8
    |
 LL | fn f9<X: ?Sized>(x1: Box<S<X>>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 LL |     f5(&(*x1, 34));
    |        ^^^^^^^^^^ doesn't have a size known at compile-time
    |
@@ -62,7 +62,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized3.rs:45:9
    |
 LL | fn f10<X: ?Sized>(x1: Box<S<X>>) {
-   |        - this type parameter needs to be `Sized`
+   |        - this type parameter needs to be `std::marker::Sized`
 LL |     f5(&(32, *x1));
    |         ^^^^^^^^^ doesn't have a size known at compile-time
    |
@@ -77,7 +77,7 @@ LL | fn f5<Y>(x: &Y) {}
    |       - required by this bound in `f5`
 ...
 LL | fn f10<X: ?Sized>(x1: Box<S<X>>) {
-   |        - this type parameter needs to be `Sized`
+   |        - this type parameter needs to be `std::marker::Sized`
 LL |     f5(&(32, *x1));
    |        ^^^^^^^^^^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/unsized5.stderr b/src/test/ui/unsized5.stderr
index a7539b0672afe..0bfd4565529aa 100644
--- a/src/test/ui/unsized5.stderr
+++ b/src/test/ui/unsized5.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized5.rs:4:9
    |
 LL | struct S1<X: ?Sized> {
-   |           - this type parameter needs to be `Sized`
+   |           - this type parameter needs to be `std::marker::Sized`
 LL |     f1: X,
    |         ^ doesn't have a size known at compile-time
    |
@@ -21,7 +21,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized5.rs:10:8
    |
 LL | struct S2<X: ?Sized> {
-   |           - this type parameter needs to be `Sized`
+   |           - this type parameter needs to be `std::marker::Sized`
 LL |     f: isize,
 LL |     g: X,
    |        ^ doesn't have a size known at compile-time
@@ -77,7 +77,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized5.rs:25:8
    |
 LL | enum E<X: ?Sized> {
-   |        - this type parameter needs to be `Sized`
+   |        - this type parameter needs to be `std::marker::Sized`
 LL |     V1(X, isize),
    |        ^ doesn't have a size known at compile-time
    |
@@ -96,7 +96,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized5.rs:29:12
    |
 LL | enum F<X: ?Sized> {
-   |        - this type parameter needs to be `Sized`
+   |        - this type parameter needs to be `std::marker::Sized`
 LL |     V2{f1: X, f: isize},
    |            ^ doesn't have a size known at compile-time
    |
diff --git a/src/test/ui/unsized6.stderr b/src/test/ui/unsized6.stderr
index 71dac236fa316..f9f7877d5426a 100644
--- a/src/test/ui/unsized6.stderr
+++ b/src/test/ui/unsized6.stderr
@@ -2,7 +2,7 @@ error[E0277]: the size for values of type `Y` cannot be known at compilation tim
   --> $DIR/unsized6.rs:9:9
    |
 LL | fn f1<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized>(x: &X) {
-   |                             - this type parameter needs to be `Sized`
+   |                             - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     let y: Y;
    |         ^ doesn't have a size known at compile-time
@@ -14,7 +14,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:7:12
    |
 LL | fn f1<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized>(x: &X) {
-   |                  - this type parameter needs to be `Sized`
+   |                  - this type parameter needs to be `std::marker::Sized`
 LL |     let _: W; // <-- this is OK, no bindings created, no initializer.
 LL |     let _: (isize, (X, isize));
    |            ^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -25,7 +25,7 @@ error[E0277]: the size for values of type `Z` cannot be known at compilation tim
   --> $DIR/unsized6.rs:11:12
    |
 LL | fn f1<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized>(x: &X) {
-   |                                        - this type parameter needs to be `Sized`
+   |                                        - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     let y: (isize, (Z, usize));
    |            ^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -36,7 +36,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:15:9
    |
 LL | fn f2<X: ?Sized, Y: ?Sized>(x: &X) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 LL |     let y: X;
    |         ^ doesn't have a size known at compile-time
    |
@@ -47,7 +47,7 @@ error[E0277]: the size for values of type `Y` cannot be known at compilation tim
   --> $DIR/unsized6.rs:17:12
    |
 LL | fn f2<X: ?Sized, Y: ?Sized>(x: &X) {
-   |                  - this type parameter needs to be `Sized`
+   |                  - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     let y: (isize, (Y, isize));
    |            ^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -58,7 +58,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:22:9
    |
 LL | fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 LL |     let y: X = *x1;
    |         ^ doesn't have a size known at compile-time
    |
@@ -69,7 +69,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:24:9
    |
 LL | fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     let y = *x2;
    |         ^ doesn't have a size known at compile-time
@@ -81,7 +81,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:26:10
    |
 LL | fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     let (y, z) = (*x3, 4);
    |          ^ doesn't have a size known at compile-time
@@ -93,7 +93,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:30:9
    |
 LL | fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 LL |     let y: X = *x1;
    |         ^ doesn't have a size known at compile-time
    |
@@ -104,7 +104,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:32:9
    |
 LL | fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     let y = *x2;
    |         ^ doesn't have a size known at compile-time
@@ -116,7 +116,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
   --> $DIR/unsized6.rs:34:10
    |
 LL | fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
-   |       - this type parameter needs to be `Sized`
+   |       - this type parameter needs to be `std::marker::Sized`
 ...
 LL |     let (y, z) = (*x3, 4);
    |          ^ doesn't have a size known at compile-time
@@ -130,7 +130,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
 LL | fn g1<X: ?Sized>(x: X) {}
    |       -          ^ doesn't have a size known at compile-time
    |       |
-   |       this type parameter needs to be `Sized`
+   |       this type parameter needs to be `std::marker::Sized`
    |
    = help: unsized fn params are gated as an unstable feature
 help: function arguments must have a statically known size, borrowed types always have a known size
@@ -144,7 +144,7 @@ error[E0277]: the size for values of type `X` cannot be known at compilation tim
 LL | fn g2<X: ?Sized + T>(x: X) {}
    |       -              ^ doesn't have a size known at compile-time
    |       |
-   |       this type parameter needs to be `Sized`
+   |       this type parameter needs to be `std::marker::Sized`
    |
    = help: unsized fn params are gated as an unstable feature
 help: function arguments must have a statically known size, borrowed types always have a known size
diff --git a/src/test/ui/unsized7.stderr b/src/test/ui/unsized7.stderr
index 5f9a2604ed5b0..7dbddd4ed2443 100644
--- a/src/test/ui/unsized7.stderr
+++ b/src/test/ui/unsized7.stderr
@@ -7,7 +7,7 @@ LL | trait T1<Z: T> {
 LL | impl<X: ?Sized + T> T1<X> for S3<X> {
    |      -              ^^^^^ doesn't have a size known at compile-time
    |      |
-   |      this type parameter needs to be `Sized`
+   |      this type parameter needs to be `std::marker::Sized`
    |
 help: consider relaxing the implicit `Sized` restriction
    |
diff --git a/src/test/ui/wf/wf-enum-bound.stderr b/src/test/ui/wf/wf-enum-bound.stderr
index e7bc858225139..7819110dd98b5 100644
--- a/src/test/ui/wf/wf-enum-bound.stderr
+++ b/src/test/ui/wf/wf-enum-bound.stderr
@@ -9,8 +9,8 @@ LL |     where T: ExtraCopy<U>
    |
 help: consider further restricting type parameter `U`
    |
-LL |     where T: ExtraCopy<U>, U: Copy
-   |                          ^^^^^^^^^
+LL |     where T: ExtraCopy<U>, U: std::marker::Copy
+   |                          ^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-enum-fields-struct-variant.stderr b/src/test/ui/wf/wf-enum-fields-struct-variant.stderr
index c97ce53885b72..4bfb2413fe99f 100644
--- a/src/test/ui/wf/wf-enum-fields-struct-variant.stderr
+++ b/src/test/ui/wf/wf-enum-fields-struct-variant.stderr
@@ -9,8 +9,8 @@ LL |         f: IsCopy<A>
    |
 help: consider restricting type parameter `A`
    |
-LL | enum AnotherEnum<A: Copy> {
-   |                   ^^^^^^
+LL | enum AnotherEnum<A: std::marker::Copy> {
+   |                   ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-enum-fields.stderr b/src/test/ui/wf/wf-enum-fields.stderr
index 85da1bf5839a3..c8a75afbab7cb 100644
--- a/src/test/ui/wf/wf-enum-fields.stderr
+++ b/src/test/ui/wf/wf-enum-fields.stderr
@@ -9,8 +9,8 @@ LL |     SomeVariant(IsCopy<A>)
    |
 help: consider restricting type parameter `A`
    |
-LL | enum SomeEnum<A: Copy> {
-   |                ^^^^^^
+LL | enum SomeEnum<A: std::marker::Copy> {
+   |                ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-fn-where-clause.stderr b/src/test/ui/wf/wf-fn-where-clause.stderr
index 22598e58bd744..e463e3db887a5 100644
--- a/src/test/ui/wf/wf-fn-where-clause.stderr
+++ b/src/test/ui/wf/wf-fn-where-clause.stderr
@@ -9,8 +9,8 @@ LL | fn foo<T,U>() where T: ExtraCopy<U>
    |
 help: consider further restricting type parameter `U`
    |
-LL | fn foo<T,U>() where T: ExtraCopy<U>, U: Copy
-   |                                    ^^^^^^^^^
+LL | fn foo<T,U>() where T: ExtraCopy<U>, U: std::marker::Copy
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the size for values of type `(dyn Copy + 'static)` cannot be known at compilation time
   --> $DIR/wf-fn-where-clause.rs:12:16
diff --git a/src/test/ui/wf/wf-in-fn-arg.stderr b/src/test/ui/wf/wf-in-fn-arg.stderr
index d6010d1d79e93..9687658feba43 100644
--- a/src/test/ui/wf/wf-in-fn-arg.stderr
+++ b/src/test/ui/wf/wf-in-fn-arg.stderr
@@ -9,8 +9,8 @@ LL | fn bar<T>(_: &MustBeCopy<T>)
    |
 help: consider restricting type parameter `T`
    |
-LL | fn bar<T: Copy>(_: &MustBeCopy<T>)
-   |         ^^^^^^
+LL | fn bar<T: std::marker::Copy>(_: &MustBeCopy<T>)
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-in-fn-ret.stderr b/src/test/ui/wf/wf-in-fn-ret.stderr
index c22252657f12e..f9a962578e650 100644
--- a/src/test/ui/wf/wf-in-fn-ret.stderr
+++ b/src/test/ui/wf/wf-in-fn-ret.stderr
@@ -9,8 +9,8 @@ LL | fn bar<T>() -> MustBeCopy<T>
    |
 help: consider restricting type parameter `T`
    |
-LL | fn bar<T: Copy>() -> MustBeCopy<T>
-   |         ^^^^^^
+LL | fn bar<T: std::marker::Copy>() -> MustBeCopy<T>
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-in-fn-type-arg.stderr b/src/test/ui/wf/wf-in-fn-type-arg.stderr
index 6d249f5f918d3..33300b3964258 100644
--- a/src/test/ui/wf/wf-in-fn-type-arg.stderr
+++ b/src/test/ui/wf/wf-in-fn-type-arg.stderr
@@ -9,8 +9,8 @@ LL |     x: fn(MustBeCopy<T>)
    |
 help: consider restricting type parameter `T`
    |
-LL | struct Bar<T: Copy> {
-   |             ^^^^^^
+LL | struct Bar<T: std::marker::Copy> {
+   |             ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-in-fn-type-ret.stderr b/src/test/ui/wf/wf-in-fn-type-ret.stderr
index 30ff365b116ec..1ffc47e6d826c 100644
--- a/src/test/ui/wf/wf-in-fn-type-ret.stderr
+++ b/src/test/ui/wf/wf-in-fn-type-ret.stderr
@@ -9,8 +9,8 @@ LL |     x: fn() -> MustBeCopy<T>
    |
 help: consider restricting type parameter `T`
    |
-LL | struct Foo<T: Copy> {
-   |             ^^^^^^
+LL | struct Foo<T: std::marker::Copy> {
+   |             ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-in-fn-where-clause.stderr b/src/test/ui/wf/wf-in-fn-where-clause.stderr
index 64e9694c0e16b..7cb9af11d799b 100644
--- a/src/test/ui/wf/wf-in-fn-where-clause.stderr
+++ b/src/test/ui/wf/wf-in-fn-where-clause.stderr
@@ -9,8 +9,8 @@ LL |     where T: MustBeCopy<U>
    |
 help: consider further restricting type parameter `U`
    |
-LL |     where T: MustBeCopy<U>, U: Copy
-   |                           ^^^^^^^^^
+LL |     where T: MustBeCopy<U>, U: std::marker::Copy
+   |                           ^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-in-obj-type-trait.stderr b/src/test/ui/wf/wf-in-obj-type-trait.stderr
index 55ea08ccbe7ff..8606eabf59c14 100644
--- a/src/test/ui/wf/wf-in-obj-type-trait.stderr
+++ b/src/test/ui/wf/wf-in-obj-type-trait.stderr
@@ -9,8 +9,8 @@ LL |     x: dyn Object<MustBeCopy<T>>
    |
 help: consider restricting type parameter `T`
    |
-LL | struct Bar<T: Copy> {
-   |             ^^^^^^
+LL | struct Bar<T: std::marker::Copy> {
+   |             ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-inherent-impl-method-where-clause.stderr b/src/test/ui/wf/wf-inherent-impl-method-where-clause.stderr
index 7bbdd4bcf2428..8e0ce557e6b43 100644
--- a/src/test/ui/wf/wf-inherent-impl-method-where-clause.stderr
+++ b/src/test/ui/wf/wf-inherent-impl-method-where-clause.stderr
@@ -9,8 +9,8 @@ LL |     fn foo(self) where T: ExtraCopy<U>
    |
 help: consider restricting type parameter `U`
    |
-LL | impl<T,U: Copy> Foo<T,U> {
-   |         ^^^^^^
+LL | impl<T,U: std::marker::Copy> Foo<T,U> {
+   |         ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-inherent-impl-where-clause.stderr b/src/test/ui/wf/wf-inherent-impl-where-clause.stderr
index 2a44e1cdc7162..bf8077ba88f6b 100644
--- a/src/test/ui/wf/wf-inherent-impl-where-clause.stderr
+++ b/src/test/ui/wf/wf-inherent-impl-where-clause.stderr
@@ -9,8 +9,8 @@ LL | impl<T,U> Foo<T,U> where T: ExtraCopy<U>
    |
 help: consider further restricting type parameter `U`
    |
-LL | impl<T,U> Foo<T,U> where T: ExtraCopy<U>, U: Copy
-   |                                         ^^^^^^^^^
+LL | impl<T,U> Foo<T,U> where T: ExtraCopy<U>, U: std::marker::Copy
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-struct-bound.stderr b/src/test/ui/wf/wf-struct-bound.stderr
index 948693ac6f87d..e85f3591438a9 100644
--- a/src/test/ui/wf/wf-struct-bound.stderr
+++ b/src/test/ui/wf/wf-struct-bound.stderr
@@ -9,8 +9,8 @@ LL |     where T: ExtraCopy<U>
    |
 help: consider further restricting type parameter `U`
    |
-LL |     where T: ExtraCopy<U>, U: Copy
-   |                          ^^^^^^^^^
+LL |     where T: ExtraCopy<U>, U: std::marker::Copy
+   |                          ^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-struct-field.stderr b/src/test/ui/wf/wf-struct-field.stderr
index 04e62a7fcb776..62ef6bb60c7a2 100644
--- a/src/test/ui/wf/wf-struct-field.stderr
+++ b/src/test/ui/wf/wf-struct-field.stderr
@@ -9,8 +9,8 @@ LL |     data: IsCopy<A>
    |
 help: consider restricting type parameter `A`
    |
-LL | struct SomeStruct<A: Copy> {
-   |                    ^^^^^^
+LL | struct SomeStruct<A: std::marker::Copy> {
+   |                    ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-trait-associated-type-bound.stderr b/src/test/ui/wf/wf-trait-associated-type-bound.stderr
index 166e3626f094e..51adfdb6bd2a9 100644
--- a/src/test/ui/wf/wf-trait-associated-type-bound.stderr
+++ b/src/test/ui/wf/wf-trait-associated-type-bound.stderr
@@ -9,8 +9,8 @@ LL |     type Type1: ExtraCopy<T>;
    |
 help: consider restricting type parameter `T`
    |
-LL | trait SomeTrait<T: Copy> {
-   |                  ^^^^^^
+LL | trait SomeTrait<T: std::marker::Copy> {
+   |                  ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-trait-bound.stderr b/src/test/ui/wf/wf-trait-bound.stderr
index abb97adcfd4cd..c9e818f8e7dc8 100644
--- a/src/test/ui/wf/wf-trait-bound.stderr
+++ b/src/test/ui/wf/wf-trait-bound.stderr
@@ -9,8 +9,8 @@ LL |     where T: ExtraCopy<U>
    |
 help: consider further restricting type parameter `U`
    |
-LL |     where T: ExtraCopy<U>, U: Copy
-   |                          ^^^^^^^^^
+LL |     where T: ExtraCopy<U>, U: std::marker::Copy
+   |                          ^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/wf/wf-trait-superbound.stderr b/src/test/ui/wf/wf-trait-superbound.stderr
index db337a7c6d0fd..6926983527178 100644
--- a/src/test/ui/wf/wf-trait-superbound.stderr
+++ b/src/test/ui/wf/wf-trait-superbound.stderr
@@ -9,8 +9,8 @@ LL | trait SomeTrait<T>: ExtraCopy<T> {
    |
 help: consider restricting type parameter `T`
    |
-LL | trait SomeTrait<T: Copy>: ExtraCopy<T> {
-   |                  ^^^^^^
+LL | trait SomeTrait<T: std::marker::Copy>: ExtraCopy<T> {
+   |                  ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr b/src/test/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
index 916c6dc6d53a4..356ba347cc36a 100644
--- a/src/test/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
+++ b/src/test/ui/where-clauses/where-clause-constraints-are-local-for-inherent-impl.stderr
@@ -9,8 +9,8 @@ LL |         require_copy(self.x);
    |
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Copy> Foo<T> {
-   |       ^^^^^^
+LL | impl<T: std::marker::Copy> Foo<T> {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr b/src/test/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
index 8814018964aa6..d84242cfe12b8 100644
--- a/src/test/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
+++ b/src/test/ui/where-clauses/where-clause-constraints-are-local-for-trait-impl.stderr
@@ -9,8 +9,8 @@ LL |         require_copy(self.x);
    |
 help: consider restricting type parameter `T`
    |
-LL | impl<T: Copy> Foo<T> for Bar<T> {
-   |       ^^^^^^
+LL | impl<T: std::marker::Copy> Foo<T> for Bar<T> {
+   |       ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to previous error