Strange borrowing issue in inherent async method.

[crlf0710]

Not sure whether it's a bug, but it is indeed strange...

struct A;
// this compiles
fn test(s: &mut A, arg: &str, handler: Box<dyn Fn() + 'static>) {
        
}
// this doesn't
impl A {
    async fn test2(&mut self, arg: &str, handler: Box<dyn Fn() + 'static>) {
        
    }
}

test2 errors with:

error[E0700]: hidden type for `impl Trait` captures lifetime that does not appear in bounds
  --> src/lib.rs:8:76
   |
8  |     async fn test2(&mut self, arg: &str, handler: Box<dyn Fn() + 'static>) {
   |                                                                            ^
   |

[crlf0710]

@rustbot modify labels to +A-async-await +C-bug +T-compiler

[crlf0710]

Seems similar to #68759 ....

[Aaron1011]

This appears to have the same underlying cause as #64552 (which @csmoe is working on in #68362).

When you write handler: Box<dyn FnOnce() + 'static> (or handler: Box<dyn FnOnce()>, which desugars to the same thing), the AST lowering doesn't create a lifetime parameter in the created opaque type, since you don't need a lifetime parameter for 'static. However,

However, when we create the generator type, we forget that the region is 'static:

rust/src/librustc_typeck/check/generator_interior.rs

Lines 124 to 144 in 9b9d2af

	// The types in the generator interior contain lifetimes local to the generator itself,
	// which should not be exposed outside of the generator. Therefore, we replace these
	// lifetimes with existentially-bound lifetimes, which reflect the exact value of the
	// lifetimes not being known by users.
	//
	// These lifetimes are used in auto trait impl checking (for example,
	// if a Sync generator contains an &'α T, we need to check whether &'α T: Sync),
	// so knowledge of the exact relationships between them isn't particularly important.
	debug!("types in generator {:?}, span = {:?}", type_list, body.value.span);
	// Replace all regions inside the generator interior with late bound regions
	// Note that each region slot in the types gets a new fresh late bound region,
	// which means that none of the regions inside relate to any other, even if
	// typeck had previously found constraints that would cause them to be related.
	let mut counter = 0;
	let type_list = fcx.tcx.fold_regions(&type_list, &mut false, |_, current_depth| {
	counter += 1;
	fcx.tcx.mk_region(ty::ReLateBound(current_depth, ty::BrAnon(counter)))
	});

Thus, we end up trying to process a member constraint for some newly created region _#0r. Since by construction we have no constraints for it, we cannot prove that it is equal to any of the regions in the member constraint (even though it's "really" 'static).

As a workaround, we could special-case 'static during the creation of the generator type, and leave it as-is instead of creating a fresh late-bound region.

As in #64552, I believe the full solution is for generator types to carry 'extra' region constraints with them in some form, so that we don't lose the lexical region information that we had prior to the lowering.

[tmandry]

Thanks @Aaron1011. I'm going to close this as a duplicate of #64552, but note on the issue that we should add a test with the code from this issue.