Rollup merge of #143303 - Kivooeo:tf28, r=tgross35 `tests/ui`: A New Order [28/28] FINAL PART > [!NOTE] > > Intermediate commits are intended to help review, but will be squashed prior to merge. Some `tests/ui/` housekeeping, to trim down number of tests directly under `tests/ui/`. Part of rust-lang/rust#133895. r? ``@tgross35``

diff --git a/tests/ui/allocator/weak-uninhabited-type.rs b/tests/ui/allocator/weak-uninhabited-type.rs
new file mode 100644
index 0000000..74258ee
--- /dev/null
+++ b/tests/ui/allocator/weak-uninhabited-type.rs

@@ -0,0 +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() {
+    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
new file mode 100644
index 0000000..e5b2ec1
--- /dev/null
+++ b/tests/ui/binding/underscore-prefixed-function-argument.rs

@@ -0,0 +1,15 @@
+//! Test that argument names starting with `_` are usable.
+
+//@ run-pass
+
+fn good(_a: &isize) {}
+
+fn called<F>(_f: F)
+where
+    F: FnOnce(&isize),
+{
+}
+
+pub fn main() {
+    called(good);
+}

diff --git a/tests/ui/borrowck/ownership-struct-update-moved-error.rs b/tests/ui/borrowck/ownership-struct-update-moved-error.rs
new file mode 100644
index 0000000..62fc1f4
--- /dev/null
+++ b/tests/ui/borrowck/ownership-struct-update-moved-error.rs

@@ -0,0 +1,19 @@
+//! Checks borrow after move error when using `self` consuming method with struct update syntax.
+
+struct Mine {
+    test: String,
+    other_val: isize,
+}
+
+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() };
+    println!("{}", start.test); //~ ERROR borrow of moved value: `start`
+}

diff --git a/tests/ui/walk-struct-literal-with.stderr b/tests/ui/borrowck/ownership-struct-update-moved-error.stderr
similarity index 62%
rename from tests/ui/walk-struct-literal-with.stderr
rename to tests/ui/borrowck/ownership-struct-update-moved-error.stderr
index 34b501f..83cfc7b 100644
--- a/tests/ui/walk-struct-literal-with.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/unused-move-capture.rs b/tests/ui/closures/no-capture-closure-call.rs
similarity index 71%
rename from tests/ui/unused-move-capture.rs
rename to tests/ui/closures/no-capture-closure-call.rs
index 5f42bcb..29e5ac6 100644
--- a/tests/ui/unused-move-capture.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/unknown-llvm-arg.rs b/tests/ui/codegen/llvm-args-invalid-flag.rs
similarity index 100%
rename from tests/ui/unknown-llvm-arg.rs
rename to tests/ui/codegen/llvm-args-invalid-flag.rs


diff --git a/tests/ui/unknown-llvm-arg.stderr b/tests/ui/codegen/llvm-args-invalid-flag.stderr
similarity index 100%
rename from tests/ui/unknown-llvm-arg.stderr
rename to tests/ui/codegen/llvm-args-invalid-flag.stderr


diff --git a/tests/ui/drop/box-drop-unused-value-statement-regression.rs b/tests/ui/drop/box-drop-unused-value-statement-regression.rs
new file mode 100644
index 0000000..43865e0
--- /dev/null
+++ b/tests/ui/drop/box-drop-unused-value-statement-regression.rs

@@ -0,0 +1,12 @@
+//! 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>.
+
+//@ run-pass
+
+pub fn main() {
+    let y: Box<_> = Box::new(1);
+    drop(y);
+}

diff --git a/tests/ui/weird-exprs.rs b/tests/ui/expr/syntax-edge-cases-lint-clean.rs
similarity index 100%
rename from tests/ui/weird-exprs.rs
rename to tests/ui/expr/syntax-edge-cases-lint-clean.rs


diff --git a/tests/ui/wrong-hashset-issue-42918.rs b/tests/ui/hashmap/hashset-enum-variant.rs
similarity index 60%
rename from tests/ui/wrong-hashset-issue-42918.rs
rename to tests/ui/hashmap/hashset-enum-variant.rs
index 5795cc5..39a59d3 100644
--- a/tests/ui/wrong-hashset-issue-42918.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/write-fmt-errors.rs b/tests/ui/io-checks/write-macro-error.rs
similarity index 82%
rename from tests/ui/write-fmt-errors.rs
rename to tests/ui/io-checks/write-macro-error.rs
index b48fa3f..857ea00 100644
--- a/tests/ui/write-fmt-errors.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 @@ fn write(&mut self, _buf: &[u8]) -> io::Result<usize> {
         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
new file mode 100644
index 0000000..2281212
--- /dev/null
+++ b/tests/ui/lang-items/lang-item-unknown-definition-error.rs

@@ -0,0 +1,12 @@
+//! 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`
+    loop {}
+}
+
+fn main() {}

