Rollup merge of #143299 - Kivooeo:tf24, r=tgross35

`tests/ui`: A New Order [24/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 #133895.

r? `@tgross35`

Author: workingjubilee

tests/ui/realloc-16687.rs renamed to tests/ui/allocator/alloc-shrink-oob-read.rs

@@ -1,13 +1,13 @@
+//! Sanity check for out-of-bounds read caused by copying the entire original buffer on shrink.
+//!
+//! Regression test for: <https://github.com/rust-lang/rust/issues/16687>
+
 //@ run-pass
-// alloc::heap::reallocate test.
-//
-// Ideally this would be revised to use no_std, but for now it serves
-// well enough to reproduce (and illustrate) the bug from #16687.
 
 #![feature(allocator_api)]
 #![feature(slice_ptr_get)]
 
-use std::alloc::{handle_alloc_error, Allocator, Global, Layout};
+use std::alloc::{Allocator, Global, Layout, handle_alloc_error};
 use std::ptr::{self, NonNull};
 
 fn main() {

tests/ui/phantom-auto-trait.rs renamed to tests/ui/auto-traits/auto-trait-phantom-data-bounds.rs

@@ -1,9 +1,9 @@
-// Ensure that auto trait checks `T` when it encounters a `PhantomData<T>` field, instead of
-// checking the `PhantomData<T>` type itself (which almost always implements an auto trait).
+//! Ensure that auto trait checks `T` when it encounters a `PhantomData<T>` field, instead of
+//! checking the `PhantomData<T>` type itself (which almost always implements an auto trait).
 
 #![feature(auto_traits)]
 
-use std::marker::{PhantomData};
+use std::marker::PhantomData;
 
 unsafe auto trait Zen {}
 

tests/ui/phantom-auto-trait.stderr renamed to tests/ui/auto-traits/auto-trait-phantom-data-bounds.stderr

@@ -1,25 +1,25 @@
 error[E0277]: `T` cannot be shared between threads safely
-  --> $DIR/phantom-auto-trait.rs:21:12
+  --> $DIR/auto-trait-phantom-data-bounds.rs:21:12
    |
 LL |     is_zen(x)
    |     ------ ^ `T` cannot be shared between threads safely
    |     |
    |     required by a bound introduced by this call
    |
 note: required for `&T` to implement `Zen`
-  --> $DIR/phantom-auto-trait.rs:10:24
+  --> $DIR/auto-trait-phantom-data-bounds.rs:10:24
    |
 LL | unsafe impl<'a, T: 'a> Zen for &'a T where T: Sync {}
    |                        ^^^     ^^^^^          ---- unsatisfied trait bound introduced here
 note: required because it appears within the type `PhantomData<&T>`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 note: required because it appears within the type `Guard<'_, T>`
-  --> $DIR/phantom-auto-trait.rs:12:8
+  --> $DIR/auto-trait-phantom-data-bounds.rs:12:8
    |
 LL | struct Guard<'a, T: 'a> {
    |        ^^^^^
 note: required by a bound in `is_zen`
-  --> $DIR/phantom-auto-trait.rs:18:14
+  --> $DIR/auto-trait-phantom-data-bounds.rs:18:14
    |
 LL | fn is_zen<T: Zen>(_: T) {}
    |              ^^^ required by this bound in `is_zen`
@@ -29,32 +29,32 @@ LL | fn not_sync<T: std::marker::Sync>(x: Guard<T>) {
    |              +++++++++++++++++++
 
 error[E0277]: `T` cannot be shared between threads safely
-  --> $DIR/phantom-auto-trait.rs:26:12
+  --> $DIR/auto-trait-phantom-data-bounds.rs:26:12
    |
 LL |     is_zen(x)
    |     ------ ^ `T` cannot be shared between threads safely
    |     |
    |     required by a bound introduced by this call
    |
 note: required for `&T` to implement `Zen`
-  --> $DIR/phantom-auto-trait.rs:10:24
+  --> $DIR/auto-trait-phantom-data-bounds.rs:10:24
    |
 LL | unsafe impl<'a, T: 'a> Zen for &'a T where T: Sync {}
    |                        ^^^     ^^^^^          ---- unsatisfied trait bound introduced here
 note: required because it appears within the type `PhantomData<&T>`
   --> $SRC_DIR/core/src/marker.rs:LL:COL
 note: required because it appears within the type `Guard<'_, T>`
-  --> $DIR/phantom-auto-trait.rs:12:8
+  --> $DIR/auto-trait-phantom-data-bounds.rs:12:8
    |
 LL | struct Guard<'a, T: 'a> {
    |        ^^^^^
 note: required because it appears within the type `Nested<Guard<'_, T>>`
-  --> $DIR/phantom-auto-trait.rs:16:8
+  --> $DIR/auto-trait-phantom-data-bounds.rs:16:8
    |
 LL | struct Nested<T>(T);
    |        ^^^^^^
 note: required by a bound in `is_zen`
-  --> $DIR/phantom-auto-trait.rs:18:14
+  --> $DIR/auto-trait-phantom-data-bounds.rs:18:14
    |
 LL | fn is_zen<T: Zen>(_: T) {}
    |              ^^^ required by this bound in `is_zen`

tests/ui/binop/binop-evaluation-order-primitive.rs

@@ -0,0 +1,15 @@
+//! Test evaluation order in binary operations with primitive types.
+
+//@ run-pass
+
+fn main() {
+    let x = Box::new(0);
+    assert_eq!(
+        0,
+        *x + {
+            drop(x);
+            let _ = Box::new(main);
+            0
+        }
+    );
+}

tests/ui/coercion/basic-ptr-coercions.rs

@@ -0,0 +1,24 @@
+//! Tests basic pointer coercions
+
+//@ run-pass
+
+pub fn main() {
+    // &mut -> &
+    let x: &mut isize = &mut 42;
+    let _x: &isize = x;
+    let _x: &isize = &mut 42;
+
+    // & -> *const
+    let x: &isize = &42;
+    let _x: *const isize = x;
+    let _x: *const isize = &42;
+
+    // &mut -> *const
+    let x: &mut isize = &mut 42;
+    let _x: *const isize = x;
+    let _x: *const isize = &mut 42;
+
+    // *mut -> *const
+    let _x: *mut isize = &mut 42;
+    let _x: *const isize = x;
+}

tests/ui/ptr-coercion.rs renamed to tests/ui/coercion/ptr-mutability-errors.rs

@@ -1,5 +1,4 @@
-// Test coercions between pointers which don't do anything fancy like unsizing.
-// These are testing that we don't lose mutability when converting to raw pointers.
+//! Tests that pointer coercions preserving mutability are enforced:
 
 //@ dont-require-annotations: NOTE
 

tests/ui/ptr-coercion.stderr renamed to tests/ui/coercion/ptr-mutability-errors.stderr

@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/ptr-coercion.rs:9:25
+  --> $DIR/ptr-mutability-errors.rs:8:25
    |
 LL |     let x: *mut isize = x;
    |            ----------   ^ types differ in mutability
@@ -10,7 +10,7 @@ LL |     let x: *mut isize = x;
               found raw pointer `*const isize`
 
 error[E0308]: mismatched types
-  --> $DIR/ptr-coercion.rs:15:25
+  --> $DIR/ptr-mutability-errors.rs:14:25
    |
 LL |     let x: *mut isize = &42;
    |            ----------   ^^^ types differ in mutability
@@ -21,7 +21,7 @@ LL |     let x: *mut isize = &42;
                 found reference `&isize`
 
 error[E0308]: mismatched types
-  --> $DIR/ptr-coercion.rs:21:25
+  --> $DIR/ptr-mutability-errors.rs:20:25
    |
 LL |     let x: *mut isize = x;
    |            ----------   ^ types differ in mutability

tests/ui/print-stdout-eprint-stderr.rs renamed to tests/ui/io-checks/stdout-stderr-separation.rs

@@ -1,3 +1,6 @@
+//! Test that print!/println! output to stdout and eprint!/eprintln!
+//! output to stderr correctly.
+
 //@ run-pass
 //@ needs-subprocess
 

tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.rs

@@ -0,0 +1,25 @@
+//! Test closure parameter type inference and type mismatch errors.
+//!
+//! Related to <https://github.com/rust-lang/rust/issues/2093>.
+
+//@ dont-require-annotations: NOTE
+
+fn let_in<T, F>(x: T, f: F)
+where
+    F: FnOnce(T),
+{
+}
+
+fn main() {
+    let_in(3u32, |i| {
+        assert!(i == 3i32);
+        //~^ ERROR mismatched types
+        //~| NOTE expected `u32`, found `i32`
+    });
+
+    let_in(3i32, |i| {
+        assert!(i == 3u32);
+        //~^ ERROR mismatched types
+        //~| NOTE expected `i32`, found `u32`
+    });
+}

tests/ui/mismatched_types/closure-parameter-type-inference-mismatch.stderr

@@ -0,0 +1,31 @@
+error[E0308]: mismatched types
+  --> $DIR/closure-parameter-type-inference-mismatch.rs:15:22
+   |
+LL |         assert!(i == 3i32);
+   |                 -    ^^^^ expected `u32`, found `i32`
+   |                 |
+   |                 expected because this is `u32`
+   |
+help: change the type of the numeric literal from `i32` to `u32`
+   |
+LL -         assert!(i == 3i32);
+LL +         assert!(i == 3u32);
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/closure-parameter-type-inference-mismatch.rs:21:22
+   |
+LL |         assert!(i == 3u32);
+   |                 -    ^^^^ expected `i32`, found `u32`
+   |                 |
+   |                 expected because this is `i32`
+   |
+help: change the type of the numeric literal from `u32` to `i32`
+   |
+LL -         assert!(i == 3u32);
+LL +         assert!(i == 3i32);
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.