Bug 18100 – crt_constructor not allow to init immutable

=========== code ============ static immutable int my_i ; int test(){ return 3; } shared static this(){ my_i = test(); // work } pragma(crt_constructor) extern(C) void init1(){ my_i = test(); // Error: cannot modify immutable expression my_i } ==========================

crt_constructor can be call from anywhere. If so it is not able to init immutable. But if it it not able to init immutable, it will be much less useful from BetterC (compare to static this).

I want to say this is WONTFIX. remember that init1 is simply a function, it's not a static ctor. So if you allowed it to rewrite immutable data, then something can call it later and mess up the value. If you want to do this, I think you need a cast. Not a tall order considering there are no real guarantees from D on how this will work.

Hi, Steven Schveighoffer To allow set immutable will open the door for pure function and tail recursion optimization , and it is not safe to cast immutable to mutable and set value. This is why static share this is better then pragma(crt_con-/destructor). Since better D is target for high performance low level code, we should allow set immutable on crt_constructor, or drop crt_constructor and support static share this.

(In reply to changlon from comment #3) > Since better D is target for high performance low level code, we should > allow set immutable on crt_constructor, or drop crt_constructor and support > static share this. It is allowed, you just cast :) We do it in druntime and it works fine. As long as your immutable isn't initialized, the compiler treats it as a variable when using it elsewhere. See here: https://github.com/dlang/druntime/blob/master/src/core/time.d#L2429 It's on you to make sure it isn't called elsewhere. What I don't want is to create a hole in const/immutable in the language. I'd rather you create the hole, and then guard it yourself. There are other reasons not to use shared static this to mean something different than "properly ordered static constructors" if they are tagged with extern(C) or some pragma.

Thanks for explain. I just use cast and it work.

Right, I think this should be wontfix also. Pragma just exposes low level functionality that does not have any semantic guarantees in relation to the rest of the language. As per comment, you can use cast to write to immutable data, but you must provide your own static (probably gshared) guard to prevent multiple evaluation. This has got nothing to do with "betterC", whatever that means.

(In reply to Iain Buclaw from comment #6) > This has got nothing to do with "betterC", whatever that means. Actually, this is all about betterC. betterC means no druntime, which means no static ctor/dtor. pragma(crt_constructor) was added as a way to hook the C library's static constructor system when you don't have druntime. But your larger point was correct.