diff --git a/tests/ui/unknown-language-item.stderr b/tests/ui/lang-items/lang-item-unknown-definition-error.stderr
similarity index 81%
rename from tests/ui/unknown-language-item.stderr
rename to tests/ui/lang-items/lang-item-unknown-definition-error.stderr
index 832f134..3b93975 100644
--- a/tests/ui/unknown-language-item.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
new file mode 100644
index 0000000..c02f606
--- /dev/null
+++ b/tests/ui/modules/module-qualified-paths-basic.rs

@@ -0,0 +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;
+    }
+}
+
+mod bar {
+    pub fn y() -> isize {
+        return 1;
+    }
+}
+
+pub fn main() {
+    foo::x();
+    bar::y();
+}

diff --git a/tests/ui/use-nested-groups.rs b/tests/ui/modules/module-use-nested-groups.rs
similarity index 85%
rename from tests/ui/use-nested-groups.rs
rename to tests/ui/modules/module-use-nested-groups.rs
index c5d66a8..84d1f91 100644
--- a/tests/ui/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
new file mode 100644
index 0000000..5c9d2a6
--- /dev/null
+++ b/tests/ui/modules/primitive-type-module-deprecated-paths.rs

@@ -0,0 +1,13 @@
+//! 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
+
+#![allow(deprecated, deprecated_in_future)]
+use std::{f32, u16};
+
+fn main() {
+    let _ = u16::MAX;
+    let _ = f32::EPSILON;
+    let _ = std::f64::MANTISSA_DIGITS;
+}

diff --git a/tests/ui/modules/use-keyword-reexport-type-alias.rs b/tests/ui/modules/use-keyword-reexport-type-alias.rs
new file mode 100644
index 0000000..c62bd96
--- /dev/null
+++ b/tests/ui/modules/use-keyword-reexport-type-alias.rs

@@ -0,0 +1,25 @@
+//! 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 self::A as B;
+    pub use super::A;
+}
+
+impl A {
+    fn f() {}
+    fn g() {
+        Self::f()
+    }
+}
+
+fn main() {
+    let a: A = test::A;
+    let b: A = test::B;
+    let c: () = A::g();
+}

diff --git a/tests/ui/unsigned-literal-negation.rs b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
similarity index 68%
rename from tests/ui/unsigned-literal-negation.rs
rename to tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.rs
index 943c7f7..4325c8b 100644
--- a/tests/ui/unsigned-literal-negation.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/unsigned-literal-negation.stderr b/tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
similarity index 85%
rename from tests/ui/unsigned-literal-negation.stderr
rename to tests/ui/numbers-arithmetic/unary-negation-unsigned-integer-error.stderr
index 0bedbc1..4ce870d 100644
--- a/tests/ui/unsigned-literal-negation.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 @@
    |
 
 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 @@
    |
 
 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
new file mode 100644
index 0000000..2226e4d
--- /dev/null
+++ b/tests/ui/panics/unwind-force-no-unwind-tables.rs

