Add tests for updated closure/generator printing

Co-authored-by: Dhruv Jauhar <dhruvjhr@gmail.com>
Co-authored-by: Logan Mosier <logmosier@gmail.com>

src/test/ui/closures/print/closure-print-generic-1.rs

@@ -0,0 +1,23 @@
+fn to_fn_once<F: FnOnce()>(f: F) -> F {
+    f
+}
+
+fn f<T: std::fmt::Display>(y: T) {
+    struct Foo<U: std::fmt::Display> {
+        x: U,
+    };
+
+    let foo = Foo { x: "x" };
+
+    let c = to_fn_once(move || {
+        println!("{} {}", foo.x, y);
+    });
+
+    c();
+    c();
+    //~^ ERROR use of moved value
+}
+
+fn main() {
+    f("S");
+}

src/test/ui/closures/print/closure-print-generic-1.stderr

@@ -0,0 +1,20 @@
+error[E0382]: use of moved value: `c`
+  --> $DIR/closure-print-generic-1.rs:17:5
+   |
+LL |     let c = to_fn_once(move || {
+   |         - move occurs because `c` has type `[closure@$DIR/closure-print-generic-1.rs:12:24: 14:6]`, which does not implement the `Copy` trait
+...
+LL |     c();
+   |     --- `c` moved due to this call
+LL |     c();
+   |     ^ value used here after move
+   |
+note: this value implements `FnOnce`, which causes it to be moved when called
+  --> $DIR/closure-print-generic-1.rs:16:5
+   |
+LL |     c();
+   |     ^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.

src/test/ui/closures/print/closure-print-generic-2.rs

@@ -0,0 +1,13 @@
+mod mod1 {
+    pub fn f<T: std::fmt::Display>(t: T) {
+        let x = 20;
+
+        let c = || println!("{} {}", t, x);
+        let c1: () = c;
+        //~^ ERROR mismatched types
+    }
+}
+
+fn main() {
+    mod1::f(5i32);
+}

src/test/ui/closures/print/closure-print-generic-2.stderr

@@ -0,0 +1,20 @@
+error[E0308]: mismatched types
+  --> $DIR/closure-print-generic-2.rs:6:22
+   |
+LL |         let c = || println!("{} {}", t, x);
+   |                 -------------------------- the found closure
+LL |         let c1: () = c;
+   |                 --   ^ expected `()`, found closure
+   |                 |
+   |                 expected due to this
+   |
+   = note: expected unit type `()`
+                found closure `[closure@$DIR/closure-print-generic-2.rs:5:17: 5:43]`
+help: use parentheses to call this closure
+   |
+LL |         let c1: () = c();
+   |                       ^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.

src/test/ui/closures/print/closure-print-generic-trim-off-verbose-2.rs

@@ -0,0 +1,16 @@
+// compile-flags: -Ztrim-diagnostic-paths=off -Zverbose
+
+mod mod1 {
+    pub fn f<T: std::fmt::Display>(t: T)
+    {
+        let x = 20;
+
+        let c = || println!("{} {}", t, x);
+        let c1 : () = c;
+        //~^ ERROR mismatched types
+    }
+}
+
+fn main() {
+    mod1::f(5i32);
+}

src/test/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr

@@ -0,0 +1,20 @@
+error[E0308]: mismatched types
+  --> $DIR/closure-print-generic-trim-off-verbose-2.rs:9:23
+   |
+LL |         let c = || println!("{} {}", t, x);
+   |                 -------------------------- the found closure
+LL |         let c1 : () = c;
+   |                  --   ^ expected `()`, found closure
+   |                  |
+   |                  expected due to this
+   |
+   = note: expected unit type `()`
+                found closure `[mod1::f<T>::{closure#0} closure_substs=(unavailable)]`
+help: use parentheses to call this closure
+   |
+LL |         let c1 : () = c();
+   |                        ^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.

src/test/ui/closures/print/closure-print-generic-verbose-1.rs

@@ -0,0 +1,24 @@
+// compile-flags: -Zverbose
+
+fn to_fn_once<F:FnOnce()>(f: F) -> F { f }
+
+fn f<T: std::fmt::Display>(y: T) {
+    struct Foo<U: std::fmt::Display> {
+        x: U
+    };
+
+    let foo =  Foo{ x: "x" };
+
+    let c = to_fn_once(move|| {
+        println!("{} {}", foo.x, y);
+    });
+
+    c();
+    c();
+    //~^ ERROR use of moved value
+}
+
+
+fn main() {
+    f("S");
+}

src/test/ui/closures/print/closure-print-generic-verbose-1.stderr

@@ -0,0 +1,20 @@
+error[E0382]: use of moved value: `c`
+  --> $DIR/closure-print-generic-verbose-1.rs:17:5
+   |
+LL |     let c = to_fn_once(move|| {
+   |         - move occurs because `c` has type `[f<T>::{closure#0} closure_kind_ty=i32 closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=(Foo<&'_#10r str>, T)]`, which does not implement the `Copy` trait
+...
+LL |     c();
+   |     --- `c` moved due to this call
+LL |     c();
+   |     ^ value used here after move
+   |
+note: this value implements `FnOnce`, which causes it to be moved when called
+  --> $DIR/closure-print-generic-verbose-1.rs:16:5
+   |
+LL |     c();
+   |     ^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0382`.

src/test/ui/closures/print/closure-print-generic-verbose-2.rs

@@ -0,0 +1,16 @@
+// compile-flags: -Zverbose
+
+mod mod1 {
+    pub fn f<T: std::fmt::Display>(t: T)
+    {
+        let x = 20;
+
+        let c = || println!("{} {}", t, x);
+        let c1 : () = c;
+        //~^ ERROR mismatched types
+    }
+}
+
+fn main() {
+    mod1::f(5i32);
+}

src/test/ui/closures/print/closure-print-generic-verbose-2.stderr

@@ -0,0 +1,20 @@
+error[E0308]: mismatched types
+  --> $DIR/closure-print-generic-verbose-2.rs:9:23
+   |
+LL |         let c = || println!("{} {}", t, x);
+   |                 -------------------------- the found closure
+LL |         let c1 : () = c;
+   |                  --   ^ expected `()`, found closure
+   |                  |
+   |                  expected due to this
+   |
+   = note: expected unit type `()`
+                found closure `[f<T>::{closure#0} closure_substs=(unavailable)]`
+help: use parentheses to call this closure
+   |
+LL |         let c1 : () = c();
+   |                        ^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.

src/test/ui/closures/print/closure-print-verbose.rs

@@ -0,0 +1,12 @@
+// compile-flags: -Zverbose
+
+// Same as closure-coerce-fn-1.rs
+
+// Ensure that capturing closures are never coerced to fns
+// Especially interesting as non-capturing closures can be.
+
+fn main() {
+    let mut a = 0u8;
+    let foo: fn(u8) -> u8 = |v: u8| { a += v; a };
+    //~^ ERROR mismatched types
+}

src/test/ui/closures/print/closure-print-verbose.stderr

@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/closure-print-verbose.rs:10:29
+   |
+LL |     let foo: fn(u8) -> u8 = |v: u8| { a += v; a };
+   |              ------------   ^^^^^^^^^^^^^^^^^^^^^ expected fn pointer, found closure
+   |              |
+   |              expected due to this
+   |
+   = note: expected fn pointer `fn(u8) -> u8`
+                 found closure `[main::{closure#0} closure_substs=(unavailable)]`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.

src/test/ui/generator/print/generator-print-verbose-1.rs

@@ -0,0 +1,60 @@
+// compile-flags: -Zverbose
+
+// Same as: src/test/ui/generator/issue-68112.stderr
+
+#![feature(generators, generator_trait)]
+
+use std::{
+    cell::RefCell,
+    sync::Arc,
+    pin::Pin,
+    ops::{Generator, GeneratorState},
+};
+
+pub struct Ready<T>(Option<T>);
+impl<T> Generator<()> for Ready<T> {
+    type Return = T;
+    type Yield = ();
+    fn resume(mut self: Pin<&mut Self>, _args: ()) -> GeneratorState<(), T> {
+        GeneratorState::Complete(self.0.take().unwrap())
+    }
+}
+pub fn make_gen1<T>(t: T) -> Ready<T> {
+    Ready(Some(t))
+}
+
+fn require_send(_: impl Send) {}
+
+fn make_non_send_generator() -> impl Generator<Return = Arc<RefCell<i32>>> {
+    make_gen1(Arc::new(RefCell::new(0)))
+}
+
+fn test1() {
+    let send_gen = || {
+        let _non_send_gen = make_non_send_generator();
+        yield;
+    };
+    require_send(send_gen);
+    //~^ ERROR generator cannot be sent between threads
+}
+
+pub fn make_gen2<T>(t: T) -> impl Generator<Return = T> {
+    || {
+        yield;
+        t
+    }
+}
+fn make_non_send_generator2() -> impl Generator<Return = Arc<RefCell<i32>>> {
+    make_gen2(Arc::new(RefCell::new(0)))
+}
+
+fn test2() {
+    let send_gen = || {
+        let _non_send_gen = make_non_send_generator2();
+        yield;
+    };
+    require_send(send_gen);
+    //~^ ERROR `RefCell<i32>` cannot be shared between threads safely
+}
+
+fn main() {}

src/test/ui/generator/print/generator-print-verbose-1.stderr

@@ -0,0 +1,40 @@
+error: generator cannot be sent between threads safely
+  --> $DIR/generator-print-verbose-1.rs:37:5
+   |
+LL | fn require_send(_: impl Send) {}
+   |                         ---- required by this bound in `require_send`
+...
+LL |     require_send(send_gen);
+   |     ^^^^^^^^^^^^ generator is not `Send`
+   |
+   = help: the trait `Sync` is not implemented for `RefCell<i32>`
+note: generator is not `Send` as this value is used across a yield
+  --> $DIR/generator-print-verbose-1.rs:35:9
+   |
+LL |         let _non_send_gen = make_non_send_generator();
+   |             ------------- has type `Opaque(DefId(0:24 ~ generator_print_verbose_1[317d]::make_non_send_generator::{opaque#0}), [])` which is not `Send`
+LL |         yield;
+   |         ^^^^^ yield occurs here, with `_non_send_gen` maybe used later
+LL |     };
+   |     - `_non_send_gen` is later dropped here
+
+error[E0277]: `RefCell<i32>` cannot be shared between threads safely
+  --> $DIR/generator-print-verbose-1.rs:56:5
+   |
+LL | fn require_send(_: impl Send) {}
+   |                         ---- required by this bound in `require_send`
+...
+LL |     require_send(send_gen);
+   |     ^^^^^^^^^^^^ `RefCell<i32>` cannot be shared between threads safely
+   |
+   = help: the trait `Sync` is not implemented for `RefCell<i32>`
+   = note: required because of the requirements on the impl of `Send` for `Arc<RefCell<i32>>`
+   = note: required because it appears within the type `[make_gen2<Arc<RefCell<i32>>>::{closure#0} upvar_tys=(Arc<RefCell<i32>>) {()}]`
+   = note: required because it appears within the type `Opaque(DefId(0:29 ~ generator_print_verbose_1[317d]::make_gen2::{opaque#0}), [std::sync::Arc<std::cell::RefCell<i32>>])`
+   = note: required because it appears within the type `Opaque(DefId(0:32 ~ generator_print_verbose_1[317d]::make_non_send_generator2::{opaque#0}), [])`
+   = note: required because it appears within the type `{Opaque(DefId(0:32 ~ generator_print_verbose_1[317d]::make_non_send_generator2::{opaque#0}), []), ()}`
+   = note: required because it appears within the type `[test2::{closure#0} upvar_tys=() {Opaque(DefId(0:32 ~ generator_print_verbose_1[317d]::make_non_send_generator2::{opaque#0}), []), ()}]`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

src/test/ui/generator/print/generator-print-verbose-2.rs

@@ -0,0 +1,24 @@
+// compile-flags: -Zverbose
+
+// Same as test/ui/generator/not-send-sync.rs
+#![feature(generators)]
+
+use std::cell::Cell;
+
+fn main() {
+    fn assert_sync<T: Sync>(_: T) {}
+    fn assert_send<T: Send>(_: T) {}
+
+    assert_sync(|| {
+        //~^ ERROR: generator cannot be shared between threads safely
+        let a = Cell::new(2);
+        yield;
+    });
+
+    let a = Cell::new(2);
+    assert_send(|| {
+        //~^ ERROR: E0277
+        drop(&a);
+        yield;
+    });
+}

src/test/ui/generator/print/generator-print-verbose-2.stderr

@@ -0,0 +1,36 @@
+error[E0277]: `Cell<i32>` cannot be shared between threads safely
+  --> $DIR/generator-print-verbose-2.rs:19:5
+   |
+LL |     fn assert_send<T: Send>(_: T) {}
+   |                       ---- required by this bound in `assert_send`
+...
+LL |     assert_send(|| {
+   |     ^^^^^^^^^^^ `Cell<i32>` cannot be shared between threads safely
+   |
+   = help: the trait `Sync` is not implemented for `Cell<i32>`
+   = note: required because of the requirements on the impl of `Send` for `&'_#3r Cell<i32>`
+   = note: required because it appears within the type `[main::{closure#1} upvar_tys=(&'_#3r Cell<i32>) _#16t]`
+
+error: generator cannot be shared between threads safely
+  --> $DIR/generator-print-verbose-2.rs:12:5
+   |
+LL |     fn assert_sync<T: Sync>(_: T) {}
+   |                       ---- required by this bound in `assert_sync`
+...
+LL |     assert_sync(|| {
+   |     ^^^^^^^^^^^ generator is not `Sync`
+   |
+   = help: within `[main::{closure#0} upvar_tys=() {Cell<i32>, ()}]`, the trait `Sync` is not implemented for `Cell<i32>`
+note: generator is not `Sync` as this value is used across a yield
+  --> $DIR/generator-print-verbose-2.rs:15:9
+   |
+LL |         let a = Cell::new(2);
+   |             - has type `Cell<i32>` which is not `Sync`
+LL |         yield;
+   |         ^^^^^ yield occurs here, with `a` maybe used later
+LL |     });
+   |     - `a` is later dropped here
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

src/test/ui/generator/print/generator-print-verbose-3.rs

@@ -0,0 +1,12 @@
+// compile-flags: -Zverbose
+
+#![feature(generators, generator_trait)]
+
+fn main() {
+    let x = "Type mismatch test";
+    let generator :() = || {
+    //~^ ERROR mismatched types
+        yield 1i32;
+        return x
+    };
+}

src/test/ui/generator/print/generator-print-verbose-3.stderr

@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/generator-print-verbose-3.rs:7:25
+   |
+LL |       let generator :() = || {
+   |  ____________________--___^
+   | |                    |
+   | |                    expected due to this
+LL | |
+LL | |         yield 1i32;
+LL | |         return x
+LL | |     };
+   | |_____^ expected `()`, found generator
+   |
+   = note: expected unit type `()`
+              found generator `[main::{closure#0} upvar_tys=(unavailable) _#5t]`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.