Hello,

Apologies in advance if this has been asked before. I can't find the right words to express what I'm looking for, but essentially, I'm wondering if the offers has the option of executing the parts that can be evaluated at compile time and then replacing them with the result of this evaluation. The C equivalent would be compiling with the -E flag as explained here : https://stackoverflow.com/questions/4900870/can-gcc-output-c-code-after-preprocessing

For example :

//main.d
import std;

void main()
{
    enum x = iota(1, 5).reduce!"a * b";
    x.writeln();
}

Then after running something like

dmd --expand-ctfe main.d -o expanded.d
cat expanded.d

We'd get :

//expanded.d
import std;

void main()
{
    24.writeln();
}

Just in case this is a consequence of the XY problem, the reason why I'm looking for this is to make sure that the code I wrote did evaluate to what I'm expecting it to. Right now I do this with an enum assignment followed by static asserts, but I'd love it for there to be some sort of visual feedback.

Thanks in advance

On Tuesday, 19 July 2022 at 21:43:01 UTC, Azi Hassan wrote:

Try the -vcg-ast flag:

import object;
import std;
void main()
{
	enum int x = 24;
	writeln(24);
	return 0;
}

// ... and a bunch of template instances

On 7/19/22 5:43 PM, Azi Hassan wrote:

template printEnum(alias x, string file = __FILE__, size_t line = __LINE__)
{
   enum printEnum = x;
   pragma(msg, file, "(", int(line), "): ", printEnum);
}

enum x = printEnum!(iota(1, 5).reduce!"a * b");

This will spit out the file, line, and value for the declaration. Assuming this is useful for your double-checking you could do this, and then switch it back when you have verified that it's correct.

-Steve

On Tuesday, 19 July 2022 at 22:27:56 UTC, Dennis wrote:

import object;
import std;
void main()
{
	enum int x = 24;
	writeln(24);
	return 0;
}

// ... and a bunch of template instances

Thanks a lot, this is exactly what I had in mind. Where did you find it though ? I checked dmd --help and man dmd before making this thread, but to no avail.

On Tuesday, 19 July 2022 at 22:41:43 UTC, Steven Schveighoffer wrote:

template printEnum(alias x, string file = __FILE__, size_t line = __LINE__)
{
   enum printEnum = x;
   pragma(msg, file, "(", int(line), "): ", printEnum);
}

enum x = printEnum!(iota(1, 5).reduce!"a * b");

Nice, a compile time console.log. Thanks a lot, this will come in handy. I wonder if it can be combined with version(debug) to only run the pragma line if compiled with -g, this way we can keep the printEnum! line as it is. Then again, the code would become polluted by debugging logic

On 7/19/22 8:33 PM, Azi Hassan wrote:

Yep:

debug template printEnum(...) {
  ... // everything we already did
}
else
enum printEnum(alias x) = x;

There's a slight bloat in the compiler symbol table when but other than that it should be effective.

-Steve

On 7/19/22 8:57 PM, Steven Schveighoffer wrote:

Obviously I didn't finish that thought...

"when -debug isn't used on the command line"

-Steve

On Wednesday, 20 July 2022 at 00:33:06 UTC, Azi Hassan wrote:

It was implemented as an internal debugging tool, not a documented feature: https://github.com/dlang/dmd/pull/6556

It turned out to be useful for users as well though, and got exposure through the "AST" button on https://run.dlang.io/

Maybe it's time to document it, currently there's only this: https://wiki.dlang.org/DMD_Source_Guide#View_emitted_templates_instances_and_string.2Fmixins

On Wednesday, 20 July 2022 at 01:15:44 UTC, Steven Schveighoffer wrote:

Oh, interesting syntax. I was thinking something along the lines of

template printEnum(...) {
    version(debug) {
        ... // everything we already did
    } else {
        enum printEnum(alias x) = x;
    }
}

But I like yours better.

On Wednesday, 20 July 2022 at 14:11:52 UTC, Dennis wrote:

I see, thanks. I'll be sure to check the wiki next time.