Type mismatch between associated type and concrete type which are the same type.

[canndrew]

Trying to build the following code:

trait WithLifetime<'a> {
    type Type;
}

struct Foo;

enum FooRef {}

impl<'a> WithLifetime<'a> for FooRef {
    type Type = &'a Foo;
}

fn wub<T, F>(f: F)
    where T: for<'a> WithLifetime<'a>,
          F: for<'a> FnOnce(&'a Foo) -> <T as WithLifetime<'a>>::Type
{
}

fn main() {
    wub::<FooRef, _>(|foo| foo)
}

Gives the error:

foo.rs:20:28: 20:31 error: mismatched types:
 expected `<FooRef as WithLifetime<'a>>::Type`,
    found `&'a Foo`
(expected associated type,
    found &-ptr) [E0308]
foo.rs:20     wub::<FooRef, _>(|foo| foo)
                                     ^~~

However <FooRef as WithLifetime<'a>>::Type and &'a Foo are the same type. And the compiler should be able to see that.

[eddyb]

cc @arielb1 @nikomatsakis Which issue is this a dupe of? I never can find which one is canonical.

@canndrew I believe is this is the usual "associated type projection under HRTB just doesn't get normalized" which is a limitation of the current implementation.
@soltanmm, IIRC, tried to approach a solution, but I haven't heard from them in a while.

[canndrew]

Is there any workaround that you know of to trick it into normalising?

Edit: Welp, explicitly specifying the return type of the closure makes it ICE.

[soltanmm]

@eddyb I'm still here! I've just also been... everywhere else. There's a lot of 'everywhere else'...

Lazy normalization AFAIK should cover this, and is WIP.

[Mark-Simulacrum]

@eddyb Is this #30867? It looks similar...

[nikomatsakis]

Related, certainly. In general we don't really normalize under binders (Yet! Coming Soon, I hope!) which leads to a lot of problems.

[dylanede]

What's the status of this issue at the moment? I seem to run into it a couple of times a year.