match binding is unexpectedly mutable

[lilyball]

Submitted from reddit. The following code works, and it shouldn't:

enum Foo {
    Bar(int)
}

fn main() {
    let bar = Bar(1);
    match bar {
        Bar(x) => { // shouldn't x be immutable?
            println!("x = {}" ,x);
            x += 1;
            println!("x = {}" ,x);
        }
    }
}

This prints

x = 1
x = 2

[alexcrichton]

Oh dear, that's bad. Nominating.

[flaper87]

This fails, though:

enum Foo {
    Bar(~[int])
}

fn main() {
    let bar = Bar(~[1,2,3]);
    match bar {
        Bar(x) => {
            println!("x = {}", x.len());
            x.push(4);
            println!("x = {}", x.len());
        }
    }
}

[lilyball]

This fails as well:

enum Foo {
    Bar(int)
}

fn main() {
    let bar = Bar(1);
    match bar {
        Bar(x) => { // shouldn't x be immutable?
            println!("x = {}" ,x);
            x += 1;
            x += 2;
            println!("x = {}" ,x);
        }
    }
}

I expect it's using whatever machinery allows let x; x = 3; and mistakenly thinks that x hasn't been assigned yet.

[arjantop]

@flaper87: but any assignment works (e. g.: x = ~[]), all after the first fail (with error x assigned in previous assignment that shouldn't be allowed)

[flaper87]

@arjantop good point, this one doesn't fail

enum Foo {
    Bar(~[int])
}

fn main() {
    let bar = Bar(~[1,2,3]);
    match bar {
        Bar(mut x) => {
            println!("x = {}", x.len());
            x = ~[1];
            println!("x = {}", x.len());
        }
    }
}

[huonw]

@flaper87 as you've written it, your code is meant to compile (mut x).

But, it also compiles without the mut: it looks like this is an control-flow thing, were the compiler is treating this pattern match the same as:

let x; // don't initialise immediately
// ...
x = 1; // initialise later

because any attempt to borrow it as &mut fails (e.g. the .push failure, and writing &mut x; instead of x = 1; fails).

[edwardw]

r?