Update tests based on feedback

bryangarza · bryangarza · commit 11b1439380d2 · 2022-10-27T22:58:54.000Z
diff --git a/src/test/ui/async-await/in-trait/async-associated-types.rs b/src/test/ui/async-await/in-trait/async-associated-types.rs
@@ -1,3 +1,5 @@
+// check-fail
+// known-bug: #102682
 // edition: 2021
 
 #![feature(async_fn_in_trait)]
@@ -18,7 +20,5 @@ impl<'a, 'b, T: Debug + Sized + 'b, U: 'a> MyTrait<'a, 'b, T> for U {
         (self, key)
     }
 }
-//~^^^^ ERROR cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
-//~| ERROR cannot infer an appropriate lifetime for lifetime parameter `'b` due to conflicting requirements
 
 fn main() {}
diff --git a/src/test/ui/async-await/in-trait/async-associated-types.stderr b/src/test/ui/async-await/in-trait/async-associated-types.stderr
@@ -1,51 +1,51 @@
 error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
-  --> $DIR/async-associated-types.rs:17:43
+  --> $DIR/async-associated-types.rs:19:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
    |                                           ^^^^^^^^^^^^^^
    |
 note: first, the lifetime cannot outlive the lifetime `'a` as defined here...
-  --> $DIR/async-associated-types.rs:14:6
+  --> $DIR/async-associated-types.rs:16:6
    |
 LL | impl<'a, 'b, T: Debug + Sized + 'b, U: 'a> MyTrait<'a, 'b, T> for U {
    |      ^^
 note: ...so that the types are compatible
-  --> $DIR/async-associated-types.rs:17:43
+  --> $DIR/async-associated-types.rs:19:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
    |                                           ^^^^^^^^^^^^^^
    = note: expected `(&'a U, &'b T)`
               found `(&U, &T)`
    = note: but, the lifetime must be valid for the static lifetime...
 note: ...so that the types are compatible
-  --> $DIR/async-associated-types.rs:17:43
+  --> $DIR/async-associated-types.rs:19:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
    |                                           ^^^^^^^^^^^^^^
    = note: expected `MyTrait<'static, 'static, T>`
               found `MyTrait<'_, '_, T>`
 
 error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'b` due to conflicting requirements
-  --> $DIR/async-associated-types.rs:17:43
+  --> $DIR/async-associated-types.rs:19:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
    |                                           ^^^^^^^^^^^^^^
    |
 note: first, the lifetime cannot outlive the lifetime `'b` as defined here...
-  --> $DIR/async-associated-types.rs:14:10
+  --> $DIR/async-associated-types.rs:16:10
    |
 LL | impl<'a, 'b, T: Debug + Sized + 'b, U: 'a> MyTrait<'a, 'b, T> for U {
    |          ^^
 note: ...so that the types are compatible
-  --> $DIR/async-associated-types.rs:17:43
+  --> $DIR/async-associated-types.rs:19:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
    |                                           ^^^^^^^^^^^^^^
    = note: expected `(&'a U, &'b T)`
               found `(&U, &T)`
    = note: but, the lifetime must be valid for the static lifetime...
 note: ...so that the types are compatible
-  --> $DIR/async-associated-types.rs:17:43
+  --> $DIR/async-associated-types.rs:19:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
    |                                           ^^^^^^^^^^^^^^
diff --git a/src/test/ui/async-await/in-trait/async-example.rs b/src/test/ui/async-await/in-trait/async-example.rs
@@ -6,12 +6,27 @@
 
 trait MyTrait {
     async fn foo(&self) -> i32;
+    async fn bar(&self) -> i32;
 }
 
 impl MyTrait for i32 {
     async fn foo(&self) -> i32 {
         *self
     }
+
+    async fn bar(&self) -> i32 {
+        self.foo().await
+    }
 }
 
-fn main() {}
+fn main() {
+    let x = 5;
+    // Calling from non-async context
+    let _ = x.foo();
+    let _ = x.bar();
+    // Calling from async block in non-async context
+    async {
+        let _ = x.foo();
+        let _ = x.bar();
+    };
+}
diff --git a/src/test/ui/async-await/in-trait/async-generics-and-bounds.rs b/src/test/ui/async-await/in-trait/async-generics-and-bounds.rs
@@ -1,3 +1,5 @@
+// check-fail
+// known-bug: #102682
 // edition: 2021
 
 #![feature(async_fn_in_trait)]
@@ -9,8 +11,6 @@ use std::hash::Hash;
 trait MyTrait<T, U> {
     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
 }
-//~^^ ERROR the parameter type `U` may not live long enough
-//~| ERROR the parameter type `T` may not live long enough
 
 impl<T, U> MyTrait<T, U> for (T, U) {
     async fn foo(&self) -> &(T, U) {
diff --git a/src/test/ui/async-await/in-trait/async-generics-and-bounds.stderr b/src/test/ui/async-await/in-trait/async-generics-and-bounds.stderr
@@ -1,33 +1,33 @@
 error[E0311]: the parameter type `U` may not live long enough
-  --> $DIR/async-generics-and-bounds.rs:10:28
+  --> $DIR/async-generics-and-bounds.rs:12:28
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
    |                            ^^^^^^^
    |
 note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
-  --> $DIR/async-generics-and-bounds.rs:10:18
+  --> $DIR/async-generics-and-bounds.rs:12:18
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
    |                  ^
 note: ...so that the reference type `&(T, U)` does not outlive the data it points at
-  --> $DIR/async-generics-and-bounds.rs:10:28
+  --> $DIR/async-generics-and-bounds.rs:12:28
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
    |                            ^^^^^^^
 
 error[E0311]: the parameter type `T` may not live long enough
-  --> $DIR/async-generics-and-bounds.rs:10:28
+  --> $DIR/async-generics-and-bounds.rs:12:28
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
    |                            ^^^^^^^
    |
 note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
-  --> $DIR/async-generics-and-bounds.rs:10:18
+  --> $DIR/async-generics-and-bounds.rs:12:18
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
    |                  ^
 note: ...so that the reference type `&(T, U)` does not outlive the data it points at
-  --> $DIR/async-generics-and-bounds.rs:10:28
+  --> $DIR/async-generics-and-bounds.rs:12:28
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
    |                            ^^^^^^^
diff --git a/src/test/ui/async-await/in-trait/async-generics.rs b/src/test/ui/async-await/in-trait/async-generics.rs
@@ -1,3 +1,5 @@
+// check-fail
+// known-bug: #102682
 // edition: 2021
 
 #![feature(async_fn_in_trait)]
@@ -6,8 +8,6 @@
 trait MyTrait<T, U> {
     async fn foo(&self) -> &(T, U);
 }
-//~^^ ERROR the parameter type `U` may not live long enough
-//~| ERROR the parameter type `T` may not live long enough
 
 impl<T, U> MyTrait<T, U> for (T, U) {
     async fn foo(&self) -> &(T, U) {
diff --git a/src/test/ui/async-await/in-trait/async-generics.stderr b/src/test/ui/async-await/in-trait/async-generics.stderr
@@ -1,33 +1,33 @@
 error[E0311]: the parameter type `U` may not live long enough
-  --> $DIR/async-generics.rs:7:28
+  --> $DIR/async-generics.rs:9:28
    |
 LL |     async fn foo(&self) -> &(T, U);
    |                            ^^^^^^^
    |
 note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
-  --> $DIR/async-generics.rs:7:18
+  --> $DIR/async-generics.rs:9:18
    |
 LL |     async fn foo(&self) -> &(T, U);
    |                  ^
 note: ...so that the reference type `&(T, U)` does not outlive the data it points at
-  --> $DIR/async-generics.rs:7:28
+  --> $DIR/async-generics.rs:9:28
    |
 LL |     async fn foo(&self) -> &(T, U);
    |                            ^^^^^^^
 
 error[E0311]: the parameter type `T` may not live long enough
-  --> $DIR/async-generics.rs:7:28
+  --> $DIR/async-generics.rs:9:28
    |
 LL |     async fn foo(&self) -> &(T, U);
    |                            ^^^^^^^
    |
 note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
-  --> $DIR/async-generics.rs:7:18
+  --> $DIR/async-generics.rs:9:18
    |
 LL |     async fn foo(&self) -> &(T, U);
    |                  ^
 note: ...so that the reference type `&(T, U)` does not outlive the data it points at
-  --> $DIR/async-generics.rs:7:28
+  --> $DIR/async-generics.rs:9:28
    |
 LL |     async fn foo(&self) -> &(T, U);
    |                            ^^^^^^^
diff --git a/src/test/ui/async-await/in-trait/async-lifetimes-and-bounds.rs b/src/test/ui/async-await/in-trait/async-lifetimes-and-bounds.rs
@@ -1,3 +1,5 @@
+// check-fail
+// known-bug: #102682
 // edition: 2021
 
 #![feature(async_fn_in_trait)]
@@ -8,8 +10,6 @@ use std::fmt::Debug;
 trait MyTrait<'a, 'b, T> {
     async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug + Sized;
 }
-//~^^ ERROR  the parameter type `Self` may not live long enough
-//~| ERROR the parameter type `T` may not live long enough
 
 impl<'a, 'b, T, U> MyTrait<'a, 'b, T> for U {
     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {
diff --git a/src/test/ui/async-await/in-trait/async-lifetimes-and-bounds.stderr b/src/test/ui/async-await/in-trait/async-lifetimes-and-bounds.stderr
@@ -1,5 +1,5 @@
 error[E0309]: the parameter type `Self` may not live long enough
-  --> $DIR/async-lifetimes-and-bounds.rs:9:43
+  --> $DIR/async-lifetimes-and-bounds.rs:11:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug + Sized;
    |                                           ^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug
    = note: ...so that the reference type `&'a Self` does not outlive the data it points at
 
 error[E0309]: the parameter type `T` may not live long enough
-  --> $DIR/async-lifetimes-and-bounds.rs:9:43
+  --> $DIR/async-lifetimes-and-bounds.rs:11:43
    |
 LL |     async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug + Sized;
    |                                           ^^^^^^^^^^^^^^^^^ ...so that the reference type `&'b T` does not outlive the data it points at
diff --git a/src/test/ui/async-await/in-trait/async-lifetimes.rs b/src/test/ui/async-await/in-trait/async-lifetimes.rs
@@ -5,9 +5,9 @@
 
 trait MyTrait<'a, 'b, T> {
     async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T);
+    //~^ ERROR the parameter type `Self` may not live long enough
+    //~| ERROR the parameter type `T` may not live long enough
 }
-//~^^ ERROR the parameter type `Self` may not live long enough
-//~| ERROR the parameter type `T` may not live long enough
 
 impl<'a, 'b, T, U> MyTrait<'a, 'b, T> for U {
     async fn foo(&'a self, key: &'b T) -> (&'a U, &'b T) {

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+// check-fail`
	`2`	`+// known-bug: #102682`
`1`	`3`	`// edition: 2021`
`2`	`4`
`3`	`5`	`#![feature(async_fn_in_trait)]`
`@@ -18,7 +20,5 @@ impl<'a, 'b, T: Debug + Sized + 'b, U: 'a> MyTrait<'a, 'b, T> for U {`
`18`	`20`	`(self, key)`
`19`	`21`	`}`
`20`	`22`	`}`
`21`		-//~^^^^ ERROR cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
`22`		-//~\| ERROR cannot infer an appropriate lifetime for lifetime parameter `'b` due to conflicting requirements
`23`	`23`
`24`	`24`	`fn main() {}`
Original file line number	Diff line number	Diff line change
`@@ -1,33 +1,33 @@`
`1`	`1`	error[E0311]: the parameter type `U` may not live long enough
`2`		`- --> $DIR/async-generics-and-bounds.rs:10:28`
	`2`	`+ --> $DIR/async-generics-and-bounds.rs:12:28`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`5`	`5`	`\| ^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
`8`		`- --> $DIR/async-generics-and-bounds.rs:10:18`
	`8`	`+ --> $DIR/async-generics-and-bounds.rs:12:18`
`9`	`9`	`\|`
`10`	`10`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`11`	`11`	`\| ^`
`12`	`12`	note: ...so that the reference type `&(T, U)` does not outlive the data it points at
`13`		`- --> $DIR/async-generics-and-bounds.rs:10:28`
	`13`	`+ --> $DIR/async-generics-and-bounds.rs:12:28`
`14`	`14`	`\|`
`15`	`15`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`16`	`16`	`\| ^^^^^^^`
`17`	`17`
`18`	`18`	error[E0311]: the parameter type `T` may not live long enough
`19`		`- --> $DIR/async-generics-and-bounds.rs:10:28`
	`19`	`+ --> $DIR/async-generics-and-bounds.rs:12:28`
`20`	`20`	`\|`
`21`	`21`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`22`	`22`	`\| ^^^^^^^`
`23`	`23`	`\|`
`24`	`24`	note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
`25`		`- --> $DIR/async-generics-and-bounds.rs:10:18`
	`25`	`+ --> $DIR/async-generics-and-bounds.rs:12:18`
`26`	`26`	`\|`
`27`	`27`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`28`	`28`	`\| ^`
`29`	`29`	note: ...so that the reference type `&(T, U)` does not outlive the data it points at
`30`		`- --> $DIR/async-generics-and-bounds.rs:10:28`
	`30`	`+ --> $DIR/async-generics-and-bounds.rs:12:28`
`31`	`31`	`\|`
`32`	`32`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`33`	`33`	`\| ^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,33 +1,33 @@`
`1`	`1`	error[E0311]: the parameter type `U` may not live long enough
`2`		`- --> $DIR/async-generics.rs:7:28`
	`2`	`+ --> $DIR/async-generics.rs:9:28`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&self) -> &(T, U);`
`5`	`5`	`\| ^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
`8`		`- --> $DIR/async-generics.rs:7:18`
	`8`	`+ --> $DIR/async-generics.rs:9:18`
`9`	`9`	`\|`
`10`	`10`	`LL \| async fn foo(&self) -> &(T, U);`
`11`	`11`	`\| ^`
`12`	`12`	note: ...so that the reference type `&(T, U)` does not outlive the data it points at
`13`		`- --> $DIR/async-generics.rs:7:28`
	`13`	`+ --> $DIR/async-generics.rs:9:28`
`14`	`14`	`\|`
`15`	`15`	`LL \| async fn foo(&self) -> &(T, U);`
`16`	`16`	`\| ^^^^^^^`
`17`	`17`
`18`	`18`	error[E0311]: the parameter type `T` may not live long enough
`19`		`- --> $DIR/async-generics.rs:7:28`
	`19`	`+ --> $DIR/async-generics.rs:9:28`
`20`	`20`	`\|`
`21`	`21`	`LL \| async fn foo(&self) -> &(T, U);`
`22`	`22`	`\| ^^^^^^^`
`23`	`23`	`\|`
`24`	`24`	note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
`25`		`- --> $DIR/async-generics.rs:7:18`
	`25`	`+ --> $DIR/async-generics.rs:9:18`
`26`	`26`	`\|`
`27`	`27`	`LL \| async fn foo(&self) -> &(T, U);`
`28`	`28`	`\| ^`
`29`	`29`	note: ...so that the reference type `&(T, U)` does not outlive the data it points at
`30`		`- --> $DIR/async-generics.rs:7:28`
	`30`	`+ --> $DIR/async-generics.rs:9:28`
`31`	`31`	`\|`
`32`	`32`	`LL \| async fn foo(&self) -> &(T, U);`
`33`	`33`	`\| ^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	error[E0309]: the parameter type `Self` may not live long enough
`2`		`- --> $DIR/async-lifetimes-and-bounds.rs:9:43`
	`2`	`+ --> $DIR/async-lifetimes-and-bounds.rs:11:43`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug + Sized;`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^`
`@@ -8,7 +8,7 @@ LL \| async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug`
`8`	`8`	= note: ...so that the reference type `&'a Self` does not outlive the data it points at
`9`	`9`
`10`	`10`	error[E0309]: the parameter type `T` may not live long enough
`11`		`- --> $DIR/async-lifetimes-and-bounds.rs:9:43`
	`11`	`+ --> $DIR/async-lifetimes-and-bounds.rs:11:43`
`12`	`12`	`\|`
`13`	`13`	`LL \| async fn foo(&'a self, key: &'b T) -> (&'a Self, &'b T) where T: Debug + Sized;`
`14`	`14`	\| ^^^^^^^^^^^^^^^^^ ...so that the reference type `&'b T` does not outlive the data it points at