rust/src/test/ui/async-await/issues/issue-63388-2.stderr

error[E0106]: missing lifetime specifier
  --> $DIR/issue-63388-2.rs:12:10
   |
LL |         foo: &dyn Foo, bar: &'a dyn Foo
   |              --------       -----------
LL |     ) -> &dyn Foo
   |          ^ expected named lifetime parameter
   |
   = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `foo` or `bar`
help: consider using the `'a` lifetime
   |
LL |     ) -> &'a dyn Foo
   |          ~~~

error: aborting due to previous error

For more information about this error, try `rustc --explain E0106`.
revamp how we handle elision in async fn We now always make fresh lifetimne parameters for all elided lifetimes, whether they are in the inputs or outputs. But then we generate `'_` in the case of elided lifetimes from the outputs. Example: ```rust async fn foo<'a>(x: &'a u32) -> &u32 { .. } ``` becomes ```rust type Foo<'a, 'b> = impl Future<Output = &'b u32>; fn foo<'a>(x: &'a u32) -> Foo<'a, '_> ``` 2019-08-12 16:15:33 -05:00			`error[E0106]: missing lifetime specifier`
--bless post no async_await gates in tests. 2019-08-01 20:48:43 -05:00			`--> $DIR/issue-63388-2.rs:12:10`
revamp how we handle elision in async fn We now always make fresh lifetimne parameters for all elided lifetimes, whether they are in the inputs or outputs. But then we generate `'_` in the case of elided lifetimes from the outputs. Example: ```rust async fn foo<'a>(x: &'a u32) -> &u32 { .. } ``` becomes ```rust type Foo<'a, 'b> = impl Future<Output = &'b u32>; fn foo<'a>(x: &'a u32) -> Foo<'a, '_> ``` 2019-08-12 16:15:33 -05:00			`\|`
Account for `fn()` types in lifetime suggestions 2020-01-27 18:13:45 -06:00			`LL \| foo: &dyn Foo, bar: &'a dyn Foo`
			`\| -------- -----------`
revamp how we handle elision in async fn We now always make fresh lifetimne parameters for all elided lifetimes, whether they are in the inputs or outputs. But then we generate `'_` in the case of elided lifetimes from the outputs. Example: ```rust async fn foo<'a>(x: &'a u32) -> &u32 { .. } ``` becomes ```rust type Foo<'a, 'b> = impl Future<Output = &'b u32>; fn foo<'a>(x: &'a u32) -> Foo<'a, '_> ``` 2019-08-12 16:15:33 -05:00			`LL \| ) -> &dyn Foo`
Tweak `'static` suggestion code Fix #71196. 2020-04-16 23:33:42 -05:00			`\| ^ expected named lifetime parameter`
revamp how we handle elision in async fn We now always make fresh lifetimne parameters for all elided lifetimes, whether they are in the inputs or outputs. But then we generate `'_` in the case of elided lifetimes from the outputs. Example: ```rust async fn foo<'a>(x: &'a u32) -> &u32 { .. } ``` becomes ```rust type Foo<'a, 'b> = impl Future<Output = &'b u32>; fn foo<'a>(x: &'a u32) -> Foo<'a, '_> ``` 2019-08-12 16:15:33 -05:00			`\|`
Account for `fn()` types in lifetime suggestions 2020-01-27 18:13:45 -06:00			= help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `foo` or `bar`
Tweak wording 2020-04-17 12:46:22 -05:00			help: consider using the `'a` lifetime
Tweak `'static` suggestion code Fix #71196. 2020-04-16 23:33:42 -05:00			`\|`
			`LL \| ) -> &'a dyn Foo`
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span 2021-06-21 21:07:19 -05:00			`\| ~~~`
revamp how we handle elision in async fn We now always make fresh lifetimne parameters for all elided lifetimes, whether they are in the inputs or outputs. But then we generate `'_` in the case of elided lifetimes from the outputs. Example: ```rust async fn foo<'a>(x: &'a u32) -> &u32 { .. } ``` becomes ```rust type Foo<'a, 'b> = impl Future<Output = &'b u32>; fn foo<'a>(x: &'a u32) -> Foo<'a, '_> ``` 2019-08-12 16:15:33 -05:00
Update tests 2020-02-06 03:33:05 -06:00			`error: aborting due to previous error`
revamp how we handle elision in async fn We now always make fresh lifetimne parameters for all elided lifetimes, whether they are in the inputs or outputs. But then we generate `'_` in the case of elided lifetimes from the outputs. Example: ```rust async fn foo<'a>(x: &'a u32) -> &u32 { .. } ``` becomes ```rust type Foo<'a, 'b> = impl Future<Output = &'b u32>; fn foo<'a>(x: &'a u32) -> Foo<'a, '_> ``` 2019-08-12 16:15:33 -05:00
			For more information about this error, try `rustc --explain E0106`.