Type inference failure with Borrow<Vec<Foo>> leads to false positive type mismatch errors

[cyqsimon]

It's quite difficult to clearly explain what's wrong, so here's a MRE:

#![allow(dead_code, unused_variables)]
use std::borrow::Borrow;

fn main() {}

struct Foo {}
fn accepts_ref_foo(ref_foo: &Foo) {
    // ...
}

/// This is the MRE.
fn this_errors(foos: impl Borrow<Vec<Foo>>) {
    let vec_of_ref_foo = foos.borrow().iter().collect::<Vec<_>>();

    // 1. observe that RA fails to infer the type of `vec_of_ref_foo` (should be `Vec<&Foo>`)
    // 2. in the following for loop, observe that RA thinks `ref_foo` is `Foo` (should be `&Foo`)
    // 3. run `cargo check` and `cargo build`; verify that the compiler sees no problems here

    for ref_foo in vec_of_ref_foo {
        // this destructing statement is critical
        // without it, RA sees no issues
        let Foo { .. } = ref_foo;
        // RA thinks there's an error here where there is none
        accepts_ref_foo(ref_foo);
    }
}

/// Only `Borrow<Vec<Foo>>` is affected, not `Vec<Borrow<Foo>>`.
fn this_is_fine_0(foos: Vec<impl Borrow<Foo>>) {
    let vec_of_ref_foo = foos.iter().map(|foo| foo.borrow()).collect::<Vec<_>>();
    for ref_foo in vec_of_ref_foo {
        let Foo { .. } = ref_foo;
        accepts_ref_foo(ref_foo);
    }
}

---

rust-analyzer version: 0.3.1309-standalone

rustc version: rustc 1.65.0 (897e37553 2022-11-02)

[cyqsimon]

[lowr]

I think this is effectively a duplicate of #5514. We cannot resolve vec_of_ref_foo's type correctly as you pointed out because of that.

rust-analyzer doesn't show type mismatch errors that come from unresolved types (i.e. {unknown}), but when it sees that let Foo { .. } = ref_foo statement there, it coerces the unresolved type to Foo because that's the only information it has.

[cyqsimon]

I think I'll leave this issue open for now, because it showcases a situation where this limitation leads to an actual false error rather than just an annoyance.