rust/tests/ui/async-await/issues/issue-62517-2.rs

// Regression test for #62517. We used to ICE when you had an `async
// fn` with an `impl Trait` return that mentioned a `dyn Bar` with no
// explicit lifetime bound.
//
// edition:2018
// check-pass

trait Object {}

trait Alpha<Param: ?Sized> {}

async fn foo<'a>(_: &'a ()) -> impl Alpha<dyn Object> {}

impl<T> Alpha<dyn Object> for T { }

fn main() { }
distinguish object-lifetime-default elision from other elision Object-lifetime-default elision is distinct from other forms of elision; it always refers to some enclosing lifetime present in the surrounding type (e.g., `&dyn Bar` expands to `&'a (dyn Bar + 'a)`. If there is no enclosing lifetime, then it expands to `'static`. Therefore, in an `impl Trait<Item = dyn Bar>` setting, we don't expand to create a lifetime parameter for the `dyn Bar + 'X` bound. It will just be resolved to `'static`. Annoyingly, the responsibility for this resolution is spread across multiple bits of code right now (`middle::resolve_lifetimes`, `lowering`). The lowering code knows that the default is for an object lifetime, but it doesn't know what the correct result would be. Probably this should be fixed, but what we do now is a surgical fix: we have it generate a different result for elided lifetimes in a object context, and then we can ignore those results when figuring out the lifetimes that are captured in the opaque type. 2019-08-08 02:36:24 -05:00			// Regression test for #62517. We used to ICE when you had an `async
			// fn` with an `impl Trait` return that mentioned a `dyn Bar` with no
			`// explicit lifetime bound.`
			`//`
			`// edition:2018`
adjust test to be check-pass 2019-08-19 12:53:06 -05:00			`// check-pass`
distinguish object-lifetime-default elision from other elision Object-lifetime-default elision is distinct from other forms of elision; it always refers to some enclosing lifetime present in the surrounding type (e.g., `&dyn Bar` expands to `&'a (dyn Bar + 'a)`. If there is no enclosing lifetime, then it expands to `'static`. Therefore, in an `impl Trait<Item = dyn Bar>` setting, we don't expand to create a lifetime parameter for the `dyn Bar + 'X` bound. It will just be resolved to `'static`. Annoyingly, the responsibility for this resolution is spread across multiple bits of code right now (`middle::resolve_lifetimes`, `lowering`). The lowering code knows that the default is for an object lifetime, but it doesn't know what the correct result would be. Probably this should be fixed, but what we do now is a surgical fix: we have it generate a different result for elided lifetimes in a object context, and then we can ignore those results when figuring out the lifetimes that are captured in the opaque type. 2019-08-08 02:36:24 -05:00
			`trait Object {}`

adjust test to be check-pass 2019-08-19 12:53:06 -05:00			`trait Alpha<Param: ?Sized> {}`
distinguish object-lifetime-default elision from other elision Object-lifetime-default elision is distinct from other forms of elision; it always refers to some enclosing lifetime present in the surrounding type (e.g., `&dyn Bar` expands to `&'a (dyn Bar + 'a)`. If there is no enclosing lifetime, then it expands to `'static`. Therefore, in an `impl Trait<Item = dyn Bar>` setting, we don't expand to create a lifetime parameter for the `dyn Bar + 'X` bound. It will just be resolved to `'static`. Annoyingly, the responsibility for this resolution is spread across multiple bits of code right now (`middle::resolve_lifetimes`, `lowering`). The lowering code knows that the default is for an object lifetime, but it doesn't know what the correct result would be. Probably this should be fixed, but what we do now is a surgical fix: we have it generate a different result for elided lifetimes in a object context, and then we can ignore those results when figuring out the lifetimes that are captured in the opaque type. 2019-08-08 02:36:24 -05:00
			`async fn foo<'a>(_: &'a ()) -> impl Alpha<dyn Object> {}`
adjust test to be check-pass 2019-08-19 12:53:06 -05:00
			`impl<T> Alpha<dyn Object> for T { }`
distinguish object-lifetime-default elision from other elision Object-lifetime-default elision is distinct from other forms of elision; it always refers to some enclosing lifetime present in the surrounding type (e.g., `&dyn Bar` expands to `&'a (dyn Bar + 'a)`. If there is no enclosing lifetime, then it expands to `'static`. Therefore, in an `impl Trait<Item = dyn Bar>` setting, we don't expand to create a lifetime parameter for the `dyn Bar + 'X` bound. It will just be resolved to `'static`. Annoyingly, the responsibility for this resolution is spread across multiple bits of code right now (`middle::resolve_lifetimes`, `lowering`). The lowering code knows that the default is for an object lifetime, but it doesn't know what the correct result would be. Probably this should be fixed, but what we do now is a surgical fix: we have it generate a different result for elided lifetimes in a object context, and then we can ignore those results when figuring out the lifetimes that are captured in the opaque type. 2019-08-08 02:36:24 -05:00
			`fn main() { }`