diff --git a/tests/run-coverage-rustdoc/doctest.coverage b/tests/run-coverage-rustdoc/doctest.coverage
index 07f1e6b3ee5d9..5797784f411cc 100644
--- a/tests/run-coverage-rustdoc/doctest.coverage
+++ b/tests/run-coverage-rustdoc/doctest.coverage
@@ -10,6 +10,8 @@ $DIR/auxiliary/doctest_crate.rs:
    LL|      3|}
 
 $DIR/doctest.rs:
+   LL|       |// aux-build:doctest_crate.rs
+   LL|       |
    LL|       |//! This test ensures that code from doctests is properly re-mapped.
    LL|       |//! See <https://github.com/rust-lang/rust/issues/79417> for more info.
    LL|       |//!
@@ -78,7 +80,7 @@ $DIR/doctest.rs:
    LL|       |//!     doctest_main()
    LL|       |//! }
    LL|       |//! ```
-   LL|       |// aux-build:doctest_crate.rs
+   LL|       |
    LL|       |/// doctest attached to fn testing external code:
    LL|       |/// ```
    LL|      1|/// extern crate doctest_crate;
diff --git a/tests/run-coverage-rustdoc/doctest.rs b/tests/run-coverage-rustdoc/doctest.rs
index 251b0c291e94d..4006d723ce02f 100644
--- a/tests/run-coverage-rustdoc/doctest.rs
+++ b/tests/run-coverage-rustdoc/doctest.rs
@@ -1,3 +1,5 @@
+// aux-build:doctest_crate.rs
+
 //! This test ensures that code from doctests is properly re-mapped.
 //! See <https://github.com/rust-lang/rust/issues/79417> for more info.
 //!
@@ -63,7 +65,7 @@
 //!     doctest_main()
 //! }
 //! ```
-// aux-build:doctest_crate.rs
+
 /// doctest attached to fn testing external code:
 /// ```
 /// extern crate doctest_crate;
diff --git a/tests/run-coverage/assert.coverage b/tests/run-coverage/assert.coverage
index 3c6108e436a1f..8b997724c4a75 100644
--- a/tests/run-coverage/assert.coverage
+++ b/tests/run-coverage/assert.coverage
@@ -7,7 +7,7 @@
                                                   ^1
    LL|      3|}
    LL|       |
