more enum and pragma troubles

[JS]

On Saturday, 17 August 2013 at 05:22:53 UTC, captaindet wrote:
> are these bugs or expected behavior? (2 issues, see code below)
>
> i thought enums are just compile time copy&paste magic so i 
> cannot think of a reason why it should not be available at 
> compile time...
>
> if buggy, what is broken, enum (really bad) or pragma(msg,...) 
> (worse enough)?
> and are they in bugzilla already? (looked but nothing caught my 
> eye)
>
> if expected behavior, can someone pls explain.
>
> cheers /det
>
>
> import std.stdio;
>
> enum Test{
> 	test2 = 2,
> 	test4 = 4
> }
>
> enum foo = Test.test2;
> Test bar = Test.test4;
>
> pragma( msg, foo );		// why does it print: cast(Test)2
> 				// it should be: test2
> 				// or at least simply: 2
>

It is 2! Notice the 2 at the end? The cast is just mumbo jumbo 
due to the the compiler deals with the stuff. You can remove the 
casts manually if you don't like them.

> //  pragma( msg, bar );		// Error: variable bar cannot be read 
> at compile time
>

Because bar is not a compile time constant. It is an runtime 
object. pragma can't display certain things that it doesn't know 
about due to the way the compiler works. It's unfortunate in some 
cases that it simply doesn't work correctly, in others, such as 
this, it works as expected.

You could argue that the compiler should know that bar is known 
at compile time up to the pragma, and I would agree... but the 
compiler simply isn't that smart.


> void main(){
> 	writeln( typeof(foo).stringof, " = ", foo );	
> 		// prints as expected: Test = test2
> 	writeln( typeof(bar).stringof, " = ", bar );	
> 		// prints as expected: Test = test4
> }

these print the value at runtime. In this case the compiler is 
already out of the picture.

Basically pragmas are evaluated during compile time, if the 
compiler can't figure out the value(or is too stupid) then it 
can't print them and throws an error.

In fact, even in CTFE stuff pragma doesn't function like one 
would hope. This again, is due to the way the compiler works. 
Just a quirky and unfortunate way that the d compiler works.