Troubles with immutable arrays

[bearophile]

After a discussion in D.learn started by someone else, after a 
suggestion of mine Timon Gehr has added a bug report:

http://d.puremagic.com/issues/show_bug.cgi?id=8400
But the bug was fixed in the opposite way of what I was thinking.

The problem was that the length of global immutable arrays arrays 
is seen as a compile-time constant.
Instead of fixing that, Issue 8400 has done the opposite, now 
even the lenght of local immutable arrays is seen sometimes as a 
compile-time constant, and example:


int[] foo(in int n) pure nothrow {
    int[] a;
    foreach (i; 0 .. n)
        a ~= i * 10;
    return a;
}
void main() {
    import core.stdc.stdio: printf;
    immutable int[] A = foo(5);
    int[A.length] B;
    printf("%zd\n", B.length);
}



The asm, compiled with -release:

_D4temp3fooFNaNbxiZAi   comdat
L0:     enter   018h,0
        push    EBX
        push    ESI
        mov dword ptr -018h[EBP],0
        mov dword ptr -014h[EBP],0
        mov dword ptr -010h[EBP],0
        mov -0Ch[EBP],EAX
L1E:        mov EAX,-010h[EBP]
        cmp EAX,-0Ch[EBP]
        jge L48
        lea ECX,-010h[EBP]
        mov EDX,[ECX]
        lea EBX,[EDX*4][EDX]
        add EBX,EBX
        push    EBX
        lea ESI,-018h[EBP]
        push    ESI
        mov EAX,offset FLAT:_D11TypeInfo_Ai6__initZ
        push    EAX
        call    near ptr __d_arrayappendcT
        add ESP,0Ch
        inc dword ptr -010h[EBP]
        jmp short   L1E
L48:        mov EDX,-014h[EBP]
        mov EAX,-018h[EBP]
        pop ESI
        pop EBX
        leave
        ret

__Dmain comdat
L0:     enter   018h,0
        push    EBX
        push    ESI
        push    5
        mov EAX,offset FLAT:_D11TypeInfo_Ai6__initZ
        push    EAX
        call    near ptr __d_arrayliteralTX
        mov dword ptr [EAX],0
        mov dword ptr 4[EAX],0Ah
        mov dword ptr 8[EAX],014h
        mov dword ptr 0Ch[EAX],01Eh
        mov dword ptr 010h[EAX],028h
        mov ECX,EAX
        mov EBX,5
        lea EDX,-018h[EBP]
        xor EAX,EAX
        mov [EDX],EAX
        mov 4[EDX],EAX
        mov 8[EDX],EAX
        mov 0Ch[EDX],EAX
        mov 010h[EDX],EAX
        push    5
        mov ESI,offset FLAT:_DATA
        push    ESI
        call    near ptr _printf
        xor EAX,EAX
        add ESP,010h
        pop ESI
        pop EBX
        leave
        ret



This code too compiles, so A is sometimes computed at run-time 
and sometimes at compile-time:

int[] foo(in int n) pure nothrow {
    int[] a;
    foreach (i; 0 .. n)
        a ~= i * 10;
    return a;
}
void main() {
    import core.stdc.stdio: printf;
    int n = 5;
    immutable int[] A = foo(n);
}



Now immutable arrays are sometimes seen as enums. I think this is 
a problem. I think in D compile-time is run only if it's 
evaluated in a context where compile-time values are required. 
But now the situation is more muddy, because knowing n at 
compile-time is not a way to ask A to be computed at compile-time.

Another problem is that compile-time arrays in many situations 
are not efficient, they gets copied every time you use them, and 
I think that __d_arrayliteralTX performs a heap allocation. So 
now both enum and immutable arrays perform heap allocations every 
time you use them, but only in some situations.

I think this is a messy situation, I think the fix for bug 8400 
should be undone, and I think Issue 8400 should be fixed the 
other way, turning global immutable arrays too into run-time 
entities.

The bug was fixed by Hara and accepted by Walter, both of them 
are very intelligent, so maybe I am just very wrong :-)

Bye,
bearophile