Concrete type inference: delivering object-oriented applications

Polymorphism in object-oriented languages, while increasing expressive power and reusability of code, sacrifices manifest concrete type information. In turn, application delivery suffers: lacking concrete type information, it is impossible to compile as efficiently, to check as thoroughly, and to eliminate dead code as effectively. The delivery problem exists for dynamically-typed languages like Smalltalk and, since type-declarations should be abstract, for statically-typed languages like C++. We have designed, implemented, and evaluated an algorithm, the cartesian product algorithm, that can infer concrete types of object-oriented programs. It applies the cartesian product to break the analysis of each polymorphic send into a case analysis; each case represents a monomorphic combination of actual arguments and can be analyzed precisely. The cartesian product algorithm improves precision and efficiency over previous algorithms and deals directly with inheritance, rather than relying on a preprocessor to expand it away. Our implementation handles most of the dynamically-typed Self language, including dynamically-dispatched messages, dynamic and multiple inheritance, lexically-scoped blocks, and non-local returns, although it supports the reflective features of Self only partially. Using the inferred concrete types, a compiler can statically bind and inline message sends, a browser can follow control-flow through message sends, an extractor can identify the essential objects for an application and discard the rest, and a checker can statically guarantee the absence of message-not-understood errors. Collaborating with other researchers, we have implemented proof-of-concept versions of these type-based application delivery tools. Measurements indicate that type inference performs well. For example, on a 167 MHz UltraSPARC our type inferencer can analyze the DeltaBlue constraint solver in 10 seconds (DeltaBlue consists of 500 lines of source code and uses an additional 900 lines from libraries). Subsequently, our extractor takes 4 seconds to produce a shrink-wrapped DeltaBlue application comprising 350 Kb, a 96% size reduction over the original 10 Mb image. Moreover, the inferred types enable static compilation of Self program, while sustaining performance comparable to that of Holzle's state-of-the-art dynamic Self compiler. Thus, concrete type inference enables delivery of object-oriented applications.