Wrapping value in noop function call changes evaluation order

[huonw]

Breaking out of #15300. These two differ in evaluation order, even though the only difference is the introduction of the noop foo((), ...) around the a on the LHS:

fn foo(_: (), x: int) -> int { x }

fn main() {
    let mut a = 2i;
    println!("{}", a * foo(a = 5, a)); // 25
    a = 2i;
    println!("{}", foo((), a) * foo(a = 5, a)); // 10
}

http://is.gd/zVdDoh

[pnkfelix]

cc me

[steveklabnik]

Triage: still a bug.

[Aatch]

So having been linked #15300, I looked at this briefly. There's an argument to be made that the second behaviour is correct and the first not. What we do for non-overloaded binops is translate the LHS, then the RHS then translate the operation. Makes sense, right? Well a identifier expression is translated to an "lvalue datum", which is just a pointer to the on-stack location of the value the variable contains. We don't actually load the value from the lvalue until after translating both sides, meaning any changes to a will be visible.

It'd be a simple fix to load the value a little earlier, but it does change visible behaviour (though you could argue that this is buggy behaviour).

[bltavares]

Triage: I could not reproduce the bug.

I had to change the int types to compile it.

fn foo(_: (), x: isize) -> isize { x }

fn main() {
    let mut a = 2isize;
    println!("{}", a * foo(a = 5, a)); // 10
    a = 2isize;
    println!("{}", foo((), a) * foo(a = 5, a)); // 10
}

http://is.gd/EiOduV

[arielb1]

I fixed it.