Method calls with custom receiver types "forget" their type arguments

[nightkr]

Methods with custom receiver types (that is, of the shape fn foo(self: Box<Self>) rather than fn foo(&self)) "forget" Self's type arguments, when inferring the return type. However, this only happens when using the method call syntax (foo.bar()), UFCS calls (Foo::bar(foo)) work fine.

This makes it quite a bit more annoying to interact with things that use Pin, such as Futures.

Repro

Open https://gitlab.com/teozkr/repros/-/blob/rust-analyzer/receiver-confusion/src/main.rs in an editor with RA variable type inlays enabled, or view https://teozkr.gitlab.io/repros/rust-analyzer/receiver-confusion/main.rs.html.

You'd expect every pair of variables to be inferred to have the same type (&i32, &i32, and &Foo<i32> respectively), but currently the method call variants are instead inferred as &i32, &{unknown}, and &Foo<{unknown}>.

I'm using d0805c6

[jonas-schievink]

Inlining a reproduction:

struct Foo<T>(T);

impl<T> Foo<T> {
    fn get_inner<'a>(self: &'a Box<Self>) -> &'a T {
        &self.0
    }

    fn get_self<'a>(self: &'a Box<Self>) -> &'a Self {
        &*self
    }
}

fn main() {
    let boxed = Box::new(Foo(0_i32));

    let bad1 = boxed.get_inner();
    let good1 = Foo::get_inner(&boxed);

    let bad2 = boxed.get_self();
    let good2 = Foo::get_self(&boxed);
}

bad1 is inferred as &{unknown} (should be &i32), bad2 as &Foo<{unknown}> (should be &Foo<i32>)