Fixup and add new tests for generator auto-trait

Author: compiler-errors

src/test/ui/async-await/auto-trait/send-2.rs

@@ -0,0 +1,46 @@
+// run-pass
+// edition:2018
+
+#![allow(unused)]
+
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Poll, Context};
+
+struct Map<Fut, F>(Fut, F);
+
+impl<Fut, F, S> Future for Map<Fut, F> where Fut: Future, F: FnOnce(Fut::Output) -> S {
+    type Output = S;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        todo!()
+    }
+}
+
+enum MaybeDone<Fut: Future> {
+    Maybe(Fut),
+    Done(Fut::Output),
+}
+
+impl<Fut: Future> Future for MaybeDone<Fut> {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        todo!()
+    }
+}
+
+fn drop_static(s: &'static str) {}
+
+async fn foo() {
+    let a = async { "hello" as &'static str};
+        let b = Map(a, drop_static);
+        let c = MaybeDone::Maybe(b);
+        c.await
+}
+
+fn needs_send<T: Send>(t: T) {}
+
+fn main() {
+    needs_send(foo());
+}

src/test/ui/async-await/auto-trait/send-3.rs

@@ -0,0 +1,23 @@
+// run-pass
+// edition:2018
+
+#![allow(unused)]
+
+use std::marker::PhantomData;
+
+pub struct One<T>(PhantomData<T>);
+pub struct Two<T, U>(PhantomData<(T, U)>);
+
+unsafe impl<T, U> Send for Two<T, U> where U: IsOne<T> {}
+
+pub trait IsOne<T> {}
+impl<T> IsOne<T> for One<T> {}
+
+fn main() {
+    fn assert_send(_: impl Send) {}
+    assert_send(async {
+        type T = Box<dyn Send + Sync + 'static>;
+        let _value = Two::<T, One<T>>(PhantomData);
+        async {}.await;
+    });
+}

src/test/ui/async-await/auto-trait/send-4.rs

@@ -0,0 +1,57 @@
+// run-pass
+// edition:2018
+
+#![allow(unused)]
+
+use core::future::Future;
+use core::marker::PhantomData;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+
+async fn f() {}
+
+pub fn fail<'a>() -> Box<dyn Future<Output = ()> + Send + 'a> {
+    Box::new(async { new(|| async { f().await }).await })
+}
+
+fn new<A, B>(_a: A) -> F<A, B>
+where
+    A: Fn() -> B,
+{
+    F { _i: PhantomData }
+}
+
+trait Stream {
+    type Item;
+}
+
+struct T<A, B> {
+    _a: PhantomData<A>,
+    _b: PhantomData<B>,
+}
+
+impl<A, B> Stream for T<A, B>
+where
+    A: Fn() -> B,
+{
+    type Item = B;
+}
+
+struct F<A, B>
+where
+    A: Fn() -> B,
+{
+    _i: PhantomData<<T<A, B> as Stream>::Item>,
+}
+
+impl<A, B> Future for F<A, B>
+where
+    A: Fn() -> B,
+{
+    type Output = ();
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
+        unimplemented!()
+    }
+}
+
+fn main() {}

src/test/ui/async-await/auto-trait/send-5.rs

@@ -0,0 +1,45 @@
+// run-pass
+// edition:2018
+
+#![allow(unused)]
+
+use std::future::Future;
+use std::marker::PhantomData;
+
+trait Stream {
+    type Item;
+}
+
+struct Filter<St: Stream> {
+    pending_item: St::Item,
+}
+
+fn filter<St: Stream>(_: St) -> Filter<St> {
+    unimplemented!();
+}
+
+struct FilterMap<Fut, F> {
+    f: F,
+    pending: PhantomData<Fut>,
+}
+
+impl<Fut, F> Stream for FilterMap<Fut, F>
+where
+    F: FnMut() -> Fut,
+    Fut: Future,
+{
+    type Item = ();
+}
+
+pub fn get_foo() -> impl Future + Send {
+    async {
+        let _y = &();
+        let _x = filter(FilterMap {
+            f: || async move { *_y },
+            pending: PhantomData,
+        });
+        async {}.await;
+    }
+}
+
+fn main() {}

src/test/ui/generator/auto-trait-regions.nll.stderr

@@ -2,13 +2,19 @@
 #![feature(auto_traits)]
 #![feature(negative_impls)]
 
+use std::cell::Cell;
+
 auto trait Foo {}
 
 struct No;
 
 impl !Foo for No {}
 
-struct A<'a, 'b>(&'a mut bool, &'b mut bool, No);
+struct A<'a, 'b>(Cell<&'a bool>, Cell<&'b mut bool>, No);
+
+impl<'a, 'b> Drop for A<'a, 'b> {
+    fn drop(&mut self) {}
+}
 
 impl<'a, 'b: 'a> Foo for A<'a, 'b> {}
 
@@ -18,36 +24,39 @@ impl Foo for &'static OnlyFooIfStaticRef {}
 struct OnlyFooIfRef(No);
 impl<'a> Foo for &'a OnlyFooIfRef {}
 
-fn assert_foo<T: Foo>(f: T) {}
+fn assert_foo<T: Foo>(_f: T) {}
 
 fn main() {
-    // Make sure 'static is erased for generator interiors so we can't match it in trait selection
-    let x: &'static _ = &OnlyFooIfStaticRef(No);
+    let z = OnlyFooIfStaticRef(No);
+    let x = &z;
     let gen = || {
         let x = x;
         yield;
         assert_foo(x);
     };
-    assert_foo(gen);
+    assert_foo(gen); // bad
     //~^ ERROR implementation of `Foo` is not general enough
     //~| ERROR implementation of `Foo` is not general enough
+    drop(z);
 
     // Allow impls which matches any lifetime
-    let x = &OnlyFooIfRef(No);
+    let z = OnlyFooIfRef(No);
+    let x = &z;
     let gen = || {
         let x = x;
         yield;
         assert_foo(x);
     };
     assert_foo(gen); // ok
+    drop(z);
 
-    // Disallow impls which relates lifetimes in the generator interior
-    let gen = || {
-        let a = A(&mut true, &mut true, No);
+    let gen = static || {
+        let mut y = true;
+        let a = A::<'static, '_>(Cell::new(&true), Cell::new(&mut y), No);
         yield;
-        assert_foo(a);
+        drop(a);
     };
     assert_foo(gen);
-    //~^ ERROR not general enough
-    //~| ERROR not general enough
+    //~^ ERROR implementation of `Foo` is not general enough
+    //~| ERROR implementation of `Foo` is not general enough
 }

src/test/ui/generator/auto-trait-regions.rs

@@ -1,23 +1,23 @@
 error: implementation of `Foo` is not general enough
-  --> $DIR/auto-trait-regions.rs:31:5
+  --> $DIR/auto-trait-regions.rs:37:5
    |
-LL |     assert_foo(gen);
+LL |     assert_foo(gen); // bad
    |     ^^^^^^^^^^ implementation of `Foo` is not general enough
    |
    = note: `&'0 OnlyFooIfStaticRef` must implement `Foo`, for any lifetime `'0`...
    = note: ...but `Foo` is actually implemented for the type `&'static OnlyFooIfStaticRef`
 
 error: implementation of `Foo` is not general enough
-  --> $DIR/auto-trait-regions.rs:31:5
+  --> $DIR/auto-trait-regions.rs:37:5
    |
-LL |     assert_foo(gen);
+LL |     assert_foo(gen); // bad
    |     ^^^^^^^^^^ implementation of `Foo` is not general enough
    |
    = note: `&'0 OnlyFooIfStaticRef` must implement `Foo`, for any lifetime `'0`...
    = note: ...but `Foo` is actually implemented for the type `&'static OnlyFooIfStaticRef`
 
 error: implementation of `Foo` is not general enough
-  --> $DIR/auto-trait-regions.rs:50:5
+  --> $DIR/auto-trait-regions.rs:59:5
    |
 LL |     assert_foo(gen);
    |     ^^^^^^^^^^ implementation of `Foo` is not general enough
@@ -26,7 +26,7 @@ LL |     assert_foo(gen);
    = note: ...but `Foo` is actually implemented for the type `A<'_, '2>`, for some specific lifetime `'2`
 
 error: implementation of `Foo` is not general enough
-  --> $DIR/auto-trait-regions.rs:50:5
+  --> $DIR/auto-trait-regions.rs:59:5
    |
 LL |     assert_foo(gen);
    |     ^^^^^^^^^^ implementation of `Foo` is not general enough