mutable variables (immutable as default)

[ethers]

Function parameters can be marked immutable.

Such variables are called immutable. The immutable property extends to expressions in the following way:

• members of immutable expressions are immutable
• index access to immutable expressions yields immutable expressions
• (perhaps some other cases we forgot about)

Immutable expressions cannot be assigned to (or be used in ++ or -- expressions) and they cannot be passed to internal functions as arguments that are not marked as immutable.

For value types, the "immutable" property can be removed if they are rvalues (need to specify this some more), and also the transition from storage to memory and memory to storage can lose the immutable property.

Todo:

• similar to isPure, collect data in the TypeChecker about whether an expression is immutable
• add the immutable keyword
• check that assignments and ++ and -- do not have immutable left-hand-sides
• check that there is no assignment from an immutable expression to a mutable expression
• check that arguments to function calls do not violate these rules

---

"The constant keyword for functions is currently not enforced by the compiler."

It sounds like Solidity can enforce this and refuse to compile.

[chriseth]

There are several stories like this still on pivotal tracker, will try to cross-link them.

[axic]

cc #992

[chriseth]

This would allow constant contract-level variables of struct and array type. If we enforce the constant keyword on those, arrays and struct members cannot be modified, not even if such constants are passed on to other functions.

Some end to end tests are disabled (referencing this issue 715) until we have constant contract-level variables of struct and array type.

[axic]

Some historical explanation on immutable is here: #1049 (comment)

[roadriverrail]

To be clear, constant will continue to be used for state variables and functions, retaining its original semantics, yes?

[axic]

Until the next breaking release.

[roadriverrail]

Ah. So the use of constant is being completely replaced, then. I wasn't sure if this was to distinguish constant from immutable or to wholly replace it.

[axic]

It seems that constant will remain solely for compile time constants, which cannot refer non-constant statements.