Rollup merge of #143301 - Kivooeo:tf26, r=tgross35

`tests/ui`: A New Order [26/N]

> [!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````

42 files changed, 271 insertions, 207 deletions

diff --git a/tests/ui/auxiliary/svh-a-base.rs b/tests/ui/auxiliary/svh-a-base.rs
deleted file mode 100644
index 36b41fc818f..00000000000
--- a/tests/ui/auxiliary/svh-a-base.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//! The `svh-a-*.rs` files are all deviations from the base file
-//! svh-a-base.rs with some difference (usually in `fn foo`) that
-//! should not affect the strict version hash (SVH) computation
-//! (#14132).
-
-#![crate_name = "a"]
-
-macro_rules! three {
-    () => { 3 }
-}
-
-pub trait U {}
-pub trait V {}
-impl U for () {}
-impl V for () {}
-
-static A_CONSTANT : isize = 2;
-
-pub fn foo<T:U>(_: isize) -> isize {
-    3
-}
-
-pub fn an_unused_name() -> isize {
-    4
-}
diff --git a/tests/ui/auxiliary/svh-b.rs b/tests/ui/auxiliary/svh-b.rs
deleted file mode 100644
index 57029f70888..00000000000
--- a/tests/ui/auxiliary/svh-b.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//! This is a client of the `a` crate defined in `svn-a-base.rs`. The
-//! rpass and cfail tests (such as `run-pass/svh-add-comment.rs`) use
-//! it by swapping in a different object code library crate built from
-//! some variant of `svn-a-base.rs`, and then we are checking if the
-//! compiler properly ignores or accepts the change, based on whether
-//! the change could affect the downstream crate content or not
-//! (#14132).
-
-#![crate_name = "b"]
-
-extern crate a;
-
-pub fn foo() { assert_eq!(a::foo::<()>(0), 3); }
diff --git a/tests/ui/super-let.borrowck.stderr b/tests/ui/borrowck/super-let-lifetime-and-drop.borrowck.stderr
index 01ef29d8758..7fe0b47ed57 100644
--- a/tests/ui/super-let.borrowck.stderr
+++ b/tests/ui/borrowck/super-let-lifetime-and-drop.borrowck.stderr
@@ -1,5 +1,5 @@
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:30:28
+  --> $DIR/super-let-lifetime-and-drop.rs:30:28
    |
 LL |             super let b = DropMe(&mut x);
    |                                  ------ `x` is borrowed here
@@ -11,7 +11,7 @@ LL |     }
    |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:46:28
+  --> $DIR/super-let-lifetime-and-drop.rs:46:28
    |
 LL |             super let b = &DropMe(&mut x);
    |                            --------------
@@ -26,7 +26,7 @@ LL |     }
    |     - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:64:32
+  --> $DIR/super-let-lifetime-and-drop.rs:64:32
    |
 LL |             super let b = identity(&DropMe(&mut x));
    |                                     --------------
@@ -40,7 +40,7 @@ LL |         };
    |          - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:87:36
+  --> $DIR/super-let-lifetime-and-drop.rs:87:36
    |
 LL |                 super let b = identity(&DropMe(&mut x));
    |                                         --------------
@@ -55,7 +55,7 @@ LL |         ));
    |           - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:107:28
+  --> $DIR/super-let-lifetime-and-drop.rs:107:28
    |
 LL |                 super let b = DropMe(&mut x);
    |                                      ------ `x` is borrowed here
@@ -67,7 +67,7 @@ LL |     }
    |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:125:28
+  --> $DIR/super-let-lifetime-and-drop.rs:125:28
    |
 LL |             super let b = DropMe(&mut x);
    |                                  ------ `x` is borrowed here
@@ -79,7 +79,7 @@ LL |     }
    |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:143:28
+  --> $DIR/super-let-lifetime-and-drop.rs:143:28
    |
 LL |             super let b = DropMe(&mut x);
    |                                  ------ `x` is borrowed here
@@ -91,7 +91,7 @@ LL |     }
    |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:159:28