@@ -0,0 +1,41 @@
+//! 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
+//@ compile-flags: -C panic=unwind -C force-unwind-tables=n
+
+use std::panic::{self, AssertUnwindSafe};
+
+struct Increase<'a>(&'a mut u8);
+
+impl Drop for Increase<'_> {
+    fn drop(&mut self) {
+        *self.0 += 1;
+    }
+}
+
+#[inline(never)]
+fn unwind() {
+    panic!();
+}
+
+#[inline(never)]
+fn increase(count: &mut u8) {
+    let _increase = Increase(count);
+    unwind();
+}
+
+fn main() {
+    let mut count = 0;
+    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
new file mode 100644
index 0000000..0950b044
--- /dev/null
+++ b/tests/ui/process/process-spawn-failure.rs

@@ -0,0 +1,84 @@
+//! 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'
+//@ ignore-fuchsia no 'ps'
+//@ ignore-nto no 'ps'
+
+#![feature(rustc_private)]
+
+use std::process::Command;
+
+// The output from "ps -A -o pid,ppid,args" should look like this:
+//   PID  PPID COMMAND
+//     1     0 /sbin/init
+//     2     0 [kthreadd]
+// ...
+//  6076  9064 /bin/zsh
+// ...
+//  7164  6076 ./spawn-failure
+//  7165  7164 [spawn-failure] <defunct>
+//  7166  7164 [spawn-failure] <defunct>
+// ...
+//  7197  7164 [spawn-failure] <defunct>
+//  7198  7164 ps -A -o pid,ppid,command
+// ...
+
+#[cfg(unix)]
+fn find_zombies() {
+    extern crate libc;
+    let my_pid = unsafe { libc::getpid() };
+
+    // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/ps.html
+    let ps_cmd_output = Command::new("ps").args(&["-A", "-o", "pid,ppid,args"]).output().unwrap();
+    let ps_output = String::from_utf8_lossy(&ps_cmd_output.stdout);
+    // On AIX, the PPID is not always present, such as when a process is blocked
+    // (marked as <exiting>), or if a process is idle. In these situations,
+    // 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();
+
+    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")
+        {
+            panic!("Zombie child {}", line);
+        }
+    }
+}
+
+#[cfg(windows)]
+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<_>>();
+
+    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
new file mode 100644
index 0000000..e661a4f
--- /dev/null
+++ b/tests/ui/process/windows-exit-code-still-active.rs

@@ -0,0 +1,26 @@
+//! 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
+
+#[cfg(windows)]
+fn main() {
+    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();
+        assert_eq!(status.code(), Some(259));
+    } else {
+        process::exit(259);
+    }
+}
+
+#[cfg(not(windows))]
+fn main() {}

diff --git a/tests/ui/reachable/diverging-expressions-unreachable-code.rs b/tests/ui/reachable/diverging-expressions-unreachable-code.rs
new file mode 100644
index 0000000..bb56987
--- /dev/null
+++ b/tests/ui/reachable/diverging-expressions-unreachable-code.rs

@@ -0,0 +1,19 @@
+//@ run-pass
+
+#![allow(unused_must_use)]
+#![allow(unreachable_code)]
+
+fn _id(x: bool) -> bool {
+    x
+}
+
+fn _call_id() {
+    let _c = panic!();
+    _id(_c);
+}
+
+fn _call_id_3() {
+    _id(return) && _id(return);
+}
+
+pub fn main() {}

diff --git a/tests/ui/unreachable-code.rs b/tests/ui/reachable/unreachable-code-diverging-expressions.rs
similarity index 75%
rename from tests/ui/unreachable-code.rs
rename to tests/ui/reachable/unreachable-code-diverging-expressions.rs
index 0c46a38..0067641 100644
--- a/tests/ui/unreachable-code.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/virtual-call-attrs-issue-137646.rs b/tests/ui/traits/virtual-call-parameter-handling.rs
similarity index 77%
rename from tests/ui/virtual-call-attrs-issue-137646.rs
rename to tests/ui/traits/virtual-call-parameter-handling.rs
index e80bd57..71ed459 100644
--- a/tests/ui/virtual-call-attrs-issue-137646.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
new file mode 100644
index 0000000..c3ee806
--- /dev/null
+++ b/tests/ui/type/unit-type-basic-usages.rs

@@ -0,0 +1,14 @@
+//! Checks the basic usage of unit type
+
+//@ run-pass
+
+fn f(u: ()) {
+    u
+}
+
+pub fn main() {
+    let u1: () = ();
+    let mut _u2: () = f(u1);
+    _u2 = ();
+    ()
+}

diff --git a/tests/ui/usize-generic-argument-parent.rs b/tests/ui/type/usize-no-generic-arguments.rs
similarity index 65%
rename from tests/ui/usize-generic-argument-parent.rs
rename to tests/ui/type/usize-no-generic-arguments.rs
index 4ab80d9..d4d1eea 100644
--- a/tests/ui/usize-generic-argument-parent.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/usize-generic-argument-parent.stderr b/tests/ui/type/usize-no-generic-arguments.stderr
similarity index 89%
rename from tests/ui/usize-generic-argument-parent.stderr
rename to tests/ui/type/usize-no-generic-arguments.stderr
index 9c081a2..f1f3456 100644
--- a/tests/ui/usize-generic-argument-parent.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/unit.rs b/tests/ui/unit.rs
deleted file mode 100644
index 04404fc..0000000
--- a/tests/ui/unit.rs
+++ /dev/null

