Comment #0 by verylonglogin.reg — 2013-06-15T13:54:04Z
As `pure` functions can access `immutable` static data `immutable pure` constructors must not be allowed for mutable construction.
So this code must be rejected:
---
immutable int i;
class C
{
int* p;
this() immutable pure
{ p = &i; }
}
void main()
{
++*new C().p; // changes `i`
}
---
Current behaviour is already documented (dlang.org pull #317) so specs have to be changed too.
Comment #1 by issues.dlang — 2013-06-15T14:53:13Z
It's fine as long as the constructor is strongly pure, but as the example shows, weak purity isn't enough.
Comment #2 by issues.dlang — 2013-06-15T14:59:55Z
Actually, I take that back. The constructor here _is_ strongly pure. The problem is not strong vs weak. The problem is that the compiler must guarantee that nothing outside of the function ends up in the constructed object (or the return value if we were dealing with a function returning a new object rather than a constructor). And in _most_ cases, strong purity is enough for that (and weak purity is often enough if the constructor's body is examined appropriately), but the example shows how it's possible for a strongly pure function to inadvertently cast away immutability on something which it doens't own thanks to the fact that normally having pure functions access statics or globals which are immutable isn't a problem.
Comment #3 by robert.schadek — 2024-12-13T18:08:16Z