+  --> $DIR/super-let-lifetime-and-drop.rs:159:28
    |
 LL |             b = DropMe(&mut x);
    |                        ------ `x` is borrowed here
@@ -102,7 +102,7 @@ LL |         drop(a);
    |              - borrow later used here
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/super-let.rs:172:33
+  --> $DIR/super-let-lifetime-and-drop.rs:172:33
    |
 LL |         #[cfg(borrowck)] { a = &String::from("asdf"); };
    |                                 ^^^^^^^^^^^^^^^^^^^^- temporary value is freed at the end of this statement
@@ -115,7 +115,7 @@ LL |         let _ = a;
    = note: consider using a `let` binding to create a longer lived value
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:206:28
+  --> $DIR/super-let-lifetime-and-drop.rs:206:28
    |
 LL |                     super let d = &DropMe(&mut x);
    |                                    --------------
@@ -130,7 +130,7 @@ LL |     }
    |     - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:227:32
+  --> $DIR/super-let-lifetime-and-drop.rs:227:32
    |
 LL |                     super let d = identity(&DropMe(&mut x));
    |                                             --------------
@@ -145,7 +145,7 @@ LL |         };
    |          - ... and the borrow might be used here, when that temporary is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:246:28
+  --> $DIR/super-let-lifetime-and-drop.rs:246:28
    |
 LL |             super let b = DropMe(&mut x);
    |                                  ------ `x` is borrowed here
@@ -157,7 +157,7 @@ LL |     }
    |     - borrow might be used here, when `b` is dropped and runs the `Drop` code for type `DropMe`
 
 error[E0506]: cannot assign to `x` because it is borrowed
-  --> $DIR/super-let.rs:263:28
+  --> $DIR/super-let-lifetime-and-drop.rs:263:28
    |
 LL |             let dropme = Some(DropMe(&mut x));
    |                                      ------ `x` is borrowed here
diff --git a/tests/ui/super-let.rs b/tests/ui/borrowck/super-let-lifetime-and-drop.rs
index 380470f792f..380470f792f 100644
--- a/tests/ui/super-let.rs
+++ b/tests/ui/borrowck/super-let-lifetime-and-drop.rs
diff --git a/tests/ui/tag-variant-cast-non-nullary.fixed b/tests/ui/cast/cast-enum-to-primitive-error.fixed
index 7e22116b955..4d447c81ac9 100644
--- a/tests/ui/tag-variant-cast-non-nullary.fixed
+++ b/tests/ui/cast/cast-enum-to-primitive-error.fixed
@@ -1,5 +1,10 @@
+//! This test verifies that a direct non-primitive cast from an enum to an integer type
+//! is correctly disallowed, even when a `From` implementation exists for that enum.
+
 //@ run-rustfix
+
 #![allow(dead_code, unused_variables)]
