Item bounds of aliases are unnormalized when collecting free regions for liveness analysis

I tried this code

trait Id {
    type SelfType;
}

impl<T> Id for T {
    type SelfType = T;
}

trait Foo {
    type Assoc<'a>: Id<SelfType: 'static>
    // type Assoc<'a>: 'static // This compiles
    where
        Self: 'a;

    fn assoc(&mut self) -> Self::Assoc<'_>;
}

fn overlapping_mut<T>(mut t: T)
where
    T: Foo,
{
    let _a = t.assoc();
    let _b = t.assoc();
}

I expected to see this happen: compiles.

Instead, this happened:

error[E0499]: cannot borrow `t` as mutable more than once at a time
  --> counter_examples/item-bound-liveness.rs:23:13
   |
22 |     let a = t.assoc();
   |             - first mutable borrow occurs here
23 |     let b = t.assoc();
   |             ^ second mutable borrow occurs here
24 | }
   | - first borrow might be used here, when `a` is dropped and runs the destructor for type `<T as Foo>::Assoc<'_>`

Cause

We should but it's difficult to normalize here

related issues: https://github.com/rust-lang/rust/issues/158461 https://github.com/rust-lang/rust/issues/158463

Reproduce the failure with counter_examples/item-bound-liveness.rs, then inspect compiler/rustc_trait_selection/src/traits/outlives_for_liveness.rs around line 40 and the linked related issues. Trace how item bounds are collected for liveness analysis; done means the alias bounds are normalized sufficiently for the example to compile without the erroneous overlapping mutable-borrow error.