Immutability - ECS | Victoria University of Wellington

256 A. Potanin et al.
1 class Foo {
2 // An immutable reference to an immutable date.
3 Date imD = new Date();
4 // A mutable reference to a mutable date.
5 Date mutD = new Date();
6 // A read−only reference to any date.
7 // Both roD and imD cannot mutate their referent,
8 // however the referent of roD might be mutated by an alias,
9 // whereas the referent of imD is immutable.
10 Date roD = ··· ? imD : mutD;
11 // A date with the same owner and immutability as this.
12 Date sameD;
13 // A date owned by this; it cannot leak.
14 Date ownedD;
15 // Anyone can access this date.
16 Date publicD;
17 // Can be called on any receiver; cannot mutate this.
18 // The method guard ‘‘?’’ is part of cJ’s syntax˜[42].
19 ? int readonlyMethod() {···}
20 // Can be called only on mutable receivers; can mutate this.
21 ? void mutatingMethod() {···}
22 // Constructor that can create (im)mutable objects.
23 ? Foo(Date d) {
24 this.sameD = d;
25 this.ownedD = new Date();
26 // Illegal, because sameD came from the outside.
27 // this.sameD.setTime(···);
28 // OK, because Raw is transitive for owned fields.
29 this.ownedD.setTime(···);
30 } }
Fig. 6. An example of OIGJ syntax
The immutability of sameD (line 12) depends on the immutability of this, i.e., sameD
is (im)mutable in an (im)mutable Foo object. Similarly, the owner of sameD is the same
as the owner of this.
Ownership example. Lines 12–16 show three different owner parameters: O, This, and
World. The owner parameter is invariant, i.e., the subtype relation preserves the owner
parameter. For instance, the types on lines 12–16 have no subtype relation with each
other because they have different owner parameters.
Reference ownedD cannot leak outside of this, whereas references sameD and publicD
can potentially be accessed by anyone with access to this. Although sameD and publicD
can be accessed by the same objects, they cannot be stored in the same places: publicD
can be stored anywhere on the heap (even in a static public variable) whereas sameD can
only be stored inside its owner.