+
 enum NonNullary {
     Nullary,
     Other(isize),
@@ -16,5 +21,7 @@ impl From<NonNullary> for isize {
 
 fn main() {
     let v = NonNullary::Nullary;
-    let val = isize::from(v); //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    let val = isize::from(v);
+    //~^ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    //~| HELP consider using the `From` trait instead
 }
diff --git a/tests/ui/tag-variant-cast-non-nullary.rs b/tests/ui/cast/cast-enum-to-primitive-error.rs
index 1a64cf1933d..fdbe63b9bc7 100644
--- a/tests/ui/tag-variant-cast-non-nullary.rs
+++ b/tests/ui/cast/cast-enum-to-primitive-error.rs
@@ -1,5 +1,10 @@
+//! This test verifies that a direct non-primitive cast from an enum to an integer type
+//! is correctly disallowed, even when a `From` implementation exists for that enum.
+
 //@ run-rustfix
+
 #![allow(dead_code, unused_variables)]
+
 enum NonNullary {
     Nullary,
     Other(isize),
@@ -16,5 +21,7 @@ impl From<NonNullary> for isize {
 
 fn main() {
     let v = NonNullary::Nullary;
-    let val = v as isize; //~ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    let val = v as isize;
+    //~^ ERROR non-primitive cast: `NonNullary` as `isize` [E0605]
+    //~| HELP consider using the `From` trait instead
 }
diff --git a/tests/ui/tag-variant-cast-non-nullary.stderr b/tests/ui/cast/cast-enum-to-primitive-error.stderr
index 8ec1c5f11ec..692e5c19e06 100644
--- a/tests/ui/tag-variant-cast-non-nullary.stderr
+++ b/tests/ui/cast/cast-enum-to-primitive-error.stderr
@@ -1,5 +1,5 @@
 error[E0605]: non-primitive cast: `NonNullary` as `isize`
-  --> $DIR/tag-variant-cast-non-nullary.rs:19:15
+  --> $DIR/cast-enum-to-primitive-error.rs:24:15
    |
 LL |     let val = v as isize;
    |               ^^^^^^^^^^ an `as` expression can be used to convert enum types to numeric types only if the enum type is unit-only or field-less
diff --git a/tests/ui/trivial_casts-rpass.rs b/tests/ui/cast/coercion-as-explicit-cast.rs
index 701e2f6166f..b99f5d93478 100644
--- a/tests/ui/trivial_casts-rpass.rs
+++ b/tests/ui/cast/coercion-as-explicit-cast.rs
@@ -1,5 +1,7 @@
+//! This test checks that various forms of "trivial" casts and coercions
+//! can be explicitly performed using the `as` keyword without compilation errors.
+
 //@ run-pass
-// Test that all coercions can actually be done using casts (modulo the lints).
 
 #![allow(trivial_casts, trivial_numeric_casts)]
 
diff --git a/tests/ui/trivial_casts-rpass.stderr b/tests/ui/cast/coercion-as-explicit-cast.stderr
index 74698b61ab4..d66298c7d44 100644
--- a/tests/ui/trivial_casts-rpass.stderr
+++ b/tests/ui/cast/coercion-as-explicit-cast.stderr
@@ -1,5 +1,5 @@
 warning: method `foo` is never used
-  --> $DIR/trivial_casts-rpass.rs:7:8
+  --> $DIR/coercion-as-explicit-cast.rs:9:8
    |
 LL | trait Foo {
    |       --- method in this trait
diff --git a/tests/ui/generics/generic-enum-errors.rs b/tests/ui/generics/generic-enum-errors.rs
new file mode 100644
index 00000000000..111f5635168
--- /dev/null
+++ b/tests/ui/generics/generic-enum-errors.rs
@@ -0,0 +1,15 @@
+//! This test checks that unused generics are rejected by compiler
+
+enum Quux<T> {
+    //~^ ERROR: parameter `T` is never used
+    Bar,
+}
+
+fn foo(c: Quux) {
+    //~^ ERROR missing generics for enum `Quux`
+    assert!((false));
+}
+
+fn main() {
+    panic!();
+}
diff --git a/tests/ui/tag-type-args.stderr b/tests/ui/generics/generic-enum-errors.stderr
index def13832e1a..47a8badbd5d 100644
--- a/tests/ui/tag-type-args.stderr
+++ b/tests/ui/generics/generic-enum-errors.stderr
@@ -1,26 +1,26 @@
 error[E0392]: type parameter `T` is never used
-  --> $DIR/tag-type-args.rs:1:11
+  --> $DIR/generic-enum-errors.rs:3:11
    |
-LL | enum Quux<T> { Bar }
+LL | enum Quux<T> {
    |           ^ unused type parameter
    |
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
    = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
 
 error[E0107]: missing generics for enum `Quux`
-  --> $DIR/tag-type-args.rs:4:11
+  --> $DIR/generic-enum-errors.rs:8:11
    |
-LL | fn foo(c: Quux) { assert!((false)); }
+LL | fn foo(c: Quux) {
    |           ^^^^ expected 1 generic argument
    |
 note: enum defined here, with 1 generic parameter: `T`
-  --> $DIR/tag-type-args.rs:1:6
+  --> $DIR/generic-enum-errors.rs:3:6
    |
-LL | enum Quux<T> { Bar }
+LL | enum Quux<T> {
    |      ^^^^ -
 help: add missing generic argument
    |
-LL | fn foo(c: Quux<T>) { assert!((false)); }
+LL | fn foo(c: Quux<T>) {
    |               +++
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/modules/module-super-access.rs b/tests/ui/modules/module-super-access.rs
new file mode 100644
index 00000000000..8acba607f6c
--- /dev/null
+++ b/tests/ui/modules/module-super-access.rs
@@ -0,0 +1,16 @@
+//! Check path resolution using `super`
+
+//@ run-pass
+
+#![allow(dead_code)]
+
+pub mod a {
+    pub fn f() {}
+    pub mod b {
+        fn g() {
+            super::f(); // Accessing `f` from module `a` (parent of `b`)
+        }
+    }
+}
+
+pub fn main() {}
diff --git a/tests/ui/modules/super-at-crate-root.rs b/tests/ui/modules/super-at-crate-root.rs
new file mode 100644
index 00000000000..d605dc0cccb
--- /dev/null
+++ b/tests/ui/modules/super-at-crate-root.rs
@@ -0,0 +1,6 @@
+//! Check that `super` keyword used at the crate root (top-level) results in a compilation error
+//! as there is no parent module to resolve.
+
+use super::f; //~ ERROR there are too many leading `super` keywords
+
+fn main() {}
diff --git a/tests/ui/super-at-top-level.stderr b/tests/ui/modules/super-at-crate-root.stderr
index 4dce81fbef4..02798708864 100644
--- a/tests/ui/super-at-top-level.stderr
+++ b/tests/ui/modules/super-at-crate-root.stderr
@@ -1,5 +1,5 @@
 error[E0433]: failed to resolve: there are too many leading `super` keywords
-  --> $DIR/super-at-top-level.rs:1:5
+  --> $DIR/super-at-crate-root.rs:4:5
    |
 LL | use super::f;
    |     ^^^^^ there are too many leading `super` keywords
diff --git a/tests/ui/trailing-comma.rs b/tests/ui/parser/syntactic-trailing-commas.rs
index 53b76fb6037..ba688dffb3c 100644
--- a/tests/ui/trailing-comma.rs
+++ b/tests/ui/parser/syntactic-trailing-commas.rs
@@ -1,3 +1,11 @@
+//! Checks trailing commas are accepted in various places:
+//! - Generic parameters in function and struct definitions.
+//! - Function and method arguments.
+//! - Tuple and array literal expressions.
+//! - Tuple and array destructuring patterns, including those with `..`.
+//! - Enum variant declarations.
+//! - Attributes.
+
 //@ run-pass
 
 fn f<T,>(_: T,) {}
diff --git a/tests/ui/ptr_ops/ptr-swap-basic.rs b/tests/ui/ptr_ops/ptr-swap-basic.rs
new file mode 100644
index 00000000000..ce230feeb32
--- /dev/null
+++ b/tests/ui/ptr_ops/ptr-swap-basic.rs
@@ -0,0 +1,14 @@
+//! Check the basic functionality of `std::mem::swap` to ensure it correctly
+//! exchanges the values of two mutable variables.
+
+//@ run-pass
+
+use std::mem::swap;
+
+pub fn main() {
+    let mut x = 3;
+    let mut y = 7;
+    swap(&mut x, &mut y);
+    assert_eq!(x, 7);
+    assert_eq!(y, 3);
+}
diff --git a/tests/ui/swap-overlapping.rs b/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
index 38d5a8109d1..8f05e937d59 100644
--- a/tests/ui/swap-overlapping.rs
+++ b/tests/ui/ptr_ops/ptr-swap-overlapping-regions.rs
@@ -1,17 +1,17 @@
+//! Check that `std::ptr::swap` behaves correctly when the source and destination
+//! pointers refer to the same memory location, avoiding issues like overlapping `memcpy`.
+//!
+//! Regression test: <https://github.com/rust-lang/rust/issues/5041>
+
 //@ run-pass
 
 #![allow(dead_code)]
-// Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same
-
 
 use std::ptr;
 
 pub fn main() {
     let mut test = TestDescAndFn {
-        desc: TestDesc {
-            name: TestName::DynTestName("test".to_string()),
-            should_fail: false
-        },
+        desc: TestDesc { name: TestName::DynTestName("test".to_string()), should_fail: false },
         testfn: TestFn::DynTestFn(22),
     };
     do_swap(&mut test);
@@ -24,7 +24,7 @@ fn do_swap(test: &mut TestDescAndFn) {
 }
 
 pub enum TestName {
-    DynTestName(String)
+    DynTestName(String),
 }
 
 pub enum TestFn {
@@ -34,7 +34,7 @@ pub enum TestFn {
 
 pub struct TestDesc {
     name: TestName,
-    should_fail: bool
+    should_fail: bool,
 }
 
 pub struct TestDescAndFn {
diff --git a/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs b/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
new file mode 100644
index 00000000000..fe10b890700
--- /dev/null
+++ b/tests/ui/recursion/recursion-tail-call-no-arg-leak.rs
@@ -0,0 +1,15 @@
+//! This test verifies that tail call optimization does not lead to argument slot leaks.
+//!
+//! Regression test for: <https://github.com/rust-lang/rust/issues/160>
+
+//@ run-pass
+
+fn inner(dummy: String, b: bool) {
+    if b {
+        return inner(dummy, false);
+    }
+}
+
+pub fn main() {
+    inner("hi".to_string(), true);
+}
diff --git a/tests/ui/recursion/recursion-tail-cps.rs b/tests/ui/recursion/recursion-tail-cps.rs
new file mode 100644
index 00000000000..9014be0ce98
--- /dev/null
+++ b/tests/ui/recursion/recursion-tail-cps.rs
@@ -0,0 +1,34 @@
+//! Verify that mutually recursive functions use CPS to avoid overflowing the stack.
+
+//@ run-pass
+
+fn checktrue(rs: bool) -> bool {
+    assert!(rs);
+    return true;
+}
+
+pub fn main() {
+    let k = checktrue;
+    evenk(42, k);
+    oddk(45, k);
+}
+
+fn evenk(n: isize, k: fn(bool) -> bool) -> bool {
+    println!("evenk");
+    println!("{}", n);
+    if n == 0 {
+        return k(true);
+    } else {
+        return oddk(n - 1, k);
+    }
+}
+
+fn oddk(n: isize, k: fn(bool) -> bool) -> bool {
+    println!("oddk");
+    println!("{}", n);
+    if n == 0 {
+        return k(false);
+    } else {
+        return evenk(n - 1, k);
+    }
+}
diff --git a/tests/ui/super-at-top-level.rs b/tests/ui/super-at-top-level.rs
deleted file mode 100644
index e4d587bc9ef..00000000000
--- a/tests/ui/super-at-top-level.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-use super::f; //~ ERROR there are too many leading `super` keywords
-
-fn main() {
-}
diff --git a/tests/ui/super.rs b/tests/ui/super.rs
deleted file mode 100644
index 69aff4f98e0..00000000000
--- a/tests/ui/super.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-
-pub mod a {
-    pub fn f() {}
-    pub mod b {
-        fn g() {
-            super::f();
-        }
-    }
-}
-
-pub fn main() {
-}
diff --git a/tests/ui/svh-add-nothing.rs b/tests/ui/svh-add-nothing.rs
deleted file mode 100644
index 6e4b9fa7f4c..00000000000
--- a/tests/ui/svh-add-nothing.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ run-pass
-// note that these aux-build directives must be in this order
-//@ aux-build:svh-a-base.rs
-//@ aux-build:svh-b.rs
-//@ aux-build:svh-a-base.rs
-
-
-extern crate a;
-extern crate b;
-
-fn main() {
-    b::foo()
-}
diff --git a/tests/ui/svh/svh-no-api-change-no-recompile.rs b/tests/ui/svh/svh-no-api-change-no-recompile.rs
new file mode 100644
index 00000000000..d4b8ac77444
--- /dev/null
+++ b/tests/ui/svh/svh-no-api-change-no-recompile.rs
@@ -0,0 +1,20 @@
+//! This test verifies that the Signature Version Hash (SVH) system correctly identifies
+//! when changes to an auxiliary crate do not affect its public API.
+//!
+//! Specifically, it checks that adding non-public items to a crate does not alter
+//! its SVH, preventing unnecessary recompilations of dependent crates.
+
+//@ run-pass
+
+// Note that these aux-build directives must be in this order
+
+//@ aux-build:svh-a-base.rs
+//@ aux-build:svh-b.rs
+//@ aux-build:svh-a-base.rs
+
+extern crate a;
+extern crate b;
+
+fn main() {
+    b::foo()
+}
diff --git a/tests/ui/swap-1.rs b/tests/ui/swap-1.rs
deleted file mode 100644
index b104c3ade42..00000000000
--- a/tests/ui/swap-1.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-
-use std::mem::swap;
-
-pub fn main() {
-    let mut x = 3; let mut y = 7;
-    swap(&mut x, &mut y);
-    assert_eq!(x, 7);
-    assert_eq!(y, 3);
-}
diff --git a/tests/ui/switched-expectations.rs b/tests/ui/switched-expectations.rs
deleted file mode 100644
index c5bc84de54c..00000000000
--- a/tests/ui/switched-expectations.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-fn main() {
-    let var = 10i32;
-    let ref string: String = var; //~ ERROR mismatched types [E0308]
-}
diff --git a/tests/ui/tag-type-args.rs b/tests/ui/tag-type-args.rs
deleted file mode 100644
index 75a54927443..00000000000
--- a/tests/ui/tag-type-args.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-enum Quux<T> { Bar }
-//~^ ERROR: parameter `T` is never used
-
-fn foo(c: Quux) { assert!((false)); } //~ ERROR missing generics for enum `Quux`
-
-fn main() { panic!(); }
diff --git a/tests/ui/tail-call-arg-leak.rs b/tests/ui/tail-call-arg-leak.rs
deleted file mode 100644
index 234924307c3..00000000000
--- a/tests/ui/tail-call-arg-leak.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//@ run-pass
-// use of tail calls causes arg slot leaks, issue #160.
-
-fn inner(dummy: String, b: bool) { if b { return inner(dummy, false); } }
-
-pub fn main() {
-    inner("hi".to_string(), true);
-}
diff --git a/tests/ui/tail-cps.rs b/tests/ui/tail-cps.rs
deleted file mode 100644
index fe99dadf795..00000000000
--- a/tests/ui/tail-cps.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ run-pass
-
-fn checktrue(rs: bool) -> bool { assert!(rs); return true; }
-
-pub fn main() { let k = checktrue; evenk(42, k); oddk(45, k); }
-
-fn evenk(n: isize, k: fn(bool) -> bool) -> bool {
-    println!("evenk");
-    println!("{}", n);
-    if n == 0 { return k(true); } else { return oddk(n - 1, k); }
-}
-
-fn oddk(n: isize, k: fn(bool) -> bool) -> bool {
-    println!("oddk");
-    println!("{}", n);
-    if n == 0 { return k(false); } else { return evenk(n - 1, k); }
-}
diff --git a/tests/ui/tail-typeck.rs b/tests/ui/tail-typeck.rs
deleted file mode 100644
index 1deb43c9496..00000000000
--- a/tests/ui/tail-typeck.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn f() -> isize { return g(); } //~ ERROR mismatched types
-
-fn g() -> usize { return 0; }
-
-fn main() { let y = f(); }
diff --git a/tests/ui/tail-typeck.stderr b/tests/ui/tail-typeck.stderr
deleted file mode 100644
index 3cfbfa0fb56..00000000000
--- a/tests/ui/tail-typeck.stderr
+++ /dev/null
@@ -1,16 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/tail-typeck.rs:1:26
-   |
-LL | fn f() -> isize { return g(); }
-   |           -----          ^^^ expected `isize`, found `usize`
-   |           |
-   |           expected `isize` because of return type
-   |
-help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
-   |
-LL | fn f() -> isize { return g().try_into().unwrap(); }
-   |                             ++++++++++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/trait-method-number-parameters.rs b/tests/ui/trait-method-number-parameters.rs
deleted file mode 100644
index 719005d6643..00000000000
--- a/tests/ui/trait-method-number-parameters.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-trait Foo {
-    fn foo(&mut self, x: i32, y: i32) -> i32;
-}
-
-impl Foo for i32 {
-    fn foo(
-        &mut self, //~ ERROR
-        x: i32,
-    ) {
-    }
-}
-
-fn main() {}
diff --git a/tests/ui/traits/trait-method-signature-mismatch.rs b/tests/ui/traits/trait-method-signature-mismatch.rs
new file mode 100644
index 00000000000..118aff69e4e
--- /dev/null
+++ b/tests/ui/traits/trait-method-signature-mismatch.rs
@@ -0,0 +1,18 @@
+//! This test verifies that implementing a trait method with a signature that does not
+//! exactly match its declaration in the trait results in a compilation error.
+//! Specifically, it checks for errors when the number of parameters or the return type
+//! in the `impl` differs from the trait definition.
+
+trait Foo {
+    fn foo(&mut self, x: i32, y: i32) -> i32;
+}
+
+impl Foo for i32 {
+    fn foo(
+        &mut self, //~ ERROR method `foo` has 2 parameters but the declaration
+        x: i32,
+    ) {
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/trait-method-number-parameters.stderr b/tests/ui/traits/trait-method-signature-mismatch.stderr
index cf9b4f2ae79..c7a77aa7aba 100644
--- a/tests/ui/trait-method-number-parameters.stderr
+++ b/tests/ui/traits/trait-method-signature-mismatch.stderr
@@ -1,5 +1,5 @@
 error[E0050]: method `foo` has 2 parameters but the declaration in trait `Foo::foo` has 3
-  --> $DIR/trait-method-number-parameters.rs:7:9
+  --> $DIR/trait-method-signature-mismatch.rs:12:9
    |
 LL |       fn foo(&mut self, x: i32, y: i32) -> i32;
    |              ------------------------- trait requires 3 parameters
diff --git a/tests/ui/traits/tryfrominterror-result-comparison.rs b/tests/ui/traits/tryfrominterror-result-comparison.rs
new file mode 100644
index 00000000000..8a2741e9058
--- /dev/null
+++ b/tests/ui/traits/tryfrominterror-result-comparison.rs
@@ -0,0 +1,19 @@
+//! This test verifies that `std::num::TryFromIntError` correctly implements `PartialEq`,
+//! allowing `Result<T, TryFromIntError>` values to be compared for equality using `==`.
+//! It specifically checks a successful numeric conversion scenario where the `Result::Ok`
+//! variant is compared, ensuring that the comparison yields the expected boolean result.
+
+//@ run-pass
+
+#![allow(unused_must_use)] // Allow ignoring the result of the comparison for the test's purpose
+
+use std::convert::TryFrom;
+use std::num::TryFromIntError;
+
+fn main() {
+    let x: u32 = 125;
+    // Attempt to convert u32 to u8, which should succeed as 125 fits in u8.
+    let y: Result<u8, TryFromIntError> = u8::try_from(x);
+    // Verify that the Result can be correctly compared with an Ok value.
+    y == Ok(125);
+}
diff --git a/tests/ui/transmute-non-immediate-to-immediate.rs b/tests/ui/transmute-non-immediate-to-immediate.rs
deleted file mode 100644
index d99bbcc600f..00000000000
--- a/tests/ui/transmute-non-immediate-to-immediate.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-// Issue #7988
-// Transmuting non-immediate type to immediate type
-
-
-pub fn main() {
-    unsafe {
-        ::std::mem::transmute::<[isize; 1],isize>([1])
-    };
-}
diff --git a/tests/ui/transmute/transmute-array-to-scalar.rs b/tests/ui/transmute/transmute-array-to-scalar.rs
new file mode 100644
index 00000000000..cd6dbb040c8
--- /dev/null
+++ b/tests/ui/transmute/transmute-array-to-scalar.rs
@@ -0,0 +1,14 @@
+//! Verify transmuting from a single-element array to a scalar is allowed.
+//!
+//! Regression test: <https://github.com/rust-lang/rust/issues/7988>
+
+//@ run-pass
+
+pub fn main() {
+    unsafe {
+        // Transmute a single-element array `[1]` (which might be treated as a "non-immediate" type)
+        // to a scalar `isize` (an "immediate" type).
+        // This is safe because `[isize; 1]` and `isize` have the same size and alignment.
+        ::std::mem::transmute::<[isize; 1], isize>([1]);
+    }
+}
diff --git a/tests/ui/transmute-equal-assoc-types.rs b/tests/ui/transmute/transmute-same-associated-type.rs
index 526f4ebbffa..8bc452c6df4 100644
--- a/tests/ui/transmute-equal-assoc-types.rs
+++ b/tests/ui/transmute/transmute-same-associated-type.rs
@@ -1,3 +1,5 @@
+//! Verify transmuting is allowed when `Src` and `Dst` are the same associated type.
+
 //@ check-pass
 
 trait Foo {
diff --git a/tests/ui/try-from-int-error-partial-eq.rs b/tests/ui/try-from-int-error-partial-eq.rs
deleted file mode 100644
index 66a78b3f842..00000000000
--- a/tests/ui/try-from-int-error-partial-eq.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ run-pass
-
-#![allow(unused_must_use)]
-
-use std::convert::TryFrom;
-use std::num::TryFromIntError;
-
-fn main() {
-    let x: u32 = 125;
-    let y: Result<u8, TryFromIntError> = u8::try_from(x);
-    y == Ok(125);
-}
diff --git a/tests/ui/typeck/mismatched-types-ref-binding.rs b/tests/ui/typeck/mismatched-types-ref-binding.rs
new file mode 100644
index 00000000000..baf9056dfeb
--- /dev/null
+++ b/tests/ui/typeck/mismatched-types-ref-binding.rs
@@ -0,0 +1,8 @@
+//! Check that a `mismatched types` error (E0308) is correctly reported when attempting to
+//! bind a reference to an `i32` to a reference to a `String`.
+//! Ensure `ref` bindings report a mismatched type error.
+
+fn main() {
+    let var = 10i32;
+    let ref string: String = var; //~ ERROR mismatched types [E0308]
+}
diff --git a/tests/ui/switched-expectations.stderr b/tests/ui/typeck/mismatched-types-ref-binding.stderr
index e235c2da1f7..c08e5d2a60b 100644
--- a/tests/ui/switched-expectations.stderr
+++ b/tests/ui/typeck/mismatched-types-ref-binding.stderr
@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/switched-expectations.rs:3:30
+  --> $DIR/mismatched-types-ref-binding.rs:7:30
    |
 LL |     let ref string: String = var;
    |                              ^^^ expected `String`, found `i32`
diff --git a/tests/ui/typeck/tail-return-type-mismatch.rs b/tests/ui/typeck/tail-return-type-mismatch.rs
new file mode 100644
index 00000000000..fa0d205ad82
--- /dev/null
+++ b/tests/ui/typeck/tail-return-type-mismatch.rs
@@ -0,0 +1,14 @@
+//! Test for type mismatch error when returning `usize` from `isize` function.
+
+fn f() -> isize {
+    return g();
+    //~^ ERROR mismatched types [E0308]
+}
+
+fn g() -> usize {
+    return 0;
+}
+
+fn main() {
+    let y = f();
+}
diff --git a/tests/ui/typeck/tail-return-type-mismatch.stderr b/tests/ui/typeck/tail-return-type-mismatch.stderr
new file mode 100644
index 00000000000..36da65d0304
--- /dev/null
+++ b/tests/ui/typeck/tail-return-type-mismatch.stderr
@@ -0,0 +1,16 @@
+error[E0308]: mismatched types
+  --> $DIR/tail-return-type-mismatch.rs:4:12
+   |
+LL | fn f() -> isize {
+   |           ----- expected `isize` because of return type
+LL |     return g();
+   |            ^^^ expected `isize`, found `usize`
+   |
+help: you can convert a `usize` to an `isize` and panic if the converted value doesn't fit
+   |
+LL |     return g().try_into().unwrap();
+   |               ++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.