Assignment into Deref is allowed and creates irrelevant errors

[kornelski]

Code

fn main() {
    let i_am_sized = String::new();
    *i_am_sized = String::new();
}

I thought I've had &mut String, not String, so * was unnecessary here.

Because the lvalue has been dereferenced anyway, it caused confusing type error about a type that is not relevant, and assigning to an unsized type that is not at fault here. But the root cause was unexpectedly triggering Deref instead of a dereference on &mut or DerefMut.

Current output

error[E0308]: mismatched types
 --> src/main.rs:3:19
  |
3 |     *i_am_sized = String::new();
  |     -----------   ^^^^^^^^^^^^^ expected `str`, found `String`
  |     |
  |     expected due to the type of this binding

error[E0277]: the size for values of type `str` cannot be known at compilation time
 --> src/main.rs:3:5
  |
3 |     *i_am_sized = String::new();
  |     ^^^^^^^^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `str`

Desired output

Something that *i_am_sized due to Deref is can't be assigned to, and suggest removing * instead.

Rust Version

rustc 1.83.0-nightly (8d6b88b16 2024-09-11)
binary: rustc
commit-hash: 8d6b88b168e45ee1624699c19443c49665322a91
commit-date: 2024-09-11
host: aarch64-apple-darwin
release: 1.83.0-nightly
LLVM version: 19.1.0

[compiler-errors]

Something that *i_am_sized due to Deref is immutable and can't be assigned to

For the record, String does implement DerefMut. We don't check mutability of the LHS place until borrowck time, but also this error really is unrelated to the fact that the variable is immutable or anything to do with DerefMut.

[workingjubilee]

Yeah, if you look at this example modified to actually use DerefMut https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=a59a8da55267c4ce3697f4158e674e26

use std::ops::DerefMut;
fn main() {
    let mut i_am_sized = String::new();
    *i_am_sized.deref_mut() = String::new();
}

We see basically the same errors:

   Compiling playground v0.0.1 (/playground)
error[E0308]: mismatched types
 --> src/main.rs:4:31
  |
4 |     *i_am_sized.deref_mut() = String::new();
  |     -----------------------   ^^^^^^^^^^^^^ expected `str`, found `String`
  |     |
  |     expected due to the type of this binding

error[E0277]: the size for values of type `str` cannot be known at compilation time
 --> src/main.rs:4:5
  |
4 |     *i_am_sized.deref_mut() = String::new();
  |     ^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `str`
  = note: the left-hand-side of an assignment must have a statically known size

[kornelski]

I've originally ran into this when using Cow (that doesn't have DerefMut):

use std::borrow::Cow;

fn main() {
    let mut i_am_sized = Cow::Borrowed("");
    *i_am_sized = "".into();
}

Messy error

error[E0277]: the trait bound `&str: Into<str>` is not satisfied
 --> src/main.rs:5:22
  |
5 |     *i_am_sized = "".into();
  |                      ^^^^ the trait `From<&str>` is not implemented for `str`, which is required by `&str: Into<_>`
  |
  = help: the following other types implement trait `From<T>`:
            `String` implements `From<&String>`
            `String` implements `From<&mut str>`
            `String` implements `From<&str>`
            `String` implements `From<Box<str>>`
            `String` implements `From<Cow<'a, str>>`
            `String` implements `From<char>`
  = note: required for `&str` to implement `Into<str>`

error[E0277]: the size for values of type `str` cannot be known at compilation time
 --> src/main.rs:5:5
  |
5 |     *i_am_sized = "".into();
  |     ^^^^^^^^^^^ doesn't have a size known at compile-time
  |
  = help: the trait `Sized` is not implemented for `str`
  = note: the left-hand-side of an assignment must have a statically known size

[workingjubilee]

Yeah, the real issue is the more high-level "you tried to deref something but in this context it doesn't really make sense..." and here we emit a size-check error and a type mismatch and we would ideally somehow combine those to instead say "...hold up, you want to rethink what you're doing here."

In the absence of that (I don't know if expecting that kind of "high-level error combining" is realistic), refining one of the errors if we detect the misplaced * seems good.