Compiler unable to determine two types are equal

[grantslatton]

The compiler seems unable to determine that two types are equal.

I tried this code:

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=b363f89f0e686e243f3a92dcc1cfc09a

trait Factory {
    type Product;
}

impl Factory for () {
    type Product = ();
}

trait ProductConsumer<P> {
    fn consume(self, product: P);
}

impl <P> ProductConsumer<P> for () {
    fn consume(self, product: P) {}
}


fn make_product_consumer<F: Factory>(f: F) -> impl ProductConsumer<F::Product> {
    ()
}

fn main() {
    let consumer = make_product_consumer(());
    consumer.consume(());
}

I expected the program to compile and run without issue, because <() as Factory>::Product> is (), so the consume call should be fine.

Instead, I got this error message:

error[E0308]: mismatched types
  --> src/main.rs:25:22
   |
25 |     consumer.consume(());
   |                      ^^ expected associated type, found `()`
   |
   = note: expected associated type `<() as Factory>::Product`
                    found unit type `()`

The problem exists on stable 1.42 and nightly 1.44

[rodrimati1992]

It somehow compiles if you replace the associated type with a type parameter:

fn make_product_consumer<T,F: Factory<Product=T>>(f: F) -> impl ProductConsumer<T> {
    ()
}

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=44455a7c12a77aa33c75b2c95658ebdb

[jonas-schievink]

cc #60414 / #62221

[jonas-schievink]

Possibly relevant rustc log entries:

[DEBUG rustc_trait_selection::infer] partially_normalize_associated_types_in(value=impl ProductConsumer<<_ as Factory>::Product>)
[DEBUG rustc_trait_selection::traits::project] normalize_with_depth(depth=0, value=impl ProductConsumer<<_ as Factory>::Product>)
[DEBUG rustc_trait_selection::traits::project] normalize_with_depth: depth=0 result=impl ProductConsumer<<() as Factory>::Product> with 0 obligations

Seems like the AssocTypeNormalizer will resolve the inference variable to yield <() as Factory>::Product, but for some reason is unable to normalize that further.

[jonas-schievink]

It seems like the opaque type impl ProductConsumer<<() as Factory>::Product> has a substs with only () in it; on first glance I'd have expected the projection <() as Factory>::Product there, but the docs on ty::Opaque do explain this:

The substitutions are for the generics of the function in question. After typeck, the concrete type can be found in the types map.

So it seems like the () is what was inserted for the F type parameter, making <() as Factory>. I'm not sure why this is represented like it is, but it seems like we need more info to be able to look at the real substs of the opaque type.

[jonas-schievink]

Duh, I forgot how opaque types work.

Not sure where <opaque>: ProductConsumer<<() as Factory>::Product> would be stored (ParamEnv? It's empty at this point according to log), but it's definitely not in the type, so this output makes sense.

[benjaminp]

This is fixed on nightly.