/*
* Copyright 2008 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.codehaus.groovy.transform;
import org.codehaus.groovy.ast.*;
import org.codehaus.groovy.ast.expr.*;
import org.codehaus.groovy.control.CompilePhase;
import org.codehaus.groovy.control.SourceUnit;
import org.codehaus.groovy.control.messages.SimpleMessage;
import groovy.lang.GroovyClassLoader;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* This visitor walks the AST tree and collects references to Annotations that
* are annotated themselves by {@link GroovyASTTransformation}. Each such
* annotation is added.
* <p/>
* This visitor is only intended to be executed once, during the
* SEMANTIC_ANALYSIS phase of compilation.
*
* @author Danno Ferrin (shemnon)
* @author Roshan Dawrani (roshandawrani)
*/
public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSupport {
private SourceUnit source;
private ClassNode classNode;
private GroovyClassLoader transformLoader;
// GRECLIPSE start
private boolean allowTransforms;
private List<String> localTransformsAllowed;
public ASTTransformationCollectorCodeVisitor(SourceUnit source, GroovyClassLoader transformLoader, boolean allowTransforms, List<String> localTransformsAllowed) {
this(source,transformLoader);
this.allowTransforms = allowTransforms;
this.localTransformsAllowed = localTransformsAllowed;
}
// GRECLIPSE end
public ASTTransformationCollectorCodeVisitor(SourceUnit source, GroovyClassLoader transformLoader) {
this.source = source;
this.transformLoader = transformLoader;
}
protected SourceUnit getSourceUnit() {
return source;
}
public void visitClass(ClassNode klassNode) {
ClassNode oldClass = classNode;
classNode = klassNode;
super.visitClass(classNode);
classNode = oldClass;
}
// GRECLIPSE add
private final static String[] NONE = new String[0];
private final static Class[] NO_CLASSES = new Class[0];
/**
* For the supplied classnode, this method will check if there is an annotation on it of kind 'GroovyASTTransformationClass'. If there is then
* the 'value' member of that annotation will be retrieved and the value considered to be the class name of a transformation.
*
* @return null if no annotation found, otherwise a String[] of classnames - this will be size 0 if no value was specified
*/
private String[] getTransformClassNames(ClassNode cn) {
if (!cn.hasClass()) {
List<AnnotationNode> annotations = cn.getAnnotations();
AnnotationNode transformAnnotation = null;
for (AnnotationNode anno: annotations) {
if (anno.getClassNode().getName().equals(GroovyASTTransformationClass.class.getName())){
transformAnnotation = anno;
break;
}
}
if (transformAnnotation!=null) {
// will work so long as signature for the member 'value' is String[]
Expression expr2 = transformAnnotation.getMember("value");
String[] values = null;
if (expr2==null) {
return NONE;
}
if (expr2 instanceof ListExpression) {
ListExpression expression = (ListExpression)expr2;
List<Expression> expressions = expression.getExpressions();
values = new String[expressions.size()];
int e=0;
for (Expression expr: expressions) {
values[e++] = ((ConstantExpression)expr).getText();
}
} else if (expr2 instanceof ConstantExpression) {
values = new String[1];
values[0] = ((ConstantExpression)expr2).getText();
} else {
throw new IllegalStateException("NYI: eclipse doesn't understand this kind of expression in an Ast transform definition: "+expr2+" (class="+expr2.getClass().getName()+")");
}
return values;
}
return null;
} else {
// FIXASC check haven't broken transforms for 'vanilla' (outside of eclipse) execution of groovyc
Annotation transformClassAnnotation = getTransformClassAnnotation(cn);
if (transformClassAnnotation == null) {
return null;
}
return getTransformClassNames(transformClassAnnotation);
}
}
private Class[] getTransformClasses(ClassNode classNode) {
if (!classNode.hasClass()) {
List<AnnotationNode> annotations = classNode.getAnnotations();
AnnotationNode transformAnnotation = null;
for (AnnotationNode anno: annotations) {
if (anno.getClassNode().getName().equals(GroovyASTTransformationClass.class.getName())){
transformAnnotation = anno;
break;
}
}
if (transformAnnotation!=null) {
Expression expr = (Expression)transformAnnotation.getMember("classes");
if (expr==null) {
return NO_CLASSES;
}
Class<?>[] values = NO_CLASSES;
// Will need to extract the classnames
if (expr instanceof ListExpression) {
List<Class<?>> loadedClasses = new ArrayList<Class<?>>();
ListExpression expression = (ListExpression)expr;
List<Expression> expressions = expression.getExpressions();
for (Expression oneExpr: expressions) {
String classname = ((ClassExpression)oneExpr).getType().getName();
try {
Class<?> clazz = Class.forName(classname,false,transformLoader);
loadedClasses.add(clazz);
} catch (ClassNotFoundException cnfe) {
source.getErrorCollector().addError(new SimpleMessage("Ast transform processing, cannot find "+classname, source));
}
}
if (loadedClasses.size()!=0) {
values = loadedClasses.toArray(new Class<?>[loadedClasses.size()]);
}
return values;
} else {
}
throw new RuntimeException("nyi implemented in eclipse: need to support: "+expr+" (class="+expr.getClass()+")");
}
return null;
} else {
Annotation transformClassAnnotation = getTransformClassAnnotation(classNode);
if (transformClassAnnotation == null) {
return null;
}
return getTransformClasses(transformClassAnnotation);
}
}
// end
/**
* If the annotation is annotated with {@link GroovyASTTransformation}
* the annotation is added to <code>stageVisitors</code> at the appropriate processor visitor.
*
* @param node the node to process
*/
public void visitAnnotations(AnnotatedNode node) {
super.visitAnnotations(node);
for (AnnotationNode annotation : node.getAnnotations()) {
// GRECLIPSE edit -- under eclipse we may be asking a node that has no backing class
/*{
Annotation transformClassAnnotation = getTransformClassAnnotation(annotation.getClassNode());
if (transformClassAnnotation == null) {
// skip if there is no such annotation
continue;
}
addTransformsToClassNode(annotation, transformClassAnnotation);
}*/
String[] transformClassNames = getTransformClassNames(annotation.getClassNode());
Class[] transformClasses = getTransformClasses(annotation.getClassNode());
if (!this.allowTransforms) { // if 'doesnt-normally-allow-transforms' then only allow those specified
transformClassNames = trimTransformNames(transformClassNames);
transformClasses = trimTransformClasses(transformClasses);
}
if (transformClassNames==null && transformClasses == null) {
continue;
}
if (transformClassNames == null) { transformClassNames = NONE; }
if (transformClasses == null) { transformClasses = NO_CLASSES; }
addTransformsToClassNode(annotation, transformClassNames, transformClasses);
// GRECLIPSE end
}
}
// GRECLIPSE start
private String[] trimTransformNames(String[]names) {
if (this.localTransformsAllowed.size()==0) {
return names;
}
if (names == null) {
return NONE;
}
List<String> newnames = new ArrayList<String>();
for (String name: names) {
if (isAllowed(name)) {
newnames.add(name);
}
}
if (newnames.size()==names.length) {
return names;
}
return newnames.toArray(new String[newnames.size()]);
}
private Class<?>[] trimTransformClasses(Class<?>[]names) {
if (this.localTransformsAllowed.size()==0) {
return names;
}
if (names == null) {
return NO_CLASSES;
}
List<Class<?>> newnames = new ArrayList<Class<?>>();
for (Class<?> clazz: names) {
String name = clazz.getSimpleName();
if (isAllowed(name)) {
newnames.add(clazz);
}
}
if (newnames.size()==names.length) {
return names;
}
return newnames.toArray(new Class[newnames.size()]);
}
/**
* Check the transform name against the allowed transforms.
*
* @param transformName the name of the transform
* @return true if it is allowed
*/
private boolean isAllowed(String transformName) {
for (String localTransformAllowed: localTransformsAllowed) {
if (localTransformAllowed.equals("*")) {
return true;
} else if (localTransformAllowed.endsWith("$")) {
// must be the last part of the name
if (transformName.endsWith(localTransformAllowed.substring(0,localTransformAllowed.length()-1))) {
return true;
}
} else {
// indexof is good enough
boolean b= transformName.indexOf(localTransformAllowed)!=-1;
if (b) {
return true;
}
}
}
return false;
}
// GRECLIPSE end
// GRECLIPSE: start: slight refactoring to provide a new method that can work with a real annotation
@SuppressWarnings("unused")
private void addTransformsToClassNode(AnnotationNode annotation, Annotation transformClassAnnotation) {
String[] transformClassNames = getTransformClassNames(annotation.getClassNode());
Class[] transformClasses = getTransformClasses(transformClassAnnotation);
addTransformsToClassNode(annotation, transformClassNames, transformClasses);
}
private void addTransformsToClassNode(AnnotationNode annotation, String[] transformClassNames, Class[] transformClasses) {
if(transformClassNames.length == 0 && transformClasses.length == 0) {
source.getErrorCollector().addError(new SimpleMessage("@GroovyASTTransformationClass in " +
annotation.getClassNode().getName() + " does not specify any transform class names/classes", source));
}
// GRECLIPSE add
if(transformClassNames.length > 0 && transformClasses.length > 0) {
source.getErrorCollector().addError(new SimpleMessage("@GroovyASTTransformationClass in " +
annotation.getClassNode().getName() + " should specify transforms only by class names or by classes and not by both", source));
}
// GRECLIPSE end
for (String transformClass : transformClassNames) {
try {
Class klass = transformLoader.loadClass(transformClass, false, true, false);
verifyAndAddTransform(annotation, klass);
} catch (ClassNotFoundException e) {
source.getErrorCollector().addErrorAndContinue(
new SimpleMessage(
"Could not find class for Transformation Processor " + transformClass
+ " declared by " + annotation.getClassNode().getName(),
source));
}
}
// GRECLIPSE add
for (Class klass : transformClasses) {
verifyAndAddTransform(annotation, klass);
}
// GRECLIPSE end
}
private void verifyAndAddTransform(AnnotationNode annotation, Class klass) {
verifyClass(annotation, klass);
verifyCompilePhase(annotation, klass);
addTransform(annotation, klass);
}
private void verifyCompilePhase(AnnotationNode annotation, Class klass) {
GroovyASTTransformation transformationClass = (GroovyASTTransformation) klass.getAnnotation(GroovyASTTransformation.class);
if (transformationClass != null) {
CompilePhase specifiedCompilePhase = transformationClass.phase();
if (specifiedCompilePhase.getPhaseNumber() < CompilePhase.SEMANTIC_ANALYSIS.getPhaseNumber()) {
source.getErrorCollector().addError(
new SimpleMessage(
annotation.getClassNode().getName() + " is defined to be run in compile phase " + specifiedCompilePhase + ". Local AST transformations must run in " + CompilePhase.SEMANTIC_ANALYSIS + " or later!",
source));
}
}
}
private void verifyClass(AnnotationNode annotation, Class klass) {
if (!ASTTransformation.class.isAssignableFrom(klass)) {
source.getErrorCollector().addError(new SimpleMessage("Not an ASTTransformation: " +
klass.getName() + " declared by " + annotation.getClassNode().getName(), source));
}
}
private void addTransform(AnnotationNode annotation, Class klass) {
classNode.addTransform(klass, annotation);
}
private static Annotation getTransformClassAnnotation(ClassNode annotatedType) {
if (!annotatedType.isResolved()) return null;
for (Annotation ann : annotatedType.getTypeClass().getAnnotations()) {
// because compiler clients are free to choose any GroovyClassLoader for
// resolving ClassNodeS such as annotatedType, we have to compare by name,
// and cannot cast the return value to GroovyASTTransformationClass
if (ann.annotationType().getName().equals(GroovyASTTransformationClass.class.getName())){
return ann;
}
}
return null;
}
/* GRECLIPSE edit
private List<String> getTransformClassNames(AnnotationNode annotation, Annotation transformClassAnnotation) {
List<String> result = new ArrayList<String>();
try {
Method valueMethod = transformClassAnnotation.getClass().getMethod("value");
String[] names = (String[]) valueMethod.invoke(transformClassAnnotation);
result.addAll(Arrays.asList(names));
Method classesMethod = transformClassAnnotation.getClass().getMethod("classes");
Class[] classes = (Class[]) classesMethod.invoke(transformClassAnnotation);
for (Class klass : classes) {
result.add(klass.getName());
}
if(names.length > 0 && classes.length > 0) {
source.getErrorCollector().addError(new SimpleMessage("@GroovyASTTransformationClass in " +
annotation.getClassNode().getName() +
" should specify transforms only by class names or by classes and not by both", source));
}
} catch (Exception e) {
source.addException(e);
}
return result;
}*/
private String[] getTransformClassNames(Annotation transformClassAnnotation) {
try {
Method valueMethod = transformClassAnnotation.getClass().getMethod("value");
return (String[]) valueMethod.invoke(transformClassAnnotation);
} catch (Exception e) {
source.addException(e);
return NONE;
}
}
private Class[] getTransformClasses(Annotation transformClassAnnotation) {
try {
Method classesMethod = transformClassAnnotation.getClass().getMethod("classes");
return (Class[]) classesMethod.invoke(transformClassAnnotation);
} catch (Exception e) {
source.addException(e);
return NO_CLASSES;
}
}
}