-   LL|      1|fn main() -> Result<(),u8> {
+   LL|      1|fn main() -> Result<(), u8> {
    LL|      1|    let mut countdown = 10;
    LL|     11|    while countdown > 0 {
    LL|     11|        if countdown == 1 {
diff --git a/tests/run-coverage/assert.rs b/tests/run-coverage/assert.rs
index d32a37e078e42..85e6662a6adc8 100644
--- a/tests/run-coverage/assert.rs
+++ b/tests/run-coverage/assert.rs
@@ -6,7 +6,7 @@ fn might_fail_assert(one_plus_one: u32) {
     assert_eq!(1 + 1, one_plus_one, "the argument was wrong");
 }
 
-fn main() -> Result<(),u8> {
+fn main() -> Result<(), u8> {
     let mut countdown = 10;
     while countdown > 0 {
         if countdown == 1 {
diff --git a/tests/run-coverage/async2.coverage b/tests/run-coverage/async2.coverage
index 7e0139ae03623..fcb0a3aed64e7 100644
--- a/tests/run-coverage/async2.coverage
+++ b/tests/run-coverage/async2.coverage
@@ -1,11 +1,5 @@
    LL|       |// compile-flags: --edition=2018
    LL|       |
-   LL|       |use core::{
-   LL|       |    future::Future,
-   LL|       |    marker::Send,
-   LL|       |    pin::Pin,
-   LL|       |};
-   LL|       |
    LL|      1|fn non_async_func() {
    LL|      1|    println!("non_async_func was covered");
    LL|      1|    let b = true;
@@ -15,9 +9,6 @@
                    ^0
    LL|      1|}
    LL|       |
-   LL|       |
-   LL|       |
-   LL|       |
    LL|      1|async fn async_func() {
    LL|      1|    println!("async_func was covered");
    LL|      1|    let b = true;
@@ -27,9 +18,6 @@
                    ^0
    LL|      1|}
    LL|       |
-   LL|       |
-   LL|       |
-   LL|       |
    LL|      1|async fn async_func_just_println() {
    LL|      1|    println!("async_func_just_println was covered");
    LL|      1|}
diff --git a/tests/run-coverage/async2.rs b/tests/run-coverage/async2.rs
index 959d48ce9db16..2884ff297affd 100644
--- a/tests/run-coverage/async2.rs
+++ b/tests/run-coverage/async2.rs
@@ -1,11 +1,5 @@
 // compile-flags: --edition=2018
 
-use core::{
-    future::Future,
-    marker::Send,
-    pin::Pin,
-};
-
 fn non_async_func() {
     println!("non_async_func was covered");
     let b = true;
@@ -14,9 +8,6 @@ fn non_async_func() {
     }
 }
 
-
-
-
 async fn async_func() {
     println!("async_func was covered");
     let b = true;
@@ -25,9 +16,6 @@ async fn async_func() {
     }
 }
 
-
-
-
 async fn async_func_just_println() {
     println!("async_func_just_println was covered");
 }
diff --git a/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs b/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs
index 2b21dee6ccff6..9dc50dae25ae2 100644
--- a/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs
+++ b/tests/run-coverage/auxiliary/inline_always_with_dead_code.rs
@@ -4,9 +4,9 @@
 
 mod foo {
     #[inline(always)]
-    pub fn called() { }
+    pub fn called() {}
 
-    fn uncalled() { }
+    fn uncalled() {}
 }
 
 pub mod bar {
diff --git a/tests/run-coverage/auxiliary/unused_mod_helper.rs b/tests/run-coverage/auxiliary/unused_mod_helper.rs
index ae1cc1531ed75..88c5dac65cb50 100644
--- a/tests/run-coverage/auxiliary/unused_mod_helper.rs
+++ b/tests/run-coverage/auxiliary/unused_mod_helper.rs
@@ -1,3 +1,4 @@
+#[allow(dead_code)]
 pub fn never_called_function() {
     println!("I am never called");
 }
diff --git a/tests/run-coverage/auxiliary/used_crate.rs b/tests/run-coverage/auxiliary/used_crate.rs
index 16592d48ddacf..c086ef21e1a9f 100644
--- a/tests/run-coverage/auxiliary/used_crate.rs
+++ b/tests/run-coverage/auxiliary/used_crate.rs
@@ -1,6 +1,8 @@
 #![allow(unused_assignments, unused_variables)]
+// Verify that coverage works with optimizations:
 // compile-flags: -C opt-level=3
-use std::fmt::Debug; // ^^ validates coverage now works with optimizations
+
+use std::fmt::Debug;
 
 pub fn used_function() {
     // Initialize test constants in a way that cannot be determined at compile time, to ensure
@@ -42,6 +44,7 @@ pub fn unused_function() {
     }
 }
 
+#[allow(dead_code)]
 fn unused_private_function() {
     let is_true = std::env::args().len() == 1;
     let mut countdown = 2;
diff --git a/tests/run-coverage/auxiliary/used_inline_crate.rs b/tests/run-coverage/auxiliary/used_inline_crate.rs
index 8b8e9d5483f33..e8929de6b360a 100644
--- a/tests/run-coverage/auxiliary/used_inline_crate.rs
+++ b/tests/run-coverage/auxiliary/used_inline_crate.rs
@@ -1,7 +1,7 @@
 #![allow(unused_assignments, unused_variables)]
-
+// Verify that coverage works with optimizations:
 // compile-flags: -C opt-level=3
-// ^^ validates coverage now works with optimizations
+
 use std::fmt::Debug;
 
 pub fn used_function() {
@@ -29,12 +29,6 @@ pub fn used_inline_function() {
     use_this_lib_crate();
 }
 
-
-
-
-
-
-
 #[inline(always)]
 pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) {
     println!("used_only_from_bin_crate_generic_function with {:?}", arg);
@@ -71,6 +65,7 @@ pub fn unused_function() {
 }
 
 #[inline(always)]
+#[allow(dead_code)]
 fn unused_private_function() {
     let is_true = std::env::args().len() == 1;
     let mut countdown = 2;
diff --git a/tests/run-coverage/closure.coverage b/tests/run-coverage/closure.coverage
index 809cf1f482119..930348dc4315a 100644
--- a/tests/run-coverage/closure.coverage
+++ b/tests/run-coverage/closure.coverage
@@ -1,11 +1,16 @@
    LL|       |#![allow(unused_assignments, unused_variables)]
    LL|       |// compile-flags: -C opt-level=2
-   LL|      1|fn main() { // ^^ fix described in rustc_middle/mir/mono.rs
+   LL|       |
+   LL|       |// This test used to be sensitive to certain coverage-specific hacks in
+   LL|       |// `rustc_middle/mir/mono.rs`, but those hacks were later cleaned up by
+   LL|       |// <https://github.com/rust-lang/rust/pull/83666>.
+   LL|       |
+   LL|      1|fn main() {
    LL|      1|    // Initialize test constants in a way that cannot be determined at compile time, to ensure
    LL|      1|    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
    LL|      1|    // dependent conditions.
    LL|      1|    let is_true = std::env::args().len() == 1;
-   LL|      1|    let is_false = ! is_true;
+   LL|      1|    let is_false = !is_true;
    LL|      1|
    LL|      1|    let mut some_string = Some(String::from("the string content"));
    LL|      1|    println!(
diff --git a/tests/run-coverage/closure.rs b/tests/run-coverage/closure.rs
index eb3a1ebff8894..16a2c4e33bd48 100644
--- a/tests/run-coverage/closure.rs
+++ b/tests/run-coverage/closure.rs
@@ -1,11 +1,16 @@
 #![allow(unused_assignments, unused_variables)]
 // compile-flags: -C opt-level=2
-fn main() { // ^^ fix described in rustc_middle/mir/mono.rs
+
+// 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 is_false = !is_true;
 
     let mut some_string = Some(String::from("the string content"));
     println!(
diff --git a/tests/run-coverage/closure_macro_async.coverage b/tests/run-coverage/closure_macro_async.coverage
index 0e4365fc797dc..018e3160e4f79 100644
--- a/tests/run-coverage/closure_macro_async.coverage
+++ b/tests/run-coverage/closure_macro_async.coverage
@@ -42,7 +42,7 @@
    LL|       |
    LL|       |#[no_coverage]
    LL|       |fn main() {
-   LL|       |    executor::block_on(test());
+   LL|       |    executor::block_on(test()).unwrap();
    LL|       |}
    LL|       |
    LL|       |mod executor {
@@ -57,16 +57,12 @@
    LL|       |        let mut future = unsafe { Pin::new_unchecked(&mut future) };
    LL|       |        use std::hint::unreachable_unchecked;
    LL|       |        static VTABLE: RawWakerVTable = RawWakerVTable::new(
-   LL|       |
    LL|       |            #[no_coverage]
    LL|       |            |_| unsafe { unreachable_unchecked() }, // clone
-   LL|       |
    LL|       |            #[no_coverage]
    LL|       |            |_| unsafe { unreachable_unchecked() }, // wake
-   LL|       |
    LL|       |            #[no_coverage]
    LL|       |            |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-   LL|       |
    LL|       |            #[no_coverage]
    LL|       |            |_| (),
    LL|       |        );
diff --git a/tests/run-coverage/closure_macro_async.rs b/tests/run-coverage/closure_macro_async.rs
index e3e89e9c8b3c9..3d6bdb38a2ab1 100644
--- a/tests/run-coverage/closure_macro_async.rs
+++ b/tests/run-coverage/closure_macro_async.rs
@@ -41,7 +41,7 @@ pub async fn test() -> Result<(), String> {
 
 #[no_coverage]
 fn main() {
-    executor::block_on(test());
+    executor::block_on(test()).unwrap();
 }
 
 mod executor {
@@ -56,16 +56,12 @@ mod executor {
         let mut future = unsafe { Pin::new_unchecked(&mut future) };
         use std::hint::unreachable_unchecked;
         static VTABLE: RawWakerVTable = RawWakerVTable::new(
-
             #[no_coverage]
             |_| unsafe { unreachable_unchecked() }, // clone
-
             #[no_coverage]
             |_| unsafe { unreachable_unchecked() }, // wake
-
             #[no_coverage]
             |_| unsafe { unreachable_unchecked() }, // wake_by_ref
-
             #[no_coverage]
             |_| (),
         );
diff --git a/tests/run-coverage/conditions.coverage b/tests/run-coverage/conditions.coverage
index 4749c353a64ff..473335ff641a1 100644
--- a/tests/run-coverage/conditions.coverage
+++ b/tests/run-coverage/conditions.coverage
@@ -59,7 +59,6 @@
    LL|       |        }
    LL|      0|    }
    LL|       |
-   LL|       |
    LL|      1|    let mut countdown = 0;
    LL|      1|    if true {
    LL|      1|        countdown = 1;
diff --git a/tests/run-coverage/conditions.rs b/tests/run-coverage/conditions.rs
index 057599d1b471a..fa7f2a116c21e 100644
--- a/tests/run-coverage/conditions.rs
+++ b/tests/run-coverage/conditions.rs
@@ -55,7 +55,6 @@ fn main() {
         }
     }
 
-
     let mut countdown = 0;
     if true {
         countdown = 1;
diff --git a/tests/run-coverage/dead_code.coverage b/tests/run-coverage/dead_code.coverage
index 5074d8b3c3774..c4ee9f23f082f 100644
--- a/tests/run-coverage/dead_code.coverage
+++ b/tests/run-coverage/dead_code.coverage
@@ -1,4 +1,4 @@
-   LL|       |#![allow(unused_assignments, unused_variables)]
+   LL|       |#![allow(dead_code, unused_assignments, unused_variables)]
    LL|       |
    LL|      0|pub fn unused_pub_fn_not_in_library() {
    LL|      0|    // Initialize test constants in a way that cannot be determined at compile time, to ensure
diff --git a/tests/run-coverage/dead_code.rs b/tests/run-coverage/dead_code.rs
index a1285df0ec62a..3492712a6f98e 100644
--- a/tests/run-coverage/dead_code.rs
+++ b/tests/run-coverage/dead_code.rs
@@ -1,4 +1,4 @@
-#![allow(unused_assignments, unused_variables)]
+#![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
diff --git a/tests/run-coverage/drop_trait.coverage b/tests/run-coverage/drop_trait.coverage
index c99b980a339ff..2c9439a93b126 100644
--- a/tests/run-coverage/drop_trait.coverage
+++ b/tests/run-coverage/drop_trait.coverage
@@ -11,7 +11,7 @@
    LL|      2|    }
    LL|       |}
    LL|       |
-   LL|      1|fn main() -> Result<(),u8> {
+   LL|      1|fn main() -> Result<(), u8> {
    LL|      1|    let _firecracker = Firework { strength: 1 };
    LL|      1|
    LL|      1|    let _tnt = Firework { strength: 100 };
diff --git a/tests/run-coverage/drop_trait.rs b/tests/run-coverage/drop_trait.rs
index a9b5d1d1e7fe9..7b062719c6b02 100644
--- a/tests/run-coverage/drop_trait.rs
+++ b/tests/run-coverage/drop_trait.rs
@@ -11,7 +11,7 @@ impl Drop for Firework {
     }
 }
 
-fn main() -> Result<(),u8> {
+fn main() -> Result<(), u8> {
     let _firecracker = Firework { strength: 1 };
 
     let _tnt = Firework { strength: 100 };
diff --git a/tests/run-coverage/generics.coverage b/tests/run-coverage/generics.coverage
index 2ff8f917ed74f..0983918356634 100644
--- a/tests/run-coverage/generics.coverage
+++ b/tests/run-coverage/generics.coverage
@@ -41,7 +41,7 @@
   ------------------
    LL|       |}
    LL|       |
-   LL|      1|fn main() -> Result<(),u8> {
+   LL|      1|fn main() -> Result<(), u8> {
    LL|      1|    let mut firecracker = Firework { strength: 1 };
    LL|      1|    firecracker.set_strength(2);
    LL|      1|
@@ -54,10 +54,6 @@
    LL|      1|        return Err(1);
    LL|      0|    }
    LL|      0|
-   LL|      0|
-   LL|      0|
-   LL|      0|
-   LL|      0|
    LL|      0|    let _ = Firework { strength: 1000 };
    LL|      0|
    LL|      0|    Ok(())
diff --git a/tests/run-coverage/generics.rs b/tests/run-coverage/generics.rs
index 150ffb9db395a..bf4c2d8d68532 100644
--- a/tests/run-coverage/generics.rs
+++ b/tests/run-coverage/generics.rs
@@ -19,7 +19,7 @@ impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display {
     }
 }
 
-fn main() -> Result<(),u8> {
+fn main() -> Result<(), u8> {
     let mut firecracker = Firework { strength: 1 };
     firecracker.set_strength(2);
 
@@ -32,10 +32,6 @@ fn main() -> Result<(),u8> {
         return Err(1);
     }
 
-
-
-
-
     let _ = Firework { strength: 1000 };
 
     Ok(())
diff --git a/tests/run-coverage/issue-85461.coverage b/tests/run-coverage/issue-85461.coverage
index f97ab23038710..cbc910664d062 100644
--- a/tests/run-coverage/issue-85461.coverage
+++ b/tests/run-coverage/issue-85461.coverage
@@ -5,9 +5,9 @@ $DIR/auxiliary/inline_always_with_dead_code.rs:
    LL|       |
    LL|       |mod foo {
    LL|       |    #[inline(always)]
-   LL|      2|    pub fn called() { }
+   LL|      2|    pub fn called() {}
    LL|       |
-   LL|      0|    fn uncalled() { }
+   LL|      0|    fn uncalled() {}
    LL|       |}
    LL|       |
    LL|       |pub mod bar {
@@ -24,6 +24,7 @@ $DIR/auxiliary/inline_always_with_dead_code.rs:
 
 $DIR/issue-85461.rs:
    LL|       |// Regression test for #85461: MSVC sometimes fail to link with dead code and #[inline(always)]
+   LL|       |
    LL|       |// aux-build:inline_always_with_dead_code.rs
    LL|       |extern crate inline_always_with_dead_code;
    LL|       |
diff --git a/tests/run-coverage/issue-85461.rs b/tests/run-coverage/issue-85461.rs
index 6f626b4a65b4d..9d4c90a827eeb 100644
--- a/tests/run-coverage/issue-85461.rs
+++ b/tests/run-coverage/issue-85461.rs
@@ -1,4 +1,5 @@
 // Regression test for #85461: MSVC sometimes fail to link with dead code and #[inline(always)]
+
 // aux-build:inline_always_with_dead_code.rs
 extern crate inline_always_with_dead_code;
 
diff --git a/tests/run-coverage/issue-93054.coverage b/tests/run-coverage/issue-93054.coverage
index 074e6b9835a4d..15f225326a427 100644
--- a/tests/run-coverage/issue-93054.coverage
+++ b/tests/run-coverage/issue-93054.coverage
@@ -1,29 +1,31 @@
+   LL|       |#![allow(dead_code, unreachable_code)]
+   LL|       |
    LL|       |// Regression test for #93054: Functions using uninhabited types often only have a single,
    LL|       |// unreachable basic block which doesn't get instrumented. This should not cause llvm-cov to fail.
    LL|       |// Since these kinds functions can't be invoked anyway, it's ok to not have coverage data for them.
    LL|       |
    LL|       |// compile-flags: --edition=2021
    LL|       |
-   LL|       |enum Never { }
+   LL|       |enum Never {}
    LL|       |
    LL|       |impl Never {
    LL|       |    fn foo(self) {
-   LL|       |        match self { }
-   LL|       |        make().map(|never| match never { });
+   LL|       |        match self {}
+   LL|       |        make().map(|never| match never {});
    LL|       |    }
    LL|       |
    LL|       |    fn bar(&self) {
-   LL|       |        match *self { }
+   LL|       |        match *self {}
    LL|       |    }
    LL|       |}
    LL|       |
    LL|      0|async fn foo2(never: Never) {
-   LL|       |    match never { }
+   LL|       |    match never {}
    LL|       |}
    LL|       |
    LL|      0|fn make() -> Option<Never> {
    LL|      0|    None
    LL|      0|}
    LL|       |
-   LL|      1|fn main() { }
+   LL|      1|fn main() {}
 
diff --git a/tests/run-coverage/issue-93054.rs b/tests/run-coverage/issue-93054.rs
index c160b3db03f8e..da546cfeef854 100644
--- a/tests/run-coverage/issue-93054.rs
+++ b/tests/run-coverage/issue-93054.rs
@@ -1,28 +1,30 @@
+#![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 { }
+enum Never {}
 
 impl Never {
     fn foo(self) {
-        match self { }
-        make().map(|never| match never { });
+        match self {}
+        make().map(|never| match never {});
     }
 
     fn bar(&self) {
-        match *self { }
+        match *self {}
     }
 }
 
 async fn foo2(never: Never) {
-    match never { }
+    match never {}
 }
 
 fn make() -> Option<Never> {
     None
 }
 
-fn main() { }
+fn main() {}
diff --git a/tests/run-coverage/loops_branches.coverage b/tests/run-coverage/loops_branches.coverage
index 148a22377f32a..8cd6f1be3f7a6 100644
--- a/tests/run-coverage/loops_branches.coverage
+++ b/tests/run-coverage/loops_branches.coverage
@@ -9,8 +9,7 @@
    LL|      1|    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    LL|      1|        if true {
    LL|      1|            if false {
-   LL|      0|                while true {
-   LL|      0|                }
+   LL|      0|                while true {}
    LL|      1|            }
    LL|      1|            write!(f, "cool")?;
                                            ^0
diff --git a/tests/run-coverage/loops_branches.rs b/tests/run-coverage/loops_branches.rs
index 7116ce47f4b9d..f3a343bcc1f42 100644
--- a/tests/run-coverage/loops_branches.rs
+++ b/tests/run-coverage/loops_branches.rs
@@ -9,8 +9,7 @@ impl std::fmt::Debug for DebugTest {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         if true {
             if false {
-                while true {
-                }
+                while true {}
             }
             write!(f, "cool")?;
         } else {
diff --git a/tests/run-coverage/match_or_pattern.coverage b/tests/run-coverage/match_or_pattern.coverage
index 0b5a2c03dd360..94c7967215c1b 100644
--- a/tests/run-coverage/match_or_pattern.coverage
+++ b/tests/run-coverage/match_or_pattern.coverage
@@ -1,5 +1,3 @@
-   LL|       |#![feature(or_patterns)]
-   LL|       |
    LL|      1|fn main() {
    LL|      1|    // Initialize test constants in a way that cannot be determined at compile time, to ensure
    LL|      1|    // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
diff --git a/tests/run-coverage/match_or_pattern.rs b/tests/run-coverage/match_or_pattern.rs
index 4c6a8a9b7037c..ab7aee51d1bc4 100644
--- a/tests/run-coverage/match_or_pattern.rs
+++ b/tests/run-coverage/match_or_pattern.rs
@@ -1,5 +1,3 @@
-#![feature(or_patterns)]
-
 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
diff --git a/tests/run-coverage/no_cov_crate.coverage b/tests/run-coverage/no_cov_crate.coverage
index c34dbde888ae9..73f6fbd0c2baa 100644
--- a/tests/run-coverage/no_cov_crate.coverage
+++ b/tests/run-coverage/no_cov_crate.coverage
@@ -12,6 +12,7 @@
    LL|       |}
    LL|       |
    LL|       |#[no_coverage]
+   LL|       |#[allow(dead_code)]
    LL|       |fn do_not_add_coverage_not_called() {
    LL|       |    println!("not called and not covered");
    LL|       |}
@@ -24,6 +25,7 @@
    LL|      1|    println!("called and covered");
    LL|      1|}
    LL|       |
+   LL|       |#[allow(dead_code)]
    LL|      0|fn add_coverage_not_called() {
    LL|      0|    println!("not called but covered");
    LL|      0|}
diff --git a/tests/run-coverage/no_cov_crate.rs b/tests/run-coverage/no_cov_crate.rs
index 0bfbdda2cab03..5b748aeefb767 100644
--- a/tests/run-coverage/no_cov_crate.rs
+++ b/tests/run-coverage/no_cov_crate.rs
@@ -12,6 +12,7 @@ fn do_not_add_coverage_2() {
 }
 
 #[no_coverage]
+#[allow(dead_code)]
 fn do_not_add_coverage_not_called() {
     println!("not called and not covered");
 }
@@ -24,6 +25,7 @@ fn add_coverage_2() {
     println!("called and covered");
 }
 
+#[allow(dead_code)]
 fn add_coverage_not_called() {
     println!("not called but covered");
 }
diff --git a/tests/run-coverage/overflow.coverage b/tests/run-coverage/overflow.coverage
index 2d60316e21582..cee076e88cd43 100644
--- a/tests/run-coverage/overflow.coverage
+++ b/tests/run-coverage/overflow.coverage
@@ -12,7 +12,7 @@
    LL|      4|    result
    LL|      4|}
    LL|       |
-   LL|      1|fn main() -> Result<(),u8> {
+   LL|      1|fn main() -> Result<(), u8> {
    LL|      1|    let mut countdown = 10;
    LL|     11|    while countdown > 0 {
    LL|     11|        if countdown == 1 {
diff --git a/tests/run-coverage/overflow.rs b/tests/run-coverage/overflow.rs
index 7df8de6f3cd13..bbb65c1b35df6 100644
--- a/tests/run-coverage/overflow.rs
+++ b/tests/run-coverage/overflow.rs
@@ -12,7 +12,7 @@ fn might_overflow(to_add: u32) -> u32 {
     result
 }
 
-fn main() -> Result<(),u8> {
+fn main() -> Result<(), u8> {
     let mut countdown = 10;
     while countdown > 0 {
         if countdown == 1 {
diff --git a/tests/run-coverage/try_error_result.coverage b/tests/run-coverage/try_error_result.coverage
index fcdb7437d00dc..5d48cbd62f207 100644
--- a/tests/run-coverage/try_error_result.coverage
+++ b/tests/run-coverage/try_error_result.coverage
@@ -1,7 +1,7 @@
    LL|       |#![allow(unused_assignments)]
    LL|       |// failure-status: 1
    LL|       |
-   LL|      6|fn call(return_error: bool) -> Result<(),()> {
+   LL|      6|fn call(return_error: bool) -> Result<(), ()> {
    LL|      6|    if return_error {
    LL|      1|        Err(())
    LL|       |    } else {
@@ -9,7 +9,7 @@
    LL|       |    }
    LL|      6|}
    LL|       |
-   LL|      1|fn test1() -> Result<(),()> {
+   LL|      1|fn test1() -> Result<(), ()> {
    LL|      1|    let mut
    LL|      1|        countdown = 10
    LL|       |    ;
@@ -38,18 +38,18 @@
    LL|       |
    LL|       |struct Thing1;
    LL|       |impl Thing1 {
-   LL|     18|    fn get_thing_2(&self, return_error: bool) -> Result<Thing2,()> {
+   LL|     18|    fn get_thing_2(&self, return_error: bool) -> Result<Thing2, ()> {
    LL|     18|        if return_error {
    LL|      1|            Err(())
    LL|       |        } else {
-   LL|     17|            Ok(Thing2{})
+   LL|     17|            Ok(Thing2 {})
    LL|       |        }
    LL|     18|    }
    LL|       |}
    LL|       |
    LL|       |struct Thing2;
    LL|       |impl Thing2 {
-   LL|     17|    fn call(&self, return_error: bool) -> Result<u32,()> {
+   LL|     17|    fn call(&self, return_error: bool) -> Result<u32, ()> {
    LL|     17|        if return_error {
    LL|      2|            Err(())
    LL|       |        } else {
@@ -58,7 +58,7 @@
    LL|     17|    }
    LL|       |}
    LL|       |
-   LL|      1|fn test2() -> Result<(),()> {
+   LL|      1|fn test2() -> Result<(), ()> {
    LL|      1|    let thing1 = Thing1{};
    LL|      1|    let mut
    LL|      1|        countdown = 10
@@ -115,7 +115,7 @@
    LL|      0|    Ok(())
    LL|      1|}
    LL|       |
-   LL|      1|fn main() -> Result<(),()> {
+   LL|      1|fn main() -> Result<(), ()> {
    LL|      1|    test1().expect_err("test1 should fail");
    LL|      1|    test2()
    LL|      1|    ?
diff --git a/tests/run-coverage/try_error_result.rs b/tests/run-coverage/try_error_result.rs
index 9eb1d2db218b6..557cbf22bfad4 100644
--- a/tests/run-coverage/try_error_result.rs
+++ b/tests/run-coverage/try_error_result.rs
@@ -1,7 +1,7 @@
 #![allow(unused_assignments)]
 // failure-status: 1
 
-fn call(return_error: bool) -> Result<(),()> {
+fn call(return_error: bool) -> Result<(), ()> {
     if return_error {
         Err(())
     } else {
@@ -9,7 +9,7 @@ fn call(return_error: bool) -> Result<(),()> {
     }
 }
 
-fn test1() -> Result<(),()> {
+fn test1() -> Result<(), ()> {
     let mut
         countdown = 10
     ;
@@ -37,18 +37,18 @@ fn test1() -> Result<(),()> {
 
 struct Thing1;
 impl Thing1 {
-    fn get_thing_2(&self, return_error: bool) -> Result<Thing2,()> {
+    fn get_thing_2(&self, return_error: bool) -> Result<Thing2, ()> {
         if return_error {
             Err(())
         } else {
-            Ok(Thing2{})
+            Ok(Thing2 {})
         }
     }
 }
 
 struct Thing2;
 impl Thing2 {
-    fn call(&self, return_error: bool) -> Result<u32,()> {
+    fn call(&self, return_error: bool) -> Result<u32, ()> {
         if return_error {
             Err(())
         } else {
@@ -57,7 +57,7 @@ impl Thing2 {
     }
 }
 
-fn test2() -> Result<(),()> {
+fn test2() -> Result<(), ()> {
     let thing1 = Thing1{};
     let mut
         countdown = 10
@@ -109,7 +109,7 @@ fn test2() -> Result<(),()> {
     Ok(())
 }
 
-fn main() -> Result<(),()> {
+fn main() -> Result<(), ()> {
     test1().expect_err("test1 should fail");
     test2()
     ?
diff --git a/tests/run-coverage/unused.coverage b/tests/run-coverage/unused.coverage
index ba25e34bf86d8..056ffeb021a03 100644
--- a/tests/run-coverage/unused.coverage
+++ b/tests/run-coverage/unused.coverage
@@ -1,3 +1,5 @@
+   LL|       |#![allow(dead_code, unused_assignments, unused_must_use, unused_variables)]
+   LL|       |
    LL|      2|fn foo<T>(x: T) {
    LL|      2|    let mut i = 0;
    LL|     22|    while i < 10 {
diff --git a/tests/run-coverage/unused.rs b/tests/run-coverage/unused.rs
index fb6113eb01c2d..d985af135470e 100644
--- a/tests/run-coverage/unused.rs
+++ b/tests/run-coverage/unused.rs
@@ -1,3 +1,5 @@
+#![allow(dead_code, unused_assignments, unused_must_use, unused_variables)]
+
 fn foo<T>(x: T) {
     let mut i = 0;
     while i < 10 {
diff --git a/tests/run-coverage/unused_mod.coverage b/tests/run-coverage/unused_mod.coverage
index 558dfaa5cffc8..a8fa24ac6a799 100644
--- a/tests/run-coverage/unused_mod.coverage
+++ b/tests/run-coverage/unused_mod.coverage
@@ -1,4 +1,5 @@
 $DIR/auxiliary/unused_mod_helper.rs:
+   LL|       |#[allow(dead_code)]
    LL|      0|pub fn never_called_function() {
    LL|      0|    println!("I am never called");
    LL|      0|}
diff --git a/tests/run-coverage/uses_crate.coverage b/tests/run-coverage/uses_crate.coverage
index 9da096dbd50af..50d92102a1093 100644
--- a/tests/run-coverage/uses_crate.coverage
+++ b/tests/run-coverage/uses_crate.coverage
@@ -1,7 +1,9 @@
 $DIR/auxiliary/used_crate.rs:
    LL|       |#![allow(unused_assignments, unused_variables)]
+   LL|       |// Verify that coverage works with optimizations:
    LL|       |// compile-flags: -C opt-level=3
-   LL|       |use std::fmt::Debug; // ^^ validates coverage now works with optimizations
+   LL|       |
+   LL|       |use std::fmt::Debug;
    LL|       |
    LL|      1|pub fn used_function() {
    LL|      1|    // Initialize test constants in a way that cannot be determined at compile time, to ensure
@@ -90,6 +92,7 @@ $DIR/auxiliary/used_crate.rs:
    LL|      0|    }
    LL|      0|}
    LL|       |
+   LL|       |#[allow(dead_code)]
    LL|      0|fn unused_private_function() {
    LL|      0|    let is_true = std::env::args().len() == 1;
    LL|      0|    let mut countdown = 2;
diff --git a/tests/run-coverage/uses_inline_crate.coverage b/tests/run-coverage/uses_inline_crate.coverage
index 48493e2079caa..cc0e01ffde1c3 100644
--- a/tests/run-coverage/uses_inline_crate.coverage
+++ b/tests/run-coverage/uses_inline_crate.coverage
@@ -1,8 +1,8 @@
 $DIR/auxiliary/used_inline_crate.rs:
    LL|       |#![allow(unused_assignments, unused_variables)]
-   LL|       |
+   LL|       |// Verify that coverage works with optimizations:
    LL|       |// compile-flags: -C opt-level=3
-   LL|       |// ^^ validates coverage now works with optimizations
+   LL|       |
    LL|       |use std::fmt::Debug;
    LL|       |
    LL|      1|pub fn used_function() {
@@ -32,12 +32,6 @@ $DIR/auxiliary/used_inline_crate.rs:
    LL|      1|    use_this_lib_crate();
    LL|      1|}
    LL|       |
-   LL|       |
-   LL|       |
-   LL|       |
-   LL|       |
-   LL|       |
-   LL|       |
    LL|       |#[inline(always)]
    LL|      2|pub fn used_only_from_bin_crate_generic_function<T: Debug>(arg: T) {
    LL|      2|    println!("used_only_from_bin_crate_generic_function with {:?}", arg);
@@ -120,6 +114,7 @@ $DIR/auxiliary/used_inline_crate.rs:
    LL|      0|}
    LL|       |
    LL|       |#[inline(always)]
+   LL|       |#[allow(dead_code)]
    LL|      0|fn unused_private_function() {
    LL|      0|    let is_true = std::env::args().len() == 1;
    LL|      0|    let mut countdown = 2;
diff --git a/tests/run-coverage/while_early_ret.coverage b/tests/run-coverage/while_early_ret.coverage
index 97808447ab74e..49d39d366038c 100644
--- a/tests/run-coverage/while_early_ret.coverage
+++ b/tests/run-coverage/while_early_ret.coverage
@@ -1,7 +1,7 @@
    LL|       |#![allow(unused_assignments)]
    LL|       |// failure-status: 1
    LL|       |
-   LL|      1|fn main() -> Result<(),u8> {
+   LL|      1|fn main() -> Result<(), u8> {
    LL|      1|    let mut countdown = 10;
    LL|       |    while
    LL|      7|        countdown
diff --git a/tests/run-coverage/while_early_ret.rs b/tests/run-coverage/while_early_ret.rs
index 1c83c8fc7a8f1..b2f0eee2cc0f4 100644
--- a/tests/run-coverage/while_early_ret.rs
+++ b/tests/run-coverage/while_early_ret.rs
@@ -1,7 +1,7 @@
 #![allow(unused_assignments)]
 // failure-status: 1
 
-fn main() -> Result<(),u8> {
+fn main() -> Result<(), u8> {
     let mut countdown = 10;
     while
         countdown
diff --git a/tests/run-coverage/yield.coverage b/tests/run-coverage/yield.coverage
index 383dd99150042..90c2641a7d661 100644
--- a/tests/run-coverage/yield.coverage
+++ b/tests/run-coverage/yield.coverage
@@ -7,7 +7,7 @@
    LL|      1|fn main() {
    LL|      1|    let mut generator = || {
    LL|      1|        yield 1;
-   LL|      1|        return "foo"
+   LL|      1|        return "foo";
    LL|      1|    };
    LL|       |
    LL|      1|    match Pin::new(&mut generator).resume(()) {
@@ -23,7 +23,7 @@
    LL|      1|        yield 1;
    LL|      1|        yield 2;
    LL|      0|        yield 3;
-   LL|      0|        return "foo"
+   LL|      0|        return "foo";
    LL|      0|    };
    LL|       |
    LL|      1|    match Pin::new(&mut generator).resume(()) {
diff --git a/tests/run-coverage/yield.rs b/tests/run-coverage/yield.rs
index ff7616656ff50..361275c921585 100644
--- a/tests/run-coverage/yield.rs
+++ b/tests/run-coverage/yield.rs
@@ -7,7 +7,7 @@ use std::pin::Pin;
 fn main() {
     let mut generator = || {
         yield 1;
-        return "foo"
+        return "foo";
     };
 
     match Pin::new(&mut generator).resume(()) {
@@ -23,7 +23,7 @@ fn main() {
         yield 1;
         yield 2;
         yield 3;
-        return "foo"
+        return "foo";
     };
 
     match Pin::new(&mut generator).resume(()) {