Spurious 'help: store this in the heap' on error involving `&Box<dyn SomeTrait>`

[Aaron1011]

The following code:

trait MyTrait {}

struct Foo {
    val: Box<dyn MyTrait>
}

fn make_it(val: &Box<dyn MyTrait>) {
    Foo {
        val
    };
}

produces the following error:

error[E0308]: mismatched types
 --> src/lib.rs:9:9
  |
9 |         val
  |         ^^^
  |         |
  |         expected struct `Box`, found reference
  |         help: store this in the heap by calling `Box::new`: `Box::new(val)`
  |
  = note: expected struct `Box<(dyn MyTrait + 'static)>`
          found reference `&Box<(dyn MyTrait + 'static)>`
  = note: for more on the distinction between the stack and the heap, read https://doc.rust-lang.org/book/ch15-01-box.html, https://doc.rust-lang.org/rust-by-example/std/box.html, and https://doc.rust-lang.org/std/boxed/index.html

error: aborting due to previous error

val is a &Box<dyn MyTrait>, so writing Box::new(val) would produce a Box<&Box<dyn MyTrait>>. This is very unlikely to be what the user wants - and in this case, it won't even work, since there are no impls for MyTrait.

Meta

Tested on rustc 1.52.0-nightly 2021-02-22

[0yoyoyo]

@rustbot claim

[0yoyoyo]

This problem occurs not only when val 's type is &Box<dyn MyTrait>, but also i32 and other types. This help message will be emitted if Box<val's type> could coerce to Box<dyn MyTrait>.

But I think this is weird. This coercion should be based on CoerceUnsized, and to coerce, we need implementation of Unsize<dyn MyTrait> for val's type. In other words, it seems that all types have implementation of Unsize<dyn MyTrait>. This behavior should be incorrect also from the doc of Unsize.

I'm going to check why the compiler provides above implementation.

[0yoyoyo]

This suggestion uses can_coerce to determine whether to emit the message. And can_coerce then calls coerce_unsized.

coerce_unsized execute trait selection. Even if a type T needs Unsize<dyn Trait> implementation, trait selection does not check T: Trait, just push T: Trait to nested. However, coerce_unsized also does not check nested unless it is Unsize or CoerceUnsized. As a result, can_coerce does not check whether val's type has implementation of MyTrait.

But, I have no idea how to fix this. I'll leave this issue.