Add support for bounds on associated types in trait definitions

[flodiebold]

E.g.

trait Trait {
    type Item: SomeOtherTrait;
}

Note that these don't simply desugar to where clauses; as I understand it, where clauses have to be proved by the user of the trait, but these bounds are proved by the implementor. (Also, where clauses on associated types are unstable.)

(Another one from my recursive solver branch...)

[bjorn3]

trait Trait {
    type Item: SomeOtherTrait;
}

is equivalent to the following, right?

trait Trait where Self::Item: SomeOtherTrait {
    type Item;
}

At least

trait B where Self::B: std::fmt::Display {
    type B;
}

impl B for () {
    type B = Vec<u8>;
}

gives an error:

error[E0277]: `std::vec::Vec<u8>` doesn't implement `std::fmt::Display`
  --> src/lib.rs:10:5
   |
5  | trait B where Self::B: std::fmt::Display {
   |               -------------------------- restricted in this bound
6  |     type B;
   |          - associated type defined here
...
9  | impl B for () {
   | ------------- in this `impl` item
10 |     type B = Vec<u8>;
   |     ^^^^^^^^^^^^^^^^^ `std::vec::Vec<u8>` cannot be formatted with the default formatter
   |
   = help: the trait `std::fmt::Display` is not implemented for `std::vec::Vec<u8>`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead

[flodiebold]

That's true, they result in the same clauses in Chalk as well.

[matklad]

bors r+

[bors]

Build succeeded:

• TypeScript
• Rust (macos-latest)
• Rust (ubuntu-latest)
• Rust (windows-latest)