tests/ui: A New Order [23/N]

tests/ui/output-slot-variants.rs → 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
-
 }

tests/ui/optimization-remark.rs → 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() {

tests/ui/codegen/shift-right-operand-mutation.rs

@@ -0,0 +1,18 @@
+//! 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
+
+pub fn main() {
+    let mut b: usize = 1;
+    while b < std::mem::size_of::<usize>() {
+        // This shift operation should not mutate `b`
+        let _ = 0_usize << b;
+        b <<= 1;
+    }
+    assert_eq!(8, b);
+}

tests/ui/codegen/sret-aliasing-rules.rs

@@ -0,0 +1,28 @@
+//! 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)]
+pub struct Foo {
+    f1: isize,
+    _f2: isize,
+}
+
+#[inline(never)]
+pub fn foo(f: &mut Foo) -> Foo {
+    let ret = *f;
+    f.f1 = 0;
+    ret
+}
+
+pub fn main() {
+    let mut f = Foo { f1: 8, _f2: 9 };
+    f = foo(&mut f);
+    assert_eq!(f.f1, 8);
+}

tests/ui/paren-span.rs → tests/ui/macros/macro-paren-span-diagnostic.rs

@@ -1,14 +1,16 @@
-// Be smart about span of parenthesized expression in macro.
+//! Check that error spans in parenthesized macro expressions point to the call site.
 
+#[rustfmt::skip]
 macro_rules! paren {
     ($e:expr) => (($e))
     //            ^^^^ do not highlight here
 }
 
 mod m {
     pub struct S {
-        x: i32
+        x: i32,
     }
+
     pub fn make() -> S {
         S { x: 0 }
     }

tests/ui/paren-span.stderr → tests/ui/macros/macro-paren-span-diagnostic.stderr

@@ -1,5 +1,5 @@
 error[E0616]: field `x` of struct `S` is private
-  --> $DIR/paren-span.rs:19:14
+  --> $DIR/macro-paren-span-diagnostic.rs:21:14
    |
 LL |     paren!(s.x);
    |              ^ private field

tests/ui/panic-while-printing.rs → tests/ui/panics/panic-during-display-formatting.rs

@@ -1,3 +1,5 @@
+//! Check that panics in `Display::fmt` during printing are properly handled.
+
 //@ run-pass
 //@ needs-unwind
 
@@ -18,8 +20,10 @@ impl Display for A {
 
 fn main() {
     set_output_capture(Some(Arc::new(Mutex::new(Vec::new()))));
-    assert!(std::panic::catch_unwind(|| {
-        eprintln!("{}", A);
-    })
-    .is_err());
+    assert!(
+        std::panic::catch_unwind(|| {
+            eprintln!("{}", A);
+        })
+        .is_err()
+    );
 }

tests/ui/panics/panic-handler-closures.rs

@@ -0,0 +1,12 @@
+//! Check that closures can be used inside `#[panic_handler]` functions.
+
+//@ check-pass
+
+#![crate_type = "rlib"]
+#![no_std]
+
+#[panic_handler]
+pub fn panicfmt(_: &::core::panic::PanicInfo) -> ! {
+    |x: u8| x;
+    loop {}
+}

tests/ui/parser/ufcs-return-unused-parens.fixed

@@ -0,0 +1,20 @@
+//! Check that UFCS syntax works correctly in return statements
+//! without requiring workaround parentheses.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/37765>.
+
+//@ run-pass
+//@ run-rustfix
+
+#![allow(dead_code)]
+#![warn(unused_parens)]
+
+fn with_parens<T: ToString>(arg: T) -> String {
+    return <T as ToString>::to_string(&arg); //~ WARN unnecessary parentheses around `return` value
+}
+
+fn no_parens<T: ToString>(arg: T) -> String {
+    return <T as ToString>::to_string(&arg);
+}
+
+fn main() {}

tests/ui/parser/ufcs-return-unused-parens.rs

@@ -0,0 +1,20 @@
+//! Check that UFCS syntax works correctly in return statements
+//! without requiring workaround parentheses.
+//!
+//! Regression test for <https://github.com/rust-lang/rust/issues/37765>.
+
+//@ run-pass
+//@ run-rustfix
+
+#![allow(dead_code)]
+#![warn(unused_parens)]
+
+fn with_parens<T: ToString>(arg: T) -> String {
+    return (<T as ToString>::to_string(&arg)); //~ WARN unnecessary parentheses around `return` value
+}
+
+fn no_parens<T: ToString>(arg: T) -> String {
+    return <T as ToString>::to_string(&arg);
+}
+
+fn main() {}

tests/ui/path-lookahead.stderr → tests/ui/parser/ufcs-return-unused-parens.stderr

@@ -1,11 +1,11 @@
 warning: unnecessary parentheses around `return` value
-  --> $DIR/path-lookahead.rs:10:12
+  --> $DIR/ufcs-return-unused-parens.rs:13:12
    |
 LL |     return (<T as ToString>::to_string(&arg));
    |            ^                                ^
    |
 note: the lint level is defined here
-  --> $DIR/path-lookahead.rs:5:9
+  --> $DIR/ufcs-return-unused-parens.rs:10:9
    |
 LL | #![warn(unused_parens)]
    |         ^^^^^^^^^^^^^

tests/ui/partialeq_help.rs → tests/ui/traits/partialeq-ref-mismatch-diagnostic.rs

@@ -1,8 +1,10 @@
+//! Check diagnostic messages for `PartialEq` trait bound mismatches between `&T` and `T`.
+
 fn foo<T: PartialEq>(a: &T, b: T) {
     a == b; //~ ERROR E0277
 }
 
-fn foo2<T: PartialEq>(a: &T, b: T) where {
+fn foo2<T: PartialEq>(a: &T, b: T) {
     a == b; //~ ERROR E0277
 }