Value assigned is never read

[kkayal]

I have the following simple code:

fn main() {
	let mut foo = String::new();
	foo = "Hi!".to_string();

	println!("{}", foo);
}

The compiler gives me the following warning:

warning: value assigned to `foo` is never read
 --> src\main.rs:2:6
  |
2 |     let mut foo = String::new();
  |         ^^^^^^^
  |
  = note: #[warn(unused_assignments)] on by default

This warning seems to be wrong to me. The assignment foo has been used in the println! macro. So I should not get this error. When I remove the mutable assignment as follows, I get no warning as expected:

fn main() {
	let foo = "Hi!".to_string();
	println!("{}", foo);
}

I am using rustc 1.24.1 (d3ae9a9 2018-02-27) on Windows 7.

[matthiaskrgr]

Hi, I think what it means is that the result of the assignment of "String::new()" is never used, since it is overwritten by "Hi!".to_string(); afterwards.

note that

fn main() {
	let foo;
	foo = "Hi!".to_string();

	println!("{}", foo);
}

doesn't trigger a warning.

[kkayal]

Hi, the warning underlines the the part mut foo. So it is telling me that I am not using the left side of the assignment:

2 |     let mut foo = String::new();
  |         ^^^^^^^

[matthiaskrgr]

Yeah, I agree that's a bit confusing.

[steveklabnik]

Tagging with A-diagnostics due to the mut issue; @matthiaskrgr is correct that fundamentally, this warning is correct.

[sanxiyn]

This is #33536 which was incorrectly closed.

[pr-yemibedu]

Hello,
Two things in the this and a point from the closed ticket:

• A message should point out the connecting value to the binding in question:
  • warning: valueString::new()assigned to binding foo is never read
• it would be nice to let the developer know that a mut was not needed from analysis

The tuple in the indirect link to the other ticket would not need a pretty print to know how to address the problem with the above advice with both lhs and rhs warnings. Like:

  |
2 |     let (mut a, b) = tup;
  |             ^^^     ^^^
  |

Thank you. Good day.

[zackmdavis]

(I am working on this)

[scottmcm]

it would be nice to let the developer know that a mut was not needed from analysis

Note that upon removing the unused initializer

fn main() {
	let mut foo;
	foo = "Hi!".to_string();

	println!("{}", foo);
}

one does indeed get another warning that

warning: variable does not need to be mutable
 --> src/main.rs:2:6
  |
2 |     let mut foo;
  |         ---^^^^
  |         |
  |         help: remove this `mut`
  |
  = note: #[warn(unused_mut)] on by default

I assume in the general case getting both at once could be hard or false-positive-y, so the two-step is probably fine for this.

[pr-yemibedu]

Hello,
I agree with @scottmcm about the benefits of the layered approach staying as implemented.

What @zackmdavis has presented in the merge looks clean and useful. Only one nitpick:

• The tuple test marks the whole value. That can confuse the developer into thinking x = (3, 4) instead of just 3. Can you either expose that value (in this case 3) in the warning message itself or limit the how much of RHS is marked?
  I am not sure how valid it would always be with other structured literals, but it is a clear win here. Thank you. Good day.