Rollup merge of #143300 - Kivooeo:tf25, r=tgross35

workingjubilee · web-flow · commit 5f415da0b52f · 2025-07-04T23:26:23.000-07:00
`tests/ui`: A New Order [25/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`
diff --git a/tests/ui/attributes/reexport-test-harness-entry-point.rs b/tests/ui/attributes/reexport-test-harness-entry-point.rs
@@ -1,3 +1,6 @@
+//! Check that `#[reexport_test_harness_main]` correctly reexports the test harness entry point
+//! and allows it to be called from within the code.
+
 //@ run-pass
 //@ compile-flags:--test
 
diff --git a/tests/ui/const-ptr/pointer-address-stability.rs b/tests/ui/const-ptr/pointer-address-stability.rs
@@ -0,0 +1,11 @@
+//! Check that taking the address of a stack variable with `&`
+//! yields a stable and comparable pointer.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/2040>.
+
+//@ run-pass
+
+pub fn main() {
+    let foo: isize = 1;
+    assert_eq!(&foo as *const isize, &foo as *const isize);
+}
diff --git a/tests/ui/diagnostic-flags/error-format-short.rs b/tests/ui/diagnostic-flags/error-format-short.rs
@@ -1,3 +1,6 @@
+//! Check that compile errors are formatted in the "short" style
+//! when `--error-format=short` is used.
+
 //@ compile-flags: --error-format=short
 
 fn foo(_: u32) {}
diff --git a/tests/ui/diagnostic-flags/error-format-short.stderr b/tests/ui/diagnostic-flags/error-format-short.stderr
@@ -0,0 +1,3 @@
+$DIR/error-format-short.rs:9:9: error[E0308]: mismatched types: expected `u32`, found `String`
+$DIR/error-format-short.rs:11:7: error[E0599]: no method named `salut` found for type `u32` in the current scope: method not found in `u32`
+error: aborting due to 2 previous errors
diff --git a/tests/ui/drop/drop-once-on-move.rs b/tests/ui/drop/drop-once-on-move.rs
@@ -1,3 +1,7 @@
+//! Check that types not implementing `Copy` are moved, not copied, during assignment
+//! operations, and their `Drop` implementation is called exactly once when the
+//! value goes out of scope.
+
 //@ run-pass
 
 #![allow(non_camel_case_types)]
@@ -15,9 +19,7 @@ impl<'a> Drop for r<'a> {
 }
 
 fn r(i: &Cell<isize>) -> r<'_> {
-    r {
-        i: i
-    }
+    r { i }
 }
 
 pub fn main() {
diff --git a/tests/ui/drop/drop-scope-exit.rs b/tests/ui/drop/drop-scope-exit.rs
@@ -1,31 +1,37 @@
+//! Check that the `Drop` implementation is called when a value goes out of scope.
+
 //@ run-pass
 
 #![allow(non_camel_case_types)]
 use std::cell::Cell;
 
 struct shrinky_pointer<'a> {
-  i: &'a Cell<isize>,
+    i: &'a Cell<isize>,
 }
 
 impl<'a> Drop for shrinky_pointer<'a> {
     fn drop(&mut self) {
-        println!("Hello!"); self.i.set(self.i.get() - 1);
+        println!("Hello!");
+        self.i.set(self.i.get() - 1);
     }
 }
 
 impl<'a> shrinky_pointer<'a> {
-    pub fn look_at(&self) -> isize { return self.i.get(); }
+    pub fn look_at(&self) -> isize {
+        return self.i.get();
+    }
 }
 
 fn shrinky_pointer(i: &Cell<isize>) -> shrinky_pointer<'_> {
-    shrinky_pointer {
-        i: i
-    }
+    shrinky_pointer { i }
 }
 
 pub fn main() {
     let my_total = &Cell::new(10);
-    { let pt = shrinky_pointer(my_total); assert_eq!(pt.look_at(), 10); }
+    {
+        let pt = shrinky_pointer(my_total);
+        assert_eq!(pt.look_at(), 10);
+    }
     println!("my_total = {}", my_total.get());
     assert_eq!(my_total.get(), 9);
 }
