rust/tests/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[E0621]: explicit lifetime required in the type of `foo`
  --> $DIR/issue-63388-2.rs:13:5
   |
LL |           foo: &dyn Foo, bar: &'a dyn Foo
   |                -------- help: add explicit lifetime `'a` to the type of `foo`: `&'a (dyn Foo + 'a)`
LL |       ) -> &dyn Foo
LL | /     {
LL | |
LL | |         foo
LL | |     }
   | |_____^ lifetime `'a` required

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0106, E0621.
For more information about an 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`
Report elision failures on the AST. 2022-06-05 11:33:09 -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
Report elision failures on the AST. 2022-06-05 11:33:09 -05:00			error[E0621]: explicit lifetime required in the type of `foo`
			`--> $DIR/issue-63388-2.rs:13:5`
			`\|`
			`LL \| foo: &dyn Foo, bar: &'a dyn Foo`
			\| -------- help: add explicit lifetime `'a` to the type of `foo`: `&'a (dyn Foo + 'a)`
			`LL \| ) -> &dyn Foo`
			`LL \| / {`
			`LL \| \|`
			`LL \| \| foo`
			`LL \| \| }`
			\| \|_____^ lifetime `'a` required

			`error: aborting due to 2 previous errors`
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
Report elision failures on the AST. 2022-06-05 11:33:09 -05:00			`Some errors have detailed explanations: E0106, E0621.`
			For more information about an error, try `rustc --explain E0106`.