@@ -1,16 +0,0 @@
-//@ run-pass
-
-#![allow(unused_assignments)]
-#![allow(unknown_lints)]
-
-#![allow(unused_variables)]
-#![allow(dead_assignment)]
-
-fn f(u: ()) { return u; }
-
-pub fn main() {
-    let u1: () = ();
-    let mut u2: () = f(u1);
-    u2 = ();
-    return ();
-}

diff --git a/tests/ui/unknown-language-item.rs b/tests/ui/unknown-language-item.rs
deleted file mode 100644
index ce206d2..0000000
--- a/tests/ui/unknown-language-item.rs
+++ /dev/null

@@ -1,10 +0,0 @@
-#![allow(unused)]
-#![feature(lang_items)]
-
-#[lang = "foo"]
-fn bar() -> ! {
-//~^^ ERROR definition of an unknown lang item: `foo`
-    loop {}
-}
-
-fn main() {}

diff --git a/tests/ui/unnamed_argument_mode.rs b/tests/ui/unnamed_argument_mode.rs
deleted file mode 100644
index 2014e0d..0000000
--- a/tests/ui/unnamed_argument_mode.rs
+++ /dev/null

@@ -1,13 +0,0 @@
-//@ run-pass
-
-fn good(_a: &isize) {
-}
-
-// unnamed argument &isize is now parse x: &isize
-
-fn called<F>(_f: F) where F: FnOnce(&isize) {
-}
-
-pub fn main() {
-    called(good);
-}

diff --git a/tests/ui/unreachable-code-1.rs b/tests/ui/unreachable-code-1.rs
deleted file mode 100644
index 9c5f7c8..0000000
--- a/tests/ui/unreachable-code-1.rs
+++ /dev/null

@@ -1,19 +0,0 @@
-//@ run-pass
-
-#![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 call_id_3() { id(return) && id(return); }
-
-pub fn main() {
-}

diff --git a/tests/ui/uninit-empty-types.rs b/tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
similarity index 60%
rename from tests/ui/uninit-empty-types.rs
rename to tests/ui/unsafe/maybe-uninit-zero-sized-types.rs
index 82474d8..e587ca5 100644
--- a/tests/ui/uninit-empty-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;
 

diff --git a/tests/ui/unused-move.rs b/tests/ui/unused-move.rs
deleted file mode 100644
index 3d5eff2..0000000
--- a/tests/ui/unused-move.rs
+++ /dev/null

@@ -1,12 +0,0 @@
-//@ run-pass
-// Issue #3878
-// Issue Name: Unused move causes a crash
-// Abstract: zero-fill to block after drop
-
-
-#![allow(path_statements)]
-
-pub fn main() {
-    let y: Box<_> = Box::new(1);
-    y;
-}

diff --git a/tests/ui/unwind-no-uwtable.rs b/tests/ui/unwind-no-uwtable.rs
deleted file mode 100644
index fb8082e..0000000
--- a/tests/ui/unwind-no-uwtable.rs
+++ /dev/null

@@ -1,34 +0,0 @@
-//@ run-pass
-//@ needs-unwind
-//@ ignore-windows target requires uwtable
-//@ compile-flags: -C panic=unwind -C force-unwind-tables=n
-
-use std::panic::{self, AssertUnwindSafe};
-
-struct Increase<'a>(&'a mut u8);
-
-impl Drop for Increase<'_> {
-    fn drop(&mut self) {
-        *self.0 += 1;
-    }
-}
-
-#[inline(never)]
-fn unwind() {
-    panic!();
-}
-
-#[inline(never)]
-fn increase(count: &mut u8) {
-    let _increase = Increase(count);
-    unwind();
-}
-
-fn main() {
-    let mut count = 0;
-    assert!(panic::catch_unwind(AssertUnwindSafe(
-        #[inline(never)]
-        || increase(&mut count)
-    )).is_err());
-    assert_eq!(count, 1);
-}

diff --git a/tests/ui/use-import-export.rs b/tests/ui/use-import-export.rs
deleted file mode 100644
index d948ffc..0000000
--- a/tests/ui/use-import-export.rs
+++ /dev/null

@@ -1,11 +0,0 @@
-//@ run-pass
-
-mod foo {
-    pub fn x() -> isize { return 1; }
-}
-
-mod bar {
-    pub fn y() -> isize { return 1; }
-}
-
-pub fn main() { foo::x(); bar::y(); }

diff --git a/tests/ui/use-keyword-2.rs b/tests/ui/use-keyword-2.rs
deleted file mode 100644
index 4f3d1ee..0000000
--- a/tests/ui/use-keyword-2.rs
+++ /dev/null

