Description Andrew Clement 2009-02-27 15:07:16 EST

We currently have @DeclareParents, which is a poor imitation of code style 'declare parents' and really implements a mixin strategy rather than what 'declare parents' does.  I've read through the posts on this and the bugs related to it and taken on board a suggestion that the JBoss mixin syntax looks neat.  Based on all that I'm proposing this kind of design for @DeclareMixin - I may then deprecate @DeclareParents.

What is a mixin?  Well the definition I'm using here is that some new type is 'mixed in' to an existing type by means of a delegate instance of the new type being maintained and forwarding methods added to the target type that forward calls on the original object to the delegate.  This is basically what @DeclareParents does now but we'll tweak the syntax and make it more friendly.

General form - the [] show where users plug details in.  Basically @DeclareMixin is attached to a factory method in an aspect that can create instances of the delegate class.

@DeclareMixin(value="[typePattern]",interfaces={[interfaceList]})
public static [interfaceName | className] create[Something](Object object) {
  return new [ImplementationType](object);
}

By allowing the user to specify the factory method, we don't have to rely on a default no-arg constructor in the Implementation class and instances of the Implementation class can know which object they are the delegate for (if they want to).  With smart defaults, it can be as simple as follows:

The interface to mixin is deduced from the return type of the factory method.

@DeclareMixin("@Foo *")
public static SomeInterface createInstance(Object object) {
  return new SomeImplementation(object);
}

or if the user doesn't care about the instance for which they are delegating:

@DeclareMixin("@Foo *")
public static SomeInterface createInstance() {
  return new SomeImplementation();
}

Here the public methods (and probably fields) are mixed in from the SomeImplementation class:

@DeclareMixin("@Foo *")
public static SomeImplementation createInstance(Object object) {
  return new SomeImplementation(object);
}

If SomeImplementation implemented interfaces we could limit (by interface) the mixed in methods, so here only A and B are mixed in - no fields would be mixed.

class MyClass implements A,B,C,D {}

@DeclareMixin("@Foo *",interfaces={A.class,B.class})
public static MyClass createInstance(Object object) {
  return new MyClass(object);
}

In terms of annotation 'copying' - any annotations on the interface methods will be copied to the delegate methods added to the target type (just as @DeclareParents does today).

Let's finish with a translation from @DeclareParents to @DeclareMixin:

@DeclareParents(value="org.xyz..*",defaultImpl=MoodyImpl.class)
private Moody implementedInterface;

@DeclareMixin("org.xyz..*")
private Moody createMoodyInstance() {
  return new MoodyImpl();
}

The declaration will work in either an annotation style or code style aspect.

(Thanks to Ramnivas Laddad for already helping me get this far)

I definetly see a phase 1 and phase 2 since field mixins need a bit more thought.