Type inference recovery can infer unsized locals

[Veykril]

Bit of a weird one and might be pointless to think about but in the following erroneous snippet

trait DynT {}
fn f(_: &dyn DynT) {}
fn main() {
    let unresolved = unresolved;
    f(&unresolved);
    unresolved.foo();
}

we assign dyn DynT to unresolved. I feel like this is a bad recovery, since we can't have unsized locals, imo it would be better in this case to fallback to an error type? Interestingly enough if we assign an error type reference to unresolved we also fall back to the same type instead of assigning an error type to the local, probably because unification takes over still.

cc @ChayimFriedman2 idk if you have opinions on this, if you think this is fine as is feel free to close :)

[ChayimFriedman2]

This is pretty difficult to change.

Assigning an error type is what rustc does, and also what I tried to do when implementing errors for unresolved infer vars. The problem is that our inference is the gate to many IDE features; and they want to be able to infer types even for incomplete code. In particular, I had tests fail after this change. So what I did was to replace errors with infer vars, like previously (not all errors though, but most of them) but with a dummy span, which ensure we won't have diagnostics about them.

[Veykril]

I see, makes sense. So I take it this is a reasonable want, but one that is difficult to implement without breaking other things.