You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2019/11/22 15:11:20 UTC
[groovy] 04/18: rework checks for annotation collectors and fix
generics warnings
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch GROOVY_3_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 3fe1cf23bb8f016e8032df0e304864082c267965
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Mon Nov 18 16:05:29 2019 -0600
rework checks for annotation collectors and fix generics warnings
evaluateExpression handles aliasing of "mode" and "processor" values
(cherry picked from commit d557787ac1ac8516d90d38b80726c4d57ac5d634)
---
.../ASTTransformationCollectorCodeVisitor.java | 241 ++++++++-------------
1 file changed, 95 insertions(+), 146 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/transform/ASTTransformationCollectorCodeVisitor.java b/src/main/java/org/codehaus/groovy/transform/ASTTransformationCollectorCodeVisitor.java
index 0ed0f11..5369e31 100644
--- a/src/main/java/org/codehaus/groovy/transform/ASTTransformationCollectorCodeVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/ASTTransformationCollectorCodeVisitor.java
@@ -25,21 +25,15 @@ import org.codehaus.groovy.ast.AnnotatedNode;
import org.codehaus.groovy.ast.AnnotationNode;
import org.codehaus.groovy.ast.ClassCodeVisitorSupport;
import org.codehaus.groovy.ast.ClassNode;
-import org.codehaus.groovy.ast.expr.ClassExpression;
-import org.codehaus.groovy.ast.expr.ConstantExpression;
import org.codehaus.groovy.ast.expr.Expression;
-import org.codehaus.groovy.ast.expr.PropertyExpression;
import org.codehaus.groovy.control.CompilePhase;
import org.codehaus.groovy.control.SourceUnit;
import org.codehaus.groovy.control.messages.ExceptionMessage;
import org.codehaus.groovy.control.messages.SimpleMessage;
-import org.codehaus.groovy.control.messages.SyntaxErrorMessage;
-import org.codehaus.groovy.syntax.SyntaxException;
import org.codehaus.groovy.transform.trait.TraitASTTransformation;
import org.codehaus.groovy.transform.trait.Traits;
import java.lang.annotation.Annotation;
-import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
@@ -48,53 +42,54 @@ import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-import java.util.TreeMap;
+import java.util.Optional;
+
+import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.evaluateExpression;
/**
- * This visitor walks the AST tree and collects references to Annotations that
- * are annotated themselves by {@link GroovyASTTransformation}. Each such
- * annotation is added.
+ * Walks the AST 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.
+ * {@code SEMANTIC_ANALYSIS} phase of compilation.
*/
public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSupport {
- private final SourceUnit source;
+
private ClassNode classNode;
+ private final SourceUnit source;
private final GroovyClassLoader transformLoader;
- public ASTTransformationCollectorCodeVisitor(SourceUnit source, GroovyClassLoader transformLoader) {
+ public ASTTransformationCollectorCodeVisitor(final SourceUnit source, final GroovyClassLoader transformLoader) {
this.source = source;
this.transformLoader = transformLoader;
}
+ @Override
protected SourceUnit getSourceUnit() {
return source;
}
- public void visitClass(ClassNode klassNode) {
- ClassNode oldClass = classNode;
- classNode = klassNode;
+ @Override
+ public void visitClass(final ClassNode classNode) {
+ ClassNode oldClass = this.classNode;
+ this.classNode = classNode;
super.visitClass(classNode);
- classNode = oldClass;
+ this.classNode = oldClass;
}
- /**
- * 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) {
+ @Override
+ public void visitAnnotations(final AnnotatedNode node) {
+ List<AnnotationNode> nodeAnnotations = node.getAnnotations();
+ if (nodeAnnotations.isEmpty()) return;
super.visitAnnotations(node);
- Map<Integer, List<AnnotationNode>> existing = new TreeMap<Integer, List<AnnotationNode>>();
- Map<Integer, List<AnnotationNode>> replacements = new LinkedHashMap<Integer, List<AnnotationNode>>();
- Map<Integer, AnnotationCollectorMode> modes = new LinkedHashMap<Integer, AnnotationCollectorMode>();
+ Map<Integer, AnnotationCollectorMode> modes = new LinkedHashMap<>();
+ Map<Integer, List<AnnotationNode>> existing = new LinkedHashMap<>();
+ Map<Integer, List<AnnotationNode>> replacements = new LinkedHashMap<>();
int index = 0;
- for (AnnotationNode annotation : node.getAnnotations()) {
+ for (AnnotationNode annotation : nodeAnnotations) {
findCollectedAnnotations(annotation, node, index, modes, existing, replacements);
- index++;
+ index += 1;
}
for (Map.Entry<Integer, List<AnnotationNode>> entry : replacements.entrySet()) {
Integer replacementIndex = entry.getKey();
@@ -102,26 +97,22 @@ public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSuppo
mergeCollectedAnnotations(modes.get(replacementIndex), existing, annotationNodeList);
existing.put(replacementIndex, annotationNodeList);
}
- List<AnnotationNode> mergedList = new ArrayList<AnnotationNode>();
- for (List<AnnotationNode> next : existing.values()) {
- mergedList.addAll(next);
- }
+ List<AnnotationNode> mergedList = new ArrayList<>();
+ existing.values().forEach(mergedList::addAll);
- node.getAnnotations().clear();
- node.getAnnotations().addAll(mergedList);
+ nodeAnnotations.clear();
+ nodeAnnotations.addAll(mergedList);
- for (AnnotationNode annotation : node.getAnnotations()) {
+ for (AnnotationNode annotation : nodeAnnotations) {
Annotation transformClassAnnotation = getTransformClassAnnotation(annotation.getClassNode());
- if (transformClassAnnotation == null) {
- // skip if there is no such annotation
- continue;
+ if (transformClassAnnotation != null) {
+ addTransformsToClassNode(annotation, transformClassAnnotation);
}
- addTransformsToClassNode(annotation, transformClassAnnotation);
}
}
- private static void mergeCollectedAnnotations(AnnotationCollectorMode mode, Map<Integer, List<AnnotationNode>> existing, List<AnnotationNode> replacements) {
- switch(mode) {
+ private static void mergeCollectedAnnotations(final AnnotationCollectorMode mode, final Map<Integer, List<AnnotationNode>> existing, final List<AnnotationNode> replacements) {
+ switch (mode) {
case PREFER_COLLECTOR:
deleteExisting(false, existing, replacements);
break;
@@ -139,36 +130,33 @@ public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSuppo
}
}
- private static void deleteExisting(boolean mergeParams, Map<Integer, List<AnnotationNode>> existingMap, List<AnnotationNode> replacements) {
+ private static void deleteExisting(final boolean mergeParams, final Map<Integer, List<AnnotationNode>> existing, final List<AnnotationNode> replacements) {
for (AnnotationNode replacement : replacements) {
- for (Map.Entry<Integer, List<AnnotationNode>> entry : existingMap.entrySet()) {
- Integer key = entry.getKey();
- List<AnnotationNode> annotationNodes = new ArrayList<AnnotationNode>(entry.getValue());
- Iterator<AnnotationNode> iterator = annotationNodes.iterator();
- while (iterator.hasNext()) {
- AnnotationNode existing = iterator.next();
- if (replacement.getClassNode().getName().equals(existing.getClassNode().getName())) {
+ for (Map.Entry<Integer, List<AnnotationNode>> entry : existing.entrySet()) {
+ List<AnnotationNode> annotationNodes = new ArrayList<>(entry.getValue());
+ for (Iterator<AnnotationNode> iterator = annotationNodes.iterator(); iterator.hasNext();) {
+ AnnotationNode annotation = iterator.next();
+ if (replacement.getClassNode().getName().equals(annotation.getClassNode().getName())) {
if (mergeParams) {
- mergeParameters(replacement, existing);
+ mergeParameters(replacement, annotation);
}
iterator.remove();
}
}
- existingMap.put(key, annotationNodes);
+ existing.put(entry.getKey(), annotationNodes);
}
}
}
- private static void deleteReplacement(boolean mergeParams, Map<Integer, List<AnnotationNode>> existingMap, List<AnnotationNode> replacements) {
- Iterator<AnnotationNode> nodeIterator = replacements.iterator();
- while (nodeIterator.hasNext()) {
+ private static void deleteReplacement(final boolean mergeParams, final Map<Integer, List<AnnotationNode>> existing, final List<AnnotationNode> replacements) {
+ for (Iterator<AnnotationNode> nodeIterator = replacements.iterator(); nodeIterator.hasNext();) {
boolean remove = false;
AnnotationNode replacement = nodeIterator.next();
- for (Map.Entry<Integer, List<AnnotationNode>> entry : existingMap.entrySet()) {
- for (AnnotationNode existing : entry.getValue()) {
- if (replacement.getClassNode().getName().equals(existing.getClassNode().getName())) {
+ for (Map.Entry<Integer, List<AnnotationNode>> entry : existing.entrySet()) {
+ for (AnnotationNode annotation : entry.getValue()) {
+ if (replacement.getClassNode().getName().equals(annotation.getClassNode().getName())) {
if (mergeParams) {
- mergeParameters(existing, replacement);
+ mergeParameters(annotation, replacement);
}
remove = true;
}
@@ -180,7 +168,7 @@ public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSuppo
}
}
- private static void mergeParameters(AnnotationNode to, AnnotationNode from) {
+ private static void mergeParameters(final AnnotationNode to, final AnnotationNode from) {
for (String name : from.getMembers().keySet()) {
if (to.getMember(name) == null) {
to.setMember(name, from.getMember(name));
@@ -188,40 +176,25 @@ public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSuppo
}
}
- private void assertStringConstant(Expression exp) {
- if (exp == null) return;
- if (!(exp instanceof ConstantExpression)) {
- source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage(new SyntaxException(
- "Expected a String constant.", exp.getLineNumber(), exp.getColumnNumber()),
- source));
- }
- ConstantExpression ce = (ConstantExpression) exp;
- if (!(ce.getValue() instanceof String)) {
- source.getErrorCollector().addErrorAndContinue(new SyntaxErrorMessage(new SyntaxException(
- "Expected a String constant.", exp.getLineNumber(), exp.getColumnNumber()),
- source));
- }
- }
-
- private void findCollectedAnnotations(AnnotationNode aliasNode, AnnotatedNode origin, Integer index, Map<Integer, AnnotationCollectorMode> modes, Map<Integer, List<AnnotationNode>> existing, Map<Integer, List<AnnotationNode>> replacements) {
- ClassNode classNode = aliasNode.getClassNode();
- for (AnnotationNode annotation : classNode.getAnnotations()) {
+ private void findCollectedAnnotations(final AnnotationNode alias, final AnnotatedNode origin, final Integer index, final Map<Integer, AnnotationCollectorMode> modes, final Map<Integer, List<AnnotationNode>> existing, final Map<Integer, List<AnnotationNode>> replacements) {
+ for (AnnotationNode annotation : alias.getClassNode().getAnnotations()) {
if (annotation.getClassNode().getName().equals(AnnotationCollector.class.getName())) {
- AnnotationCollectorMode mode = getMode(annotation);
- if (mode == null) {
- mode = AnnotationCollectorMode.DUPLICATE;
- }
- modes.put(index, mode);
- Expression processorExp = annotation.getMember("processor");
+ Expression mode = annotation.getMember("mode");
+ modes.put(index, Optional.ofNullable(mode)
+ .map(exp -> evaluateExpression(exp, source.getConfiguration()))
+ .map(val -> (AnnotationCollectorMode) val)
+ .orElse(AnnotationCollectorMode.DUPLICATE)
+ );
+
+ Expression processor = annotation.getMember("processor");
AnnotationCollectorTransform act = null;
- assertStringConstant(processorExp);
- if (processorExp != null) {
- String className = (String) ((ConstantExpression) processorExp).getValue();
- Class klass = loadTransformClass(className, aliasNode);
+ if (processor != null) {
+ String className = (String) evaluateExpression(processor, source.getConfiguration());
+ Class<?> klass = loadTransformClass(className, alias);
if (klass != null) {
try {
act = (AnnotationCollectorTransform) klass.getDeclaredConstructor().newInstance();
- } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
+ } catch (ReflectiveOperationException e) {
source.getErrorCollector().addErrorAndContinue(new ExceptionMessage(e, true, source));
}
}
@@ -229,104 +202,83 @@ public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSuppo
act = new AnnotationCollectorTransform();
}
if (act != null) {
- replacements.put(index, act.visit(annotation, aliasNode, origin, source));
+ replacements.put(index, act.visit(annotation, alias, origin, source));
return;
}
}
}
if (!replacements.containsKey(index)) {
- existing.put(index, Collections.singletonList(aliasNode));
+ existing.put(index, Collections.singletonList(alias));
}
}
- private static AnnotationCollectorMode getMode(AnnotationNode node) {
- final Expression member = node.getMember("mode");
- if (member instanceof PropertyExpression) {
- PropertyExpression prop = (PropertyExpression) member;
- Expression oe = prop.getObjectExpression();
- if (oe instanceof ClassExpression) {
- ClassExpression ce = (ClassExpression) oe;
- if (ce.getType().getName().equals("groovy.transform.AnnotationCollectorMode")) {
- return AnnotationCollectorMode.valueOf(prop.getPropertyAsString());
- }
- }
- }
- return null;
- }
-
- private void addTransformsToClassNode(AnnotationNode annotation, Annotation transformClassAnnotation) {
+ private void addTransformsToClassNode(final AnnotationNode annotation, final Annotation transformClassAnnotation) {
List<String> transformClassNames = getTransformClassNames(annotation, transformClassAnnotation);
if (transformClassNames.isEmpty()) {
- source.getErrorCollector().addError(new SimpleMessage("@GroovyASTTransformationClass in " +
- annotation.getClassNode().getName() + " does not specify any transform class names/classes", source));
+ String error = "@GroovyASTTransformationClass in " + annotation.getClassNode().getName() + " does not specify any transform class names/classes";
+ source.getErrorCollector().addError(new SimpleMessage(error, source));
}
for (String transformClass : transformClassNames) {
- Class klass = loadTransformClass(transformClass, annotation);
+ Class<?> klass = loadTransformClass(transformClass, annotation);
if (klass != null) {
verifyAndAddTransform(annotation, klass);
}
}
}
- private Class loadTransformClass(String transformClass, AnnotationNode annotation) {
+ private Class<?> loadTransformClass(final String transformClass, final AnnotationNode annotation) {
try {
return transformLoader.loadClass(transformClass, false, true, false);
- } catch (ClassNotFoundException e) {
- source.getErrorCollector().addErrorAndContinue(
- new SimpleMessage(
- "Could not find class for Transformation Processor " + transformClass
- + " declared by " + annotation.getClassNode().getName(),
- source));
+ } catch (ReflectiveOperationException | LinkageError e) {
+ String error = "Could not find class for Transformation Processor " + transformClass + " declared by " + annotation.getClassNode().getName();
+ source.getErrorCollector().addErrorAndContinue(new SimpleMessage(error, source));
}
return null;
}
- private void verifyAndAddTransform(AnnotationNode annotation, Class klass) {
+ private void verifyAndAddTransform(final AnnotationNode annotation, final Class<?> klass) {
verifyClass(annotation, klass);
verifyCompilePhase(annotation, klass);
addTransform(annotation, klass);
}
- private void verifyCompilePhase(AnnotationNode annotation, Class<?> klass) {
+ private void verifyClass(final AnnotationNode annotation, final Class<?> klass) {
+ if (!ASTTransformation.class.isAssignableFrom(klass)) {
+ String error = "Not an ASTTransformation: " + klass.getName() + " declared by " + annotation.getClassNode().getName();
+ source.getErrorCollector().addError(new SimpleMessage(error, source));
+ }
+ }
+
+ private void verifyCompilePhase(final AnnotationNode annotation, final Class<?> klass) {
GroovyASTTransformation transformationClass = 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));
+ String error = annotation.getClassNode().getName() + " is defined to be run in compile phase " + specifiedCompilePhase + ". Local AST transformations must run in " + CompilePhase.SEMANTIC_ANALYSIS + " or later!";
+ source.getErrorCollector().addError(new SimpleMessage(error, source));
}
-
} else {
- source.getErrorCollector().addError(
- new SimpleMessage("AST transformation implementation classes must be annotated with " + GroovyASTTransformation.class.getName() + ". " + klass.getName() + " lacks this annotation.", 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));
+ String error = "AST transformation implementation classes must be annotated with " + GroovyASTTransformation.class.getName() + ". " + klass.getName() + " lacks this annotation.";
+ source.getErrorCollector().addError(new SimpleMessage(error, source));
}
}
@SuppressWarnings("unchecked")
- private void addTransform(AnnotationNode annotation, Class klass) {
+ private void addTransform(final AnnotationNode annotation, final Class<?> klass) {
boolean apply = !Traits.isTrait(classNode) || klass == TraitASTTransformation.class;
if (apply) {
- classNode.addTransform(klass, annotation);
+ classNode.addTransform((Class<? extends ASTTransformation>) klass, annotation);
}
}
- private static Annotation getTransformClassAnnotation(ClassNode annotatedType) {
+ private static Annotation getTransformClassAnnotation(final 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,
+ // 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;
@@ -336,29 +288,26 @@ public class ASTTransformationCollectorCodeVisitor extends ClassCodeVisitorSuppo
return null;
}
- private List<String> getTransformClassNames(AnnotationNode annotation, Annotation transformClassAnnotation) {
- List<String> result = new ArrayList<String>();
-
+ private List<String> getTransformClassNames(final AnnotationNode annotation, final Annotation transformClassAnnotation) {
+ List<String> result = new ArrayList<>();
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) {
+ 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));
+ String error = "@GroovyASTTransformationClass in " + annotation.getClassNode().getName() + " should specify transforms only by class names or by classes and not by both";
+ source.getErrorCollector().addError(new SimpleMessage(error, source));
}
} catch (Exception e) {
source.addException(e);
}
-
return result;
}
}