union mutability

[Jonathan M Davis via Digitalmars-d-learn]

On Thursday, August 25, 2016 15:22:23 Jack Applegame via Digitalmars-d-learn 
wrote:
> Code:
>
> union A {
>      immutable int f;
> }
>
> union B {
>      immutable int f;
>      int e;
> }
>
> void main() {
>      A a = A(1);
>      //a = A(2); // a.f is immutable, fails to compile as expected
>
>      B b = B(1);
>      b = B(2); // compiles!!!
> }
>
> It turns out that if the union contains at least one mutable
> member, then the entire union is considered to be mutable.
> It's logical, but does it meet the specs? I couldn't find
> description of this behavior.

Well, Rebindable depends on it (though Rebindable is in a legal grey area at
best and technically in violation of the rules at worst). It's basically the
same as when you cast away const or immutable - it's fine as long as you
don't mutate the variable and thus break the guarantees that compiler has
for const or immutable objects. But I don't know how you can really do
anything with it without violating immutable. Certainly, in any case other
than what Rebindable is up to, I wouldn't do it, and even then, I suspect
that Rebindable is in a situation where it's technically violating the
compiler's guarantees but does so in a way that will never actually result
in problems in practice.

But yes, this behavior is known, albeit questionable.

- Jonathan M Davis