GDC doesn't catch this ambiguity

[Mike]

In the following code:

module trace;

private nothrow pure void SendCommand(in int command, in void*
message)
{
     asm
     {
        "mov r0, %[cmd];
        mov r1, %[msg];
        bkpt #0xAB"
        :
        : [cmd] "r" command, [msg] "r" message
        : "r0", "r1";
     };
}

private static nothrow pure void SendMessage(in void* ptr, in
uint length)
{
     // Create semihosting message message
     uint[3] message =
     [
        2,                // stderr
        cast(uint)ptr,    // ptr to string
        length            // size of string
     ];

     // Send semihosting command
     SendCommand(0x05, &message);
}

struct Trace
{
     static nothrow pure void Write(in string text)
     {
        SendMessage(text.ptr, text.length);
     }

     static nothrow pure void Write(uint value)
     {
        char[32] buffer;
        
        char* p = buffer.ptr + 31;
        do
        {
            p--;
            *p = '0' + (value % 10);
            value /= 10;
        } while(value > 0);

        SendMessage(p, (buffer.ptr + 31) - p);
     }

     static nothrow pure void Write(A...)(A a)
     {
        foreach(t; a)
        {
            Write(t);
        }
     }

     static nothrow pure void WriteLine(A...)(A a)
     {
        foreach(t; a)
        {
            Write(t);
        }
        Write("\r\n");
     }
}

GDC doesn't catch the ambiguity between...
   static nothrow pure void Write(A...)(A a)
     and
   static nothrow pure void Write(in string text)
... but LDC does.

Who's right?