Ensure that the sync object is mutable in a synchronize(obj) {...} statement.

[JohanEngelen]

This PR is related to Issue 14251. I think it fixes it completely, but I am uncertain what the correct behavior should be for pure functions.

The PR adds a check for mutability of the sync object: it it passed to druntime functions that require mutability of it, and so passing an immutable object may result in bad runtime behavior.

A simple testcase that shows the problem in LDC is:

import std.stdio : writeln;
interface Foo {}
void main() {
    writeln(cast(size_t) typeid(Foo).__monitor);
    synchronized(typeid(Foo)) { }
    writeln(cast(size_t) typeid(Foo).__monitor);
}

typeid returns an immutable(TypeInfo) in LDC. Without optimizations, this prints zero and a non-zero value; with optimizations turned on it prints two zeroes.

Current Phobos contains one case where synchronization inside a const method is done: std.concurrency. I think this is a latent bug, however that method is marked for removal in March 2016.
https://github.com/D-Programming-Language/phobos/blob/master/std/concurrency.d#L1815

[dnadlinger]

Ping @WalterBright @andralex since this is technically a language change.

[MartinNowak]

Just because you fixed phobos doesn't mean you can directly turn this into an error, please start with a deprecation.

[JohanEngelen]

Perhaps DMD does not optimize enough for this to result in bad codegen. But for LDC, this will have to be an error, because it results in crashing code and was never supported.

[dnadlinger]

@MartinNowak: Doesn't DMD ever put immutable objects into .rodata? If it does, this is merely fixing an accepts-invalid bug and should go straight to an error.

[JohanEngelen]

Needs more in-depth study and discussion