Auto merge of #83790 - Dylan-DPC:rollup-p6ep8jo, r=Dylan-DPC

Rollup of 7 pull requests

Successful merges:

 - #83065 (Rework `std::sys::windows::alloc`)
 - #83478 (rustdoc: Add unstable option to only emit shared/crate-specific files)
 - #83629 (Fix double-drop in `Vec::from_iter(vec.into_iter())` specialization when items drop during panic)
 - #83673 (give full path of constraint in suggest_constraining_type_param)
 - #83755 (Simplify coverage tests)
 - #83757 (2229: Support migration via rustfix)
 - #83771 (Fix stack overflow detection on FreeBSD 11.1+)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

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,

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 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;
+        if captured_by_move_projs.is_empty() {
+            return needs_drop(base_path_ty);
         }
 
-        if captured_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,
+            // and we know it is not completely captured because of the previous checks.
+
+            // 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<_>>();
 
-    format!("drop(&({}));", migrations_list_concat)
+    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(", ");
+
+    (migration_string, migrated_variables_concat)
 }
 
 /// Helper function to determine if we need to escalate CaptureKind from

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);
+        }
     }
 }
 

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) };
 

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)"];

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)

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};
 
+#[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;
+
+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;
+}
+
+// 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 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);
 
-unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {
-    &mut *(ptr as *mut Header).offset(-1)
-}
-
-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
-}
-
+// 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_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 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) }
         }
     }
 }

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);
+}

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(

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,

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)];

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";

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())
-    }
-}

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]",
+            )
+        }),
     ]
 }
 

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))

src/test/run-make-fulldeps/coverage-spanview/Makefile

@@ -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

src/test/run-make-fulldeps/coverage-spanview/escape_url.py

@@ -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:])))

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.abort/abort.might_abort.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.assert/assert.might_fail_assert.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.c.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.d.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.e.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#1}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#2}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on-VTABLE-{closure#3}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.executor-block_on.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.f.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.foo.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.g.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.h.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.i.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-c.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-d.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j-f.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.j.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.k.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.l.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.m.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.async/async.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#0}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#10}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#11}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#1}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#2}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#3}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#4}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#5}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#6}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#7}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#8}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.closure/closure.main-{closure#9}.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.conditions/conditions.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_fn.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.dead_code/dead_code.unused_pub_fn_not_in_library.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest/doctest.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.doctest_crate/doctest_crate.fn_run_in_doctests.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.drop_trait/drop_trait.{impl#0}-drop.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#0}-set_strength.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.generics/generics.{impl#1}-drop.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if/if.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.if_else/if_else.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.display.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.error.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.length.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutate.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.permutations.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inline/inline.swap.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-InTrait-default_trait_func.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-in_func.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main-{impl#0}-trait_func.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.inner_items/inner_items.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.lazy_boolean/lazy_boolean.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loop_break_value/loop_break_value.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.loops_branches/loops_branches.{impl#0}-fmt.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.match_or_pattern/match_or_pattern.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.nested_loops/nested_loops.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.overflow/overflow.might_overflow.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.panic_unwind/panic_unwind.might_panic.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.main.-------.InstrumentCoverage.0.html

@@ -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>

src/test/run-make-fulldeps/coverage-spanview/expected_mir_dump.partial_eq/partial_eq.{impl#0}-new.-------.InstrumentCoverage.0.html

@@ -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>