Known Bugs of the Replace Inheritance with Delegation Refactoring

• A constructor of Superclass that is called (via super) from a constructor of Class and that calls a method overridden in Class (via open recursion) should prevent delegation if the method overridden in Class calls a method from Superclass, because this would be delegated to a not yet exisiting delgatee, causing a null pointer exception:

class Super {
      Super() {
            m();
      }
      void m() {}
      void n() {}
}
 
class Sub extends Super {
      Sub() {
            super();
      }
      void m() {
            n();
      }
}

Note that calling overridable methods from a construcor (which can also occur without delegation) is a known pitfall of Java and can be prevented by separating instantiation from initialization.

• Down casts are not always considered. For instance, in

public interface I {}

public class Super implements I {}

public class Sub extends Super {  
      I make() {
            return new Sub();
      }
      void cast() {
            Super o = (Super) make();
      }
      public static void main(String[] args) {
            new Sub().cast();
      }
}

the cast to Super is ignored, causing a Type Cast Error after the refactoring.

• Split identity is not considered: If a method inherited from Superclass returns this or passes this on as a parameter, the result points to a different object (an instance of Delegator) after replacing inheritance with delegation than before (an instance of Sublcass). Note that this is no problem for calling methods on the returned pointer (since this is a case of open recursion and therefore leads to reverse forwarding to the original receiver), but only for testing identity with ==.

public interface Inter {}

public class Super implements Inter {
      public void exportThisTo(Client c) {
            c.receive(this);
      }
}

public class Sub extends Super {}


public class Client {
      Sub server = new Sub();

      void receive(Inter object) {
            assert object == server;
      }

      void send() {
            server.exportThisTo(this);
      }
     
      public static void main(String[] args) {
            (new Client()).send();
      }
}