cleaned up some tests

4 files changed, 63 insertions, 39 deletions

diff --git a/tests/ui/codegen/output-slot-init-vs-noninit.rs b/tests/ui/codegen/output-slot-init-vs-noninit.rs
index 97757e74fc4..55586843740 100644
--- a/tests/ui/codegen/output-slot-init-vs-noninit.rs
+++ b/tests/ui/codegen/output-slot-init-vs-noninit.rs
@@ -1,26 +1,48 @@
+//! Check that output slots work correctly for both initializing and non-initializing assignments.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/24>.
+
 //@ run-pass
 
 #![allow(dead_code)]
 #![allow(unused_assignments)]
 #![allow(unknown_lints)]
-
 #![allow(dead_assignment)]
 #![allow(unused_variables)]
 
-struct A { a: isize, b: isize }
-struct Abox { a: Box<isize>, b: Box<isize> }
+struct A {
+    a: isize,
+    b: isize,
+}
 
-fn ret_int_i() -> isize { 10 }
+struct Abox {
+    a: Box<isize>,
+    b: Box<isize>,
+}
 
-fn ret_ext_i() -> Box<isize> { Box::new(10) }
+fn ret_int_i() -> isize {
+    10
+}
 
-fn ret_int_rec() -> A { A {a: 10, b: 10} }
+fn ret_ext_i() -> Box<isize> {
+    Box::new(10)
+}
 
-fn ret_ext_rec() -> Box<A> { Box::new(A {a: 10, b: 10}) }
+fn ret_int_rec() -> A {
+    A { a: 10, b: 10 }
+}
 
-fn ret_ext_mem() -> Abox { Abox {a: Box::new(10), b: Box::new(10) } }
+fn ret_ext_rec() -> Box<A> {
+    Box::new(A { a: 10, b: 10 })
+}
+
+fn ret_ext_mem() -> Abox {
+    Abox { a: Box::new(10), b: Box::new(10) }
+}
 
-fn ret_ext_ext_mem() -> Box<Abox> { Box::new(Abox{a: Box::new(10), b: Box::new(10) }) }
+fn ret_ext_ext_mem() -> Box<Abox> {
+    Box::new(Abox { a: Box::new(10), b: Box::new(10) })
+}
 
 pub fn main() {
     let mut int_i: isize;
@@ -29,40 +51,28 @@ pub fn main() {
     let mut ext_rec: Box<A>;
     let mut ext_mem: Abox;
     let mut ext_ext_mem: Box<Abox>;
-    int_i = ret_int_i(); // initializing
 
+    int_i = ret_int_i(); // initializing
     int_i = ret_int_i(); // non-initializing
-
     int_i = ret_int_i(); // non-initializing
 
     ext_i = ret_ext_i(); // initializing
-
     ext_i = ret_ext_i(); // non-initializing
-
     ext_i = ret_ext_i(); // non-initializing
 
     int_rec = ret_int_rec(); // initializing
-
     int_rec = ret_int_rec(); // non-initializing
-
     int_rec = ret_int_rec(); // non-initializing
 
     ext_rec = ret_ext_rec(); // initializing
-
     ext_rec = ret_ext_rec(); // non-initializing
-
     ext_rec = ret_ext_rec(); // non-initializing
 
     ext_mem = ret_ext_mem(); // initializing
-
     ext_mem = ret_ext_mem(); // non-initializing
-
     ext_mem = ret_ext_mem(); // non-initializing
 
     ext_ext_mem = ret_ext_ext_mem(); // initializing
-
     ext_ext_mem = ret_ext_ext_mem(); // non-initializing
-
     ext_ext_mem = ret_ext_ext_mem(); // non-initializing
-
 }
diff --git a/tests/ui/codegen/remark-flag-functionality.rs b/tests/ui/codegen/remark-flag-functionality.rs
index 165fc63c007..797c55ba830 100644
--- a/tests/ui/codegen/remark-flag-functionality.rs
+++ b/tests/ui/codegen/remark-flag-functionality.rs
@@ -1,24 +1,26 @@
+//! Check that `-Cremark` flag correctly emits LLVM optimization remarks.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/90924>.
+
 //@ build-pass
 //@ ignore-pass
 //@ revisions: all inline merge1 merge2
 //@ compile-flags: --crate-type=lib -Cdebuginfo=1 -Copt-level=2
-//
+
 // Check that remarks can be enabled individually or with "all":
-//
 //@ [all]    compile-flags: -Cremark=all
 //@ [inline] compile-flags: -Cremark=inline
-//
+
 // Check that values of -Cremark flag are accumulated:
-//
 //@ [merge1] compile-flags: -Cremark=all    -Cremark=giraffe
 //@ [merge2] compile-flags: -Cremark=inline -Cremark=giraffe
+
 //@ dont-check-compiler-stderr
 //@ dont-require-annotations: NOTE
 
 #[no_mangle]
 #[inline(never)]
-pub fn f() {
-}
+pub fn f() {}
 
 #[no_mangle]
 pub fn g() {
diff --git a/tests/ui/codegen/shift-right-operand-mutation.rs b/tests/ui/codegen/shift-right-operand-mutation.rs
index 016a667e937..b37a0baa6f8 100644
--- a/tests/ui/codegen/shift-right-operand-mutation.rs
+++ b/tests/ui/codegen/shift-right-operand-mutation.rs
@@ -1,12 +1,19 @@
+//! Ensure shift operations don't mutate their right operand.
+//!
+//! This test checks that expressions like `0 << b` don't accidentally
+//! modify the variable `b` due to codegen issues with virtual registers.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/152>.
+
 //@ run-pass
 
-#![allow(unused_must_use)]
-// Regression test for issue #152.
 pub fn main() {
-    let mut b: usize = 1_usize;
-    while b < std::mem::size_of::<usize>() {
-        0_usize << b;
-        b <<= 1_usize;
-        println!("{}", b);
+    let mut b: usize = 1;
+    while b < size_of::<usize>() {
+        // This shift operation should not mutate `b`
+        let _ = 0_usize << b;
+        b <<= 1;
+        std::hint::black_box(b);
     }
+    assert_eq!(size_of::<usize>(), b);
 }
diff --git a/tests/ui/codegen/sret-aliasing-rules.rs b/tests/ui/codegen/sret-aliasing-rules.rs
index 0dfaa19fadb..f35e722f764 100644
--- a/tests/ui/codegen/sret-aliasing-rules.rs
+++ b/tests/ui/codegen/sret-aliasing-rules.rs
@@ -1,3 +1,11 @@
+//! Check that functions with sret results don't violate aliasing rules.
+//!
+//! When `foo = func(&mut foo)` is called, the compiler must avoid creating
+//! two mutable references to the same variable simultaneously (one for the
+//! parameter and one for the hidden sret out-pointer).
+//!
+//! Regression test for <https://github.com/rust-lang/rust/pull/18250>.
+
 //@ run-pass
 
 #[derive(Copy, Clone)]
@@ -14,10 +22,7 @@ pub fn foo(f: &mut Foo) -> Foo {
 }
 
 pub fn main() {
-    let mut f = Foo {
-        f1: 8,
-        _f2: 9,
-    };
+    let mut f = Foo { f1: 8, _f2: 9 };
     f = foo(&mut f);
     assert_eq!(f.f1, 8);
 }