/**
* Adds the annotation to the internal target list if a match is found.
*
* @param node the node to be processed
*/
public void visitAnnotations(AnnotatedNode node) {
super.visitAnnotations(node);
for (AnnotationNode annotation : node.getAnnotations()) {
if (transforms.containsKey(annotation)) {
targetNodes.add(new ASTNode[] {annotation, node});
}
}
}
/**
* Main loop entry.
*
* <p>First, it delegates to the super visitClass so we can collect the relevant annotations in an
* AST tree walk.
*
* <p>Second, it calls the visit method on the transformation for each relevant annotation found.
*
* @param classNode the class to visit
*/
public void visitClass(ClassNode classNode) {
// only descend if we have annotations to look for
Map<Class<? extends ASTTransformation>, Set<ASTNode>> baseTransforms =
classNode.getTransforms(phase);
if (!baseTransforms.isEmpty()) {
final Map<Class<? extends ASTTransformation>, ASTTransformation> transformInstances =
new HashMap<Class<? extends ASTTransformation>, ASTTransformation>();
for (Class<? extends ASTTransformation> transformClass : baseTransforms.keySet()) {
try {
transformInstances.put(transformClass, transformClass.newInstance());
} catch (InstantiationException e) {
source
.getErrorCollector()
.addError(
new SimpleMessage(
"Could not instantiate Transformation Processor "
+ transformClass, // + " declared by " +
// annotation.getClassNode().getName(),
source));
} catch (IllegalAccessException e) {
source
.getErrorCollector()
.addError(
new SimpleMessage(
"Could not instantiate Transformation Processor "
+ transformClass, // + " declared by " +
// annotation.getClassNode().getName(),
source));
}
}
// invert the map, is now one to many
transforms = new HashMap<ASTNode, List<ASTTransformation>>();
for (Map.Entry<Class<? extends ASTTransformation>, Set<ASTNode>> entry :
baseTransforms.entrySet()) {
for (ASTNode node : entry.getValue()) {
List<ASTTransformation> list = transforms.get(node);
if (list == null) {
list = new ArrayList<ASTTransformation>();
transforms.put(node, list);
}
list.add(transformInstances.get(entry.getKey()));
}
}
targetNodes = new LinkedList<ASTNode[]>();
// first pass, collect nodes
super.visitClass(classNode);
// second pass, call visit on all of the collected nodes
for (ASTNode[] node : targetNodes) {
for (ASTTransformation snt : transforms.get(node[0])) {
if (snt instanceof CompilationUnitAware) {
((CompilationUnitAware) snt).setCompilationUnit(context.getCompilationUnit());
}
snt.visit(node, source);
}
}
}
}