Converting Java classes to use generics

Abstract

Generics offer significant software engineering benefits since they provide code reuse without compromising type safety. Thus generics will be added to the Java language in the next release. While this extension to Java will help programmers when they are writing new code, it will not help legacy code unless it is rewritten to use generics. In our experience, manually modifying existing programs to use generics is complex and can be error prone and labor intensive. We describe a system, Ilwith, that (i) converts non-generic classes to generic classes and (ii) rewrites their clients to use the newly generified classes. Our experiments with a number of Java container classes show that our system is effective in modifying legacy code to use generics.

Generics and Reverse Generics for Pharo

“…This takes place in two steps: with reverse generics a brand new generic version is obtained starting from existing code; then, by instantiating generic classes, the generic code is adapted and reused in a new context. There seem to be similarities among reverse generics and some refactoring approaches: however, the intent of reverse generics is not to perform reverse engineering or refactoring of existing code, (see, e.g., (Duggan, 1999;von Dincklage and Diwan, 2004;Kiezun et al, 2007)) but to extrapolate possible generic "template" code from existing one, and reuse it for generating new code. Note that this programming methodology will permit modifying only the original existing code, and then, automatically, spread the modifications to the one obtained by reverse generics.…”

Refactoring for Parameterizing Java Classes

“…Our approach fully supports Java 1.5 generics, including bounded and unbounded wildcards, and it has been implemented as a refactoring in Eclipse. Previous approaches for solving the parameterization problem [9,7,22] did not include a practical implementation, and produced incorrect or suboptimal results, as will be discussed in Section 5.…”

“…Our algorithm and implementation fully support parameterization in the presence of generic methods, e.g., those in java.util.Collections but we have not yet implemented adding type parameters to methods. (Von Dincklage and Diwan used heuristics to handle generic methods [22]-such heuristics may also be applicable to our work. In previous work, we used a contextsensitive version of the generic instantiation algorithm to parameterize methods [11].…”

“…Von Dincklage and Diwan [22] also present a combined approach for the parameterization of classes and for the inference of actual type parameters in clients of those classes. Similarly to Duggan [9], their tool (Ilwith) creates one type parameter per declaration, then uses heuristics to merge type parameters.…”

Towards improving interface modularity in legacy Java software through automated refactoring

“…Refactoring [16] is a process in which code is restructured to improve software design and safety features while preserving the original program semantics. Refactoring tools typically automatically assist developers with a range of software evolution and maintenance tasks, including migrating source code to a new platform version [6,10,11,13,20,23] or to make use of more desirable paradigms for performance improvements [4], translating existing code to a new platform [3,12,24], and restructuring code to reflect a superior design philosophy [5,9,14].…”