New lint: mutating implicit copy of const

[ExoticMatter]

Constants are instantiated every time they are used, even for non-Copy types. This results in behavior that may seem unintuitive at a first glance. The following code looks like it shouldn't compile at all:

#[derive(Debug)]
struct Foo {
    v: Vec<usize>,
}

const FOO: Foo = Foo { v: Vec::new() };

fn main() {
    for i in 0..32 {
        FOO.v.push(i); // attempting to modify a constant
    }
    println!("{:?}", FOO);
}

However, this code is actually valid. Of course, constants can't actually be modified. What really happens is that every usage of FOO creates a new temporary-like value that can be freely mutated even though FOO is const.

Suggest creating a local variable from the constant and mutating the variable instead, or using a static with interior mutability if a global state is truly necessary.

---

As a side note, the following code does work. Is it bad style?

fn main() {
    let foo = &mut FOO; // actually borrows an implicit local variable, not FOO
    for i in 0..32 {
        foo.v.push(i);
    }
    println!("{:?}", foo); // Foo: { v: [0, 1, 2, 3, ...] }
    println!("{:?}", FOO); // Foo: { v: [] }
}