Auto merge of #117484 - Zalathar:tests, r=cjgillot

coverage: Unify `tests/coverage-map` and `tests/run-coverage` into `tests/coverage`

Ever since the introduction of the `coverage-map` suite, it's been awkward to have to manage two separate coverage test directories containing dozens of mostly-identical files.

However, those two suites were separate for good reasons. They have very different requirements (since only one of them requires actually running the test program), running only one suite is noticeably faster than running both, and having separate suites allows them to be blessed separately if desired. So while unifying them was an obvious idea, actually doing so was non-trivial.

---

Nevertheless, this PR finds a way to merge the two suites into one directory while retaining almost all of the developer-experience benefits of having two suites. This required non-trivial implementations of `Step`, but the end result works very smoothly.

---

The first 5 commits are a copy of #117340, which has been closed in favour of this PR.

206 files changed, 435 insertions, 2385 deletions

diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index e2b515a3086..39667d16b7b 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1305,6 +1305,47 @@ macro_rules! test_definitions {
     };
 }
 
+/// Declares an alias for running the [`Coverage`] tests in only one mode.
+/// Adapted from [`test_definitions`].
+macro_rules! coverage_test_alias {
+    ($name:ident {
+        alias_and_mode: $alias_and_mode:expr,
+        default: $default:expr,
+        only_hosts: $only_hosts:expr $(,)?
+    }) => {
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+        pub struct $name {
+            pub compiler: Compiler,
+            pub target: TargetSelection,
+        }
+
+        impl $name {
+            const MODE: &'static str = $alias_and_mode;
+        }
+
+        impl Step for $name {
+            type Output = ();
+            const DEFAULT: bool = $default;
+            const ONLY_HOSTS: bool = $only_hosts;
+
+            fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+                run.alias($alias_and_mode)
+            }
+
+            fn make_run(run: RunConfig<'_>) {
+                let compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
+
+                run.builder.ensure($name { compiler, target: run.target });
+            }
+
+            fn run(self, builder: &Builder<'_>) {
+                Coverage { compiler: self.compiler, target: self.target }
+                    .run_unified_suite(builder, Self::MODE)
+            }
+        }
+    };
+}
+
 default_test!(Ui { path: "tests/ui", mode: "ui", suite: "ui" });
 
 default_test!(RunPassValgrind {
@@ -1349,13 +1390,66 @@ host_test!(RunMakeFullDeps {
 
 default_test!(Assembly { path: "tests/assembly", mode: "assembly", suite: "assembly" });
 
-default_test!(CoverageMap {
-    path: "tests/coverage-map",
-    mode: "coverage-map",
-    suite: "coverage-map"
+/// Custom test step that is responsible for running the coverage tests
+/// in multiple different modes.
+///
+/// Each individual mode also has its own alias that will run the tests in
+/// just that mode.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Coverage {
+    pub compiler: Compiler,
+    pub target: TargetSelection,
+}
+
+impl Coverage {
+    const PATH: &'static str = "tests/coverage";
+    const SUITE: &'static str = "coverage";
+
+    fn run_unified_suite(&self, builder: &Builder<'_>, mode: &'static str) {
+        builder.ensure(Compiletest {
+            compiler: self.compiler,
+            target: self.target,
+            mode,
+            suite: Self::SUITE,
+            path: Self::PATH,
+            compare_mode: None,
+        })
+    }
+}
+
+impl Step for Coverage {
+    type Output = ();
+    const DEFAULT: bool = false;
+    const ONLY_HOSTS: bool = false;
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.suite_path(Self::PATH)
+    }
+
+    fn make_run(run: RunConfig<'_>) {
+        let compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
+
+        run.builder.ensure(Coverage { compiler, target: run.target });
+    }
+
+    fn run(self, builder: &Builder<'_>) {
+        self.run_unified_suite(builder, CoverageMap::MODE);
+        self.run_unified_suite(builder, RunCoverage::MODE);
+    }
+}
+
+// Aliases for running the coverage tests in only one mode.
+coverage_test_alias!(CoverageMap {
+    alias_and_mode: "coverage-map",
+    default: true,
+    only_hosts: false,
+});
+coverage_test_alias!(RunCoverage {
+    alias_and_mode: "run-coverage",
+    default: true,
+    only_hosts: true,
 });
 
-host_test!(RunCoverage { path: "tests/run-coverage", mode: "run-coverage", suite: "run-coverage" });
 host_test!(RunCoverageRustdoc {
     path: "tests/run-coverage-rustdoc",
     mode: "run-coverage",
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index 44cdbe38de3..38eb4633273 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -727,6 +727,7 @@ impl<'a> Builder<'a> {
                 test::Tidy,
                 test::Ui,
                 test::RunPassValgrind,
+                test::Coverage,
                 test::CoverageMap,
                 test::RunCoverage,
                 test::MirOpt,
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 0e1bf0c6c2d..a908218fff1 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -78,7 +78,7 @@ impl Default for Mode {
 }
 
 impl Mode {
-    pub fn disambiguator(self) -> &'static str {
+    pub fn aux_dir_disambiguator(self) -> &'static str {
         // Pretty-printing tests could run concurrently, and if they do,
         // they need to keep their output segregated.
         match self {
@@ -86,6 +86,15 @@ impl Mode {
             _ => "",
         }
     }
+
+    pub fn output_dir_disambiguator(self) -> &'static str {
+        // Coverage tests use the same test files for multiple test modes,
+        // so each mode should have a separate output directory.
+        match self {
+            CoverageMap | RunCoverage => self.to_str(),
+            _ => "",
+        }
+    }
 }
 
 string_enum! {
@@ -699,6 +708,7 @@ pub fn output_testname_unique(
     let mode = config.compare_mode.as_ref().map_or("", |m| m.to_str());
     let debugger = config.debugger.as_ref().map_or("", |m| m.to_str());
     PathBuf::from(&testpaths.file.file_stem().unwrap())
+        .with_extra_extension(config.mode.output_dir_disambiguator())
         .with_extra_extension(revision.unwrap_or(""))
         .with_extra_extension(mode)
         .with_extra_extension(debugger)
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 620844f6f09..cbcd3dc2fde 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2193,7 +2193,7 @@ impl<'test> TestCx<'test> {
             || self.is_vxworks_pure_static()
             || self.config.target.contains("bpf")
             || !self.config.target_cfg().dynamic_linking
-            || self.config.mode == RunCoverage
+            || matches!(self.config.mode, CoverageMap | RunCoverage)
         {
             // We primarily compile all auxiliary libraries as dynamic libraries
             // to avoid code size bloat and large binaries as much as possible
@@ -2481,9 +2481,9 @@ impl<'test> TestCx<'test> {
             RunCoverage => {
                 rustc.arg("-Cinstrument-coverage");
                 // Coverage reports are sometimes sensitive to optimizations,
-                // and the current snapshots assume no optimization unless
+                // and the current snapshots assume `opt-level=2` unless
                 // overridden by `compile-flags`.
-                rustc.arg("-Copt-level=0");
+                rustc.arg("-Copt-level=2");
             }
             RunPassValgrind | Pretty | DebugInfo | Codegen | Rustdoc | RustdocJson | RunMake
             | CodegenUnits | JsDocTest | Assembly => {
@@ -2720,7 +2720,7 @@ impl<'test> TestCx<'test> {
     fn aux_output_dir_name(&self) -> PathBuf {
         self.output_base_dir()
             .join("auxiliary")
-            .with_extra_extension(self.config.mode.disambiguator())
+            .with_extra_extension(self.config.mode.aux_dir_disambiguator())
     }
 
     /// Generates a unique name for the test, such as `testname.revision.mode`.
diff --git a/tests/coverage-map/README.md b/tests/coverage-map/README.md
deleted file mode 100644
index 60d1352cd64..00000000000
--- a/tests/coverage-map/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-The tests in `./status-quo` were copied from `tests/run-coverage` in order to
-capture the current behavior of the instrumentor on non-trivial programs.
-The actual mappings have not been closely inspected.
-
-## Maintenance note
-
-These tests can be sensitive to small changes in MIR spans or MIR control flow,
-especially in HIR-to-MIR lowering or MIR optimizations.
-
-If you haven't touched the coverage code directly, and the `run-coverage` test
-suite still works, then it should usually be OK to just `--bless` these
-coverage mapping tests as necessary, without worrying too much about the exact
-changes.
diff --git a/tests/coverage-map/if.cov-map b/tests/coverage-map/if.cov-map
deleted file mode 100644
index 3cedb5ffbec..00000000000
--- a/tests/coverage-map/if.cov-map
+++ /dev/null
@@ -1,15 +0,0 @@
-Function name: if::main
-Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 03, 01, 02, 0c, 05, 02, 0d, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 01, 02]
-Number of files: 1
-- file 0 => global file 1
-Number of expressions: 2
-- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
-- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
-Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 3, 1) to (start + 2, 12)
-- Code(Counter(1)) at (prev + 2, 13) to (start + 2, 6)
-- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
-    = (c0 - c1)
-- Code(Expression(1, Add)) at (prev + 1, 5) to (start + 1, 2)
-    = (c1 + (c0 - c1))
-
diff --git a/tests/coverage-map/if.rs b/tests/coverage-map/if.rs
deleted file mode 100644
index ed3f69bdc98..00000000000
--- a/tests/coverage-map/if.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-// compile-flags: --edition=2021
-
-fn main() {
-    let cond = std::env::args().len() == 1;
-    if cond {
-        println!("true");
-    }
-    println!("done");
-}
diff --git a/tests/coverage-map/status-quo/overflow.rs b/tests/coverage-map/status-quo/overflow.rs
deleted file mode 100644
index bbb65c1b35d..00000000000
--- a/tests/coverage-map/status-quo/overflow.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 101
-
-fn might_overflow(to_add: u32) -> u32 {
-    if to_add > 5 {
-        println!("this will probably overflow");
-    }
-    let add_to = u32::MAX - 5;
-    println!("does {} + {} overflow?", add_to, to_add);
-    let result = to_add + add_to;
-    println!("continuing after overflow check");
-    result
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown == 1 {
-            let result = might_overflow(10);
-            println!("Result: {}", result);
-        } else if countdown < 5 {
-            let result = might_overflow(1);
-            println!("Result: {}", result);
-        }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the very similar test `assert.rs`,
-//      and similar tests `panic_unwind.rs`, abort.rs` and `try_error_result.rs`.
-//   2. This test confirms the coverage generated when a program passes or fails a
-//      compiler-generated `TerminatorKind::Assert` (based on an overflow check, in this case).
-//   3. Similar to how the coverage instrumentation handles `TerminatorKind::Call`,
-//      compiler-generated assertion failures are assumed to be a symptom of a program bug, not
-//      expected behavior. To simplify the coverage graphs and keep instrumented programs as
-//      small and fast as possible, `Assert` terminators are assumed to always succeed, and
-//      therefore are considered "non-branching" terminators. So, an `Assert` terminator does not
-//      get its own coverage counter.
-//   4. After an unhandled panic or failed Assert, coverage results may not always be intuitive.
-//      In this test, the final count for the statements after the `if` block in `might_overflow()`
-//      is 4, even though the lines after `to_add + add_to` were executed only 3 times. Depending
-//      on the MIR graph and the structure of the code, this count could have been 3 (which might
-//      have been valid for the overflowed add `+`, but should have been 4 for the lines before
-//      the overflow. The reason for this potential uncertainty is, a `CounterKind` is incremented
-//      via StatementKind::Counter at the end of the block, but (as in the case in this test),
-//      a CounterKind::Expression is always evaluated. In this case, the expression was based on
-//      a `Counter` incremented as part of the evaluation of the `if` expression, which was
-//      executed, and counted, 4 times, before reaching the overflow add.
-
-// If the program did not overflow, the coverage for `might_overflow()` would look like this:
-//
-//     4|       |fn might_overflow(to_add: u32) -> u32 {
-//     5|      4|    if to_add > 5 {
-//     6|      0|        println!("this will probably overflow");
-//     7|      4|    }
-//     8|      4|    let add_to = u32::MAX - 5;
-//     9|      4|    println!("does {} + {} overflow?", add_to, to_add);
-//    10|      4|    let result = to_add + add_to;
-//    11|      4|    println!("continuing after overflow check");
-//    12|      4|    result
-//    13|      4|}
diff --git a/tests/coverage-map/status-quo/sort_groups.rs b/tests/coverage-map/status-quo/sort_groups.rs
deleted file mode 100644
index f89f9f3ec61..00000000000
--- a/tests/coverage-map/status-quo/sort_groups.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// compile-flags: --edition=2021
-
-// Demonstrate that `sort_subviews.py` can sort instantiation groups into a
-// predictable order, while preserving their heterogeneous contents.
-
-fn main() {
-    let cond = std::env::args().len() > 1;
-    generic_fn::<()>(cond);
-    generic_fn::<&'static str>(!cond);
-    if false {
-        generic_fn::<char>(cond);
-    }
-    generic_fn::<i32>(cond);
-    other_fn();
-}
-
-fn generic_fn<T>(cond: bool) {
-    if cond {
-        println!("{}", std::any::type_name::<T>());
-    }
-}
-
-fn other_fn() {}
diff --git a/tests/coverage/README.md b/tests/coverage/README.md
new file mode 100644
index 00000000000..f1e403c65e3
--- /dev/null
+++ b/tests/coverage/README.md
@@ -0,0 +1,16 @@
+The tests in this directory are shared by two different test modes, and can be
+run in multiple different ways:
+
+- `./x.py test coverage-map` (compiles to LLVM IR and checks coverage mappings)
+- `./x.py test run-coverage` (runs a test binary and checks its coverage report)
+- `./x.py test coverage` (runs both `coverage-map` and `run-coverage`)
+
+## Maintenance note
+
+These tests can be sensitive to small changes in MIR spans or MIR control flow,
+especially in HIR-to-MIR lowering or MIR optimizations.
+
+If you haven't touched the coverage code directly, and the tests still pass in
+`run-coverage` mode, then it should usually be OK to just re-bless the mappings
+as necessary with `./x.py test coverage-map --bless`, without worrying too much
+about the exact changes.
diff --git a/tests/coverage-map/status-quo/abort.cov-map b/tests/coverage/abort.cov-map
index 45d3795eff8..45d3795eff8 100644
--- a/tests/coverage-map/status-quo/abort.cov-map
+++ b/tests/coverage/abort.cov-map
diff --git a/tests/run-coverage/abort.coverage b/tests/coverage/abort.coverage
index ceef6386780..ceef6386780 100644
--- a/tests/run-coverage/abort.coverage
+++ b/tests/coverage/abort.coverage
diff --git a/tests/coverage-map/status-quo/abort.rs b/tests/coverage/abort.rs
index 98264bdc1af..98264bdc1af 100644
--- a/tests/coverage-map/status-quo/abort.rs
+++ b/tests/coverage/abort.rs
diff --git a/tests/coverage-map/status-quo/assert.cov-map b/tests/coverage/assert.cov-map
index dd413123de7..dd413123de7 100644
--- a/tests/coverage-map/status-quo/assert.cov-map
+++ b/tests/coverage/assert.cov-map
diff --git a/tests/run-coverage/assert.coverage b/tests/coverage/assert.coverage
index 8b997724c4a..8b997724c4a 100644
--- a/tests/run-coverage/assert.coverage
+++ b/tests/coverage/assert.coverage
diff --git a/tests/coverage-map/status-quo/assert.rs b/tests/coverage/assert.rs
index 85e6662a6ad..85e6662a6ad 100644
--- a/tests/coverage-map/status-quo/assert.rs
+++ b/tests/coverage/assert.rs
diff --git a/tests/coverage-map/status-quo/async.cov-map b/tests/coverage/async.cov-map
index 598791537ad..598791537ad 100644
--- a/tests/coverage-map/status-quo/async.cov-map
+++ b/tests/coverage/async.cov-map
diff --git a/tests/run-coverage/async.coverage b/tests/coverage/async.coverage
index 07bc16c2d92..07bc16c2d92 100644
--- a/tests/run-coverage/async.coverage
+++ b/tests/coverage/async.coverage
diff --git a/tests/coverage-map/status-quo/async.rs b/tests/coverage/async.rs
index efd9e62d64e..efd9e62d64e 100644
--- a/tests/coverage-map/status-quo/async.rs
+++ b/tests/coverage/async.rs
diff --git a/tests/coverage-map/status-quo/async2.cov-map b/tests/coverage/async2.cov-map
index cc7aed9aee3..cc7aed9aee3 100644
--- a/tests/coverage-map/status-quo/async2.cov-map
+++ b/tests/coverage/async2.cov-map
diff --git a/tests/run-coverage/async2.coverage b/tests/coverage/async2.coverage
index fcb0a3aed64..fcb0a3aed64 100644
--- a/tests/run-coverage/async2.coverage
+++ b/tests/coverage/async2.coverage
diff --git a/tests/coverage-map/status-quo/async2.rs b/tests/coverage/async2.rs
index 2884ff297af..2884ff297af 100644
--- a/tests/coverage-map/status-quo/async2.rs
+++ b/tests/coverage/async2.rs
diff --git a/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs b/tests/coverage/auxiliary/inline_always_with_dead_code.rs
index 9dc50dae25a..9dc50dae25a 100644
--- a/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs
+++ b/tests/coverage/auxiliary/inline_always_with_dead_code.rs
diff --git a/tests/run-coverage/auxiliary/unused_mod_helper.rs b/tests/coverage/auxiliary/unused_mod_helper.rs
index 88c5dac65cb..88c5dac65cb 100644
--- a/tests/run-coverage/auxiliary/unused_mod_helper.rs
+++ b/tests/coverage/auxiliary/unused_mod_helper.rs
diff --git a/tests/run-coverage/auxiliary/used_crate.rs b/tests/coverage/auxiliary/used_crate.rs
index c086ef21e1a..c086ef21e1a 100644
--- a/tests/run-coverage/auxiliary/used_crate.rs
+++ b/tests/coverage/auxiliary/used_crate.rs
diff --git a/tests/run-coverage/auxiliary/used_inline_crate.rs b/tests/coverage/auxiliary/used_inline_crate.rs
index e8929de6b36..e8929de6b36 100644
--- a/tests/run-coverage/auxiliary/used_inline_crate.rs
+++ b/tests/coverage/auxiliary/used_inline_crate.rs
diff --git a/tests/coverage-map/status-quo/bad_counter_ids.cov-map b/tests/coverage/bad_counter_ids.cov-map
index 0b8081acfa6..0b8081acfa6 100644
--- a/tests/coverage-map/status-quo/bad_counter_ids.cov-map
+++ b/tests/coverage/bad_counter_ids.cov-map
diff --git a/tests/run-coverage/bad_counter_ids.coverage b/tests/coverage/bad_counter_ids.coverage
index d69ebf160ea..d69ebf160ea 100644
--- a/tests/run-coverage/bad_counter_ids.coverage
+++ b/tests/coverage/bad_counter_ids.coverage
diff --git a/tests/coverage-map/status-quo/bad_counter_ids.rs b/tests/coverage/bad_counter_ids.rs
index ef5460102b7..ef5460102b7 100644
--- a/tests/coverage-map/status-quo/bad_counter_ids.rs
+++ b/tests/coverage/bad_counter_ids.rs
diff --git a/tests/coverage-map/status-quo/closure.cov-map b/tests/coverage/closure.cov-map
index 522c1e73afe..522c1e73afe 100644
--- a/tests/coverage-map/status-quo/closure.cov-map
+++ b/tests/coverage/closure.cov-map
diff --git a/tests/run-coverage/closure.coverage b/tests/coverage/closure.coverage
index 67014f792c8..67014f792c8 100644
--- a/tests/run-coverage/closure.coverage
+++ b/tests/coverage/closure.coverage
diff --git a/tests/coverage-map/status-quo/closure.rs b/tests/coverage/closure.rs
index 16a2c4e33bd..16a2c4e33bd 100644
--- a/tests/coverage-map/status-quo/closure.rs
+++ b/tests/coverage/closure.rs
diff --git a/tests/coverage-map/status-quo/closure_bug.cov-map b/tests/coverage/closure_bug.cov-map
index 90eeb1a6686..90eeb1a6686 100644
--- a/tests/coverage-map/status-quo/closure_bug.cov-map
+++ b/tests/coverage/closure_bug.cov-map
diff --git a/tests/run-coverage/closure_bug.coverage b/tests/coverage/closure_bug.coverage
index f3299834bce..f3299834bce 100644
--- a/tests/run-coverage/closure_bug.coverage
+++ b/tests/coverage/closure_bug.coverage
diff --git a/tests/coverage-map/status-quo/closure_bug.rs b/tests/coverage/closure_bug.rs
index 739bc5f0b51..739bc5f0b51 100644
--- a/tests/coverage-map/status-quo/closure_bug.rs
+++ b/tests/coverage/closure_bug.rs
diff --git a/tests/coverage-map/status-quo/closure_macro.cov-map b/tests/coverage/closure_macro.cov-map
index b02c7e2e4c6..b02c7e2e4c6 100644
--- a/tests/coverage-map/status-quo/closure_macro.cov-map
+++ b/tests/coverage/closure_macro.cov-map
diff --git a/tests/run-coverage/closure_macro.coverage b/tests/coverage/closure_macro.coverage
index 0f2c917e090..0f2c917e090 100644
--- a/tests/run-coverage/closure_macro.coverage
+++ b/tests/coverage/closure_macro.coverage
diff --git a/tests/coverage-map/status-quo/closure_macro.rs b/tests/coverage/closure_macro.rs
index 9b289141c2e..9b289141c2e 100644
--- a/tests/coverage-map/status-quo/closure_macro.rs
+++ b/tests/coverage/closure_macro.rs
diff --git a/tests/coverage-map/status-quo/closure_macro_async.cov-map b/tests/coverage/closure_macro_async.cov-map
index 7f8666948d9..7f8666948d9 100644
--- a/tests/coverage-map/status-quo/closure_macro_async.cov-map
+++ b/tests/coverage/closure_macro_async.cov-map
diff --git a/tests/run-coverage/closure_macro_async.coverage b/tests/coverage/closure_macro_async.coverage
index 74247f1bc6f..74247f1bc6f 100644
--- a/tests/run-coverage/closure_macro_async.coverage
+++ b/tests/coverage/closure_macro_async.coverage
diff --git a/tests/coverage-map/status-quo/closure_macro_async.rs b/tests/coverage/closure_macro_async.rs
index b4275599e59..b4275599e59 100644
--- a/tests/coverage-map/status-quo/closure_macro_async.rs
+++ b/tests/coverage/closure_macro_async.rs
diff --git a/tests/coverage-map/status-quo/conditions.cov-map b/tests/coverage/conditions.cov-map
index 7600d2d96bd..7600d2d96bd 100644
--- a/tests/coverage-map/status-quo/conditions.cov-map
+++ b/tests/coverage/conditions.cov-map
diff --git a/tests/run-coverage/conditions.coverage b/tests/coverage/conditions.coverage
index 473335ff641..473335ff641 100644
--- a/tests/run-coverage/conditions.coverage
+++ b/tests/coverage/conditions.coverage
diff --git a/tests/coverage-map/status-quo/conditions.rs b/tests/coverage/conditions.rs
index fa7f2a116c2..fa7f2a116c2 100644
--- a/tests/coverage-map/status-quo/conditions.rs
+++ b/tests/coverage/conditions.rs
diff --git a/tests/coverage-map/status-quo/continue.cov-map b/tests/coverage/continue.cov-map
index 82f3d7c6095..82f3d7c6095 100644
--- a/tests/coverage-map/status-quo/continue.cov-map
+++ b/tests/coverage/continue.cov-map
diff --git a/tests/run-coverage/continue.coverage b/tests/coverage/continue.coverage
index 4916cac0038..4916cac0038 100644
--- a/tests/run-coverage/continue.coverage
+++ b/tests/coverage/continue.coverage
diff --git a/tests/coverage-map/status-quo/continue.rs b/tests/coverage/continue.rs
index 624aa98341b..624aa98341b 100644
--- a/tests/coverage-map/status-quo/continue.rs
+++ b/tests/coverage/continue.rs
diff --git a/tests/coverage-map/status-quo/coroutine.cov-map b/tests/coverage/coroutine.cov-map
index 2f4936d9ab8..2f4936d9ab8 100644
--- a/tests/coverage-map/status-quo/coroutine.cov-map
+++ b/tests/coverage/coroutine.cov-map
diff --git a/tests/run-coverage/coroutine.coverage b/tests/coverage/coroutine.coverage
index 3a9791a0dbd..3a9791a0dbd 100644
--- a/tests/run-coverage/coroutine.coverage
+++ b/tests/coverage/coroutine.coverage
diff --git a/tests/coverage-map/status-quo/coroutine.rs b/tests/coverage/coroutine.rs
index 86d19af6f4f..86d19af6f4f 100644
--- a/tests/coverage-map/status-quo/coroutine.rs
+++ b/tests/coverage/coroutine.rs
diff --git a/tests/coverage-map/status-quo/dead_code.cov-map b/tests/coverage/dead_code.cov-map
index 0b8a40a8cde..0b8a40a8cde 100644
--- a/tests/coverage-map/status-quo/dead_code.cov-map
+++ b/tests/coverage/dead_code.cov-map
diff --git a/tests/run-coverage/dead_code.coverage b/tests/coverage/dead_code.coverage
index c4ee9f23f08..c4ee9f23f08 100644
--- a/tests/run-coverage/dead_code.coverage
+++ b/tests/coverage/dead_code.coverage
diff --git a/tests/coverage-map/status-quo/dead_code.rs b/tests/coverage/dead_code.rs
index 3492712a6f9..3492712a6f9 100644
--- a/tests/coverage-map/status-quo/dead_code.rs
+++ b/tests/coverage/dead_code.rs
diff --git a/tests/coverage-map/status-quo/drop_trait.cov-map b/tests/coverage/drop_trait.cov-map
index 203d1048b05..203d1048b05 100644
--- a/tests/coverage-map/status-quo/drop_trait.cov-map
+++ b/tests/coverage/drop_trait.cov-map
diff --git a/tests/run-coverage/drop_trait.coverage b/tests/coverage/drop_trait.coverage
index 2c9439a93b1..2c9439a93b1 100644
--- a/tests/run-coverage/drop_trait.coverage
+++ b/tests/coverage/drop_trait.coverage
diff --git a/tests/coverage-map/status-quo/drop_trait.rs b/tests/coverage/drop_trait.rs
index 7b062719c6b..7b062719c6b 100644
--- a/tests/coverage-map/status-quo/drop_trait.rs
+++ b/tests/coverage/drop_trait.rs
diff --git a/tests/coverage-map/fn_sig_into_try.cov-map b/tests/coverage/fn_sig_into_try.cov-map
index 6e26c61aac9..6e26c61aac9 100644
--- a/tests/coverage-map/fn_sig_into_try.cov-map
+++ b/tests/coverage/fn_sig_into_try.cov-map
diff --git a/tests/run-coverage/fn_sig_into_try.coverage b/tests/coverage/fn_sig_into_try.coverage
index f1ddb1da780..f1ddb1da780 100644
--- a/tests/run-coverage/fn_sig_into_try.coverage
+++ b/tests/coverage/fn_sig_into_try.coverage
diff --git a/tests/coverage-map/fn_sig_into_try.rs b/tests/coverage/fn_sig_into_try.rs
index 92850c8a188..92850c8a188 100644
--- a/tests/coverage-map/fn_sig_into_try.rs
+++ b/tests/coverage/fn_sig_into_try.rs
diff --git a/tests/coverage-map/status-quo/generics.cov-map b/tests/coverage/generics.cov-map
index 6079a433cd0..6079a433cd0 100644
--- a/tests/coverage-map/status-quo/generics.cov-map
+++ b/tests/coverage/generics.cov-map
diff --git a/tests/run-coverage/generics.coverage b/tests/coverage/generics.coverage
index 09839183566..09839183566 100644
--- a/tests/run-coverage/generics.coverage
+++ b/tests/coverage/generics.coverage
diff --git a/tests/coverage-map/status-quo/generics.rs b/tests/coverage/generics.rs
index bf4c2d8d685..bf4c2d8d685 100644
--- a/tests/coverage-map/status-quo/generics.rs
+++ b/tests/coverage/generics.rs
diff --git a/tests/coverage-map/status-quo/if.cov-map b/tests/coverage/if.cov-map
index 391a69e0e82..391a69e0e82 100644
--- a/tests/coverage-map/status-quo/if.cov-map
+++ b/tests/coverage/if.cov-map
diff --git a/tests/run-coverage/if.coverage b/tests/coverage/if.coverage
index 2e6845190aa..2e6845190aa 100644
--- a/tests/run-coverage/if.coverage
+++ b/tests/coverage/if.coverage
diff --git a/tests/coverage-map/status-quo/if.rs b/tests/coverage/if.rs
index 8ad5042ff7b..8ad5042ff7b 100644
--- a/tests/coverage-map/status-quo/if.rs
+++ b/tests/coverage/if.rs
diff --git a/tests/coverage-map/status-quo/if_else.cov-map b/tests/coverage/if_else.cov-map
index da692ca3aa2..da692ca3aa2 100644
--- a/tests/coverage-map/status-quo/if_else.cov-map
+++ b/tests/coverage/if_else.cov-map
diff --git a/tests/run-coverage/if_else.coverage b/tests/coverage/if_else.coverage
index 0274401f004..0274401f004 100644
--- a/tests/run-coverage/if_else.coverage
+++ b/tests/coverage/if_else.coverage
diff --git a/tests/coverage-map/status-quo/if_else.rs b/tests/coverage/if_else.rs
index 3244e1e3afd..3244e1e3afd 100644
--- a/tests/coverage-map/status-quo/if_else.rs
+++ b/tests/coverage/if_else.rs
diff --git a/tests/coverage-map/status-quo/inline-dead.cov-map b/tests/coverage/inline-dead.cov-map
index 958b423f24c..958b423f24c 100644
--- a/tests/coverage-map/status-quo/inline-dead.cov-map
+++ b/tests/coverage/inline-dead.cov-map
diff --git a/tests/run-coverage/inline-dead.coverage b/tests/coverage/inline-dead.coverage
index de96aa17acd..de96aa17acd 100644
--- a/tests/run-coverage/inline-dead.coverage
+++ b/tests/coverage/inline-dead.coverage
diff --git a/tests/coverage-map/status-quo/inline-dead.rs b/tests/coverage/inline-dead.rs
index 854fa062967..854fa062967 100644
--- a/tests/coverage-map/status-quo/inline-dead.rs
+++ b/tests/coverage/inline-dead.rs
diff --git a/tests/coverage-map/status-quo/inline.cov-map b/tests/coverage/inline.cov-map
index 72b10fd0cc2..72b10fd0cc2 100644
--- a/tests/coverage-map/status-quo/inline.cov-map
+++ b/tests/coverage/inline.cov-map
diff --git a/tests/run-coverage/inline.coverage b/tests/coverage/inline.coverage
index 6efd9a0830b..6efd9a0830b 100644
--- a/tests/run-coverage/inline.coverage
+++ b/tests/coverage/inline.coverage
diff --git a/tests/coverage-map/status-quo/inline.rs b/tests/coverage/inline.rs
index 9cfab9ddbad..9cfab9ddbad 100644
--- a/tests/coverage-map/status-quo/inline.rs
+++ b/tests/coverage/inline.rs
diff --git a/tests/coverage-map/status-quo/inner_items.cov-map b/tests/coverage/inner_items.cov-map
index 3f39d74efba..3f39d74efba 100644
--- a/tests/coverage-map/status-quo/inner_items.cov-map
+++ b/tests/coverage/inner_items.cov-map
diff --git a/tests/run-coverage/inner_items.coverage b/tests/coverage/inner_items.coverage
index 65493bcd9db..65493bcd9db 100644
--- a/tests/run-coverage/inner_items.coverage
+++ b/tests/coverage/inner_items.coverage
diff --git a/tests/coverage-map/status-quo/inner_items.rs b/tests/coverage/inner_items.rs
index bcb62b3031c..bcb62b3031c 100644
--- a/tests/coverage-map/status-quo/inner_items.rs
+++ b/tests/coverage/inner_items.rs
diff --git a/tests/coverage-map/status-quo/issue-83601.cov-map b/tests/coverage/issue-83601.cov-map
index f5db3a89750..f5db3a89750 100644
--- a/tests/coverage-map/status-quo/issue-83601.cov-map
+++ b/tests/coverage/issue-83601.cov-map
diff --git a/tests/run-coverage/issue-83601.coverage b/tests/coverage/issue-83601.coverage
index 7995332cad3..7995332cad3 100644
--- a/tests/run-coverage/issue-83601.coverage
+++ b/tests/coverage/issue-83601.coverage
diff --git a/tests/coverage-map/status-quo/issue-83601.rs b/tests/coverage/issue-83601.rs
index 0b72a81947c..0b72a81947c 100644
--- a/tests/coverage-map/status-quo/issue-83601.rs
+++ b/tests/coverage/issue-83601.rs
diff --git a/tests/coverage-map/status-quo/issue-84561.cov-map b/tests/coverage/issue-84561.cov-map
index 82582b309bf..82582b309bf 100644
--- a/tests/coverage-map/status-quo/issue-84561.cov-map
+++ b/tests/coverage/issue-84561.cov-map
diff --git a/tests/run-coverage/issue-84561.coverage b/tests/coverage/issue-84561.coverage
index e693866e277..e693866e277 100644
--- a/tests/run-coverage/issue-84561.coverage
+++ b/tests/coverage/issue-84561.coverage
diff --git a/tests/coverage-map/status-quo/issue-84561.rs b/tests/coverage/issue-84561.rs
index facf5b5b4cf..facf5b5b4cf 100644
--- a/tests/coverage-map/status-quo/issue-84561.rs
+++ b/tests/coverage/issue-84561.rs
diff --git a/tests/coverage/issue-85461.cov-map b/tests/coverage/issue-85461.cov-map
new file mode 100644
index 00000000000..d1c449b9a35
--- /dev/null
+++ b/tests/coverage/issue-85461.cov-map
@@ -0,0 +1,8 @@
+Function name: issue_85461::main
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 08, 01, 03, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 8, 1) to (start + 3, 2)
+
diff --git a/tests/run-coverage/issue-85461.coverage b/tests/coverage/issue-85461.coverage
index cbc910664d0..cbc910664d0 100644
--- a/tests/run-coverage/issue-85461.coverage
+++ b/tests/coverage/issue-85461.coverage
diff --git a/tests/run-coverage/issue-85461.rs b/tests/coverage/issue-85461.rs
index 9d4c90a827e..9d4c90a827e 100644
--- a/tests/run-coverage/issue-85461.rs
+++ b/tests/coverage/issue-85461.rs
diff --git a/tests/coverage-map/status-quo/issue-93054.cov-map b/tests/coverage/issue-93054.cov-map
index c2c6e9a6516..c2c6e9a6516 100644
--- a/tests/coverage-map/status-quo/issue-93054.cov-map
+++ b/tests/coverage/issue-93054.cov-map
diff --git a/tests/run-coverage/issue-93054.coverage b/tests/coverage/issue-93054.coverage
index 15f225326a4..15f225326a4 100644
--- a/tests/run-coverage/issue-93054.coverage
+++ b/tests/coverage/issue-93054.coverage
diff --git a/tests/coverage-map/status-quo/issue-93054.rs b/tests/coverage/issue-93054.rs
index da546cfeef8..da546cfeef8 100644
--- a/tests/coverage-map/status-quo/issue-93054.rs
+++ b/tests/coverage/issue-93054.rs
diff --git a/tests/coverage-map/status-quo/lazy_boolean.cov-map b/tests/coverage/lazy_boolean.cov-map
index 0ad393c40fa..0ad393c40fa 100644
--- a/tests/coverage-map/status-quo/lazy_boolean.cov-map
+++ b/tests/coverage/lazy_boolean.cov-map
diff --git a/tests/run-coverage/lazy_boolean.coverage b/tests/coverage/lazy_boolean.coverage
index 8f14082ef68..8f14082ef68 100644
--- a/tests/run-coverage/lazy_boolean.coverage
+++ b/tests/coverage/lazy_boolean.coverage
diff --git a/tests/coverage-map/status-quo/lazy_boolean.rs b/tests/coverage/lazy_boolean.rs
index bb6219e851c..bb6219e851c 100644
--- a/tests/coverage-map/status-quo/lazy_boolean.rs
+++ b/tests/coverage/lazy_boolean.rs
diff --git a/tests/coverage-map/long_and_wide.cov-map b/tests/coverage/long_and_wide.cov-map
index 97aebf9b18a..97aebf9b18a 100644
--- a/tests/coverage-map/long_and_wide.cov-map
+++ b/tests/coverage/long_and_wide.cov-map
diff --git a/tests/coverage/long_and_wide.coverage b/tests/coverage/long_and_wide.coverage
new file mode 100644
index 00000000000..d7d29ca40cd
--- /dev/null
+++ b/tests/coverage/long_and_wide.coverage
@@ -0,0 +1,151 @@
+   LL|       |// compile-flags: --edition=2021
+   LL|       |// ignore-tidy-linelength
+   LL|       |
+   LL|       |// This file deliberately contains line and column numbers larger than 127,
+   LL|       |// to verify that `coverage-dump`'s ULEB128 parser can handle them.
+   LL|       |
+   LL|      1|fn main() {
+   LL|      1|    wide_function();
+   LL|      1|    long_function();
+   LL|      1|    far_function();
+   LL|      1|}
+   LL|       |
+   LL|       |#[rustfmt::skip]
+   LL|      1|fn wide_function() { /*                                                                                                           */ (); }
+   LL|       |
+   LL|      1|fn long_function() {
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|    //
+   LL|      1|}
+   LL|       |
+   LL|      1|fn far_function() {}
+
diff --git a/tests/coverage-map/long_and_wide.rs b/tests/coverage/long_and_wide.rs
index a7cbcd48027..a7cbcd48027 100644
--- a/tests/coverage-map/long_and_wide.rs
+++ b/tests/coverage/long_and_wide.rs
diff --git a/tests/coverage-map/status-quo/loop_break_value.cov-map b/tests/coverage/loop_break_value.cov-map
index 75018442d07..75018442d07 100644
--- a/tests/coverage-map/status-quo/loop_break_value.cov-map
+++ b/tests/coverage/loop_break_value.cov-map
diff --git a/tests/run-coverage/loop_break_value.coverage b/tests/coverage/loop_break_value.coverage
index 1f0630636dd..1f0630636dd 100644
--- a/tests/run-coverage/loop_break_value.coverage
+++ b/tests/coverage/loop_break_value.coverage
diff --git a/tests/coverage-map/status-quo/loop_break_value.rs b/tests/coverage/loop_break_value.rs
index dbc4fad7a23..dbc4fad7a23 100644
--- a/tests/coverage-map/status-quo/loop_break_value.rs
+++ b/tests/coverage/loop_break_value.rs
diff --git a/tests/coverage-map/status-quo/loops_branches.cov-map b/tests/coverage/loops_branches.cov-map
index 813583a9de7..813583a9de7 100644
--- a/tests/coverage-map/status-quo/loops_branches.cov-map
+++ b/tests/coverage/loops_branches.cov-map
diff --git a/tests/run-coverage/loops_branches.coverage b/tests/coverage/loops_branches.coverage
index 8cd6f1be3f7..8cd6f1be3f7 100644
--- a/tests/run-coverage/loops_branches.coverage
+++ b/tests/coverage/loops_branches.coverage
diff --git a/tests/coverage-map/status-quo/loops_branches.rs b/tests/coverage/loops_branches.rs
index f3a343bcc1f..f3a343bcc1f 100644
--- a/tests/coverage-map/status-quo/loops_branches.rs
+++ b/tests/coverage/loops_branches.rs
diff --git a/tests/coverage-map/status-quo/match_or_pattern.cov-map b/tests/coverage/match_or_pattern.cov-map
index d63407a99c3..d63407a99c3 100644
--- a/tests/coverage-map/status-quo/match_or_pattern.cov-map
+++ b/tests/coverage/match_or_pattern.cov-map
diff --git a/tests/run-coverage/match_or_pattern.coverage b/tests/coverage/match_or_pattern.coverage
index 94c7967215c..94c7967215c 100644
--- a/tests/run-coverage/match_or_pattern.coverage
+++ b/tests/coverage/match_or_pattern.coverage
diff --git a/tests/coverage-map/status-quo/match_or_pattern.rs b/tests/coverage/match_or_pattern.rs
index ab7aee51d1b..ab7aee51d1b 100644
--- a/tests/coverage-map/status-quo/match_or_pattern.rs
+++ b/tests/coverage/match_or_pattern.rs
diff --git a/tests/coverage-map/status-quo/nested_loops.cov-map b/tests/coverage/nested_loops.cov-map
index 35d92594e75..35d92594e75 100644
--- a/tests/coverage-map/status-quo/nested_loops.cov-map
+++ b/tests/coverage/nested_loops.cov-map
diff --git a/tests/run-coverage/nested_loops.coverage b/tests/coverage/nested_loops.coverage
index 143d0d26aa7..143d0d26aa7 100644
--- a/tests/run-coverage/nested_loops.coverage
+++ b/tests/coverage/nested_loops.coverage
diff --git a/tests/coverage-map/status-quo/nested_loops.rs b/tests/coverage/nested_loops.rs
index 4c7c7842796..4c7c7842796 100644
--- a/tests/coverage-map/status-quo/nested_loops.rs
+++ b/tests/coverage/nested_loops.rs
diff --git a/tests/coverage-map/status-quo/no_cov_crate.cov-map b/tests/coverage/no_cov_crate.cov-map
index 05b6448bbd2..05b6448bbd2 100644
--- a/tests/coverage-map/status-quo/no_cov_crate.cov-map
+++ b/tests/coverage/no_cov_crate.cov-map
diff --git a/tests/run-coverage/no_cov_crate.coverage b/tests/coverage/no_cov_crate.coverage
index f5a0322bf3e..f5a0322bf3e 100644
--- a/tests/run-coverage/no_cov_crate.coverage
+++ b/tests/coverage/no_cov_crate.coverage
diff --git a/tests/coverage-map/status-quo/no_cov_crate.rs b/tests/coverage/no_cov_crate.rs
index e12e4bc55e3..e12e4bc55e3 100644
--- a/tests/coverage-map/status-quo/no_cov_crate.rs
+++ b/tests/coverage/no_cov_crate.rs
diff --git a/tests/coverage-map/status-quo/overflow.cov-map b/tests/coverage/overflow.cov-map
index bfffd9b2ab5..39a5c05f879 100644
--- a/tests/coverage-map/status-quo/overflow.cov-map
+++ b/tests/coverage/overflow.cov-map
@@ -1,5 +1,5 @@
 Function name: overflow::main
-Raw bytes (65): 0x[01, 01, 08, 01, 1b, 05, 1f, 09, 0d, 03, 11, 16, 05, 03, 11, 05, 1f, 09, 0d, 09, 01, 0f, 01, 01, 1b, 03, 02, 0b, 00, 18, 16, 01, 0c, 00, 1a, 05, 00, 1b, 03, 0a, 12, 03, 13, 00, 20, 09, 00, 21, 03, 0a, 0d, 03, 0a, 00, 0b, 1b, 01, 09, 00, 17, 11, 02, 05, 01, 02]
+Raw bytes (65): 0x[01, 01, 08, 01, 1b, 05, 1f, 09, 0d, 03, 11, 16, 05, 03, 11, 05, 1f, 09, 0d, 09, 01, 10, 01, 01, 1b, 03, 02, 0b, 00, 18, 16, 01, 0c, 00, 1a, 05, 00, 1b, 03, 0a, 12, 03, 13, 00, 20, 09, 00, 21, 03, 0a, 0d, 03, 0a, 00, 0b, 1b, 01, 09, 00, 17, 11, 02, 05, 01, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 8
@@ -12,7 +12,7 @@ Number of expressions: 8
 - expression 6 operands: lhs = Counter(1), rhs = Expression(7, Add)
 - expression 7 operands: lhs = Counter(2), rhs = Counter(3)
 Number of file 0 mappings: 9
-- Code(Counter(0)) at (prev + 15, 1) to (start + 1, 27)
+- Code(Counter(0)) at (prev + 16, 1) to (start + 1, 27)
 - Code(Expression(0, Add)) at (prev + 2, 11) to (start + 0, 24)
     = (c0 + (c1 + (c2 + c3)))
 - Code(Expression(5, Sub)) at (prev + 1, 12) to (start + 0, 26)
@@ -27,14 +27,14 @@ Number of file 0 mappings: 9
 - Code(Counter(4)) at (prev + 2, 5) to (start + 1, 2)
 
 Function name: overflow::might_overflow
-Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 04, 01, 01, 12, 05, 01, 13, 02, 06, 02, 02, 06, 00, 07, 07, 01, 09, 05, 02]
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 05, 01, 01, 12, 05, 01, 13, 02, 06, 02, 02, 06, 00, 07, 07, 01, 09, 05, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
 - expression 0 operands: lhs = Counter(0), rhs = Counter(1)
 - expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 4, 1) to (start + 1, 18)
+- Code(Counter(0)) at (prev + 5, 1) to (start + 1, 18)
 - Code(Counter(1)) at (prev + 1, 19) to (start + 2, 6)
 - Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
     = (c0 - c1)
diff --git a/tests/run-coverage/overflow.coverage b/tests/coverage/overflow.coverage
index cee076e88cd..4f8dffc0c48 100644
--- a/tests/run-coverage/overflow.coverage
+++ b/tests/coverage/overflow.coverage
@@ -1,4 +1,5 @@
    LL|       |#![allow(unused_assignments)]
+   LL|       |// compile-flags: -Coverflow-checks=yes
    LL|       |// failure-status: 101
    LL|       |
    LL|      4|fn might_overflow(to_add: u32) -> u32 {
diff --git a/tests/run-coverage/overflow.rs b/tests/coverage/overflow.rs
index bbb65c1b35d..1c40771b274 100644
--- a/tests/run-coverage/overflow.rs
+++ b/tests/coverage/overflow.rs
@@ -1,4 +1,5 @@
 #![allow(unused_assignments)]
+// compile-flags: -Coverflow-checks=yes
 // failure-status: 101
 
 fn might_overflow(to_add: u32) -> u32 {
diff --git a/tests/coverage-map/status-quo/panic_unwind.cov-map b/tests/coverage/panic_unwind.cov-map
index f6089ce55ae..f6089ce55ae 100644
--- a/tests/coverage-map/status-quo/panic_unwind.cov-map
+++ b/tests/coverage/panic_unwind.cov-map
diff --git a/tests/run-coverage/panic_unwind.coverage b/tests/coverage/panic_unwind.coverage
index 2b0777ef215..2b0777ef215 100644
--- a/tests/run-coverage/panic_unwind.coverage
+++ b/tests/coverage/panic_unwind.coverage
diff --git a/tests/coverage-map/status-quo/panic_unwind.rs b/tests/coverage/panic_unwind.rs
index 638d2eb6aaa..638d2eb6aaa 100644
--- a/tests/coverage-map/status-quo/panic_unwind.rs
+++ b/tests/coverage/panic_unwind.rs
diff --git a/tests/coverage-map/status-quo/partial_eq.cov-map b/tests/coverage/partial_eq.cov-map
index 3549116db7a..3549116db7a 100644
--- a/tests/coverage-map/status-quo/partial_eq.cov-map
+++ b/tests/coverage/partial_eq.cov-map
diff --git a/tests/run-coverage/partial_eq.coverage b/tests/coverage/partial_eq.coverage
index c6d9ad6cf27..c6d9ad6cf27 100644
--- a/tests/run-coverage/partial_eq.coverage
+++ b/tests/coverage/partial_eq.coverage
diff --git a/tests/coverage-map/status-quo/partial_eq.rs b/tests/coverage/partial_eq.rs
index dd8b42c18ce..dd8b42c18ce 100644
--- a/tests/coverage-map/status-quo/partial_eq.rs
+++ b/tests/coverage/partial_eq.rs
diff --git a/tests/coverage-map/status-quo/simple_loop.cov-map b/tests/coverage/simple_loop.cov-map
index f1691ffc5e6..f1691ffc5e6 100644
--- a/tests/coverage-map/status-quo/simple_loop.cov-map
+++ b/tests/coverage/simple_loop.cov-map
diff --git a/tests/run-coverage/simple_loop.coverage b/tests/coverage/simple_loop.coverage
index 691c6cd1e7d..691c6cd1e7d 100644
--- a/tests/run-coverage/simple_loop.coverage
+++ b/tests/coverage/simple_loop.coverage
diff --git a/tests/coverage-map/status-quo/simple_loop.rs b/tests/coverage/simple_loop.rs
index 6f7f23475b8..6f7f23475b8 100644
--- a/tests/coverage-map/status-quo/simple_loop.rs
+++ b/tests/coverage/simple_loop.rs
diff --git a/tests/coverage-map/status-quo/simple_match.cov-map b/tests/coverage/simple_match.cov-map
index 4a32745d292..4a32745d292 100644
--- a/tests/coverage-map/status-quo/simple_match.cov-map
+++ b/tests/coverage/simple_match.cov-map
diff --git a/tests/run-coverage/simple_match.coverage b/tests/coverage/simple_match.coverage
index 7f5dd3bb646..7f5dd3bb646 100644
--- a/tests/run-coverage/simple_match.coverage
+++ b/tests/coverage/simple_match.coverage
diff --git a/tests/coverage-map/status-quo/simple_match.rs b/tests/coverage/simple_match.rs
index be99e59a826..be99e59a826 100644
--- a/tests/coverage-map/status-quo/simple_match.rs
+++ b/tests/coverage/simple_match.rs
diff --git a/tests/coverage-map/status-quo/sort_groups.cov-map b/tests/coverage/sort_groups.cov-map
index db027f3dc32..3cbda6fbe1a 100644
--- a/tests/coverage-map/status-quo/sort_groups.cov-map
+++ b/tests/coverage/sort_groups.cov-map
@@ -28,6 +28,21 @@ Number of file 0 mappings: 4
 - Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
     = (c1 + (c0 - c1))
 
+Function name: sort_groups::generic_fn::<char>
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 11, 01, 01, 0c, 05, 01, 0d, 02, 06, 02, 02, 06, 00, 07, 07, 01, 01, 00, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 2
+- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
+Number of file 0 mappings: 4
+- Code(Counter(0)) at (prev + 17, 1) to (start + 1, 12)
+- Code(Counter(1)) at (prev + 1, 13) to (start + 2, 6)
+- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
+    = (c0 - c1)
+- Code(Expression(1, Add)) at (prev + 1, 1) to (start + 0, 2)
+    = (c1 + (c0 - c1))
+
 Function name: sort_groups::generic_fn::<i32>
 Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 11, 01, 01, 0c, 05, 01, 0d, 02, 06, 02, 02, 06, 00, 07, 07, 01, 01, 00, 02]
 Number of files: 1
@@ -44,19 +59,19 @@ Number of file 0 mappings: 4
     = (c1 + (c0 - c1))
 
 Function name: sort_groups::main
-Raw bytes (28): 0x[01, 01, 02, 01, 00, 00, 02, 04, 01, 06, 01, 04, 0d, 00, 04, 0e, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 02, 02]
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 06, 01, 04, 23, 05, 04, 24, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 02, 02]
 Number of files: 1
 - file 0 => global file 1
 Number of expressions: 2
-- expression 0 operands: lhs = Counter(0), rhs = Zero
-- expression 1 operands: lhs = Zero, rhs = Expression(0, Sub)
+- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
 Number of file 0 mappings: 4
-- Code(Counter(0)) at (prev + 6, 1) to (start + 4, 13)
-- Code(Zero) at (prev + 4, 14) to (start + 2, 6)
+- Code(Counter(0)) at (prev + 6, 1) to (start + 4, 35)
+- Code(Counter(1)) at (prev + 4, 36) to (start + 2, 6)
 - Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
-    = (c0 - Zero)
+    = (c0 - c1)
 - Code(Expression(1, Add)) at (prev + 1, 5) to (start + 2, 2)
-    = (Zero + (c0 - Zero))
+    = (c1 + (c0 - c1))
 
 Function name: sort_groups::other_fn
 Raw bytes (9): 0x[01, 01, 00, 01, 01, 17, 01, 00, 11]
diff --git a/tests/run-coverage/sort_groups.coverage b/tests/coverage/sort_groups.coverage
index 8733bf48a9c..c70d7b3b282 100644
--- a/tests/run-coverage/sort_groups.coverage
+++ b/tests/coverage/sort_groups.coverage
@@ -7,7 +7,7 @@
    LL|      1|    let cond = std::env::args().len() > 1;
    LL|      1|    generic_fn::<()>(cond);
    LL|      1|    generic_fn::<&'static str>(!cond);
-   LL|      1|    if false {
+   LL|      1|    if std::hint::black_box(false) {
    LL|      0|        generic_fn::<char>(cond);
    LL|      1|    }
    LL|      1|    generic_fn::<i32>(cond);
diff --git a/tests/run-coverage/sort_groups.rs b/tests/coverage/sort_groups.rs
index f89f9f3ec61..5adbbc6a87d 100644
--- a/tests/run-coverage/sort_groups.rs
+++ b/tests/coverage/sort_groups.rs
@@ -7,7 +7,7 @@ fn main() {
     let cond = std::env::args().len() > 1;
     generic_fn::<()>(cond);
     generic_fn::<&'static str>(!cond);
-    if false {
+    if std::hint::black_box(false) {
         generic_fn::<char>(cond);
     }
     generic_fn::<i32>(cond);
diff --git a/tests/coverage-map/status-quo/test_harness.cov-map b/tests/coverage/test_harness.cov-map
index 6940d2e2824..6940d2e2824 100644
--- a/tests/coverage-map/status-quo/test_harness.cov-map
+++ b/tests/coverage/test_harness.cov-map
diff --git a/tests/run-coverage/test_harness.coverage b/tests/coverage/test_harness.coverage
index ff6009f6fce..ff6009f6fce 100644
--- a/tests/run-coverage/test_harness.coverage
+++ b/tests/coverage/test_harness.coverage
diff --git a/tests/coverage-map/status-quo/test_harness.rs b/tests/coverage/test_harness.rs
index 12a755734c1..12a755734c1 100644
--- a/tests/coverage-map/status-quo/test_harness.rs
+++ b/tests/coverage/test_harness.rs
diff --git a/tests/coverage-map/status-quo/tight_inf_loop.cov-map b/tests/coverage/tight_inf_loop.cov-map
index 7fe3146b080..7fe3146b080 100644
--- a/tests/coverage-map/status-quo/tight_inf_loop.cov-map
+++ b/tests/coverage/tight_inf_loop.cov-map
diff --git a/tests/run-coverage/tight_inf_loop.coverage b/tests/coverage/tight_inf_loop.coverage
index c15c76b3aba..c15c76b3aba 100644
--- a/tests/run-coverage/tight_inf_loop.coverage
+++ b/tests/coverage/tight_inf_loop.coverage
diff --git a/tests/coverage-map/status-quo/tight_inf_loop.rs b/tests/coverage/tight_inf_loop.rs
index cef99027aaa..cef99027aaa 100644
--- a/tests/coverage-map/status-quo/tight_inf_loop.rs
+++ b/tests/coverage/tight_inf_loop.rs
diff --git a/tests/coverage-map/trivial.cov-map b/tests/coverage/trivial.cov-map
index 874e294a1c4..874e294a1c4 100644
--- a/tests/coverage-map/trivial.cov-map
+++ b/tests/coverage/trivial.cov-map
diff --git a/tests/coverage/trivial.coverage b/tests/coverage/trivial.coverage
new file mode 100644
index 00000000000..4f417979ef9
--- /dev/null
+++ b/tests/coverage/trivial.coverage
@@ -0,0 +1,4 @@
+   LL|       |// compile-flags: --edition=2021
+   LL|       |
+   LL|      1|fn main() {}
+
diff --git a/tests/coverage-map/trivial.rs b/tests/coverage/trivial.rs
index d0a9b44fb36..d0a9b44fb36 100644
--- a/tests/coverage-map/trivial.rs
+++ b/tests/coverage/trivial.rs
diff --git a/tests/coverage-map/status-quo/try_error_result.cov-map b/tests/coverage/try_error_result.cov-map
index 8367103a21a..8367103a21a 100644
--- a/tests/coverage-map/status-quo/try_error_result.cov-map
+++ b/tests/coverage/try_error_result.cov-map
diff --git a/tests/run-coverage/try_error_result.coverage b/tests/coverage/try_error_result.coverage
index 5d48cbd62f2..5d48cbd62f2 100644
--- a/tests/run-coverage/try_error_result.coverage
+++ b/tests/coverage/try_error_result.coverage
diff --git a/tests/coverage-map/status-quo/try_error_result.rs b/tests/coverage/try_error_result.rs
index 557cbf22bfa..557cbf22bfa 100644
--- a/tests/coverage-map/status-quo/try_error_result.rs
+++ b/tests/coverage/try_error_result.rs
diff --git a/tests/coverage-map/unreachable.cov-map b/tests/coverage/unreachable.cov-map
index 495419820c1..495419820c1 100644
--- a/tests/coverage-map/unreachable.cov-map
+++ b/tests/coverage/unreachable.cov-map
diff --git a/tests/run-coverage/unreachable.coverage b/tests/coverage/unreachable.coverage
index fa0ac9ccfa1..fa0ac9ccfa1 100644
--- a/tests/run-coverage/unreachable.coverage
+++ b/tests/coverage/unreachable.coverage
diff --git a/tests/coverage-map/unreachable.rs b/tests/coverage/unreachable.rs
index 6385bfa160d..6385bfa160d 100644
--- a/tests/coverage-map/unreachable.rs
+++ b/tests/coverage/unreachable.rs
diff --git a/tests/coverage-map/status-quo/unused.cov-map b/tests/coverage/unused.cov-map
index 9383d1e90ac..9383d1e90ac 100644
--- a/tests/coverage-map/status-quo/unused.cov-map
+++ b/tests/coverage/unused.cov-map
diff --git a/tests/run-coverage/unused.coverage b/tests/coverage/unused.coverage
index 056ffeb021a..056ffeb021a 100644
--- a/tests/run-coverage/unused.coverage
+++ b/tests/coverage/unused.coverage
diff --git a/tests/coverage-map/status-quo/unused.rs b/tests/coverage/unused.rs
index d985af13547..d985af13547 100644
--- a/tests/coverage-map/status-quo/unused.rs
+++ b/tests/coverage/unused.rs
diff --git a/tests/coverage/unused_mod.cov-map b/tests/coverage/unused_mod.cov-map
new file mode 100644
index 00000000000..241cb2610ff
--- /dev/null
+++ b/tests/coverage/unused_mod.cov-map
@@ -0,0 +1,16 @@
+Function name: unused_mod::main
+Raw bytes (9): 0x[01, 02, 00, 01, 01, 04, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 2
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 4, 1) to (start + 2, 2)
+
+Function name: unused_mod::unused_module::never_called_function (unused)
+Raw bytes (9): 0x[01, 01, 00, 01, 00, 02, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Zero) at (prev + 2, 1) to (start + 2, 2)
+
diff --git a/tests/run-coverage/unused_mod.coverage b/tests/coverage/unused_mod.coverage
index a8fa24ac6a7..a8fa24ac6a7 100644
--- a/tests/run-coverage/unused_mod.coverage
+++ b/tests/coverage/unused_mod.coverage
diff --git a/tests/run-coverage/unused_mod.rs b/tests/coverage/unused_mod.rs
index 6e62839c998..6e62839c998 100644
--- a/tests/run-coverage/unused_mod.rs
+++ b/tests/coverage/unused_mod.rs
diff --git a/tests/coverage/uses_crate.cov-map b/tests/coverage/uses_crate.cov-map
new file mode 100644
index 00000000000..9c06eab7005
--- /dev/null
+++ b/tests/coverage/uses_crate.cov-map
@@ -0,0 +1,40 @@
+Function name: used_crate::used_from_bin_crate_and_lib_crate_generic_function::<alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1b, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 27, 1) to (start + 2, 2)
+
+Function name: used_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 19, 1) to (start + 2, 2)
+
+Function name: used_crate::used_only_from_bin_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 13, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 19, 1) to (start + 2, 2)
+
+Function name: used_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 1f, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 31, 1) to (start + 2, 2)
+
+Function name: uses_crate::main
+Raw bytes (9): 0x[01, 02, 00, 01, 01, 0c, 01, 07, 02]
+Number of files: 1
+- file 0 => global file 2
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 12, 1) to (start + 7, 2)
+
diff --git a/tests/run-coverage/uses_crate.coverage b/tests/coverage/uses_crate.coverage
index 50d92102a10..50d92102a10 100644
--- a/tests/run-coverage/uses_crate.coverage
+++ b/tests/coverage/uses_crate.coverage
diff --git a/tests/run-coverage/uses_crate.rs b/tests/coverage/uses_crate.rs
index ab203ad781d..ab203ad781d 100644
--- a/tests/run-coverage/uses_crate.rs
+++ b/tests/coverage/uses_crate.rs
diff --git a/tests/coverage/uses_inline_crate.cov-map b/tests/coverage/uses_inline_crate.cov-map
new file mode 100644
index 00000000000..6b621825c88
--- /dev/null
+++ b/tests/coverage/uses_inline_crate.cov-map
@@ -0,0 +1,55 @@
+Function name: used_inline_crate::used_from_bin_crate_and_lib_crate_generic_function::<alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 2c, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 44, 1) to (start + 2, 2)
+
+Function name: used_inline_crate::used_inline_function
+Raw bytes (28): 0x[01, 01, 02, 01, 05, 05, 02, 04, 01, 14, 01, 06, 0f, 05, 06, 10, 02, 06, 02, 02, 06, 00, 07, 07, 01, 05, 01, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 2
+- expression 0 operands: lhs = Counter(0), rhs = Counter(1)
+- expression 1 operands: lhs = Counter(1), rhs = Expression(0, Sub)
+Number of file 0 mappings: 4
+- Code(Counter(0)) at (prev + 20, 1) to (start + 6, 15)
+- Code(Counter(1)) at (prev + 6, 16) to (start + 2, 6)
+- Code(Expression(0, Sub)) at (prev + 2, 6) to (start + 0, 7)
+    = (c0 - c1)
+- Code(Expression(1, Add)) at (prev + 1, 5) to (start + 1, 2)
+    = (c1 + (c0 - c1))
+
+Function name: used_inline_crate::used_only_from_bin_crate_generic_function::<&alloc::vec::Vec<i32>>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 33, 1) to (start + 2, 2)
+
+Function name: used_inline_crate::used_only_from_bin_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 21, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 33, 1) to (start + 2, 2)
+
+Function name: used_inline_crate::used_with_same_type_from_bin_crate_and_lib_crate_generic_function::<&str>
+Raw bytes (9): 0x[01, 01, 00, 01, 01, 31, 01, 02, 02]
+Number of files: 1
+- file 0 => global file 1
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 49, 1) to (start + 2, 2)
+
+Function name: uses_inline_crate::main
+Raw bytes (9): 0x[01, 02, 00, 01, 01, 0c, 01, 0a, 02]
+Number of files: 1
+- file 0 => global file 2
+Number of expressions: 0
+Number of file 0 mappings: 1
+- Code(Counter(0)) at (prev + 12, 1) to (start + 10, 2)
+
diff --git a/tests/run-coverage/uses_inline_crate.coverage b/tests/coverage/uses_inline_crate.coverage
index cc0e01ffde1..cc0e01ffde1 100644
--- a/tests/run-coverage/uses_inline_crate.coverage
+++ b/tests/coverage/uses_inline_crate.coverage
diff --git a/tests/run-coverage/uses_inline_crate.rs b/tests/coverage/uses_inline_crate.rs
index d7b4c3c057f..d7b4c3c057f 100644
--- a/tests/run-coverage/uses_inline_crate.rs
+++ b/tests/coverage/uses_inline_crate.rs
diff --git a/tests/coverage-map/status-quo/while.cov-map b/tests/coverage/while.cov-map
index af250f3fb71..af250f3fb71 100644
--- a/tests/coverage-map/status-quo/while.cov-map
+++ b/tests/coverage/while.cov-map
diff --git a/tests/run-coverage/while.coverage b/tests/coverage/while.coverage
index c9d497651c9..c9d497651c9 100644
--- a/tests/run-coverage/while.coverage
+++ b/tests/coverage/while.coverage
diff --git a/tests/coverage-map/status-quo/while.rs b/tests/coverage/while.rs
index 781b90b3566..781b90b3566 100644
--- a/tests/coverage-map/status-quo/while.rs
+++ b/tests/coverage/while.rs
diff --git a/tests/coverage-map/status-quo/while_early_ret.cov-map b/tests/coverage/while_early_ret.cov-map
index 369ebe891f1..369ebe891f1 100644
--- a/tests/coverage-map/status-quo/while_early_ret.cov-map
+++ b/tests/coverage/while_early_ret.cov-map
diff --git a/tests/run-coverage/while_early_ret.coverage b/tests/coverage/while_early_ret.coverage
index 49d39d36603..49d39d36603 100644
--- a/tests/run-coverage/while_early_ret.coverage
+++ b/tests/coverage/while_early_ret.coverage
diff --git a/tests/coverage-map/status-quo/while_early_ret.rs b/tests/coverage/while_early_ret.rs
index b2f0eee2cc0..b2f0eee2cc0 100644
--- a/tests/coverage-map/status-quo/while_early_ret.rs
+++ b/tests/coverage/while_early_ret.rs
diff --git a/tests/coverage-map/status-quo/yield.cov-map b/tests/coverage/yield.cov-map
index c9c9709fa4f..c9c9709fa4f 100644
--- a/tests/coverage-map/status-quo/yield.cov-map
+++ b/tests/coverage/yield.cov-map
diff --git a/tests/run-coverage/yield.coverage b/tests/coverage/yield.coverage
index d7e455f211e..d7e455f211e 100644
--- a/tests/run-coverage/yield.coverage
+++ b/tests/coverage/yield.coverage
diff --git a/tests/coverage-map/status-quo/yield.rs b/tests/coverage/yield.rs
index b7e2ba31b59..b7e2ba31b59 100644
--- a/tests/coverage-map/status-quo/yield.rs
+++ b/tests/coverage/yield.rs
diff --git a/tests/run-coverage/abort.rs b/tests/run-coverage/abort.rs
deleted file mode 100644
index 98264bdc1af..00000000000
--- a/tests/run-coverage/abort.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#![feature(c_unwind)]
-#![allow(unused_assignments)]
-
-extern "C" fn might_abort(should_abort: bool) {
-    if should_abort {
-        println!("aborting...");
-        panic!("panics and aborts");
-    } else {
-        println!("Don't Panic");
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown < 5 {
-            might_abort(false);
-        }
-        // See discussion (below the `Notes` section) on coverage results for the closing brace.
-        if countdown < 5 { might_abort(false); } // Counts for different regions on one line.
-        // For the following example, the closing brace is the last character on the line.
-        // This shows the character after the closing brace is highlighted, even if that next
-        // character is a newline.
-        if countdown < 5 { might_abort(false); }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the similar tests
-//      `panic_unwind.rs` and `try_error_result.rs`.
-//   2. This test confirms the coverage generated when a program includes `UnwindAction::Terminate`.
-//   3. The test does not invoke the abort. By executing to a successful completion, the coverage
-//      results show where the program did and did not execute.
-//   4. If the program actually aborted, the coverage counters would not be saved (which "works as
-//      intended"). Coverage results would show no executed coverage regions.
-//   6. If `should_abort` is `true` and the program aborts, the program exits with a `132` status
-//      (on Linux at least).
-
-/*
-
-Expect the following coverage results:
-
-```text
-    16|     11|    while countdown > 0 {
-    17|     10|        if countdown < 5 {
-    18|      4|            might_abort(false);
-    19|      6|        }
-```
-
-This is actually correct.
-
-The condition `countdown < 5` executed 10 times (10 loop iterations).
-
-It evaluated to `true` 4 times, and executed the `might_abort()` call.
-
-It skipped the body of the `might_abort()` call 6 times. If an `if` does not include an explicit
-`else`, the coverage implementation injects a counter, at the character immediately after the `if`s
-closing brace, to count the "implicit" `else`. This is the only way to capture the coverage of the
-non-true condition.
-
-As another example of why this is important, say the condition was `countdown < 50`, which is always
-`true`. In that case, we wouldn't have a test for what happens if `might_abort()` is not called.
-The closing brace would have a count of `0`, highlighting the missed coverage.
-*/
diff --git a/tests/run-coverage/assert.rs b/tests/run-coverage/assert.rs
deleted file mode 100644
index 85e6662a6ad..00000000000
--- a/tests/run-coverage/assert.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 101
-
-fn might_fail_assert(one_plus_one: u32) {
-    println!("does 1 + 1 = {}?", one_plus_one);
-    assert_eq!(1 + 1, one_plus_one, "the argument was wrong");
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown == 1 {
-            might_fail_assert(3);
-        } else if countdown < 5 {
-            might_fail_assert(2);
-        }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the very similar test
-//      `panic_unwind.rs`, and similar tests `abort.rs` and `try_error_result.rs`.
-//   2. This test confirms the coverage generated when a program passes or fails an `assert!()` or
-//      related `assert_*!()` macro.
-//   3. Notably, the `assert` macros *do not* generate `TerminatorKind::Assert`. The macros produce
-//      conditional expressions, `TerminatorKind::SwitchInt` branches, and a possible call to
-//      `begin_panic_fmt()` (that begins a panic unwind, if the assertion test fails).
-//   4. `TerminatoKind::Assert` is, however, also present in the MIR generated for this test
-//      (and in many other coverage tests). The `Assert` terminator is typically generated by the
-//      Rust compiler to check for runtime failures, such as numeric overflows.
diff --git a/tests/run-coverage/async.rs b/tests/run-coverage/async.rs
deleted file mode 100644
index efd9e62d64e..00000000000
--- a/tests/run-coverage/async.rs
+++ /dev/null
@@ -1,128 +0,0 @@
-#![allow(unused_assignments, dead_code)]
-
-// compile-flags: --edition=2018 -C opt-level=1
-
-async fn c(x: u8) -> u8 {
-    if x == 8 {
-        1
-    } else {
-        0
-    }
-}
-
-async fn d() -> u8 { 1 }
-
-async fn e() -> u8 { 1 } // unused function; executor does not block on `g()`
-
-async fn f() -> u8 { 1 }
-
-async fn foo() -> [bool; 10] { [false; 10] } // unused function; executor does not block on `h()`
-
-pub async fn g(x: u8) {
-    match x {
-        y if e().await == y => (),
-        y if f().await == y => (),
-        _ => (),
-    }
-}
-
-async fn h(x: usize) { // The function signature is counted when called, but the body is not
-                       // executed (not awaited) so the open brace has a `0` count (at least when
-                       // displayed with `llvm-cov show` in color-mode).
-    match x {
-        y if foo().await[y] => (),
-        _ => (),
-    }
-}
-
-async fn i(x: u8) { // line coverage is 1, but there are 2 regions:
-                    // (a) the function signature, counted when the function is called; and
-                    // (b) the open brace for the function body, counted once when the body is
-                    // executed asynchronously.
-    match x {
-        y if c(x).await == y + 1 => { d().await; }
-        y if f().await == y + 1 => (),
-        _ => (),
-    }
-}
-
-fn j(x: u8) {
-    // non-async versions of `c()`, `d()`, and `f()` to make it similar to async `i()`.
-    fn c(x: u8) -> u8 {
-        if x == 8 {
-            1 // This line appears covered, but the 1-character expression span covering the `1`
-              // is not executed. (`llvm-cov show` displays a `^0` below the `1` ). This is because
-              // `fn j()` executes the open brace for the function body, followed by the function's
-              // first executable statement, `match x`. Inner function declarations are not
-              // "visible" to the MIR for `j()`, so the code region counts all lines between the
-              // open brace and the first statement as executed, which is, in a sense, true.
-              // `llvm-cov show` overcomes this kind of situation by showing the actual counts
-              // of the enclosed coverages, (that is, the `1` expression was not executed, and
-              // accurately displays a `0`).
-        } else {
-            0
-        }
-    }
-    fn d() -> u8 { 1 } // inner function is defined in-line, but the function is not executed
-    fn f() -> u8 { 1 }
-    match x {
-        y if c(x) == y + 1 => { d(); }
-        y if f() == y + 1 => (),
-        _ => (),
-    }
-}
-
-fn k(x: u8) { // unused function
-    match x {
-        1 => (),
-        2 => (),
-        _ => (),
-    }
-}
-
-fn l(x: u8) {
-    match x {
-        1 => (),
-        2 => (),
-        _ => (),
-    }
-}
-
-async fn m(x: u8) -> u8 { x - 1 }
-
-fn main() {
-    let _ = g(10);
-    let _ = h(9);
-    let mut future = Box::pin(i(8));
-    j(7);
-    l(6);
-    let _ = m(5);
-    executor::block_on(future.as_mut());
-}
-
-mod executor {
-    use core::{
-        future::Future,
-        pin::Pin,
-        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-    };
-
-    pub fn block_on<F: Future>(mut future: F) -> F::Output {
-        let mut future = unsafe { Pin::new_unchecked(&mut future) };
-        use std::hint::unreachable_unchecked;
-        static VTABLE: RawWakerVTable = RawWakerVTable::new(
-            |_| unsafe { unreachable_unchecked() }, // clone
-            |_| unsafe { unreachable_unchecked() }, // wake
-            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-            |_| (),
-        );
-        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
-        let mut context = Context::from_waker(&waker);
-
-        loop {
-            if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
-                break val;
-            }
-        }
-    }
-}
diff --git a/tests/run-coverage/async2.rs b/tests/run-coverage/async2.rs
deleted file mode 100644
index 2884ff297af..00000000000
--- a/tests/run-coverage/async2.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// compile-flags: --edition=2018
-
-fn non_async_func() {
-    println!("non_async_func was covered");
-    let b = true;
-    if b {
-        println!("non_async_func println in block");
-    }
-}
-
-async fn async_func() {
-    println!("async_func was covered");
-    let b = true;
-    if b {
-        println!("async_func println in block");
-    }
-}
-
-async fn async_func_just_println() {
-    println!("async_func_just_println was covered");
-}
-
-fn main() {
-    println!("codecovsample::main");
-
-    non_async_func();
-
-    executor::block_on(async_func());
-    executor::block_on(async_func_just_println());
-}
-
-mod executor {
-    use core::{
-        future::Future,
-        pin::Pin,
-        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-    };
-
-    pub fn block_on<F: Future>(mut future: F) -> F::Output {
-        let mut future = unsafe { Pin::new_unchecked(&mut future) };
-        use std::hint::unreachable_unchecked;
-        static VTABLE: RawWakerVTable = RawWakerVTable::new(
-            |_| unsafe { unreachable_unchecked() }, // clone
-            |_| unsafe { unreachable_unchecked() }, // wake
-            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-            |_| (),
-        );
-        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
-        let mut context = Context::from_waker(&waker);
-
-        loop {
-            if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
-                break val;
-            }
-        }
-    }
-}
diff --git a/tests/run-coverage/bad_counter_ids.rs b/tests/run-coverage/bad_counter_ids.rs
deleted file mode 100644
index ef5460102b7..00000000000
--- a/tests/run-coverage/bad_counter_ids.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-#![feature(coverage_attribute)]
-// compile-flags: --edition=2021 -Copt-level=0 -Zmir-opt-level=3
-
-// Regression test for <https://github.com/rust-lang/rust/issues/117012>.
-//
-// If some coverage counters were removed by MIR optimizations, we need to take
-// care not to refer to those counter IDs in coverage mappings, and instead
-// replace them with a constant zero value. If we don't, `llvm-cov` might see
-// a too-large counter ID and silently discard the entire function from its
-// coverage reports.
-
-#[derive(Debug, PartialEq, Eq)]
-struct Foo(u32);
-
-fn eq_good() {
-    println!("a");
-    assert_eq!(Foo(1), Foo(1));
-}
-
-fn eq_good_message() {
-    println!("b");
-    assert_eq!(Foo(1), Foo(1), "message b");
-}
-
-fn ne_good() {
-    println!("c");
-    assert_ne!(Foo(1), Foo(3));
-}
-
-fn ne_good_message() {
-    println!("d");
-    assert_ne!(Foo(1), Foo(3), "message d");
-}
-
-fn eq_bad() {
-    println!("e");
-    assert_eq!(Foo(1), Foo(3));
-}
-
-fn eq_bad_message() {
-    println!("f");
-    assert_eq!(Foo(1), Foo(3), "message f");
-}
-
-fn ne_bad() {
-    println!("g");
-    assert_ne!(Foo(1), Foo(1));
-}
-
-fn ne_bad_message() {
-    println!("h");
-    assert_ne!(Foo(1), Foo(1), "message h");
-}
-
-#[coverage(off)]
-fn main() {
-    eq_good();
-    eq_good_message();
-    ne_good();
-    ne_good_message();
-
-    assert!(std::panic::catch_unwind(eq_bad).is_err());
-    assert!(std::panic::catch_unwind(eq_bad_message).is_err());
-    assert!(std::panic::catch_unwind(ne_bad).is_err());
-    assert!(std::panic::catch_unwind(ne_bad_message).is_err());
-}
diff --git a/tests/run-coverage/closure.rs b/tests/run-coverage/closure.rs
deleted file mode 100644
index 16a2c4e33bd..00000000000
--- a/tests/run-coverage/closure.rs
+++ /dev/null
@@ -1,220 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-// compile-flags: -C opt-level=2
-
-// This test used to be sensitive to certain coverage-specific hacks in
-// `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by
-// <https://github.com/rust-lang/rust/pull/83666>.
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-    let is_false = !is_true;
-
-    let mut some_string = Some(String::from("the string content"));
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            ||
-            {
-                let mut countdown = 0;
-                if is_false {
-                    countdown = 10;
-                }
-                "alt string 1".to_owned()
-            }
-        )
-    );
-
-    some_string = Some(String::from("the string content"));
-    let
-        a
-    =
-        ||
-    {
-        let mut countdown = 0;
-        if is_false {
-            countdown = 10;
-        }
-        "alt string 2".to_owned()
-    };
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            a
-        )
-    );
-
-    some_string = None;
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            ||
-            {
-                let mut countdown = 0;
-                if is_false {
-                    countdown = 10;
-                }
-                "alt string 3".to_owned()
-            }
-        )
-    );
-
-    some_string = None;
-    let
-        a
-    =
-        ||
-    {
-        let mut countdown = 0;
-        if is_false {
-            countdown = 10;
-        }
-        "alt string 4".to_owned()
-    };
-    println!(
-        "The string or alt: {}"
-        ,
-        some_string
-            .
-            unwrap_or_else
-        (
-            a
-        )
-    );
-
-    let
-        quote_closure
-    =
-        |val|
-    {
-        let mut countdown = 0;
-        if is_false {
-            countdown = 10;
-        }
-        format!("'{}'", val)
-    };
-    println!(
-        "Repeated, quoted string: {:?}"
-        ,
-        std::iter::repeat("repeat me")
-            .take(5)
-            .map
-        (
-            quote_closure
-        )
-            .collect::<Vec<_>>()
-    );
-
-    let
-        _unused_closure
-    =
-        |
-            mut countdown
-        |
-    {
-        if is_false {
-            countdown = 10;
-        }
-        "closure should be unused".to_owned()
-    };
-
-    let mut countdown = 10;
-    let _short_unused_closure = | _unused_arg: u8 | countdown += 1;
-
-
-    let short_used_covered_closure_macro = | used_arg: u8 | println!("called");
-    let short_used_not_covered_closure_macro = | used_arg: u8 | println!("not called");
-    let _short_unused_closure_macro = | _unused_arg: u8 | println!("not called");
-
-
-
-
-    let _short_unused_closure_block = | _unused_arg: u8 | { println!("not called") };
-
-    let _shortish_unused_closure = | _unused_arg: u8 | {
-        println!("not called")
-    };
-
-    let _as_short_unused_closure = |
-        _unused_arg: u8
-    | { println!("not called") };
-
-    let _almost_as_short_unused_closure = |
-        _unused_arg: u8
-    | { println!("not called") }
-    ;
-
-
-
-
-
-    let _short_unused_closure_line_break_no_block = | _unused_arg: u8 |
-println!("not called")
-    ;
-
-    let _short_unused_closure_line_break_no_block2 =
-        | _unused_arg: u8 |
-            println!(
-                "not called"
-            )
-    ;
-
-    let short_used_not_covered_closure_line_break_no_block_embedded_branch =
-        | _unused_arg: u8 |
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-    ;
-
-    let short_used_not_covered_closure_line_break_block_embedded_branch =
-        | _unused_arg: u8 |
-        {
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-        }
-    ;
-
-    let short_used_covered_closure_line_break_no_block_embedded_branch =
-        | _unused_arg: u8 |
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-    ;
-
-    let short_used_covered_closure_line_break_block_embedded_branch =
-        | _unused_arg: u8 |
-        {
-            println!(
-                "not called: {}",
-                if is_true { "check" } else { "me" }
-            )
-        }
-    ;
-
-    if is_false {
-        short_used_not_covered_closure_macro(0);
-        short_used_not_covered_closure_line_break_no_block_embedded_branch(0);
-        short_used_not_covered_closure_line_break_block_embedded_branch(0);
-    }
-    short_used_covered_closure_macro(0);
-    short_used_covered_closure_line_break_no_block_embedded_branch(0);
-    short_used_covered_closure_line_break_block_embedded_branch(0);
-}
diff --git a/tests/run-coverage/closure_bug.rs b/tests/run-coverage/closure_bug.rs
deleted file mode 100644
index 739bc5f0b51..00000000000
--- a/tests/run-coverage/closure_bug.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Regression test for #115930.
-// All of these closures are identical, and should produce identical output in
-// the coverage report. However, an unstable sort was causing them to be treated
-// inconsistently when preparing coverage spans.
-
-fn main() {
-    let truthy = std::env::args().len() == 1;
-
-    let a
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    a();
-    if truthy { a(); }
-
-    let b
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    b();
-    if truthy { b(); }
-
-    let c
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    c();
-    if truthy { c(); }
-
-    let d
-        =
-        |
-        |
-        if truthy { true } else { false };
-
-    d();
-    if truthy { d(); }
-}
diff --git a/tests/run-coverage/closure_macro.rs b/tests/run-coverage/closure_macro.rs
deleted file mode 100644
index 9b289141c2e..00000000000
--- a/tests/run-coverage/closure_macro.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// compile-flags: --edition=2018
-#![feature(coverage_attribute)]
-
-macro_rules! bail {
-    ($msg:literal $(,)?) => {
-        if $msg.len() > 0 {
-            println!("no msg");
-        } else {
-            println!($msg);
-        }
-        return Err(String::from($msg));
-    };
-}
-
-macro_rules! on_error {
-    ($value:expr, $error_message:expr) => {
-        $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
-            let message = format!($error_message, e);
-            if message.len() > 0 {
-                println!("{}", message);
-                Ok(String::from("ok"))
-            } else {
-                bail!("error");
-            }
-        })
-    };
-}
-
-fn load_configuration_files() -> Result<String, String> {
-    Ok(String::from("config"))
-}
-
-pub fn main() -> Result<(), String> {
-    println!("Starting service");
-    let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
-
-    let startup_delay_duration = String::from("arg");
-    let _ = (config, startup_delay_duration);
-    Ok(())
-}
diff --git a/tests/run-coverage/closure_macro_async.rs b/tests/run-coverage/closure_macro_async.rs
deleted file mode 100644
index b4275599e59..00000000000
--- a/tests/run-coverage/closure_macro_async.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-// compile-flags: --edition=2018
-#![feature(coverage_attribute)]
-
-macro_rules! bail {
-    ($msg:literal $(,)?) => {
-        if $msg.len() > 0 {
-            println!("no msg");
-        } else {
-            println!($msg);
-        }
-        return Err(String::from($msg));
-    };
-}
-
-macro_rules! on_error {
-    ($value:expr, $error_message:expr) => {
-        $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
-            let message = format!($error_message, e);
-            if message.len() > 0 {
-                println!("{}", message);
-                Ok(String::from("ok"))
-            } else {
-                bail!("error");
-            }
-        })
-    };
-}
-
-fn load_configuration_files() -> Result<String, String> {
-    Ok(String::from("config"))
-}
-
-pub async fn test() -> Result<(), String> {
-    println!("Starting service");
-    let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
-
-    let startup_delay_duration = String::from("arg");
-    let _ = (config, startup_delay_duration);
-    Ok(())
-}
-
-#[coverage(off)]
-fn main() {
-    executor::block_on(test()).unwrap();
-}
-
-mod executor {
-    use core::{
-        future::Future,
-        pin::Pin,
-        task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
-    };
-
-    #[coverage(off)]
-    pub fn block_on<F: Future>(mut future: F) -> F::Output {
-        let mut future = unsafe { Pin::new_unchecked(&mut future) };
-        use std::hint::unreachable_unchecked;
-        static VTABLE: RawWakerVTable = RawWakerVTable::new(
-            #[coverage(off)]
-            |_| unsafe { unreachable_unchecked() }, // clone
-            #[coverage(off)]
-            |_| unsafe { unreachable_unchecked() }, // wake
-            #[coverage(off)]
-            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-            #[coverage(off)]
-            |_| (),
-        );
-        let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
-        let mut context = Context::from_waker(&waker);
-
-        loop {
-            if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
-                break val;
-            }
-        }
-    }
-}
diff --git a/tests/run-coverage/conditions.rs b/tests/run-coverage/conditions.rs
deleted file mode 100644
index fa7f2a116c2..00000000000
--- a/tests/run-coverage/conditions.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    let mut countdown = 0;
-    if true {
-        countdown = 10;
-    }
-
-    const B: u32 = 100;
-    let x = if countdown > 7 {
-        countdown -= 4;
-        B
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-        countdown
-    } else {
-        return;
-    };
-
-    let mut countdown = 0;
-    if true {
-        countdown = 10;
-    }
-
-    if countdown > 7 {
-        countdown -= 4;
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-    } else {
-        return;
-    }
-
-    if true {
-        let mut countdown = 0;
-        if true {
-            countdown = 10;
-        }
-
-        if countdown > 7 {
-            countdown -= 4;
-        }
-        else if countdown > 2 {
-            if countdown < 1 || countdown > 5 || countdown != 9 {
-                countdown = 0;
-            }
-            countdown -= 5;
-        } else {
-            return;
-        }
-    }
-
-    let mut countdown = 0;
-    if true {
-        countdown = 1;
-    }
-
-    let z = if countdown > 7 {
-        countdown -= 4;
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-    } else {
-        let should_be_reachable = countdown;
-        println!("reached");
-        return;
-    };
-
-    let w = if countdown > 7 {
-        countdown -= 4;
-    } else if countdown > 2 {
-        if countdown < 1 || countdown > 5 || countdown != 9 {
-            countdown = 0;
-        }
-        countdown -= 5;
-    } else {
-        return;
-    };
-}
diff --git a/tests/run-coverage/continue.rs b/tests/run-coverage/continue.rs
deleted file mode 100644
index 624aa98341b..00000000000
--- a/tests/run-coverage/continue.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    let is_true = std::env::args().len() == 1;
-
-    let mut x = 0;
-    for _ in 0..10 {
-        match is_true {
-            true => {
-                continue;
-            }
-            _ => {
-                x = 1;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            false => {
-                x = 1;
-            }
-            _ => {
-                continue;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            true => {
-                x = 1;
-            }
-            _ => {
-                continue;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        if is_true {
-            continue;
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            false => {
-                x = 1;
-            }
-            _ => {
-                let _ = x;
-            }
-        }
-        x = 3;
-    }
-    for _ in 0..10 {
-        match is_true {
-            false => {
-                x = 1;
-            }
-            _ => {
-                break;
-            }
-        }
-        x = 3;
-    }
-    let _ = x;
-}
diff --git a/tests/run-coverage/coroutine.rs b/tests/run-coverage/coroutine.rs
deleted file mode 100644
index 86d19af6f4f..00000000000
--- a/tests/run-coverage/coroutine.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![feature(coroutines, coroutine_trait)]
-
-use std::ops::{Coroutine, CoroutineState};
-use std::pin::Pin;
-
-// The following implementation of a function called from a `yield` statement
-// (apparently requiring the Result and the `String` type or constructor)
-// creates conditions where the `coroutine::StateTransform` MIR transform will
-// drop all `Counter` `Coverage` statements from a MIR. `simplify.rs` has logic
-// to handle this condition, and still report dead block coverage.
-fn get_u32(val: bool) -> Result<u32, String> {
-    if val { Ok(1) } else { Err(String::from("some error")) }
-}
-
-fn main() {
-    let is_true = std::env::args().len() == 1;
-    let mut coroutine = || {
-        yield get_u32(is_true);
-        return "foo";
-    };
-
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(Ok(1)) => {}
-        _ => panic!("unexpected return from resume"),
-    }
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Complete("foo") => {}
-        _ => panic!("unexpected return from resume"),
-    }
-}
diff --git a/tests/run-coverage/dead_code.rs b/tests/run-coverage/dead_code.rs
deleted file mode 100644
index 3492712a6f9..00000000000
--- a/tests/run-coverage/dead_code.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![allow(dead_code, unused_assignments, unused_variables)]
-
-pub fn unused_pub_fn_not_in_library() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-}
-
-fn unused_fn() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-}
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-}
diff --git a/tests/run-coverage/drop_trait.rs b/tests/run-coverage/drop_trait.rs
deleted file mode 100644
index 7b062719c6b..00000000000
--- a/tests/run-coverage/drop_trait.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-struct Firework {
-    strength: i32,
-}
-
-impl Drop for Firework {
-    fn drop(&mut self) {
-        println!("BOOM times {}!!!", self.strength);
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let _firecracker = Firework { strength: 1 };
-
-    let _tnt = Firework { strength: 100 };
-
-    if true {
-        println!("Exiting with error...");
-        return Err(1);
-    }
-
-    let _ = Firework { strength: 1000 };
-
-    Ok(())
-}
-
-// Expected program output:
-//   Exiting with error...
-//   BOOM times 100!!!
-//   BOOM times 1!!!
-//   Error: 1
diff --git a/tests/run-coverage/fn_sig_into_try.rs b/tests/run-coverage/fn_sig_into_try.rs
deleted file mode 100644
index 92850c8a188..00000000000
--- a/tests/run-coverage/fn_sig_into_try.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![feature(coverage_attribute)]
-// compile-flags: --edition=2021
-
-// Regression test for inconsistent handling of function signature spans that
-// are followed by code using the `?` operator.
-//
-// For each of these similar functions, the line containing the function
-// signature should be handled in the same way.
-
-fn a() -> Option<i32>
-{
-    Some(7i32);
-    Some(0)
-}
-
-fn b() -> Option<i32>
-{
-    Some(7i32)?;
-    Some(0)
-}
-
-fn c() -> Option<i32>
-{
-    let _ = Some(7i32)?;
-    Some(0)
-}
-
-fn d() -> Option<i32>
-{
-    let _: () = ();
-    Some(7i32)?;
-    Some(0)
-}
-
-#[coverage(off)]
-fn main() {
-    a();
-    b();
-    c();
-    d();
-}
diff --git a/tests/run-coverage/generics.rs b/tests/run-coverage/generics.rs
deleted file mode 100644
index bf4c2d8d685..00000000000
--- a/tests/run-coverage/generics.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-struct Firework<T> where T: Copy + std::fmt::Display {
-    strength: T,
-}
-
-impl<T> Firework<T> where T: Copy + std::fmt::Display {
-    #[inline(always)]
-    fn set_strength(&mut self, new_strength: T) {
-        self.strength = new_strength;
-    }
-}
-
-impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display {
-    #[inline(always)]
-    fn drop(&mut self) {
-        println!("BOOM times {}!!!", self.strength);
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let mut firecracker = Firework { strength: 1 };
-    firecracker.set_strength(2);
-
-    let mut tnt = Firework { strength: 100.1 };
-    tnt.set_strength(200.1);
-    tnt.set_strength(300.3);
-
-    if true {
-        println!("Exiting with error...");
-        return Err(1);
-    }
-
-    let _ = Firework { strength: 1000 };
-
-    Ok(())
-}
-
-// Expected program output:
-//   Exiting with error...
-//   BOOM times 100!!!
-//   BOOM times 1!!!
-//   Error: 1
diff --git a/tests/run-coverage/if.rs b/tests/run-coverage/if.rs
deleted file mode 100644
index 8ad5042ff7b..00000000000
--- a/tests/run-coverage/if.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let
-    is_true
-    =
-        std::env::args().len()
-    ==
-        1
-    ;
-    let
-        mut
-    countdown
-    =
-        0
-    ;
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-}
diff --git a/tests/run-coverage/if_else.rs b/tests/run-coverage/if_else.rs
deleted file mode 100644
index 3244e1e3afd..00000000000
--- a/tests/run-coverage/if_else.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-    else // Note coverage region difference without semicolon
-    {
-        countdown
-        =
-            100
-    }
-
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-    else
-    {
-        countdown
-        =
-            100
-        ;
-    }
-}
diff --git a/tests/run-coverage/inline-dead.rs b/tests/run-coverage/inline-dead.rs
deleted file mode 100644
index 854fa062967..00000000000
--- a/tests/run-coverage/inline-dead.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Regression test for issue #98833.
-// compile-flags: -Zinline-mir -Cdebug-assertions=off
-
-fn main() {
-    println!("{}", live::<false>());
-
-    let f = |x: bool| {
-        debug_assert!(
-            x
-        );
-    };
-    f(false);
-}
-
-#[inline]
-fn live<const B: bool>() -> u32 {
-    if B {
-        dead()
-    } else {
-        0
-    }
-}
-
-#[inline]
-fn dead() -> u32 {
-    42
-}
diff --git a/tests/run-coverage/inline.rs b/tests/run-coverage/inline.rs
deleted file mode 100644
index 9cfab9ddbad..00000000000
--- a/tests/run-coverage/inline.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-// compile-flags: -Zinline-mir
-
-use std::fmt::Display;
-
-fn main() {
-    permutations(&['a', 'b', 'c']);
-}
-
-#[inline(always)]
-fn permutations<T: Copy + Display>(xs: &[T]) {
-    let mut ys = xs.to_owned();
-    permutate(&mut ys, 0);
-}
-
-fn permutate<T: Copy + Display>(xs: &mut [T], k: usize) {
-    let n = length(xs);
-    if k == n {
-        display(xs);
-    } else if k < n {
-        for i in k..n {
-            swap(xs, i, k);
-            permutate(xs, k + 1);
-            swap(xs, i, k);
-        }
-    } else {
-        error();
-    }
-}
-
-fn length<T>(xs: &[T]) -> usize {
-    xs.len()
-}
-
-#[inline]
-fn swap<T: Copy>(xs: &mut [T], i: usize, j: usize) {
-    let t = xs[i];
-    xs[i] = xs[j];
-    xs[j] = t;
-}
-
-fn display<T: Display>(xs: &[T]) {
-    for x in xs {
-        print!("{}", x);
-    }
-    println!();
-}
-
-#[inline(always)]
-fn error() {
-    panic!("error");
-}
diff --git a/tests/run-coverage/inner_items.rs b/tests/run-coverage/inner_items.rs
deleted file mode 100644
index bcb62b3031c..00000000000
--- a/tests/run-coverage/inner_items.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-#![allow(unused_assignments, unused_variables, dead_code)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-    if is_true {
-        countdown = 10;
-    }
-
-    mod in_mod {
-        const IN_MOD_CONST: u32 = 1000;
-    }
-
-    fn in_func(a: u32) {
-        let b = 1;
-        let c = a + b;
-        println!("c = {}", c)
-    }
-
-    struct InStruct {
-        in_struct_field: u32,
-    }
-
-    const IN_CONST: u32 = 1234;
-
-    trait InTrait {
-        fn trait_func(&mut self, incr: u32);
-
-        fn default_trait_func(&mut self) {
-            in_func(IN_CONST);
-            self.trait_func(IN_CONST);
-        }
-    }
-
-    impl InTrait for InStruct {
-        fn trait_func(&mut self, incr: u32) {
-            self.in_struct_field += incr;
-            in_func(self.in_struct_field);
-        }
-    }
-
-    type InType = String;
-
-    if is_true {
-        in_func(countdown);
-    }
-
-    let mut val = InStruct {
-        in_struct_field: 101,
-    };
-
-    val.default_trait_func();
-}
diff --git a/tests/run-coverage/issue-83601.rs b/tests/run-coverage/issue-83601.rs
deleted file mode 100644
index 0b72a81947c..00000000000
--- a/tests/run-coverage/issue-83601.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Shows that rust-lang/rust/83601 is resolved
-
-#[derive(Debug, PartialEq, Eq)]
-struct Foo(u32);
-
-fn main() {
-    let bar = Foo(1);
-    assert_eq!(bar, Foo(1));
-    let baz = Foo(0);
-    assert_ne!(baz, Foo(1));
-    println!("{:?}", Foo(1));
-    println!("{:?}", bar);
-    println!("{:?}", baz);
-}
diff --git a/tests/run-coverage/issue-84561.rs b/tests/run-coverage/issue-84561.rs
deleted file mode 100644
index facf5b5b4cf..00000000000
--- a/tests/run-coverage/issue-84561.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-// This demonstrated Issue #84561: function-like macros produce unintuitive coverage results.
-
-// failure-status: 101
-#[derive(PartialEq, Eq)]
-struct Foo(u32);
-fn test3() {
-    let is_true = std::env::args().len() == 1;
-    let bar = Foo(1);
-    assert_eq!(bar, Foo(1));
-    let baz = Foo(0);
-    assert_ne!(baz, Foo(1));
-    println!("{:?}", Foo(1));
-    println!("{:?}", bar);
-    println!("{:?}", baz);
-
-    assert_eq!(Foo(1), Foo(1));
-    assert_ne!(Foo(0), Foo(1));
-    assert_eq!(Foo(2), Foo(2));
-    let bar = Foo(0);
-    assert_ne!(bar, Foo(3));
-    assert_ne!(Foo(0), Foo(4));
-    assert_eq!(Foo(3), Foo(3), "with a message");
-    println!("{:?}", bar);
-    println!("{:?}", Foo(1));
-
-    assert_ne!(Foo(0), Foo(5), "{}", if is_true { "true message" } else { "false message" });
-    assert_ne!(
-        Foo(0)
-        ,
-        Foo(5)
-        ,
-        "{}"
-        ,
-        if
-        is_true
-        {
-            "true message"
-        } else {
-            "false message"
-        }
-    );
-
-    let is_true = std::env::args().len() == 1;
-
-    assert_eq!(
-        Foo(1),
-        Foo(1)
-    );
-    assert_ne!(
-        Foo(0),
-        Foo(1)
-    );
-    assert_eq!(
-        Foo(2),
-        Foo(2)
-    );
-    let bar = Foo(1);
-    assert_ne!(
-        bar,
-        Foo(3)
-    );
-    if is_true {
-        assert_ne!(
-            Foo(0),
-            Foo(4)
-        );
-    } else {
-        assert_eq!(
-            Foo(3),
-            Foo(3)
-        );
-    }
-    if is_true {
-        assert_ne!(
-            Foo(0),
-            Foo(4),
-            "with a message"
-        );
-    } else {
-        assert_eq!(
-            Foo(3),
-            Foo(3),
-            "with a message"
-        );
-    }
-    assert_ne!(
-        if is_true {
-            Foo(0)
-        } else {
-            Foo(1)
-        },
-        Foo(5)
-    );
-    assert_ne!(
-        Foo(5),
-        if is_true {
-            Foo(0)
-        } else {
-            Foo(1)
-        }
-    );
-    assert_ne!(
-        if is_true {
-            assert_eq!(
-                Foo(3),
-                Foo(3)
-            );
-            Foo(0)
-        } else {
-            assert_ne!(
-                if is_true {
-                    Foo(0)
-                } else {
-                    Foo(1)
-                },
-                Foo(5)
-            );
-            Foo(1)
-        },
-        Foo(5),
-        "with a message"
-    );
-    assert_eq!(
-        Foo(1),
-        Foo(3),
-        "this assert should fail"
-    );
-    assert_eq!(
-        Foo(3),
-        Foo(3),
-        "this assert should not be reached"
-    );
-}
-
-impl std::fmt::Debug for Foo {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "try and succeed")?;
-        Ok(())
-    }
-}
-
-static mut DEBUG_LEVEL_ENABLED: bool = false;
-
-macro_rules! debug {
-    ($($arg:tt)+) => (
-        if unsafe { DEBUG_LEVEL_ENABLED } {
-            println!($($arg)+);
-        }
-    );
-}
-
-fn test1() {
-    debug!("debug is enabled");
-    debug!("debug is enabled");
-    let _ = 0;
-    debug!("debug is enabled");
-    unsafe {
-        DEBUG_LEVEL_ENABLED = true;
-    }
-    debug!("debug is enabled");
-}
-
-macro_rules! call_debug {
-    ($($arg:tt)+) => (
-        fn call_print(s: &str) {
-            print!("{}", s);
-        }
-
-        call_print("called from call_debug: ");
-        debug!($($arg)+);
-    );
-}
-
-fn test2() {
-    call_debug!("debug is enabled");
-}
-
-fn main() {
-    test1();
-    test2();
-    test3();
-}
diff --git a/tests/run-coverage/issue-93054.rs b/tests/run-coverage/issue-93054.rs
deleted file mode 100644
index da546cfeef8..00000000000
--- a/tests/run-coverage/issue-93054.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![allow(dead_code, unreachable_code)]
-
-// Regression test for #93054: Functions using uninhabited types often only have a single,
-// unreachable basic block which doesn't get instrumented. This should not cause llvm-cov to fail.
-// Since these kinds functions can't be invoked anyway, it's ok to not have coverage data for them.
-
-// compile-flags: --edition=2021
-
-enum Never {}
-
-impl Never {
-    fn foo(self) {
-        match self {}
-        make().map(|never| match never {});
-    }
-
-    fn bar(&self) {
-        match *self {}
-    }
-}
-
-async fn foo2(never: Never) {
-    match never {}
-}
-
-fn make() -> Option<Never> {
-    None
-}
-
-fn main() {}
diff --git a/tests/run-coverage/lazy_boolean.rs b/tests/run-coverage/lazy_boolean.rs
deleted file mode 100644
index bb6219e851c..00000000000
--- a/tests/run-coverage/lazy_boolean.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let (mut a, mut b, mut c) = (0, 0, 0);
-    if is_true {
-        a = 1;
-        b = 10;
-        c = 100;
-    }
-    let
-        somebool
-        =
-            a < b
-        ||
-            b < c
-    ;
-    let
-        somebool
-        =
-            b < a
-        ||
-            b < c
-    ;
-    let somebool = a < b && b < c;
-    let somebool = b < a && b < c;
-
-    if
-        !
-        is_true
-    {
-        a = 2
-        ;
-    }
-
-    if
-        is_true
-    {
-        b = 30
-        ;
-    }
-    else
-    {
-        c = 400
-        ;
-    }
-
-    if !is_true {
-        a = 2;
-    }
-
-    if is_true {
-        b = 30;
-    } else {
-        c = 400;
-    }
-}
diff --git a/tests/run-coverage/loop_break_value.rs b/tests/run-coverage/loop_break_value.rs
deleted file mode 100644
index dbc4fad7a23..00000000000
--- a/tests/run-coverage/loop_break_value.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    let result
-        =
-            loop
-        {
-            break
-            10
-            ;
-        }
-    ;
-}
diff --git a/tests/run-coverage/loops_branches.rs b/tests/run-coverage/loops_branches.rs
deleted file mode 100644
index f3a343bcc1f..00000000000
--- a/tests/run-coverage/loops_branches.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-#![allow(unused_assignments, unused_variables, while_true)]
-
-// This test confirms that (1) unexecuted infinite loops are handled correctly by the
-// InstrumentCoverage MIR pass; and (2) Counter Expressions that subtract from zero can be dropped.
-
-struct DebugTest;
-
-impl std::fmt::Debug for DebugTest {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        if true {
-            if false {
-                while true {}
-            }
-            write!(f, "cool")?;
-        } else {
-        }
-
-        for i in 0..10 {
-            if true {
-                if false {
-                    while true {}
-                }
-                write!(f, "cool")?;
-            } else {
-            }
-        }
-        Ok(())
-    }
-}
-
-struct DisplayTest;
-
-impl std::fmt::Display for DisplayTest {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        if false {
-        } else {
-            if false {
-                while true {}
-            }
-            write!(f, "cool")?;
-        }
-        for i in 0..10 {
-            if false {
-            } else {
-                if false {
-                    while true {}
-                }
-                write!(f, "cool")?;
-            }
-        }
-        Ok(())
-    }
-}
-
-fn main() {
-    let debug_test = DebugTest;
-    println!("{:?}", debug_test);
-    let display_test = DisplayTest;
-    println!("{}", display_test);
-}
diff --git a/tests/run-coverage/match_or_pattern.rs b/tests/run-coverage/match_or_pattern.rs
deleted file mode 100644
index ab7aee51d1b..00000000000
--- a/tests/run-coverage/match_or_pattern.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut a: u8 = 0;
-    let mut b: u8 = 0;
-    if is_true {
-        a = 2;
-        b = 0;
-    }
-    match (a, b) {
-        // Or patterns generate MIR `SwitchInt` with multiple targets to the same `BasicBlock`.
-        // This test confirms a fix for Issue #79569.
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-    if is_true {
-        a = 0;
-        b = 0;
-    }
-    match (a, b) {
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-    if is_true {
-        a = 2;
-        b = 2;
-    }
-    match (a, b) {
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-    if is_true {
-        a = 0;
-        b = 2;
-    }
-    match (a, b) {
-        (0 | 1, 2 | 3) => {}
-        _ => {}
-    }
-}
diff --git a/tests/run-coverage/nested_loops.rs b/tests/run-coverage/nested_loops.rs
deleted file mode 100644
index 4c7c7842796..00000000000
--- a/tests/run-coverage/nested_loops.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-fn main() {
-    let is_true = std::env::args().len() == 1;
-    let mut countdown = 10;
-
-    'outer: while countdown > 0 {
-        let mut a = 100;
-        let mut b = 100;
-        for _ in 0..50 {
-            if a < 30 {
-                break;
-            }
-            a -= 5;
-            b -= 5;
-            if b < 90 {
-                a -= 10;
-                if is_true {
-                    break 'outer;
-                } else {
-                    a -= 2;
-                }
-            }
-        }
-        countdown -= 1;
-    }
-}
diff --git a/tests/run-coverage/no_cov_crate.rs b/tests/run-coverage/no_cov_crate.rs
deleted file mode 100644
index e12e4bc55e3..00000000000
--- a/tests/run-coverage/no_cov_crate.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Enables `coverage(off)` on the entire crate
-#![feature(coverage_attribute)]
-
-#[coverage(off)]
-fn do_not_add_coverage_1() {
-    println!("called but not covered");
-}
-
-fn do_not_add_coverage_2() {
-    #![coverage(off)]
-    println!("called but not covered");
-}
-
-#[coverage(off)]
-#[allow(dead_code)]
-fn do_not_add_coverage_not_called() {
-    println!("not called and not covered");
-}
-
-fn add_coverage_1() {
-    println!("called and covered");
-}
-
-fn add_coverage_2() {
-    println!("called and covered");
-}
-
-#[allow(dead_code)]
-fn add_coverage_not_called() {
-    println!("not called but covered");
-}
-
-// FIXME: These test-cases illustrate confusing results of nested functions.
-// See https://github.com/rust-lang/rust/issues/93319
-mod nested_fns {
-    #[coverage(off)]
-    pub fn outer_not_covered(is_true: bool) {
-        fn inner(is_true: bool) {
-            if is_true {
-                println!("called and covered");
-            } else {
-                println!("absolutely not covered");
-            }
-        }
-        println!("called but not covered");
-        inner(is_true);
-    }
-
-    pub fn outer(is_true: bool) {
-        println!("called and covered");
-        inner_not_covered(is_true);
-
-        #[coverage(off)]
-        fn inner_not_covered(is_true: bool) {
-            if is_true {
-                println!("called but not covered");
-            } else {
-                println!("absolutely not covered");
-            }
-        }
-    }
-
-    pub fn outer_both_covered(is_true: bool) {
-        println!("called and covered");
-        inner(is_true);
-
-        fn inner(is_true: bool) {
-            if is_true {
-                println!("called and covered");
-            } else {
-                println!("absolutely not covered");
-            }
-        }
-    }
-}
-
-fn main() {
-    let is_true = std::env::args().len() == 1;
-
-    do_not_add_coverage_1();
-    do_not_add_coverage_2();
-    add_coverage_1();
-    add_coverage_2();
-
-    nested_fns::outer_not_covered(is_true);
-    nested_fns::outer(is_true);
-    nested_fns::outer_both_covered(is_true);
-}
diff --git a/tests/run-coverage/panic_unwind.rs b/tests/run-coverage/panic_unwind.rs
deleted file mode 100644
index 638d2eb6aaa..00000000000
--- a/tests/run-coverage/panic_unwind.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 101
-
-fn might_panic(should_panic: bool) {
-    if should_panic {
-        println!("panicking...");
-        panic!("panics");
-    } else {
-        println!("Don't Panic");
-    }
-}
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while countdown > 0 {
-        if countdown == 1 {
-            might_panic(true);
-        } else if countdown < 5 {
-            might_panic(false);
-        }
-        countdown -= 1;
-    }
-    Ok(())
-}
-
-// Notes:
-//   1. Compare this program and its coverage results to those of the similar tests `abort.rs` and
-//      `try_error_result.rs`.
-//   2. Since the `panic_unwind.rs` test is allowed to unwind, it is also allowed to execute the
-//      normal program exit cleanup, including writing out the current values of the coverage
-//      counters.
diff --git a/tests/run-coverage/partial_eq.rs b/tests/run-coverage/partial_eq.rs
deleted file mode 100644
index dd8b42c18ce..00000000000
--- a/tests/run-coverage/partial_eq.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// This test confirms an earlier problem was resolved, supporting the MIR graph generated by the
-// structure of this test.
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Version {
-    major: usize,
-    minor: usize,
-    patch: usize,
-}
-
-impl Version {
-    pub fn new(major: usize, minor: usize, patch: usize) -> Self {
-        Self {
-            major,
-            minor,
-            patch,
-        }
-    }
-}
-
-fn main() {
-    let version_3_2_1 = Version::new(3, 2, 1);
-    let version_3_3_0 = Version::new(3, 3, 0);
-
-    println!("{:?} < {:?} = {}", version_3_2_1, version_3_3_0, version_3_2_1 < version_3_3_0);
-}
-
-/*
-
-This test verifies a bug was fixed that otherwise generated this error:
-
-thread 'rustc' panicked at 'No counters provided the source_hash for function:
-    Instance {
-        def: Item(WithOptConstParam {
-            did: DefId(0:101 ~ autocfg[c44a]::version::{impl#2}::partial_cmp),
-            const_param_did: None
-        }),
-        args: []
-    }'
-The `PartialOrd` derived by `Version` happened to generate a MIR that generated coverage
-without a code region associated with any `Counter`. Code regions were associated with at least
-one expression, which is allowed, but the `function_source_hash` was only passed to the codegen
-(coverage mapgen) phase from a `Counter`s code region. A new method was added to pass the
-`function_source_hash` without a code region, if necessary.
-
-*/
diff --git a/tests/run-coverage/simple_loop.rs b/tests/run-coverage/simple_loop.rs
deleted file mode 100644
index 6f7f23475b8..00000000000
--- a/tests/run-coverage/simple_loop.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#![allow(unused_assignments)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 0;
-
-    if
-        is_true
-    {
-        countdown
-        =
-            10
-        ;
-    }
-
-    loop
-    {
-        if
-            countdown
-                ==
-            0
-        {
-            break
-            ;
-        }
-        countdown
-        -=
-        1
-        ;
-    }
-}
diff --git a/tests/run-coverage/simple_match.rs b/tests/run-coverage/simple_match.rs
deleted file mode 100644
index be99e59a826..00000000000
--- a/tests/run-coverage/simple_match.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#![allow(unused_assignments, unused_variables)]
-
-fn main() {
-    // Initialize test constants in a way that cannot be determined at compile time, to ensure
-    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
-    // dependent conditions.
-    let is_true = std::env::args().len() == 1;
-
-    let mut countdown = 1;
-    if is_true {
-        countdown = 0;
-    }
-
-    for
-        _
-    in
-        0..2
-    {
-        let z
-        ;
-        match
-            countdown
-        {
-            x
-            if
-                x
-                    <
-                1
-            =>
-            {
-                z = countdown
-                ;
-                let y = countdown
-                ;
-                countdown = 10
-                ;
-            }
-            _
-            =>
-            {}
-        }
-    }
-}
diff --git a/tests/run-coverage/test_harness.rs b/tests/run-coverage/test_harness.rs
deleted file mode 100644
index 12a755734c1..00000000000
--- a/tests/run-coverage/test_harness.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Verify that the entry point injected by the test harness doesn't cause
-// weird artifacts in the coverage report (e.g. issue #10749).
-
-// compile-flags: --test
-
-#[allow(dead_code)]
-fn unused() {}
-
-#[test]
-fn my_test() {}
diff --git a/tests/run-coverage/tight_inf_loop.rs b/tests/run-coverage/tight_inf_loop.rs
deleted file mode 100644
index cef99027aaa..00000000000
--- a/tests/run-coverage/tight_inf_loop.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
-    if false {
-        loop {}
-    }
-}
diff --git a/tests/run-coverage/try_error_result.rs b/tests/run-coverage/try_error_result.rs
deleted file mode 100644
index 557cbf22bfa..00000000000
--- a/tests/run-coverage/try_error_result.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-fn call(return_error: bool) -> Result<(), ()> {
-    if return_error {
-        Err(())
-    } else {
-        Ok(())
-    }
-}
-
-fn test1() -> Result<(), ()> {
-    let mut
-        countdown = 10
-    ;
-    for
-        _
-    in
-        0..10
-    {
-        countdown
-            -= 1
-        ;
-        if
-            countdown < 5
-        {
-            call(/*return_error=*/ true)?;
-            call(/*return_error=*/ false)?;
-        }
-        else
-        {
-            call(/*return_error=*/ false)?;
-        }
-    }
-    Ok(())
-}
-
-struct Thing1;
-impl Thing1 {
-    fn get_thing_2(&self, return_error: bool) -> Result<Thing2, ()> {
-        if return_error {
-            Err(())
-        } else {
-            Ok(Thing2 {})
-        }
-    }
-}
-
-struct Thing2;
-impl Thing2 {
-    fn call(&self, return_error: bool) -> Result<u32, ()> {
-        if return_error {
-            Err(())
-        } else {
-            Ok(57)
-        }
-    }
-}
-
-fn test2() -> Result<(), ()> {
-    let thing1 = Thing1{};
-    let mut
-        countdown = 10
-    ;
-    for
-        _
-    in
-        0..10
-    {
-        countdown
-            -= 1
-        ;
-        if
-            countdown < 5
-        {
-            thing1.get_thing_2(/*err=*/ false)?.call(/*err=*/ true).expect_err("call should fail");
-            thing1
-                .
-                get_thing_2(/*return_error=*/ false)
-                ?
-                .
-                call(/*return_error=*/ true)
-                .
-                expect_err(
-                    "call should fail"
-                );
-            let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ true)?;
-            assert_eq!(val, 57);
-            let val = thing1.get_thing_2(/*return_error=*/ true)?.call(/*return_error=*/ false)?;
-            assert_eq!(val, 57);
-        }
-        else
-        {
-            let val = thing1.get_thing_2(/*return_error=*/ false)?.call(/*return_error=*/ false)?;
-            assert_eq!(val, 57);
-            let val = thing1
-                .get_thing_2(/*return_error=*/ false)?
-                .call(/*return_error=*/ false)?;
-            assert_eq!(val, 57);
-            let val = thing1
-                .get_thing_2(/*return_error=*/ false)
-                ?
-                .call(/*return_error=*/ false)
-                ?
-                ;
-            assert_eq!(val, 57);
-        }
-    }
-    Ok(())
-}
-
-fn main() -> Result<(), ()> {
-    test1().expect_err("test1 should fail");
-    test2()
-    ?
-    ;
-    Ok(())
-}
diff --git a/tests/run-coverage/unreachable.rs b/tests/run-coverage/unreachable.rs
deleted file mode 100644
index 6385bfa160d..00000000000
--- a/tests/run-coverage/unreachable.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![feature(core_intrinsics)]
-#![feature(coverage_attribute)]
-// compile-flags: --edition=2021
-
-// <https://github.com/rust-lang/rust/issues/116171>
-// If we instrument a function for coverage, but all of its counter-increment
-// statements are removed by MIR optimizations, LLVM will think it isn't
-// instrumented and it will disappear from coverage maps and coverage reports.
-// Most MIR opts won't cause this because they tend not to remove statements
-// from bb0, but `UnreachablePropagation` can do so if it sees that bb0 ends
-// with `TerminatorKind::Unreachable`.
-
-use std::hint::{black_box, unreachable_unchecked};
-
-static UNREACHABLE_CLOSURE: fn() = || unsafe { unreachable_unchecked() };
-
-fn unreachable_function() {
-    unsafe { unreachable_unchecked() }
-}
-
-// Use an intrinsic to more reliably trigger unreachable-propagation.
-fn unreachable_intrinsic() {
-    unsafe { std::intrinsics::unreachable() }
-}
-
-#[coverage(off)]
-fn main() {
-    if black_box(false) {
-        UNREACHABLE_CLOSURE();
-    }
-    if black_box(false) {
-        unreachable_function();
-    }
-    if black_box(false) {
-        unreachable_intrinsic();
-    }
-}
diff --git a/tests/run-coverage/unused.rs b/tests/run-coverage/unused.rs
deleted file mode 100644
index d985af13547..00000000000
--- a/tests/run-coverage/unused.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#![allow(dead_code, unused_assignments, unused_must_use, unused_variables)]
-
-fn foo<T>(x: T) {
-    let mut i = 0;
-    while i < 10 {
-        i != 0 || i != 0;
-        i += 1;
-    }
-}
-
-fn unused_template_func<T>(x: T) {
-    let mut i = 0;
-    while i < 10 {
-        i != 0 || i != 0;
-        i += 1;
-    }
-}
-
-fn unused_func(mut a: u32) {
-    if a != 0 {
-        a += 1;
-    }
-}
-
-fn unused_func2(mut a: u32) {
-    if a != 0 {
-        a += 1;
-    }
-}
-
-fn unused_func3(mut a: u32) {
-    if a != 0 {
-        a += 1;
-    }
-}
-
-fn main() -> Result<(), u8> {
-    foo::<u32>(0);
-    foo::<f32>(0.0);
-    Ok(())
-}
diff --git a/tests/run-coverage/while.rs b/tests/run-coverage/while.rs
deleted file mode 100644
index 781b90b3566..00000000000
--- a/tests/run-coverage/while.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
-    let num = 9;
-    while num >= 10 {
-    }
-}
diff --git a/tests/run-coverage/while_early_ret.rs b/tests/run-coverage/while_early_ret.rs
deleted file mode 100644
index b2f0eee2cc0..00000000000
--- a/tests/run-coverage/while_early_ret.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#![allow(unused_assignments)]
-// failure-status: 1
-
-fn main() -> Result<(), u8> {
-    let mut countdown = 10;
-    while
-        countdown
-            >
-        0
-    {
-        if
-            countdown
-                <
-            5
-        {
-            return
-                if
-                    countdown
-                        >
-                    8
-                {
-                    Ok(())
-                }
-                else
-                {
-                    Err(1)
-                }
-                ;
-        }
-        countdown
-            -=
-        1
-        ;
-    }
-    Ok(())
-}
-
-// ISSUE(77553): Originally, this test had `Err(1)` on line 22 (instead of `Ok(())`) and
-// `std::process::exit(2)` on line 26 (instead of `Err(1)`); and this worked as expected on Linux
-// and MacOS. But on Windows (MSVC, at least), the call to `std::process::exit()` exits the program
-// without saving the InstrProf coverage counters. The use of `std::process:exit()` is not critical
-// to the coverage test for early returns, but this is a limitation that should be fixed.
diff --git a/tests/run-coverage/yield.rs b/tests/run-coverage/yield.rs
deleted file mode 100644
index b7e2ba31b59..00000000000
--- a/tests/run-coverage/yield.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![feature(coroutines, coroutine_trait)]
-#![allow(unused_assignments)]
-
-use std::ops::{Coroutine, CoroutineState};
-use std::pin::Pin;
-
-fn main() {
-    let mut coroutine = || {
-        yield 1;
-        return "foo";
-    };
-
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(1) => {}
-        _ => panic!("unexpected value from resume"),
-    }
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Complete("foo") => {}
-        _ => panic!("unexpected value from resume"),
-    }
-
-    let mut coroutine = || {
-        yield 1;
-        yield 2;
-        yield 3;
-        return "foo";
-    };
-
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(1) => {}
-        _ => panic!("unexpected value from resume"),
-    }
-    match Pin::new(&mut coroutine).resume(()) {
-        CoroutineState::Yielded(2) => {}
-        _ => panic!("unexpected value from resume"),
-    }
-}