Trait resolution fails, and then `rustc` hangs.

[frankmcsherry]

I tried this code:

trait Index {
    type IndexRef;
}

trait Borrow {
    type Borrowed<'a>;
}

trait Test {
    type Ref<'a>;
    type Container: Borrow where for<'a> <Self::Container as Borrow>::Borrowed<'a> : Index<IndexRef = Self::Ref<'a>>;
}

This builds fine if <Self::Container as Borrow>::Borrowed<'a> is replaced by &'a Self::Container. However, the above both errors, and also hangs rustc (still running after many minutes; wedges playground). The error is

binding for associated type Ref references lifetime 'a, which does not appear in the trait input types

I don't understand the error, though I could imagine that it is my fault or a known limitation of GATs. However, the hanging of rustc seems likely to be a bug.

Meta

rustc --version --verbose:

rustc 1.83.0 (90b35a623 2024-11-26)

Compiler output before hang

error[E0582]: binding for associated type `IndexRef` references lifetime `'a`, which does not appear in the trait input types
  --> lib.rs:11:92
   |
11 |     type Container: Borrow where for<'a> <Self::Container as Borrow>::Borrowed<'a> : Index<IndexRef = Self::Ref<'a>>;
   |                                                                                            ^^^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to 1 previous error

[compiler-errors]

Firstly, I think the right thing you wanted to express is:

trait Index {
    type IndexRef;
}

trait Borrow {
    type Borrowed<'a>;
}

trait Test {
    type Ref<'a>;
    type Container: for<'a> Borrow<Borrowed<'a>: Index<IndexRef = Self::Ref<'a>>>;
}

Writing it as a where clause will mean that this turns into an obligation that the user of the GAT has to prove for the GAT is valid, not an assumption that they can rely on when they have an instance of that GAT.

---

But yeah, the hanging is a bit suspicious. It's fixed by the new trait solver for the record, but I'm not confident that it's possible to make the old trait solver be able to detect these cases where we have a runaway series of type normalizations like we do here.

Here's a minimal repr:

trait Trait {
    type Type<'a>;
}

trait Trait2 {
    type Type2;
}

trait Test {
    type Assoc: Trait
    where
        for<'a> <Self::Assoc as Trait>::Type<'a>: Trait2<Type2 = ()>;
}