rustc decides variable is of unsized type even when it is clear later it's not

[ChayimFriedman2]

I tried this code:

fn any<T>() -> T { loop {} }

fn foo() {
    let v = any();
    let r: &[i32] = &v;
    let _: [i32; 1] = v;
}

Playground.

I expected to see this happen: compiles successfully, with v deduced to be [i32; 1]

Instead, this happened:

error: mismatched types
 --> src/lib.rs:6:23
  |
5 |     let r: &[i32] = &v;
  |                      - here the type of `v` is inferred to be `[i32]`
6 |     let _: [i32; 1] = v;
  |            --------   ^ expected `[i32; 1]`, found `[i32]`
  |            |
  |            expected due to this

error: the size for values of type `[i32]` cannot be known at compilation time
 --> src/lib.rs:4:9
  |
4 |     let v = any();
  |         ^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `[i32]`
  = note: all local variables must have a statically known size
  = help: unsized locals are gated as an unstable feature

error: the size for values of type `[i32]` cannot be known at compilation time
 --> src/lib.rs:4:13
  |
4 |     let v = any();
  |             ^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `[i32]`
note: required by a bound in `any`
 --> src/lib.rs:1:8
  |
1 | fn any<T>() -> T { loop {} }
  |        ^ required by this bound in `any`
help: consider relaxing the implicit `Sized` restriction
  |
1 | fn any<T: ?Sized>() -> T { loop {} }
  |         ++++++++

rustc assumes v: [i32], and then fails both because it's an unsized type and because it can't match with let _: [i32; 1] = v;.

Strangely enough, it does compile with trait objects:

fn any<T>() -> T { loop {} }

fn foo() {
    let v = any();
    let r: &dyn std::fmt::Debug = &v;
    let _: [i32; 1] = v;
}

Playground.

[bjorn3]

You only get one shot at performing a coercion, so what happens here I believe is the following:

• Rustc looks at let v = any(); and concludes that v has some inference variable T as type.
• Rustc looks at let r: &[i32] = &v; and tries to unify &T with &[i32] resulting in T equals [i32]. It does not try to coerce &[i32; 1] to &[i32] as it doesn't know that this would be necessary.
• Rustc looks at let _: [i32; 1] = v; and tries to unify T with [i32; 1] and fails. It does not go back to the previous statement and try to insert a coercion as the one chance to add a coercion is already gone.

As for why you only get one shot at performing a coercion, this is because typechecking in rust is undecidable. This isn't noticed most of the time, but going back and trying to perform coercions would make this a much worse problem.

Strangely enough, it does compile with trait objects

No idea why this works.

[ChayimFriedman2]

Isn't this what ExpectRvalueLikeUnsized is for?