Nondeterministic behavior when referencing a closure more than once

[bstrie]

This program works as expected:

fn main() {
    let a = |x:int| { |y:int| -> int { x + y } };
    let b = a(2);
    //println(int::to_str(a(2)(3)));
    println(int::to_str(b(3)));  // 6
}

Uncomment that line and something goofy happens:

fn main() {
    let a = |x:int| { |y:int| -> int { x + y } };
    let b = a(2);
    println(int::to_str(a(2)(3)));  // 6
    println(int::to_str(b(3)));  // completely random number
}

The second print will be a different number every time it is run. This feels quite dangerous.

And if you try to use error!(b(3)), even in the first program, you get a segfault. But that might be a separate bug.

[bblum]

Can't reproduce. By default, this no longer typechecks, since the type of the second closure is inferred as a stack closure. If I annotate it, any combination of sigils that makes it compile seems to work properly.

Lightly modernized code as follows:

fn main() {
    let a: &fn(int) -> @fn(int) -> int = |x:int| |y:int| -> int x + y;
    let b = a(2);
    println(a(2)(3).to_str());  // 6
    println(b(3).to_str());  // completely random number
}

[bblum]

I expect @nikomatsakis might have fixed a bug in closure lifetime inference that recently fixed this bug?

[emberian]

Same. Needstest.

[huonw]

Closed by #8799.