Rewrite associated types to use projection rather than dummy type parameters

[nikomatsakis]

Rewrite associated types to use projection rather than dummy type parameters. This closes almost every (major) open issue, but I'm holding off on that until the code has landed and baked a bit. Probably it should have more tests, as well, but I wanted to get this landed as fast as possible so that we can collaborate on improving it.

The commit history is a little messy, particularly the merge commit at the end. If I get some time, I might just "reset" to the beginning and try to carve up the final state into logical pieces. Let me know if it seems hard to follow. By far the most crucial commit is "Implement associated type projection and normalization."

r? @nick29581

[nikomatsakis]

Oh, and this incorporates PR #20159 so I will close that.

[jroesch]

Awesome, I'm excited to see this land!

[jroesch]

This makes me happy, it seems like a really clean way to handle this extra constraints.

[nrc]

item_name should have a more precise name or a comment (which item is it - the associated item, the trait, the concrete item?) It would be good to have a comment on the fn too stating what normalisation actually is

[nrc]

missing comment?

[kinghajj]

The following example still fails to compile with this branch merged.

#![feature(associated_types)]

trait Foo {
  fn foo(&self) -> ();
}

trait Bar {
  type F: Foo;
}

struct Wat<B: Bar> {
  fs: Vec<B::F>,
}

impl<B: Bar> Wat<B> {
  fn wat(&mut self) -> () {
    self.fs.pop().unwrap().foo();
  }
}

fn main() {
}

I get the following error:

17:33 error: type `<B as Bar>::F` does not implement any method in scope named `foo`

[nrc]

\o/ I'm so glad this is gone

[nrc]

r=me with the changes (all minor)

[nikomatsakis]

@kinghajj the reason is that the method dispatch is not yet integrated with assoc types; should open an issue on that. If you convert to UFCS form, your test passes:

#![feature(associated_types)]

trait Foo {
  fn foo(&self) -> ();
}

trait Bar {
  type F: Foo;
}

struct Wat<B: Bar> {
  fs: Vec<B::F>,
}

impl<B: Bar> Wat<B> {
  fn wat(&mut self) -> () {
      Foo::foo(&self.fs.pop().unwrap()); // <-- changed to UFCS here
  }
}

fn main() {
}