Error when rustc reports none, related to associated types on supertraits/trait aliases

[Artemis21]

rust-analyzer version: 0.3.1238-standalone and also 1.66.0-nightly (a6b7274 2022-10-10)

rustc version: rustc 1.66.0-nightly (a6b7274a4 2022-10-10)

#![feature(trait_alias)]
trait Foo {
    type A;

    fn foo(&self, _: impl Fn() -> Self::A) {}
}

impl Foo for () {
    type A = ();
}

trait EmptyFoo = Foo<A = ()>;

fn empty() -> impl EmptyFoo {}

fn main() {
    empty().foo(|| ());
}

This produces an error on the penultimate line in rust analyzer: expected <impl EmptyFoo as Foo>::A, found (). This is confusing, since the associated type A of trait Foo for any type implementing EmptyFoo is (). It conflicts with rustc, which compiles and runs the code without error.

If the parameter type for foo is just Self::A (and we pass () as the parameter), there is no error.

[Artemis21]

trait Foo {
    type A;

    fn foo(&self, _: impl Fn() -> Self::A) {}
}

trait EmptyFoo: Foo<A = ()> {}

impl<T: Foo<A = ()>> EmptyFoo for T {}

impl Foo for () {
    type A = ();
}

fn empty() -> impl EmptyFoo {}

fn main() {
    empty().foo(|| ());
}

The same issue occurs without the unstable trait aliases feature, so it affects stable rust.

[lowr]

We haven't implemented trait aliases properly (#2773). #2773 (comment) describes how we currently handle them, but it differs from the correct semantics.

That said, we should be able to deduce the associated type in both snippets (even with our current handling of trait aliases). I think this is on chalk but need to investigate further.

[Artemis21]

Alright, I'll see if I can try this with chalk directly. (See the second snippet that doesn't use trait aliases.)

[sethp]

I'm seeing something similar, I think, with the latest nightly: rustc 1.70.0-nightly (4087deacc 2023-04-12)

    fn no_alias() -> impl nom::Parser<(), (), ()> {
        |_| todo!()
    }

    trait UnitParserAlias = nom::Parser<(), (), ()>;
    fn alias() -> impl UnitParserAlias {
        |_| todo!()
    }

    let mut ok = no_alias();
    ok.parse(());

    let mut nope = alias();
    nope.parse(()); // this `parse` method compiles fine, but isn't found by rust-analyzer

Notice how rust-analyzer can't tell that parse is an &mut method in the second example (there's no underline); it also doesn't auto-complete or display documentation on hover or offer go-to-definition.

Explicitly using a supertrait as suggested by the previous implementation seems to avoid the analysis failure:

    trait UnitSuperParser: nom::Parser<(), (), ()> {}
    impl<T> UnitSuperParser for T where T: nom::Parser<(), (), ()> {}
    fn super_trait() -> impl UnitSuperParser {
        |_| todo!()
    }
    let mut ok2 = super_trait();
    ok2.parse(());