The Infer Type Refactoring, Version 3

Purpose

to replace the declared types of declaration elements with ones that have no unneeded members; to minimize coupling between classes

System requirements

Eclipse 3.6
Java 5
for large projects, ample heap space

Infer Type can be automatically applied by the Declared Type Generalization Checker, which you might want to try as well.

Decription

Infer Type 3 is the latest version of a new Eclipse refactoring that decouples classes by computing for a selected declaration element its maximally general type (interface or abstract class), i.e., that type that contains only the members accessed through the declaration element and the ones it gets assigned to. It then offers the redeclaration of the involved declaration elements with the inferred type (or types, in case this should be necessary).

For users of Eclipse’s other type refactorings, Infer Type can be described as an automatic version of Extract Interface, combined with Generalize Declared Type and Use Supertype Where Possible. However, Infer Type cannot be replaced by any combination of these.

What’s new

Infer Type 3 differs from its predecessor (which is part of the Yoxos Eclipse distribution) in the following respects:

It uses, and extends, Eclipse’s built-in type constraint framework.
It handles generics.
It infers types from import statements, meaning that it computes the exact required interface of a class.
It computes the exact required interface for a whole package.
It generalizes type arguments for generic type references.
It leverages Eclipe’s refactoring framework, by providing a full preview to all changes.
It does no longer present changes to the type hierarchy in a class diagram, so that it does not require GEF.

Usage

In an Editor, place the curser at a declaration element (variable or method declaration), or a single type import declaration, and start Infer Type from the context menu.
In an Outline view, select a declaration element or an import of a type and start Infer Type from the context menu.
Save all changes to files if so prompted.
Infer Type presents the inferred specifications of one or more types (interfaces or abstract classes) that contain all members needed. Additional members can be selected, if deemed appropriate. However, these will be unneeded for the selected declaration element(s), therefore introducing unnecessary coupling.
If an inferred type does not yet exist, or if you want to create a new type anyway, enter a suitable name.
Review the changes to be made by the refactoring by pressing the Preview button.

Examples

Decoupling clients from servers

A client class referencing a server class is coupled to that server class through the reference. If the server offers more than the client needs, this couplig is unnecessarily strong in that the server cannot be replaced by others not offering the unneeded members. For instance, in the code

public class Client {
      Server s;
      public Client(Server s) {
            s.m();
            this.s = s;
      }
      void n() {
            s.n();
      }
}

class Client references class Server twice, through its field s and through the formal parameter of its constructor. Depending on what else the server offers in his public interface, this coupling can be reduced by replacing references to Server with an inferred type. Executing Infer Type on field s produces

public interface IServer {
    void n();
}

public class Server implements IServer {...}

public class Client {
      IServer s;
      public Client(Server s) {
            s.m();
            this.s = s;
      }
      void n() {
            s.n();
      }
}

executing it on the parameter of the constructor produces

public interface IServer {
    void n();
    void m();
}

public class Server implements IServer {...}

public class Client {
      IServer s;
      public Client(IServer s) {
            s.m();
            this.s = s;
      }
      void n() {
            s.n();
      }
}

To make sure that all references of a class to another are replaced with a single new type in a single refactoring, Infer Type must be executed on the corresponding import statement.

Computing the required interface of a class

Given the code

package exp;

public class D {
      public void m() {}
      public void n() {}
      public void o() {}
}

package imp;

import exp.D;

public class C {
      D d;
      D e;
      void m() {d.m(); e.n();}
}

executing Infer Type on the import of D in C will compute and insert a new supertype of D containing only m() and n(). Likewise, in the example of Client and Server above, executing Infer Type on the import of Server in Client will replace all occurrences of Server in Client with one new inferred type, independently of any particular declaration element.

Generalizing type arguments

The Infer Generic Type Arguments refactoring of Eclipse can derive the most specific type parameter for a declaration using a raw type. Conversely, Infer Type can compute the maximally general type parameter for that declaration. For instance, given the code

public class C {
      List<C> l = new ArrayList<C>();
      public void m() {
            C c = l.get(1);
            c.m();
      }
      public void n() {}
}

executing Infer Type on the type argument C computes a new abstract supertype for C containing only m(), and replaces the type parameter C with it:

public interface I {
    void m();
}
public class C implements I {
      List<I> l = new ArrayList<I>();
      public void m() {
            I c = l.get(1);
            c.m();
      }
      public void n() {}
}

Things to note

Infer Type aims at decoupling classes. Therefore, it computes only interfaces or, in case an interface cannot be inserted in the type hierarchy (because it would have to subtype a class), abstract classes with the protocol of an interface (i.e., classes containing only public abstract methods).
Because Infer Type introduces only interfaces or correpsonding abstract classes, it does not infer the types of declaration elements accessing non-public or static members, or fields.
Because Infer Type adds new supertypes to the types of declaration elements, it cannot execute if the source code of these types is inaccessible. This is typically the case for library classes such as the JDK’s.
Because it must maintain assignment compatibility, Infer Type usually also redeclares other declaration elements than the ones it was started on. If these declaration elements are declared with supertypes of the original type, the inferred type may have to subtype these supertypes. In this case, if the supertype is a class, the inferred type cannot be an interface. Infer Type tries to insert an abstract class instead, but fails if the original type already has a superclass and the new superclass cannot be inserted in the superclass chain.

Testing

Infer Type has been automatically applied to all declaration elements of several large code bases.

Known bugs

In presence of overloading, Infer Type may introduce duplicate methods and method ambiguous errors.

Installation

Copy this jar into Eclipse’s plugin directory and restart Eclipse.
The source code is available here.

Team

Hannes Kegel
Friedrich Steimann