diff --git a/tests/ui/generics/trait-incorrect-generic-args.rs b/tests/ui/generics/trait-incorrect-generic-args.rs
@@ -1,5 +1,7 @@
+//! Check for compilation errors when a trait is used with an incorrect number of generic arguments.
+
 fn main() {
-    trait Seq { }
+    trait Seq {}
 
     impl<T> Seq<T> for Vec<T> {
         //~^ ERROR trait takes 0 generic arguments but 1 generic argument
diff --git a/tests/ui/generics/trait-incorrect-generic-args.stderr b/tests/ui/generics/trait-incorrect-generic-args.stderr
@@ -1,29 +1,29 @@
 error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
-  --> $DIR/seq-args.rs:4:13
+  --> $DIR/trait-incorrect-generic-args.rs:6:13
    |
 LL |     impl<T> Seq<T> for Vec<T> {
    |             ^^^--- help: remove the unnecessary generics
    |             |
    |             expected 0 generic arguments
    |
 note: trait defined here, with 0 generic parameters
-  --> $DIR/seq-args.rs:2:11
+  --> $DIR/trait-incorrect-generic-args.rs:4:11
    |
-LL |     trait Seq { }
+LL |     trait Seq {}
    |           ^^^
 
 error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied
-  --> $DIR/seq-args.rs:9:10
+  --> $DIR/trait-incorrect-generic-args.rs:11:10
    |
 LL |     impl Seq<bool> for u32 {
    |          ^^^------ help: remove the unnecessary generics
    |          |
    |          expected 0 generic arguments
    |
 note: trait defined here, with 0 generic parameters
-  --> $DIR/seq-args.rs:2:11
+  --> $DIR/trait-incorrect-generic-args.rs:4:11
    |
-LL |     trait Seq { }
+LL |     trait Seq {}
    |           ^^^
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/io-checks/io-stdout-blocking-writes.rs b/tests/ui/io-checks/io-stdout-blocking-writes.rs
@@ -1,10 +1,12 @@
+//! Check that writes to standard output are blocking, avoiding interleaving
+//! even with concurrent writes from multiple threads.
+
 //@ run-pass
 //@ needs-subprocess
 
-use std::env;
 use std::io::prelude::*;
 use std::process::Command;
-use std::thread;
+use std::{env, thread};
 
 const THREADS: usize = 20;
 const WRITES: usize = 100;
@@ -33,14 +35,16 @@ fn parent() {
 }
 
 fn child() {
-    let threads = (0..THREADS).map(|_| {
-        thread::spawn(|| {
-            let buf = [b'a'; WRITE_SIZE];
-            for _ in 0..WRITES {
-                write_all(&buf);
-            }
+    let threads = (0..THREADS)
+        .map(|_| {
+            thread::spawn(|| {
+                let buf = [b'a'; WRITE_SIZE];
+                for _ in 0..WRITES {
+                    write_all(&buf);
+                }
+            })
         })
-    }).collect::<Vec<_>>();
+        .collect::<Vec<_>>();
 
     for thread in threads {
         thread.join().unwrap();
@@ -63,8 +67,8 @@ fn write_all(buf: &[u8]) {
 fn write_all(buf: &[u8]) {
     use std::fs::File;
     use std::mem;
-    use std::os::windows::raw::*;
     use std::os::windows::prelude::*;
+    use std::os::windows::raw::*;
 
     const STD_OUTPUT_HANDLE: u32 = (-11i32) as u32;
 
diff --git a/tests/ui/shadowed/primitive-type-shadowing.rs b/tests/ui/shadowed/primitive-type-shadowing.rs
@@ -1,3 +1,6 @@
+//! Check that a primitive type can be shadowed by a user-defined type, and the primitive type
+//! can still be referenced using its fully qualified path (e.g., `core::primitive::bool`).
+
 //@ check-pass
 
 mod bar {
diff --git a/tests/ui/shadowed/use-shadows-reexport.rs b/tests/ui/shadowed/use-shadows-reexport.rs
@@ -1,3 +1,5 @@
+//! Check that a local `use` declaration can shadow a re-exported item within the same module.
+
 //@ run-pass
 
 #![allow(unused_imports)]
diff --git a/tests/ui/short-error-format.stderr b/tests/ui/short-error-format.stderr
diff --git a/tests/ui/sized-borrowed-pointer.rs b/tests/ui/sized-borrowed-pointer.rs
diff --git a/tests/ui/sized-cycle-note.rs b/tests/ui/sized-cycle-note.rs
diff --git a/tests/ui/sized-cycle-note.stderr b/tests/ui/sized-cycle-note.stderr
diff --git a/tests/ui/sized-owned-pointer.rs b/tests/ui/sized-owned-pointer.rs
diff --git a/tests/ui/sized/recursive-type-infinite-size.rs b/tests/ui/sized/recursive-type-infinite-size.rs
@@ -0,0 +1,16 @@
+//! Check for compilation errors when recursive types are defined in a way
+//! that leads to an infinite size.
+
+struct Baz {
+    //~^ ERROR recursive types `Baz` and `Foo` have infinite size
+    q: Option<Foo>,
+}
+struct Foo {
+    q: Option<Baz>,
+}
+
+impl Foo {
+    fn bar(&self) {}
+}
+
+fn main() {}
diff --git a/tests/ui/sized/recursive-type-infinite-size.stderr b/tests/ui/sized/recursive-type-infinite-size.stderr
@@ -0,0 +1,25 @@
+error[E0072]: recursive types `Baz` and `Foo` have infinite size
+  --> $DIR/recursive-type-infinite-size.rs:4:1
+   |
+LL | struct Baz {
+   | ^^^^^^^^^^
+LL |
+LL |     q: Option<Foo>,
+   |               --- recursive without indirection
+LL | }
+LL | struct Foo {
+   | ^^^^^^^^^^
+LL |     q: Option<Baz>,
+   |               --- recursive without indirection
+   |
+help: insert some indirection (e.g., a `Box`, `Rc`, or `&`) to break the cycle
+   |
+LL ~     q: Option<Box<Foo>>,
+LL | }
+LL | struct Foo {
+LL ~     q: Option<Box<Baz>>,
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0072`.
diff --git a/tests/ui/sized/sized-box-unsized-content.rs b/tests/ui/sized/sized-box-unsized-content.rs
@@ -0,0 +1,11 @@
+//! Check that `Box<T>` is `Sized`, even when `T` is a dynamically sized type.
+
+//@ run-pass
+
+#![allow(dead_code)]
+
+fn bar<T: Sized>() {}
+fn foo<T>() {
+    bar::<Box<T>>()
+}
+pub fn main() {}
diff --git a/tests/ui/sized/sized-reference-to-unsized.rs b/tests/ui/sized/sized-reference-to-unsized.rs
@@ -0,0 +1,11 @@
+//! Check that a reference to a potentially unsized type (`&T`) is itself considered `Sized`.
+
+//@ run-pass
+
+#![allow(dead_code)]
+
+fn bar<T: Sized>() {}
+fn foo<T>() {
+    bar::<&T>()
+}
+pub fn main() {}
diff --git a/tests/ui/stable-addr-of.rs b/tests/ui/stable-addr-of.rs
diff --git a/tests/ui/sync/atomic-types-not-copyable.rs b/tests/ui/sync/atomic-types-not-copyable.rs
@@ -1,8 +1,10 @@
-// Issue #8380
+//! Check that atomic types from `std::sync::atomic` are not `Copy`
+//! and cannot be moved out of a shared reference.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/8380>.
 
-
-use std::sync::atomic::*;
 use std::ptr;
+use std::sync::atomic::*;
 
 fn main() {
     let x = AtomicBool::new(false);
diff --git a/tests/ui/sync/atomic-types-not-copyable.stderr b/tests/ui/sync/atomic-types-not-copyable.stderr
@@ -1,5 +1,5 @@
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:9:13
+  --> $DIR/atomic-types-not-copyable.rs:11:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicBool`, which does not implement the `Copy` trait
@@ -11,7 +11,7 @@ LL +     let x = &x;
    |
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:11:13
+  --> $DIR/atomic-types-not-copyable.rs:13:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicIsize`, which does not implement the `Copy` trait
@@ -23,7 +23,7 @@ LL +     let x = &x;
    |
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:13:13
+  --> $DIR/atomic-types-not-copyable.rs:15:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicUsize`, which does not implement the `Copy` trait
@@ -35,7 +35,7 @@ LL +     let x = &x;
    |
 
 error[E0507]: cannot move out of a shared reference
-  --> $DIR/std-uncopyable-atomics.rs:15:13
+  --> $DIR/atomic-types-not-copyable.rs:17:13
    |
 LL |     let x = *&x;
    |             ^^^ move occurs because value has type `std::sync::atomic::AtomicPtr<usize>`, which does not implement the `Copy` trait
diff --git a/tests/ui/target-feature/target-feature-detection.rs b/tests/ui/target-feature/target-feature-detection.rs
diff --git a/tests/ui/traits/error-trait-object-from-string.rs b/tests/ui/traits/error-trait-object-from-string.rs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	+$DIR/error-format-short.rs:9:9: error[E0308]: mismatched types: expected `u32`, found `String`
	`2`	+$DIR/error-format-short.rs:11:7: error[E0599]: no method named `salut` found for type `u32` in the current scope: method not found in `u32`
	`3`	`+error: aborting due to 2 previous errors`
Original file line number	Diff line number	Diff line change
`@@ -1,29 +1,29 @@`
`1`	`1`	`error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied`
`2`		`- --> $DIR/seq-args.rs:4:13`
	`2`	`+ --> $DIR/trait-incorrect-generic-args.rs:6:13`
`3`	`3`	`\|`
`4`	`4`	`LL \| impl<T> Seq<T> for Vec<T> {`
`5`	`5`	`\| ^^^--- help: remove the unnecessary generics`
`6`	`6`	`\| \|`
`7`	`7`	`\| expected 0 generic arguments`
`8`	`8`	`\|`
`9`	`9`	`note: trait defined here, with 0 generic parameters`
`10`		`- --> $DIR/seq-args.rs:2:11`
	`10`	`+ --> $DIR/trait-incorrect-generic-args.rs:4:11`
`11`	`11`	`\|`
`12`		`-LL \| trait Seq { }`
	`12`	`+LL \| trait Seq {}`
`13`	`13`	`\| ^^^`
`14`	`14`
`15`	`15`	`error[E0107]: trait takes 0 generic arguments but 1 generic argument was supplied`
`16`		`- --> $DIR/seq-args.rs:9:10`
	`16`	`+ --> $DIR/trait-incorrect-generic-args.rs:11:10`
`17`	`17`	`\|`
`18`	`18`	`LL \| impl Seq<bool> for u32 {`
`19`	`19`	`\| ^^^------ help: remove the unnecessary generics`
`20`	`20`	`\| \|`
`21`	`21`	`\| expected 0 generic arguments`
`22`	`22`	`\|`
`23`	`23`	`note: trait defined here, with 0 generic parameters`
`24`		`- --> $DIR/seq-args.rs:2:11`
	`24`	`+ --> $DIR/trait-incorrect-generic-args.rs:4:11`
`25`	`25`	`\|`
`26`		`-LL \| trait Seq { }`
	`26`	`+LL \| trait Seq {}`
`27`	`27`	`\| ^^^`
`28`	`28`
`29`	`29`	`error: aborting due to 2 previous errors`