cleaned up some tests

26 files changed, 177 insertions, 112 deletions

diff --git a/tests/ui/allocator/weak-uninhabited-type.rs b/tests/ui/allocator/weak-uninhabited-type.rs
index ce7d5786b41..74258eedc6a 100644
--- a/tests/ui/allocator/weak-uninhabited-type.rs
+++ b/tests/ui/allocator/weak-uninhabited-type.rs
@@ -1,7 +1,13 @@
+//! Checks that `Weak` pointers can be created with an empty enum type parameter.
+//! And generic `Weak` handles zero-variant enums without error.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/48493>
+
 //@ run-pass
 
+enum Void {}
+
 fn main() {
-    enum Void {}
     let _ = std::rc::Weak::<Void>::new();
     let _ = std::sync::Weak::<Void>::new();
 }
diff --git a/tests/ui/binding/underscore-prefixed-function-argument.rs b/tests/ui/binding/underscore-prefixed-function-argument.rs
index 2014e0d23d8..e5b2ec1b5f0 100644
--- a/tests/ui/binding/underscore-prefixed-function-argument.rs
+++ b/tests/ui/binding/underscore-prefixed-function-argument.rs
@@ -1,11 +1,13 @@
-//@ run-pass
+//! Test that argument names starting with `_` are usable.
 
-fn good(_a: &isize) {
-}
+//@ run-pass
 
-// unnamed argument &isize is now parse x: &isize
+fn good(_a: &isize) {}
 
