Synchronization on immutable object

[Alex Parrill via Digitalmars-d]

On Tuesday, 22 March 2016 at 10:49:01 UTC, Johan Engelen wrote:
> Quiz: does this compile or not?
> ```
> class Klass {}
> void main() {
>     immutable Klass klass = new Klass;
>     synchronized (klass)
>     {
>         // do smth
>     }
> }
> ```
>
> A D object contains two (!) hidden pointers. Two? Yes: the 
> vtable pointer __vptr, and a pointer to a Monitor struct which 
> contains a synchronization mutex.
> The synchronized statement is lowered into druntime calls that 
> *write* to __monitor.
> Quiz answer: yes it compiles. Oops?
>
> This is related to an earlier discussion on whether TypeInfo 
> objects should be immutable or not [1]. Should one be able to 
> synchronize on typeid(...) or not?
> ```
> interface Foo {}
> void main() {
>     synchronized(typeid(Foo)) {
>        // do smth
>     }
> }
> ```
> Because LDC treats the result of typeid as immutable, the code 
> is bugged depending on the optimization level.
>
> [1] 
> http://forum.dlang.org/post/entjlarqzpfqohvnnwjb@forum.dlang.org

As long as there's no race conditions in the initial creation of 
the mutex, it shouldn't matter, even though it does internally 
mutate the object, because it's transparent to developers (unless 
you're going out of your way to access the internal __monitor 
field).

What exactly is bugged about the typeid example under LDC?