normalization may result in unconstrained regions

[lcnr]

trait Super {
    type SAssoc;
}
trait Trait<'a>: Super<SAssoc = <Self as Trait<'a>>::TAssoc> {
    type TAssoc;
}

fn unconstrained_lt<T: for<'a> Trait<'a>>(x: <T as Super>::SAssoc) {}

The function argument of unconstrained_lt normalizes to <T as Trait<'unconstrained>>::TAssoc

[lcnr]

Because proving alias-outlives bounds checks for equality between regions, this results in the undesirable errors:

trait Super {
    type SAssoc;
}
trait Trait<'a>: Super<SAssoc = <Self as Trait<'a>>::TAssoc> {
    type TAssoc;
}

fn test<'a, T: 'a>() {}

fn unconstrained_lt<'arg, T: for<'a> Trait<'a>>(x: &'arg <T as Super>::SAssoc) {
    test::<'arg, <T as Super>::SAssoc>();
}

normalizing "through" the alias with unconstrained regions does compile:

trait Super {
    type SAssoc;
}
trait Trait<'a>: Super<SAssoc = <Self as Trait<'a>>::TAssoc> {
    type TAssoc;
}

fn test<'a, T: 'a>() {}

fn unconstrained_lt<'arg, T: for<'a> Trait<'a, TAssoc = T>>(x: &'arg <T as Super>::SAssoc) {
    test::<'arg, <T as Super>::SAssoc>();
}

[lcnr]

via alias-bound instead

trait Super {
    type SAssoc;
}
trait Trait<'a>: Super<SAssoc = <Self as Trait<'a>>::TAssoc> {
    type TAssoc;
}

trait AliasBound {
    type WithBound: for<'a> Trait<'a>;
}

fn unconstrained_lt<T: AliasBound>(x: <T::WithBound as Super>::SAssoc) {}