Use return type Span on async fns instead of whole fn def Span

estebank · estebank · commit 302546526064 · 2025-11-04T18:02:19.000Z
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1669,7 +1669,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let output = match coro {
             Some(coro) => {
                 let fn_def_id = self.local_def_id(fn_node_id);
-                self.lower_coroutine_fn_ret_ty(&decl.output, fn_def_id, coro, kind, fn_span)
+                self.lower_coroutine_fn_ret_ty(&decl.output, fn_def_id, coro, kind)
             }
             None => match &decl.output {
                 FnRetTy::Ty(ty) => {
@@ -1754,9 +1754,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         fn_def_id: LocalDefId,
         coro: CoroutineKind,
         fn_kind: FnDeclKind,
-        fn_span: Span,
     ) -> hir::FnRetTy<'hir> {
-        let span = self.lower_span(fn_span);
+        let span = self.lower_span(output.span());
 
         let (opaque_ty_node_id, allowed_features) = match coro {
             CoroutineKind::Async { return_impl_trait_id, .. } => (return_impl_trait_id, None),
diff --git a/tests/ui/async-await/async-await-let-else.stderr b/tests/ui/async-await/async-await-let-else.stderr
@@ -22,7 +22,7 @@ error[E0277]: `Rc<()>` cannot be sent between threads safely
   --> $DIR/async-await-let-else.rs:47:13
    |
 LL | async fn foo2(x: Option<bool>) {
-   | ------------------------------ within this `impl Future<Output = ()>`
+   |                               - within this `impl Future<Output = ()>`
 ...
 LL |     is_send(foo2(Some(true)));
    |     ------- ^^^^^^^^^^^^^^^^ `Rc<()>` cannot be sent between threads safely
diff --git a/tests/ui/async-await/async-fn/recurse-ice-129215.stderr b/tests/ui/async-await/async-fn/recurse-ice-129215.stderr
@@ -7,10 +7,10 @@ LL |     a()
    = help: the trait `Future` is not implemented for `()`
 
 error[E0277]: `()` is not a future
-  --> $DIR/recurse-ice-129215.rs:3:1
+  --> $DIR/recurse-ice-129215.rs:3:13
    |
 LL | async fn a() {
-   | ^^^^^^^^^^^^ `()` is not a future
+   |             ^ `()` is not a future
    |
    = help: the trait `Future` is not implemented for `()`
 
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-boxed-in-trait.stderr b/tests/ui/async-await/in-trait/async-example-desugared-boxed-in-trait.stderr
@@ -1,8 +1,8 @@
 error[E0053]: method `foo` has an incompatible type for trait
-  --> $DIR/async-example-desugared-boxed-in-trait.rs:11:5
+  --> $DIR/async-example-desugared-boxed-in-trait.rs:11:28
    |
 LL |     async fn foo(&self) -> i32 {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<Box<dyn Future<Output = i32>>>`, found future
+   |                            ^^^ expected `Pin<Box<dyn Future<Output = i32>>>`, found future
    |
 note: type in trait
   --> $DIR/async-example-desugared-boxed-in-trait.rs:7:22
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr b/tests/ui/async-await/in-trait/async-example-desugared-boxed.stderr
@@ -2,7 +2,7 @@ warning: impl trait in impl method signature does not match trait method signatu
   --> $DIR/async-example-desugared-boxed.rs:14:22
    |
 LL |     async fn foo(&self) -> i32;
-   |     --------------------------- return type from trait method defined here
+   |                            --- return type from trait method defined here
 ...
 LL |     fn foo(&self) -> Pin<Box<dyn Future<Output = i32> + '_>> {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr b/tests/ui/async-await/in-trait/async-example-desugared-manual.stderr
@@ -2,7 +2,7 @@ warning: impl trait in impl method signature does not match trait method signatu
   --> $DIR/async-example-desugared-manual.rs:22:22
    |
 LL |     async fn foo(&self) -> i32;
-   |     --------------------------- return type from trait method defined here
+   |                            --- return type from trait method defined here
 ...
 LL |     fn foo(&self) -> MyFuture {
    |                      ^^^^^^^^
diff --git a/tests/ui/async-await/in-trait/async-generics-and-bounds.stderr b/tests/ui/async-await/in-trait/async-generics-and-bounds.stderr
@@ -1,25 +1,23 @@
 error[E0311]: the parameter type `T` may not live long enough
-  --> $DIR/async-generics-and-bounds.rs:8:5
+  --> $DIR/async-generics-and-bounds.rs:8:28
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
-   |     ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |     |            |
-   |     |            the parameter type `T` must be valid for the anonymous lifetime as defined here...
-   |     ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  -         ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  |
+   |                  the parameter type `T` must be valid for the anonymous lifetime as defined here...
    |
 help: consider adding an explicit lifetime bound
    |
 LL |     async fn foo<'a>(&'a self) -> &'a (T, U) where T: Debug + Sized, U: Hash, T: 'a;
    |                 ++++  ++           ++                                       +++++++
 
 error[E0311]: the parameter type `U` may not live long enough
-  --> $DIR/async-generics-and-bounds.rs:8:5
+  --> $DIR/async-generics-and-bounds.rs:8:28
    |
 LL |     async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
-   |     ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |     |            |
-   |     |            the parameter type `U` must be valid for the anonymous lifetime as defined here...
-   |     ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  -         ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  |
+   |                  the parameter type `U` must be valid for the anonymous lifetime as defined here...
    |
 help: consider adding an explicit lifetime bound
    |
diff --git a/tests/ui/async-await/in-trait/async-generics.stderr b/tests/ui/async-await/in-trait/async-generics.stderr
@@ -1,25 +1,23 @@
 error[E0311]: the parameter type `T` may not live long enough
-  --> $DIR/async-generics.rs:5:5
+  --> $DIR/async-generics.rs:5:28
    |
 LL |     async fn foo(&self) -> &(T, U);
-   |     ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^
-   |     |            |
-   |     |            the parameter type `T` must be valid for the anonymous lifetime as defined here...
-   |     ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  -         ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  |
+   |                  the parameter type `T` must be valid for the anonymous lifetime as defined here...
    |
 help: consider adding an explicit lifetime bound
    |
 LL |     async fn foo<'a>(&'a self) -> &'a (T, U) where T: 'a;
    |                 ++++  ++           ++        +++++++++++
 
 error[E0311]: the parameter type `U` may not live long enough
-  --> $DIR/async-generics.rs:5:5
+  --> $DIR/async-generics.rs:5:28
    |
 LL |     async fn foo(&self) -> &(T, U);
-   |     ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^
-   |     |            |
-   |     |            the parameter type `U` must be valid for the anonymous lifetime as defined here...
-   |     ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  -         ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
+   |                  |
+   |                  the parameter type `U` must be valid for the anonymous lifetime as defined here...
    |
 help: consider adding an explicit lifetime bound
    |
diff --git a/tests/ui/async-await/in-trait/dont-project-to-specializable-projection.stderr b/tests/ui/async-await/in-trait/dont-project-to-specializable-projection.stderr
@@ -1,14 +1,14 @@
 error[E0053]: method `foo` has an incompatible type for trait
-  --> $DIR/dont-project-to-specializable-projection.rs:14:5
+  --> $DIR/dont-project-to-specializable-projection.rs:14:35
    |
 LL |     default async fn foo(_: T) -> &'static str {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected associated type, found future
+   |                                   ^^^^^^^^^^^^ expected associated type, found future
    |
 note: type in trait
-  --> $DIR/dont-project-to-specializable-projection.rs:10:5
+  --> $DIR/dont-project-to-specializable-projection.rs:10:27
    |
 LL |     async fn foo(_: T) -> &'static str;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                           ^^^^^^^^^^^^
    = note: expected signature `fn(_) -> impl Future<Output = &'static str>`
               found signature `fn(_) -> impl Future<Output = &'static str>`
 
diff --git a/tests/ui/async-await/inference_var_self_argument.stderr b/tests/ui/async-await/inference_var_self_argument.stderr
@@ -8,10 +8,10 @@ LL |     async fn foo(self: &dyn Foo) {
    = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
 error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/inference_var_self_argument.rs:5:5
+  --> $DIR/inference_var_self_argument.rs:5:33
    |
 LL |     async fn foo(self: &dyn Foo) {
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Foo` is not dyn compatible
+   |                                 ^ `Foo` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
diff --git a/tests/ui/async-await/issue-64130-3-other.stderr b/tests/ui/async-await/issue-64130-3-other.stderr
@@ -2,7 +2,7 @@ error[E0277]: the trait bound `Foo: Qux` is not satisfied in `impl Future<Output
   --> $DIR/issue-64130-3-other.rs:25:12
    |
 LL | async fn bar() {
-   | -------------- within this `impl Future<Output = ()>`
+   |               - within this `impl Future<Output = ()>`
 ...
 LL |     is_qux(bar());
    |            ^^^^^ unsatisfied trait bound
diff --git a/tests/ui/async-await/issues/issue-67893.stderr b/tests/ui/async-await/issues/issue-67893.stderr
@@ -6,10 +6,10 @@ LL |     g(issue_67893::run())
    |     |
    |     required by a bound introduced by this call
    |
-  ::: $DIR/auxiliary/issue_67893.rs:9:1
+  ::: $DIR/auxiliary/issue_67893.rs:9:19
    |
 LL | pub async fn run() {
-   | ------------------ within this `impl Future<Output = ()>`
+   |                   - within this `impl Future<Output = ()>`
    |
    = help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `std::sync::MutexGuard<'_, ()>`
 note: required because it's used within this `async` fn body
diff --git a/tests/ui/async-await/partial-drop-partial-reinit.stderr b/tests/ui/async-await/partial-drop-partial-reinit.stderr
@@ -7,7 +7,7 @@ LL |     gimme_send(foo());
    |     required by a bound introduced by this call
 ...
 LL | async fn foo() {
-   | -------------- within this `impl Future<Output = ()>`
+   |               - within this `impl Future<Output = ()>`
    |
 help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `NotSend`
   --> $DIR/partial-drop-partial-reinit.rs:19:1
diff --git a/tests/ui/c-variadic/not-async.stderr b/tests/ui/c-variadic/not-async.stderr
@@ -14,19 +14,19 @@ error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that
   --> $DIR/not-async.rs:5:62
    |
 LL | async unsafe extern "C" fn fn_cannot_be_async(x: isize, ...) {}
-   | ------------------------------------------------------------ ^^
-   | |
-   | opaque type defined here
+   |                                                             -^^
+   |                                                             |
+   |                                                             opaque type defined here
    |
    = note: hidden type `{async fn body of fn_cannot_be_async()}` captures lifetime `'_`
 
 error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
   --> $DIR/not-async.rs:12:70
    |
 LL |     async unsafe extern "C" fn method_cannot_be_async(x: isize, ...) {}
-   |     ---------------------------------------------------------------- ^^
-   |     |
-   |     opaque type defined here
+   |                                                                     -^^
+   |                                                                     |
+   |                                                                     opaque type defined here
    |
    = note: hidden type `{async fn body of S::method_cannot_be_async()}` captures lifetime `'_`
 
diff --git a/tests/ui/impl-trait/in-trait/async-and-ret-ref.stderr b/tests/ui/impl-trait/in-trait/async-and-ret-ref.stderr
@@ -1,11 +1,11 @@
 error[E0310]: the associated type `impl T` may not live long enough
-  --> $DIR/async-and-ret-ref.rs:7:5
+  --> $DIR/async-and-ret-ref.rs:7:23
    |
 LL |     async fn foo() -> &'static impl T;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |     |
-   |     the associated type `impl T` must be valid for the static lifetime...
-   |     ...so that the reference type `&'static impl T` does not outlive the data it points at
+   |                       ^^^^^^^^^^^^^^^
+   |                       |
+   |                       the associated type `impl T` must be valid for the static lifetime...
+   |                       ...so that the reference type `&'static impl T` does not outlive the data it points at
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/inference/note-and-explain-ReVar-124973.stderr b/tests/ui/inference/note-and-explain-ReVar-124973.stderr
@@ -8,9 +8,9 @@ error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that
   --> $DIR/note-and-explain-ReVar-124973.rs:5:73
    |
 LL | async unsafe extern "C" fn multiple_named_lifetimes<'a, 'b>(_: u8, ...) {}
-   | ----------------------------------------------------------------------- ^^
-   | |
-   | opaque type defined here
+   |                                                                        -^^
+   |                                                                        |
+   |                                                                        opaque type defined here
    |
    = note: hidden type `{async fn body of multiple_named_lifetimes<'a, 'b>()}` captures lifetime `'_`
 
diff --git a/tests/ui/lifetimes/issue-76168-hr-outlives-3.stderr b/tests/ui/lifetimes/issue-76168-hr-outlives-3.stderr
@@ -34,24 +34,18 @@ LL | for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a,
    = help: the trait `for<'a> FnOnce(&'a mut i32)` is not implemented for `i32`
 
 error[E0277]: expected a `FnOnce(&'a mut i32)` closure, found `i32`
-  --> $DIR/issue-76168-hr-outlives-3.rs:6:1
+  --> $DIR/issue-76168-hr-outlives-3.rs:6:26
    |
-LL | / async fn wrapper<F>(f: F)
-...  |
-LL | | F:,
-LL | | for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a,
-   | |__________________________________________________________________________^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
+LL | async fn wrapper<F>(f: F)
+   |                          ^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
    |
    = help: the trait `for<'a> FnOnce(&'a mut i32)` is not implemented for `i32`
 
 error[E0277]: expected a `FnOnce(&'a mut i32)` closure, found `i32`
-  --> $DIR/issue-76168-hr-outlives-3.rs:6:1
+  --> $DIR/issue-76168-hr-outlives-3.rs:6:26
    |
-LL | / async fn wrapper<F>(f: F)
-...  |
-LL | | F:,
-LL | | for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a,
-   | |__________________________________________________________________________^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
+LL | async fn wrapper<F>(f: F)
+   |                          ^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
    |
    = help: the trait `for<'a> FnOnce(&'a mut i32)` is not implemented for `i32`
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
diff --git a/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr b/tests/ui/traits/non_lifetime_binders/type-match-with-late-bound.stderr
@@ -8,15 +8,12 @@ LL | #![feature(non_lifetime_binders)]
    = note: `#[warn(incomplete_features)]` on by default
 
 error[E0309]: the placeholder type `F` may not live long enough
-  --> $DIR/type-match-with-late-bound.rs:8:1
-   |
-LL |   async fn walk2<'a, T: 'a>(_: T)
-   |   ^              -- the placeholder type `F` must be valid for the lifetime `'a` as defined here...
-   |  _|
-   | |
-LL | | where
-LL | |     for<F> F: 'a,
-   | |_________________^ ...so that the type `F` will meet its required lifetime bounds...
+  --> $DIR/type-match-with-late-bound.rs:8:32
+   |
+LL | async fn walk2<'a, T: 'a>(_: T)
+   |                --              ^ ...so that the type `F` will meet its required lifetime bounds...
+   |                |
+   |                the placeholder type `F` must be valid for the lifetime `'a` as defined here...
    |
 note: ...that is required by this bound
   --> $DIR/type-match-with-late-bound.rs:10:15
diff --git a/tests/ui/type-alias-impl-trait/hkl_forbidden4.stderr b/tests/ui/type-alias-impl-trait/hkl_forbidden4.stderr
@@ -18,10 +18,10 @@ LL |     call(operation).await
    |     ^^^^^^^^^^^^^^^ expected `{async fn body of operation()}`, got `FutNothing<'_>`
    |
 note: previous use here
-  --> $DIR/hkl_forbidden4.rs:12:1
+  --> $DIR/hkl_forbidden4.rs:12:35
    |
 LL | async fn operation(_: &mut ()) -> () {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                   ^^
 
 error: aborting due to 2 previous errors
 

Original file line number	Diff line number	Diff line change
@@ -22,7 +22,7 @@ error[E0277]: `Rc<()>` cannot be sent between threads safely
`22`	`22`	`--> $DIR/async-await-let-else.rs:47:13`
`23`	`23`	`\|`
`24`	`24`	`LL \| async fn foo2(x: Option<bool>) {`
`25`		- \| ------------------------------ within this `impl Future<Output = ()>`
	`25`	+ \| - within this `impl Future<Output = ()>`
`26`	`26`	`...`
`27`	`27`	`LL \| is_send(foo2(Some(true)));`
`28`	`28`	\| ------- ^^^^^^^^^^^^^^^^ `Rc<()>` cannot be sent between threads safely
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ LL \| a()`
`7`	`7`	= help: the trait `Future` is not implemented for `()`
`8`	`8`
`9`	`9`	error[E0277]: `()` is not a future
`10`		`- --> $DIR/recurse-ice-129215.rs:3:1`
	`10`	`+ --> $DIR/recurse-ice-129215.rs:3:13`
`11`	`11`	`\|`
`12`	`12`	`LL \| async fn a() {`
`13`		- \| ^^^^^^^^^^^^ `()` is not a future
	`13`	+ \| ^ `()` is not a future
`14`	`14`	`\|`
`15`	`15`	= help: the trait `Future` is not implemented for `()`
`16`	`16`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	error[E0053]: method `foo` has an incompatible type for trait
`2`		`- --> $DIR/async-example-desugared-boxed-in-trait.rs:11:5`
	`2`	`+ --> $DIR/async-example-desugared-boxed-in-trait.rs:11:28`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&self) -> i32 {`
`5`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<Box<dyn Future<Output = i32>>>`, found future
	`5`	+ \| ^^^ expected `Pin<Box<dyn Future<Output = i32>>>`, found future
`6`	`6`	`\|`
`7`	`7`	`note: type in trait`
`8`	`8`	`--> $DIR/async-example-desugared-boxed-in-trait.rs:7:22`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ warning: impl trait in impl method signature does not match trait method signatu`
`2`	`2`	`--> $DIR/async-example-desugared-boxed.rs:14:22`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&self) -> i32;`
`5`		`- \| --------------------------- return type from trait method defined here`
	`5`	`+ \| --- return type from trait method defined here`
`6`	`6`	`...`
`7`	`7`	`LL \| fn foo(&self) -> Pin<Box<dyn Future<Output = i32> + '_>> {`
`8`	`8`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ warning: impl trait in impl method signature does not match trait method signatu`
`2`	`2`	`--> $DIR/async-example-desugared-manual.rs:22:22`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&self) -> i32;`
`5`		`- \| --------------------------- return type from trait method defined here`
	`5`	`+ \| --- return type from trait method defined here`
`6`	`6`	`...`
`7`	`7`	`LL \| fn foo(&self) -> MyFuture {`
`8`	`8`	`\| ^^^^^^^^`
Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,23 @@`
`1`	`1`	error[E0311]: the parameter type `T` may not live long enough
`2`		`- --> $DIR/async-generics-and-bounds.rs:8:5`
	`2`	`+ --> $DIR/async-generics-and-bounds.rs:8:28`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`5`		`- \| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`6`		`- \| \| \|`
`7`		- \| \| the parameter type `T` must be valid for the anonymous lifetime as defined here...
`8`		- \| ...so that the reference type `&(T, U)` does not outlive the data it points at
	`5`	+ \| - ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
	`6`	`+ \| \|`
	`7`	+ \| the parameter type `T` must be valid for the anonymous lifetime as defined here...
`9`	`8`	`\|`
`10`	`9`	`help: consider adding an explicit lifetime bound`
`11`	`10`	`\|`
`12`	`11`	`LL \| async fn foo<'a>(&'a self) -> &'a (T, U) where T: Debug + Sized, U: Hash, T: 'a;`
`13`	`12`	`\| ++++ ++ ++ +++++++`
`14`	`13`
`15`	`14`	error[E0311]: the parameter type `U` may not live long enough
`16`		`- --> $DIR/async-generics-and-bounds.rs:8:5`
	`15`	`+ --> $DIR/async-generics-and-bounds.rs:8:28`
`17`	`16`	`\|`
`18`	`17`	`LL \| async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;`
`19`		`- \| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`20`		`- \| \| \|`
`21`		- \| \| the parameter type `U` must be valid for the anonymous lifetime as defined here...
`22`		- \| ...so that the reference type `&(T, U)` does not outlive the data it points at
	`18`	+ \| - ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
	`19`	`+ \| \|`
	`20`	+ \| the parameter type `U` must be valid for the anonymous lifetime as defined here...
`23`	`21`	`\|`
`24`	`22`	`help: consider adding an explicit lifetime bound`
`25`	`23`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,23 @@`
`1`	`1`	error[E0311]: the parameter type `T` may not live long enough
`2`		`- --> $DIR/async-generics.rs:5:5`
	`2`	`+ --> $DIR/async-generics.rs:5:28`
`3`	`3`	`\|`
`4`	`4`	`LL \| async fn foo(&self) -> &(T, U);`
`5`		`- \| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^`
`6`		`- \| \| \|`
`7`		- \| \| the parameter type `T` must be valid for the anonymous lifetime as defined here...
`8`		- \| ...so that the reference type `&(T, U)` does not outlive the data it points at
	`5`	+ \| - ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
	`6`	`+ \| \|`
	`7`	+ \| the parameter type `T` must be valid for the anonymous lifetime as defined here...
`9`	`8`	`\|`
`10`	`9`	`help: consider adding an explicit lifetime bound`
`11`	`10`	`\|`
`12`	`11`	`LL \| async fn foo<'a>(&'a self) -> &'a (T, U) where T: 'a;`
`13`	`12`	`\| ++++ ++ ++ +++++++++++`
`14`	`13`
`15`	`14`	error[E0311]: the parameter type `U` may not live long enough
`16`		`- --> $DIR/async-generics.rs:5:5`
	`15`	`+ --> $DIR/async-generics.rs:5:28`
`17`	`16`	`\|`
`18`	`17`	`LL \| async fn foo(&self) -> &(T, U);`
`19`		`- \| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^`
`20`		`- \| \| \|`
`21`		- \| \| the parameter type `U` must be valid for the anonymous lifetime as defined here...
`22`		- \| ...so that the reference type `&(T, U)` does not outlive the data it points at
	`18`	+ \| - ^^^^^^^ ...so that the reference type `&(T, U)` does not outlive the data it points at
	`19`	`+ \| \|`
	`20`	+ \| the parameter type `U` must be valid for the anonymous lifetime as defined here...
`23`	`21`	`\|`
`24`	`22`	`help: consider adding an explicit lifetime bound`
`25`	`23`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,14 +1,14 @@`
`1`	`1`	error[E0053]: method `foo` has an incompatible type for trait
`2`		`- --> $DIR/dont-project-to-specializable-projection.rs:14:5`
	`2`	`+ --> $DIR/dont-project-to-specializable-projection.rs:14:35`
`3`	`3`	`\|`
`4`	`4`	`LL \| default async fn foo(_: T) -> &'static str {`
`5`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected associated type, found future`
	`5`	`+ \| ^^^^^^^^^^^^ expected associated type, found future`
`6`	`6`	`\|`
`7`	`7`	`note: type in trait`
`8`		`- --> $DIR/dont-project-to-specializable-projection.rs:10:5`
	`8`	`+ --> $DIR/dont-project-to-specializable-projection.rs:10:27`
`9`	`9`	`\|`
`10`	`10`	`LL \| async fn foo(_: T) -> &'static str;`
`11`		`- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
	`11`	`+ \| ^^^^^^^^^^^^`
`12`	`12`	= note: expected signature `fn(_) -> impl Future<Output = &'static str>`
`13`	`13`	found signature `fn(_) -> impl Future<Output = &'static str>`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@ LL \| async fn foo(self: &dyn Foo) {`
`8`	`8`	= help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
`9`	`9`
`10`	`10`	error[E0038]: the trait `Foo` is not dyn compatible
`11`		`- --> $DIR/inference_var_self_argument.rs:5:5`
	`11`	`+ --> $DIR/inference_var_self_argument.rs:5:33`
`12`	`12`	`\|`
`13`	`13`	`LL \| async fn foo(self: &dyn Foo) {`
`14`		- \| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Foo` is not dyn compatible
	`14`	+ \| ^ `Foo` is not dyn compatible
`15`	`15`	`\|`
`16`	`16`	`note: for a trait to be dyn compatible it needs to allow building a vtable`
`17`	`17`	`for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>`