Problem confirmed on Windows, DMD 2.052, compiled with:
-inline -release -noboundscheck

A bit reduced code:


import std.conv: to;
void main() {
    int[string] aa;
    to!string(aa);
}

More reduction:

import std.conv: to;
void main() {
    int[int] aa;
    foreach (v; aa)
        to!string("");
}

Well, given the error, it involves creating a tuple, which none of the code here is doing directly, so in theory, it should be possible to reduce it to code which creates a tuple, but I don't know how you'd do that in this case. I assume that v in the foreach loop is a tuple of the key and value, and that's probably where the problem is, but I don't use associative arrays all that often, and when I do, I rarely iterate over them, so I'm not sure. Regardless, if you're really trying to reuduce it, in theory, you should be able to reduce it down to the creation of a tuple with a particular set of types.

(In reply to comment #3)
> I assume that v in the foreach loop is a tuple of the key and value,

It's just a value, so it's an int.

It has nothing to do with the AA. Also, -inline alone is actually enough to trigger this bug. This seems to be a problem in string pooling in compile time.


import std.conv;
import std.typecons;

void ik(T,U)(T t, U u) {
    Tuple!(T,U) x;
}
pragma(msg, ik!(string,string));

void main() {
    () { to!string("lit"); } ();
}

Further removing the Tuple:



import std.conv;

void ik(T)(T) {
    enum a = to!string("foo") ~ to!string("bar");
    static assert(a == "foobar");
}
alias ik!int ik2;

void main() {
    cast(void) () { to!string("lit"); };
}

As of 2.052 it asserts:

~/Downloads:911$ dmd -inline y.d
y.d(5): Error: static assert  ("foofoo" == "foobar") is false
y.d(7):        instantiated from here: ik!(int)

Further removing all Phobos dependency:



string b(string s) { return s; }
string a(string s) { return b(s); }

void ik(T)(T) {
    enum p = a("foo");
    enum q = a("bar");
    static assert(q == "bar");
}
alias ik!int ik2;

void main() {
    cast(void) () { a("lit"); };
}



Currently asserts:

y.d(7): Error: static assert  ("foo" == "bar") is false
y.d(9):        instantiated from here: ik!(int)

Don's still-in-progress CTFE overhaul seems to fix this:
https://github.com/donc/dmd/tree/ctfemem

(In reply to comment #8)
> Don's still-in-progress CTFE overhaul seems to fix this:
> https://github.com/donc/dmd/tree/ctfemem

Yes, it fixes almost all CTFE bugs involving arrays.

Fixed.
D1:
https://github.com/D-Programming-Language/dmd/commit/ef2a0f1da10331c4de102ca3e029ea1c1c1a46bf

D2:
https://github.com/D-Programming-Language/dmd/commit/0219a5f0dcc88076759a4c472582954d0fb804b0

It doesn't seem like this is fixed in dmd 2.053, but it should be according to the changelog.

(In reply to comment #10)
> It doesn't seem like this is fixed in dmd 2.053, but it should be according to
> the changelog.

Can you describe what's failing? The test in comment 7 works for me.

The test in comment 7 asserts for me.
I'm using dmd 2.053 on Windows.

It doesn't work on Fedora 15 either.

I'm using dmd 2.053 directly from the zip file on the digitalmars site (for both Fedora 15 and Windows).

Don, is your dmd built from source?  Maybe there's a difference between mine and yours.

I think there was something wrong with that test case, it wasn't instantiating the template. Here's a reduced test case:

string b(string s) { return s; }
string a(string s) { return b(s); }

void bug5708() {
    void m() { a("lit"); }
    static assert(a("foo") == "foo");
    static assert(a("bar") == "bar");
}

It was accidentally fixed in this commit:
6072 - [CTFE] Regression(git master): Cannot declare variable inside an 'if' condition

which actually fixed the treatment of comma expressions in CTFE.

https://github.com/D-Programming-Language/dmd/commit/1bcae90e09f5eb6988fcd6df4309a137c9901084

I'm adding this to the test suite so it stays fixed.