I ran into a strange and hard-to-describe problem with nested functions closing over the argument to their enclosing function.

When a nested function (A) returns the value of another nested function (B) that returns a parameter of the enclosing function (C), and when (A) is returned from (C), then calling (A) returns an incorrect value if either run from a 32-bit program, or run from 64-bit and (A) has a parameter of class type (it works when (A) has no class parameters).

The following code demonstrates the issue:


auto foo(T)(int val)
{
    int nested()
    {
        return val;
    }

    int escaping(T ignored)
    {
        return nested();
    }

    return &escaping;
}

struct Bar {}

class Baz {}

void main()
{
    auto func1 = foo!int(55);
    auto val1 = func1(12);
    // 64-bit ok, 32-bit fail (varying)
    assert(val1 == 55);

    auto func2 = foo!Bar(55);
    Bar bar;
    auto val2 = func2(bar);
    // 64-bit ok, 32-bit fail (equal to incorrect val1)
    assert(val2 == 55);

    auto func3 = foo!Baz(55);
    auto baz = new Baz();
    auto val3 = func3(baz);
    // 64- and 32-bit fail (varying, different from val1/val2)
    assert(val3 == 55);
}