Implement __ctfeWrite builtin

changelog/dmd.ctfeWrite.dd

@@ -0,0 +1,28 @@
+Added `__ctfeWrite` to write messages from CTFE
+
+The special function `__ctfeWrite` can now be used to write messages
+during CTFE, similar to `pragma(msg, ...)`. It is Implementation Defined
+how the message is presented to the user; the recommended way is by
+printing the message to `stderr`, standard error stream.
+The function is available in `object.d` and accepts any value implicitly
+convertible to `const(char)[]`.
+
+For example:
+
+```d
+int greeting()
+{
+    __ctfeWrite("Hello from CTFE. Today is ");
+    __ctfeWrite(__DATE__);
+    __ctfeWrite("\n");
+    return 0;
+}
+
+enum forceCTFE = greeting();
+```
+
+Compiling this program will generate the following output:
+
+```
+Hello from CTFE. Today is <current date>
+```

compiler/src/dmd/builtin.d

@@ -88,7 +88,7 @@
 
     // Look for core.math, core.bitop, std.math, and std.math.<package>
     const id2 = (md.packages.length == 2) ? md.packages[1] : md.id;
-    if (id2 != Id.math && id2 != Id.bitop)
+    if (id2 != Id.math && id2 != Id.bitop && id2 != Id.builtinsModuleName)
         return BUILTIN.unimp;
 
     if (md.packages.length != 1 && !(md.packages.length == 2 && id2 == Id.math))
@@ -108,6 +108,12 @@
         return BUILTIN.unimp;
     }
 
+    if (id1 == Id.core && id2 == Id.builtinsModuleName)
+    {
+        if (id3 == Id.ctfeWrite)  return BUILTIN.ctfeWrite;
+        return BUILTIN.unimp;
+    }
+
     // Math
     if (id3 == Id.sin)   return BUILTIN.sin;
     if (id3 == Id.cos)   return BUILTIN.cos;
@@ -167,6 +173,20 @@
     return null;
 }
 
+Expression eval_ctfeWrite(Loc loc, FuncDeclaration fd, Expressions* arguments)
+{
+    import core.stdc.stdio: fprintf, stderr;
+    import dmd.expression: CTFEExp;
+    import dmd.ctfeexpr: resolveSlice;
+
+    Expression e = (*arguments)[0];
+    const se = resolveSlice(e).toStringExp();
+    assert(se);
+    const slice = se.peekString();
+    fprintf(stderr, "%.*s", cast(int)slice.length, slice.ptr);
+    return CTFEExp.voidexp;
+}
+
 Expression eval_sin(Loc loc, FuncDeclaration fd, Expressions* arguments)
 {
     Expression arg0 = (*arguments)[0];

compiler/src/dmd/frontend.h

@@ -741,6 +741,7 @@ enum class BUILTIN : uint8_t
     toPrecFloat = 33u,
     toPrecDouble = 34u,
     toPrecReal = 35u,
+    ctfeWrite = 36u,
 };
 
 enum class Include : uint8_t
@@ -8628,6 +8629,8 @@ struct Id final
     static Identifier* outp;
     static Identifier* outpl;
     static Identifier* outpw;
+    static Identifier* builtinsModuleName;
+    static Identifier* ctfeWrite;
     static Identifier* isAbstractClass;
     static Identifier* isArithmetic;
     static Identifier* isAssociativeArray;

compiler/src/dmd/func.d

@@ -113,7 +113,8 @@ enum BUILTIN : ubyte
     yl2xp1,
     toPrecFloat,
     toPrecDouble,
-    toPrecReal
+    toPrecReal,
+    ctfeWrite,
 }
 
 /* Tweak all return statements and dtor call for nrvo_var, for correct NRVO.

compiler/src/dmd/id.d

@@ -448,6 +448,8 @@ immutable Msgtable[] msgtable =
     { "outp"},
     { "outpl"},
     { "outpw"},
+    { "builtinsModuleName", "builtins" },
+    { "ctfeWrite", "__ctfeWrite" },
 
     // Traits
     { "isAbstractClass" },

compiler/test/compilable/test__ctfeWrite.d

@@ -0,0 +1,58 @@
+/*
+TEST_OUTPUT:
+---
+Hello
+World
+from
+CTFE
+Hello[1 .. 3] = el
+S.str
+abcdefghij[2 .. 6] = cdef
+---
+*/
+
+struct S
+{
+    string str = "S.str";
+    alias str this;
+}
+
+int greeting(scope const char[][] values) pure nothrow @safe @nogc
+{
+    const string newline = "\n";
+
+    foreach (const val; values)
+    {
+        __ctfeWrite(val);
+        __ctfeWrite(newline);
+    }
+
+    // Test slices
+    const val = values[0];
+    __ctfeWrite(val[]);
+    __ctfeWrite(['[','1',' ','.','.',' ','3',']',' ','=',' ']);
+    __ctfeWrite(val[1 .. 3]);
+    __ctfeWrite(newline);
+
+    S s;
+    __ctfeWrite(s);
+    __ctfeWrite(newline);
+
+    // Test mutable slices
+    char[10] buffer;
+    fill(buffer); // Avoid potential shortcuts for literals
+    __ctfeWrite(buffer[0 .. $]);
+    __ctfeWrite("[2 .. 6] = ");
+    __ctfeWrite(buffer[2 .. 6]);
+    __ctfeWrite(newline);
+
+    return 0;
+}
+
+void fill(ref char[10] buffer) pure nothrow @safe @nogc
+{
+    foreach (const idx, ref ch; buffer)
+        ch = cast(char)('a' + idx);
+}
+
+enum forceCTFE = greeting(["Hello", "World", "from", "CTFE"]);