add tests of issue + bless one other test

Author: LorrensP-2158466

tests/ui/unboxed-closures/unboxed-closures-infer-argument-types-two-region-pointers.stderr

@@ -4,7 +4,7 @@ error: lifetime may not live long enough
 LL |     doit(0, &|x, y| {
    |               -  - has type `&'1 i32`
    |               |
-   |               has type `&Cell<&'2 i32>`
+   |               has type `&'2 Cell<&i32>`
 LL |         x.set(y);
    |         ^^^^^^^^ argument requires that `'1` must outlive `'2`
    |

tests/ui/wf/check-wf-of-closure-args-complex.rs

@@ -0,0 +1,48 @@
+// The same as check-wf-of-closure-args-complex, but this example causes
+// a use-after-free if we don't perform the wf check.
+//
+#![feature(unboxed_closures)]
+
+use std::sync::OnceLock;
+
+type Payload = Box<i32>;
+
+static STORAGE: OnceLock<&'static Payload> = OnceLock::new();
+
+trait Store {
+    fn store(&self);
+}
+impl Store for &'static Payload {
+    fn store(&self) {
+        STORAGE.set(*self).unwrap();
+    }
+}
+
+#[repr(transparent)]
+struct MyTy<T: Store>(T);
+impl<T: Store> Drop for MyTy<T> {
+    fn drop(&mut self) {
+        self.0.store();
+    }
+}
+
+trait IsFn: for<'x> Fn<(&'x Payload,)> {}
+
+impl IsFn for for<'x> fn(&'x Payload) -> MyTy<&'x Payload> {}
+
+fn foo(f: impl for<'x> Fn(&'x Payload)) {
+    let a = Box::new(1);
+    f(&a);
+}
+fn bar<F: IsFn>(f: F) {
+    foo(|x| { f(x); });
+}
+
+fn main() {
+    // If no wf-check is done on this closure given to `bar`, this compiles fine and
+    // a use-after-free will occur.
+    bar::<for<'a> fn(&'a Payload) -> MyTy<&'a Payload>>(|x| unsafe { //~ ERROR: lifetime may not live long enough
+        std::mem::transmute::<&Payload, MyTy<&Payload>>(x)
+    });
+    println!("{}", STORAGE.get().unwrap());
+}

tests/ui/wf/check-wf-of-closure-args-complex.stderr

@@ -0,0 +1,10 @@
+error: lifetime may not live long enough
+  --> $DIR/check-wf-of-closure-args-complex.rs:44:60
+   |
+LL |     bar::<for<'a> fn(&'a Payload) -> MyTy<&'a Payload>>(|x| unsafe {
+   |                                                          - ^ requires that `'1` must outlive `'static`
+   |                                                          |
+   |                                                          has type `&'1 Box<i32>`
+
+error: aborting due to 1 previous error
+

tests/ui/wf/check-wf-of-closure-args.rs

@@ -0,0 +1,14 @@
+// Checks that we perform WF checks on closure args, regardless of wether they
+// are used in the closure it self.
+// related to issue #104478
+
+struct MyTy<T: Trait>(T);
+trait Trait {}
+impl Trait for &'static str {}
+fn wf<T>(_: T) {}
+
+fn main() {
+    let _: for<'x> fn(MyTy<&'x str>) = |_| {}; //~ ERROR: lifetime may not live long enough
+
+    let _: for<'x> fn(MyTy<&'x str>) = |x| wf(x); //~ ERROR: lifetime may not live long enough
+}

tests/ui/wf/check-wf-of-closure-args.stderr

@@ -0,0 +1,20 @@
+error: lifetime may not live long enough
+  --> $DIR/check-wf-of-closure-args.rs:11:41
+   |
+LL |     let _: for<'x> fn(MyTy<&'x str>) = |_| {};
+   |                                         ^
+   |                                         |
+   |                                         has type `MyTy<&'1 str>`
+   |                                         requires that `'1` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/check-wf-of-closure-args.rs:13:41
+   |
+LL |     let _: for<'x> fn(MyTy<&'x str>) = |x| wf(x);
+   |                                         ^
+   |                                         |
+   |                                         has type `MyTy<&'1 str>`
+   |                                         requires that `'1` must outlive `'static`
+
+error: aborting due to 2 previous errors
+