Ownership and immutability in generic Java

Abstract

The Java language lacks the important notions of ownership (an object owns its representation to prevent unwanted aliasing) and immutability (the division into mutable, immutable, and readonly data and references). Programmers are prone to design errors, such as representation exposure or violation of immutability contracts. This paper presents Ownership Immutability Generic Java (OIGJ), a backward-compatible purely-static language extension supporting ownership and immutability. We formally defined a core calculus for OIGJ, based on Featherweight Java, and proved it sound. We also implemented OIGJ and performed case studies on 33,000 lines of code.Creation of immutable cyclic structures requires a "cooking phase" in which the structure is mutated but the outside world cannot observe this mutation. OIGJ uses ownership information to facilitate creation of immutable cyclic structures, by safely prolonging the cooking phase even after the constructor finishes.OIGJ is easy for a programmer to use, and it is easy to implement (flow-insensitive, adding only 14 rules to those of Java). Yet, OIGJ is more expressive than previous ownership languages, in the sense that it can type-check more good code. OIGJ can express the factory and visitor patterns, and OIGJ can type-check Sun's java.util collections (except for the clone method) without refactoring and with only a small number of annotations. Previous work required major refactoring of existing code in order to fit its ownership restrictions. Forcing refactoring of well-designed code is undesirable because it costs programmer effort, degrades the design, and hinders adoption in the mainstream community.

Tracing and preventing sharing and mutation

“…As shown by the examples of Sect.2, this type system is very powerful. Notably, it discriminates between well-typed and ill-typed terms in situations where type systems only based on declaring qualifiers are either too restrictive or require rather tricky rules [18,17,29].…”

“…The last few decades have seen considerable interest in type systems for controlling sharing and interference, to make programs easier to maintain and understand. A simple and widely used technique is to enrich the type of an expression evaluating to a reference x by type qualifiers [29,18,25,10] or by capabilities [5,7]. Depending on the qualifier of x , restrictions are imposed and assumptions can be made on the (reachable) object graph of x .…”

Correctness of a Concurrent Object Collector for Actor Languages

“…Such requirements are satisfied by many type systems with read-only references or immutability (e.g. [7,11,18,23,29,33,37,41]). An implication of A1 and A2 is that capabilities degrade with growing paths, i.e., the prefix of a path has more rights than its extensions.…”

Exploring language support for immutability

“…Rust provides facilities for borrowing ownership at function call boundaries in order to make function calls more convenient. The ownership system OIGJ [45] extends IGJ with a notion of ownership so that objects cannot leak outside their owners. Potanin's chapter on immutability [29] gives more detail on ownership types and immutability in general.…”