"non-defining opaque type use" with equal bound regions due to closure

[lcnr]

#![feature(type_alias_impl_trait)]
trait Trait<'a, 'b> {}
impl Trait<'_, '_> for () {}
type Tait<'a, 'b> = impl Trait<'a, 'b>;
fn fail<'a: 'b, 'b: 'a>() -> Tait<'a, 'b> {
    (|| {})()
}

results in the following but should ideally compile.

error: non-defining opaque type use in defining scope
 --> src/main.rs:6:5
  |
6 |     (|| {})()
  |     ^^^^^^^^^
  |
note: lifetime used multiple times
 --> src/main.rs:4:11
  |
4 | type Tait<'a, 'b> = impl Trait<'a, 'b>;
  |           ^^  ^^

[lcnr]

I think the issue is that the closure erases regions in its signature and does not have any user type, so its generic params for the opaque aren't really sensible.

I feel like maybe closures should return their opaque constraints via https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/mir/struct.BorrowCheckResult.html#structfield.closure_requirements instead of dealing with them itself?

[compiler-errors]

why does this fail even if a closure is just defined in-scope? 🤔

#![feature(type_alias_impl_trait)]

trait Trait<'a, 'b> {}

impl Trait<'_, '_> for () {}

type Tait<'a, 'b> = impl Trait<'a, 'b>;

fn fail<'a: 'b, 'b: 'a>() -> Tait<'a, 'b> {
    let x = || {};

    ()
}

fn main() {}

[compiler-errors]

idk, maybe pinging @aliemjay who knows more about borrowck + closures 🤣

[aliemjay]

I disagree that the OP's code should pass. Even more, I think it is a bug that we accept this:

#![feature(type_alias_impl_trait)]
trait Trait<'a, 'b> {}
impl Trait<'_, '_> for () {}
type Tait<'a, 'b> = impl Trait<'a, 'b>;
fn fail<'a: 'b, 'b: 'a>() -> Tait<'a, 'b> {
    ()
}

because it is in no way different than writing fn fail<'a>() -> Tait<'a, 'a> { ... }, which we currently reject and for a good reason.

The reason we accept these illegal defining uses of TAIT is due to a bug in

rust/compiler/rustc_borrowck/src/region_infer/opaque_types.rs

Line 80 in 776f222

let to_universal_region = |vid, subst_regions: &mut Vec<_>| {

which evaluates lifetime equality based on the constraint graph alone, ignoring the the environment bounds. This is why this trivial change triggers the error:

fn fail<'a: 'b, 'b: 'a>() -> Tait<'a, 'b> {
+   let _ = None::<&'a &'b &'a ()>; // Now 'a and 'b are equal in the constraint graph
    ()
+   //~^ ERROR non-defining opaque type use in defining scope
}

and this explains why using closures anywhere in the body triggers the error, because it somehow adds the environmet bounds (on early-bound lifetimes exclusively) to the constraint graph.