-fn called<F>(_f: F) where F: FnOnce(&isize) {
+fn called<F>(_f: F)
+where
+    F: FnOnce(&isize),
+{
 }
 
 pub fn main() {
diff --git a/tests/ui/borrowck/ownership-struct-update-moved-error.rs b/tests/ui/borrowck/ownership-struct-update-moved-error.rs
index ee1a77eb9a4..62fc1f42969 100644
--- a/tests/ui/borrowck/ownership-struct-update-moved-error.rs
+++ b/tests/ui/borrowck/ownership-struct-update-moved-error.rs
@@ -1,17 +1,19 @@
-struct Mine{
+//! Checks borrow after move error when using `self` consuming method with struct update syntax.
+
+struct Mine {
     test: String,
-    other_val: isize
+    other_val: isize,
 }
 
-impl Mine{
-    fn make_string_bar(mut self) -> Mine{
+impl Mine {
+    fn make_string_bar(mut self) -> Mine {
         self.test = "Bar".to_string();
         self
     }
 }
 
-fn main(){
-    let start = Mine{test:"Foo".to_string(), other_val:0};
-    let end = Mine{other_val:1, ..start.make_string_bar()};
+fn main() {
+    let start = Mine { test: "Foo".to_string(), other_val: 0 };
+    let end = Mine { other_val: 1, ..start.make_string_bar() };
     println!("{}", start.test); //~ ERROR borrow of moved value: `start`
 }
diff --git a/tests/ui/borrowck/ownership-struct-update-moved-error.stderr b/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
index 34b501f8ec8..83cfc7bb412 100644
--- a/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
+++ b/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
@@ -1,17 +1,17 @@
 error[E0382]: borrow of moved value: `start`
-  --> $DIR/walk-struct-literal-with.rs:16:20
+  --> $DIR/ownership-struct-update-moved-error.rs:18:20
    |
-LL |     let start = Mine{test:"Foo".to_string(), other_val:0};
+LL |     let start = Mine { test: "Foo".to_string(), other_val: 0 };
    |         ----- move occurs because `start` has type `Mine`, which does not implement the `Copy` trait
-LL |     let end = Mine{other_val:1, ..start.make_string_bar()};
-   |                                         ----------------- `start` moved due to this method call
+LL |     let end = Mine { other_val: 1, ..start.make_string_bar() };
+   |                                            ----------------- `start` moved due to this method call
 LL |     println!("{}", start.test);
    |                    ^^^^^^^^^^ value borrowed here after move
    |
 note: `Mine::make_string_bar` takes ownership of the receiver `self`, which moves `start`
-  --> $DIR/walk-struct-literal-with.rs:7:28
+  --> $DIR/ownership-struct-update-moved-error.rs:9:28
    |
-LL |     fn make_string_bar(mut self) -> Mine{
+LL |     fn make_string_bar(mut self) -> Mine {
    |                            ^^^^
    = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/closures/no-capture-closure-call.rs b/tests/ui/closures/no-capture-closure-call.rs
index 5f42bcbe280..29e5ac635b4 100644
--- a/tests/ui/closures/no-capture-closure-call.rs
+++ b/tests/ui/closures/no-capture-closure-call.rs
@@ -1,3 +1,5 @@
+//! Sanity check for no capture closures
+
 //@ run-pass
 
 pub fn main() {
diff --git a/tests/ui/drop/box-drop-unused-value-statement-regression.rs b/tests/ui/drop/box-drop-unused-value-statement-regression.rs
index 3d5eff2c48d..43865e08444 100644
--- a/tests/ui/drop/box-drop-unused-value-statement-regression.rs
+++ b/tests/ui/drop/box-drop-unused-value-statement-regression.rs
@@ -1,12 +1,12 @@
-//@ run-pass
-// Issue #3878
-// Issue Name: Unused move causes a crash
-// Abstract: zero-fill to block after drop
-
+//! Regression test for a crash caused by an "unsused move"
+//! (specifically, a variable bound to a `Box` used as a statement)
+//! leading to incorrect memory zero-filling after drop.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/3878>.
 
-#![allow(path_statements)]
+//@ run-pass
 
 pub fn main() {
     let y: Box<_> = Box::new(1);
-    y;
+    drop(y);
 }
diff --git a/tests/ui/hashmap/hashset-enum-variant.rs b/tests/ui/hashmap/hashset-enum-variant.rs
index 5795cc527cf..39a59d3a39b 100644
--- a/tests/ui/hashmap/hashset-enum-variant.rs
+++ b/tests/ui/hashmap/hashset-enum-variant.rs
@@ -1,26 +1,27 @@
+//! Check for correct initialization of `HashSet` with enums. This is a regression test for a
+//! codegen bug that caused the `HashSet` to appear as if it contained one of each enum variant.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/42918>
+
 //@ run-pass
-//
-#![allow(dead_code)]
 //@ compile-flags: -O
 
+#![allow(dead_code)]
+
 use std::collections::HashSet;
 
 #[derive(PartialEq, Debug, Hash, Eq, Clone, PartialOrd, Ord)]
 enum MyEnum {
     E0,
-
     E1,
-
     E2,
     E3,
     E4,
-
     E5,
     E6,
     E7,
 }
 
-
 fn main() {
     use MyEnum::*;
     let s: HashSet<_> = [E4, E1].iter().cloned().collect();
diff --git a/tests/ui/io-checks/write-macro-error.rs b/tests/ui/io-checks/write-macro-error.rs
index b48fa3f11cc..857ea0024e1 100644
--- a/tests/ui/io-checks/write-macro-error.rs
+++ b/tests/ui/io-checks/write-macro-error.rs
@@ -1,3 +1,6 @@
+//! Tests that errors from both the writer (`Write::write`) and formatter (`Display::fmt`)
+//! are correctly propagated: writer errors return `Err`, formatter errors cause panics.
+
 //@ run-pass
 //@ needs-unwind
 
@@ -24,7 +27,9 @@ impl Write for ErrorWriter {
         Err(Error::new(WRITER_ERROR, "not connected"))
     }
 
-    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
 }
 
 fn main() {
@@ -37,7 +42,8 @@ fn main() {
     let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
     assert!(
         err.contains("formatting trait implementation returned an error"),
-        "unexpected panic: {}", err
+        "unexpected panic: {}",
+        err
     );
 
     // Writer error when there's some string before the first `{}`
@@ -50,6 +56,7 @@ fn main() {
     let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
     assert!(
         err.contains("formatting trait implementation returned an error"),
-        "unexpected panic: {}", err
+        "unexpected panic: {}",
+        err
     );
 }
diff --git a/tests/ui/lang-items/lang-item-unknown-definition-error.rs b/tests/ui/lang-items/lang-item-unknown-definition-error.rs
index ce206d20358..22812128c2d 100644
--- a/tests/ui/lang-items/lang-item-unknown-definition-error.rs
+++ b/tests/ui/lang-items/lang-item-unknown-definition-error.rs
@@ -1,9 +1,11 @@
+//! Checks that compiler prevernt attempting to define an unrecognized or unknown lang item
+
 #![allow(unused)]
 #![feature(lang_items)]
 
 #[lang = "foo"]
 fn bar() -> ! {
-//~^^ ERROR definition of an unknown lang item: `foo`
+    //~^^ ERROR definition of an unknown lang item: `foo`
     loop {}
 }
 
diff --git a/tests/ui/lang-items/lang-item-unknown-definition-error.stderr b/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
index 832f1342418..3b939757ac2 100644
--- a/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
+++ b/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
@@ -1,5 +1,5 @@
 error[E0522]: definition of an unknown lang item: `foo`
-  --> $DIR/unknown-language-item.rs:4:1
+  --> $DIR/lang-item-unknown-definition-error.rs:6:1
    |
 LL | #[lang = "foo"]
    | ^^^^^^^^^^^^^^^ definition of unknown lang item `foo`
diff --git a/tests/ui/modules/module-qualified-paths-basic.rs b/tests/ui/modules/module-qualified-paths-basic.rs
index d948ffc1520..c02f6060caa 100644
--- a/tests/ui/modules/module-qualified-paths-basic.rs
+++ b/tests/ui/modules/module-qualified-paths-basic.rs
@@ -1,11 +1,20 @@
+//! Checks that functions from different modules are accessible via their fully-qualified paths.
+
 //@ run-pass
 
 mod foo {
-    pub fn x() -> isize { return 1; }
+    pub fn x() -> isize {
+        return 1;
+    }
 }
 
 mod bar {
-    pub fn y() -> isize { return 1; }
+    pub fn y() -> isize {
+        return 1;
+    }
 }
 
-pub fn main() { foo::x(); bar::y(); }
+pub fn main() {
+    foo::x();
+    bar::y();
+}
diff --git a/tests/ui/modules/module-use-nested-groups.rs b/tests/ui/modules/module-use-nested-groups.rs
index c5d66a86935..84d1f9141a8 100644
--- a/tests/ui/modules/module-use-nested-groups.rs
+++ b/tests/ui/modules/module-use-nested-groups.rs
@@ -1,3 +1,5 @@
+//! Checks complex `use` syntax and availability of types across nested modules.
+
 //@ run-pass
 
 mod a {
diff --git a/tests/ui/modules/primitive-type-module-deprecated-paths.rs b/tests/ui/modules/primitive-type-module-deprecated-paths.rs
index 6e8c7053c57..5c9d2a616b3 100644
--- a/tests/ui/modules/primitive-type-module-deprecated-paths.rs
+++ b/tests/ui/modules/primitive-type-module-deprecated-paths.rs
@@ -1,9 +1,10 @@
+//! Make sure the module level constants are still there and accessible even after
+//! the corresponding associated constants have been added, and later stabilized.
+
 //@ run-pass
 
-// Make sure the module level constants are still there and accessible even after
-// the corresponding associated constants have been added, and later stabilized.
 #![allow(deprecated, deprecated_in_future)]
-use std::{u16, f32};
+use std::{f32, u16};
 
 fn main() {
     let _ = u16::MAX;
diff --git a/tests/ui/modules/use-keyword-reexport-type-alias.rs b/tests/ui/modules/use-keyword-reexport-type-alias.rs
index 4f3d1ee500d..c62bd9687ae 100644
--- a/tests/ui/modules/use-keyword-reexport-type-alias.rs
+++ b/tests/ui/modules/use-keyword-reexport-type-alias.rs
@@ -1,18 +1,20 @@
+//! Checks module re-exports, aliasing with `pub use`,
+//! and calling private methods via `Self` in an impl block.
+
 //@ run-pass
 
 #![allow(unused_variables)]
 pub struct A;
 
 mod test {
-    pub use super :: A;
-
-    pub use self :: A as B;
+    pub use self::A as B;
+    pub use super::A;
 }
 
 impl A {
     fn f() {}
     fn g() {
-        Self :: f()
+        Self::f()
     }
 }
 
diff --git a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
index 943c7f79742..4325c8b111b 100644
--- a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
+++ b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
@@ -1,3 +1,5 @@
+//! This test ensures that the unary negation operator (`-`) cannot be applied to unsigned ints
+
 fn main() {
     let x = -1 as usize; //~ ERROR: cannot apply unary operator `-`
     let x = (-1) as usize; //~ ERROR: cannot apply unary operator `-`
diff --git a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
index 0bedbc1accd..4ce870ded9f 100644
--- a/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
+++ b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
@@ -1,5 +1,5 @@
 error[E0600]: cannot apply unary operator `-` to type `usize`
-  --> $DIR/unsigned-literal-negation.rs:2:13
+  --> $DIR/unary-negation-unsigned-integer-error.rs:4:13
    |
 LL |     let x = -1 as usize;
    |             ^^ cannot apply unary operator `-`
@@ -12,7 +12,7 @@ LL +     let x = usize::MAX;
    |
 
 error[E0600]: cannot apply unary operator `-` to type `usize`
-  --> $DIR/unsigned-literal-negation.rs:3:13
+  --> $DIR/unary-negation-unsigned-integer-error.rs:5:13
    |
 LL |     let x = (-1) as usize;
    |             ^^^^ cannot apply unary operator `-`
@@ -25,7 +25,7 @@ LL +     let x = usize::MAX;
    |
 
 error[E0600]: cannot apply unary operator `-` to type `u32`
-  --> $DIR/unsigned-literal-negation.rs:4:18
+  --> $DIR/unary-negation-unsigned-integer-error.rs:6:18
    |
 LL |     let x: u32 = -1;
    |                  ^^ cannot apply unary operator `-`
diff --git a/tests/ui/panics/unwind-force-no-unwind-tables.rs b/tests/ui/panics/unwind-force-no-unwind-tables.rs
index fb8082e3188..2226e4dd03e 100644
--- a/tests/ui/panics/unwind-force-no-unwind-tables.rs
+++ b/tests/ui/panics/unwind-force-no-unwind-tables.rs
@@ -1,3 +1,7 @@
+//! This test checks that Rust's unwinding mechanism correctly executes `Drop`
+//! implementations during stack unwinding, even when unwind tables (`uwtable`)
+//! are explicitly disabled via `-C force-unwind-tables=n`.
+
 //@ run-pass
 //@ needs-unwind
 //@ ignore-windows target requires uwtable
@@ -26,9 +30,12 @@ fn increase(count: &mut u8) {
 
 fn main() {
     let mut count = 0;
-    assert!(panic::catch_unwind(AssertUnwindSafe(
-        #[inline(never)]
-        || increase(&mut count)
-    )).is_err());
+    assert!(
+        panic::catch_unwind(AssertUnwindSafe(
+            #[inline(never)]
+            || increase(&mut count)
+        ))
+        .is_err()
+    );
     assert_eq!(count, 1);
 }
diff --git a/tests/ui/process/process-spawn-failure.rs b/tests/ui/process/process-spawn-failure.rs
index 4a7f2bee9d9..0950b044c97 100644
--- a/tests/ui/process/process-spawn-failure.rs
+++ b/tests/ui/process/process-spawn-failure.rs
@@ -1,3 +1,9 @@
+//! Tests that repeatedly spawning a failing command does not create zombie processes.
+//! Spawns a deliberately invalid command multiple times, verifies each spawn fails,
+//! then uses `ps` (on Unix) to detect any leftover zombie (defunct) child processes.
+//! Checks Rust's process spawning cleans up resources properly.
+//! Skipped on platforms without `ps` utility.
+
 //@ run-pass
 //@ needs-subprocess
 //@ ignore-vxworks no 'ps'
@@ -36,35 +42,42 @@ fn find_zombies() {
     // the PPID column contains a "-" for the respective process.
     // Filter out any lines that have a "-" as the PPID as the PPID is
     // expected to be an integer.
-    let filtered_ps: Vec<_> = ps_output
-        .lines()
-        .filter(|line| line.split_whitespace().nth(1) != Some("-"))
-        .collect();
+    let filtered_ps: Vec<_> =
+        ps_output.lines().filter(|line| line.split_whitespace().nth(1) != Some("-")).collect();
 
     for (line_no, line) in filtered_ps.into_iter().enumerate() {
-        if 0 < line_no && 0 < line.len() &&
-           my_pid == line.split(' ').filter(|w| 0 < w.len()).nth(1)
-                         .expect("1st column should be PPID")
-                         .parse().ok()
-                         .expect("PPID string into integer") &&
-           line.contains("defunct") {
+        if 0 < line_no
+            && 0 < line.len()
+            && my_pid
+                == line
+                    .split(' ')
+                    .filter(|w| 0 < w.len())
+                    .nth(1)
+                    .expect("1st column should be PPID")
+                    .parse()
+                    .ok()
+                    .expect("PPID string into integer")
+            && line.contains("defunct")
+        {
             panic!("Zombie child {}", line);
         }
     }
 }
 
 #[cfg(windows)]
-fn find_zombies() { }
+fn find_zombies() {}
 
 fn main() {
     let too_long = format!("/NoSuchCommand{:0300}", 0u8);
 
-    let _failures = (0..100).map(|_| {
-        let mut cmd = Command::new(&too_long);
-        let failed = cmd.spawn();
-        assert!(failed.is_err(), "Make sure the command fails to spawn(): {:?}", cmd);
-        failed
-    }).collect::<Vec<_>>();
+    let _failures = (0..100)
+        .map(|_| {
+            let mut cmd = Command::new(&too_long);
+            let failed = cmd.spawn();
+            assert!(failed.is_err(), "Make sure the command fails to spawn(): {:?}", cmd);
+            failed
+        })
+        .collect::<Vec<_>>();
 
     find_zombies();
     // then _failures goes out of scope
diff --git a/tests/ui/process/windows-exit-code-still-active.rs b/tests/ui/process/windows-exit-code-still-active.rs
index e016343f8ba..e661a4f6adc 100644
--- a/tests/ui/process/windows-exit-code-still-active.rs
+++ b/tests/ui/process/windows-exit-code-still-active.rs
@@ -1,23 +1,21 @@
+//! On Windows the GetExitCodeProcess API is used to get the exit code of a
+//! process, but it's easy to mistake a process exiting with the code 259 as
+//! "still running" because this is the value of the STILL_ACTIVE constant. Make
+//! sure we handle this case in the standard library and correctly report the
+//! status.
+//!
+//! Note that this is disabled on unix as processes exiting with 259 will have
+//! their exit status truncated to 3 (only the lower 8 bits are used).
+
 //@ run-pass
-// On Windows the GetExitCodeProcess API is used to get the exit code of a
-// process, but it's easy to mistake a process exiting with the code 259 as
-// "still running" because this is the value of the STILL_ACTIVE constant. Make
-// sure we handle this case in the standard library and correctly report the
-// status.
-//
-// Note that this is disabled on unix as processes exiting with 259 will have
-// their exit status truncated to 3 (only the lower 8 bits are used).
 
 #[cfg(windows)]
 fn main() {
-    use std::process::{self, Command};
     use std::env;
+    use std::process::{self, Command};
 
     if env::args().len() == 1 {
-        let status = Command::new(env::current_exe().unwrap())
-                             .arg("foo")
-                             .status()
-                             .unwrap();
+        let status = Command::new(env::current_exe().unwrap()).arg("foo").status().unwrap();
         assert_eq!(status.code(), Some(259));
     } else {
         process::exit(259);
diff --git a/tests/ui/reachable/diverging-expressions-unreachable-code.rs b/tests/ui/reachable/diverging-expressions-unreachable-code.rs
index 9c5f7c8f451..bb56987775f 100644
--- a/tests/ui/reachable/diverging-expressions-unreachable-code.rs
+++ b/tests/ui/reachable/diverging-expressions-unreachable-code.rs
@@ -3,17 +3,17 @@
 #![allow(unused_must_use)]
 #![allow(unreachable_code)]
 
-#![allow(unused_variables)]
-#![allow(dead_code)]
-
-fn id(x: bool) -> bool { x }
-
-fn call_id() {
-    let c = panic!();
-    id(c);
+fn _id(x: bool) -> bool {
+    x
 }
 
-fn call_id_3() { id(return) && id(return); }
+fn _call_id() {
+    let _c = panic!();
+    _id(_c);
+}
 
-pub fn main() {
+fn _call_id_3() {
+    _id(return) && _id(return);
 }
+
+pub fn main() {}
diff --git a/tests/ui/reachable/unreachable-code-diverging-expressions.rs b/tests/ui/reachable/unreachable-code-diverging-expressions.rs
index 0c46a38d73f..00676418002 100644
--- a/tests/ui/reachable/unreachable-code-diverging-expressions.rs
+++ b/tests/ui/reachable/unreachable-code-diverging-expressions.rs
@@ -26,9 +26,13 @@ fn call_id_3() {
 
 fn ret_guard() {
     match 2 {
-      x if (return) => { x; }
-      x if let true = return => { x; }
-      _ => {}
+        x if (return) => {
+            x;
+        }
+        x if let true = return => {
+            x;
+        }
+        _ => {}
     }
 }
 
diff --git a/tests/ui/traits/virtual-call-parameter-handling.rs b/tests/ui/traits/virtual-call-parameter-handling.rs
index e80bd5768a4..71ed459d15a 100644
--- a/tests/ui/traits/virtual-call-parameter-handling.rs
+++ b/tests/ui/traits/virtual-call-parameter-handling.rs
@@ -1,5 +1,7 @@
-//! Regression test for https://github.com/rust-lang/rust/issues/137646.
-//! The parameter value at all calls to `check` should be `(1, 1, 1)`.
+//! This test checks the correct parameter handling during virtual method calls
+//! through a `dyn Trait` object.
+//!
+//! Regression test for: <https://github.com/rust-lang/rust/issues/137646>
 
 //@ run-pass
 
diff --git a/tests/ui/type/unit-type-basic-usages.rs b/tests/ui/type/unit-type-basic-usages.rs
index 04404fc3f5e..c3ee8067f59 100644
--- a/tests/ui/type/unit-type-basic-usages.rs
+++ b/tests/ui/type/unit-type-basic-usages.rs
@@ -1,16 +1,14 @@
-//@ run-pass
-
-#![allow(unused_assignments)]
-#![allow(unknown_lints)]
+//! Checks the basic usage of unit type
 
-#![allow(unused_variables)]
-#![allow(dead_assignment)]
+//@ run-pass
 
-fn f(u: ()) { return u; }
+fn f(u: ()) {
+    u
+}
 
 pub fn main() {
     let u1: () = ();
-    let mut u2: () = f(u1);
-    u2 = ();
-    return ();
+    let mut _u2: () = f(u1);
+    _u2 = ();
+    ()
 }
diff --git a/tests/ui/type/usize-no-generic-arguments.rs b/tests/ui/type/usize-no-generic-arguments.rs
index 4ab80d944a5..d4d1eea757c 100644
--- a/tests/ui/type/usize-no-generic-arguments.rs
+++ b/tests/ui/type/usize-no-generic-arguments.rs
@@ -1,3 +1,5 @@
+//! Sanity test that primitives cannot have const generics.
+
 fn foo() {
     let x: usize<foo>; //~ ERROR const arguments are not allowed on builtin type `usize`
 }
diff --git a/tests/ui/type/usize-no-generic-arguments.stderr b/tests/ui/type/usize-no-generic-arguments.stderr
index 9c081a287ed..f1f3456461f 100644
--- a/tests/ui/type/usize-no-generic-arguments.stderr
+++ b/tests/ui/type/usize-no-generic-arguments.stderr
@@ -1,5 +1,5 @@
 error[E0109]: const arguments are not allowed on builtin type `usize`
-  --> $DIR/usize-generic-argument-parent.rs:2:18
+  --> $DIR/usize-no-generic-arguments.rs:4:18
    |
 LL |     let x: usize<foo>;
    |            ----- ^^^ const argument not allowed
diff --git a/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs b/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
index 82474d873b7..e587ca554fe 100644
--- a/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
+++ b/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
@@ -1,6 +1,9 @@
-//@ build-pass
-// Test the uninit() construct returning various empty types.
+//! This test checks that ZSTs can be safely initialized from
+//! `MaybeUninit::uninit().assume_init()` and `std::mem::uninitialized()`
+//! (which is deprecated). This is safe because ZSTs inherently
+//! require no actual memory initialization, as they occupy no memory.
 
+//@ build-pass
 
 use std::mem::MaybeUninit;