@@ -1,23 +0,0 @@
-//@ run-pass
-
-#![allow(unused_variables)]
-pub struct A;
-
-mod test {
-    pub use super :: A;
-
-    pub use self :: A as B;
-}
-
-impl A {
-    fn f() {}
-    fn g() {
-        Self :: f()
-    }
-}
-
-fn main() {
-    let a: A = test::A;
-    let b: A = test::B;
-    let c: () = A::g();
-}

diff --git a/tests/ui/use-module-level-int-consts.rs b/tests/ui/use-module-level-int-consts.rs
deleted file mode 100644
index 6e8c705..0000000
--- a/tests/ui/use-module-level-int-consts.rs
+++ /dev/null

@@ -1,12 +0,0 @@
-//@ 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};
-
-fn main() {
-    let _ = u16::MAX;
-    let _ = f32::EPSILON;
-    let _ = std::f64::MANTISSA_DIGITS;
-}

diff --git a/tests/ui/wait-forked-but-failed-child.rs b/tests/ui/wait-forked-but-failed-child.rs
deleted file mode 100644
index 4a7f2be..0000000
--- a/tests/ui/wait-forked-but-failed-child.rs
+++ /dev/null

@@ -1,71 +0,0 @@
-//@ run-pass
-//@ needs-subprocess
-//@ ignore-vxworks no 'ps'
-//@ ignore-fuchsia no 'ps'
-//@ ignore-nto no 'ps'
-
-#![feature(rustc_private)]
-
-use std::process::Command;
-
-// The output from "ps -A -o pid,ppid,args" should look like this:
-//   PID  PPID COMMAND
-//     1     0 /sbin/init
-//     2     0 [kthreadd]
-// ...
-//  6076  9064 /bin/zsh
-// ...
-//  7164  6076 ./spawn-failure
-//  7165  7164 [spawn-failure] <defunct>
-//  7166  7164 [spawn-failure] <defunct>
-// ...
-//  7197  7164 [spawn-failure] <defunct>
-//  7198  7164 ps -A -o pid,ppid,command
-// ...
-
-#[cfg(unix)]
-fn find_zombies() {
-    extern crate libc;
-    let my_pid = unsafe { libc::getpid() };
-
-    // https://pubs.opengroup.org/onlinepubs/9699919799/utilities/ps.html
-    let ps_cmd_output = Command::new("ps").args(&["-A", "-o", "pid,ppid,args"]).output().unwrap();
-    let ps_output = String::from_utf8_lossy(&ps_cmd_output.stdout);
-    // On AIX, the PPID is not always present, such as when a process is blocked
-    // (marked as <exiting>), or if a process is idle. In these situations,
-    // 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();
-
-    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") {
-            panic!("Zombie child {}", line);
-        }
-    }
-}
-
-#[cfg(windows)]
-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<_>>();
-
-    find_zombies();
-    // then _failures goes out of scope
-}

diff --git a/tests/ui/walk-struct-literal-with.rs b/tests/ui/walk-struct-literal-with.rs
deleted file mode 100644
index ee1a77e..0000000
--- a/tests/ui/walk-struct-literal-with.rs
+++ /dev/null

@@ -1,17 +0,0 @@
-struct Mine{
-    test: String,
-    other_val: isize
-}
-
-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()};
-    println!("{}", start.test); //~ ERROR borrow of moved value: `start`
-}

diff --git a/tests/ui/weak-new-uninhabited-issue-48493.rs b/tests/ui/weak-new-uninhabited-issue-48493.rs
deleted file mode 100644
index ce7d578..0000000
--- a/tests/ui/weak-new-uninhabited-issue-48493.rs
+++ /dev/null

@@ -1,7 +0,0 @@
-//@ run-pass
-
-fn main() {
-    enum Void {}
-    let _ = std::rc::Weak::<Void>::new();
-    let _ = std::sync::Weak::<Void>::new();
-}

diff --git a/tests/ui/weird-exit-code.rs b/tests/ui/weird-exit-code.rs
deleted file mode 100644
index e016343..0000000
--- a/tests/ui/weird-exit-code.rs
+++ /dev/null

@@ -1,28 +0,0 @@
-//@ 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;
-
-    if env::args().len() == 1 {
-        let status = Command::new(env::current_exe().unwrap())
-                             .arg("foo")
-                             .status()
-                             .unwrap();
-        assert_eq!(status.code(), Some(259));
-    } else {
-        process::exit(259);
-    }
-}
-
-#[cfg(not(windows))]
-fn main() {}