minor edits
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
index bbca52a..9b30986 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
@@ -102,7 +102,6 @@
DYNAMIC_TYPE = makeCached(Object.class),
OBJECT_TYPE = DYNAMIC_TYPE,
CLOSURE_TYPE = makeCached(Closure.class),
- SERIALIZEDLAMBDA_TYPE = makeCached(SerializedLambda .class),
GSTRING_TYPE = makeCached(GString.class),
RANGE_TYPE = makeCached(Range.class),
PATTERN_TYPE = makeCached(Pattern.class),
@@ -138,6 +137,7 @@
ELEMENT_TYPE_TYPE = makeCached(ElementType.class),
AUTOCLOSEABLE_TYPE = makeCached(AutoCloseable.class),
SERIALIZABLE_TYPE = makeCached(Serializable.class),
+ SERIALIZEDLAMBDA_TYPE = makeCached(SerializedLambda.class),
// uncached constants
MAP_TYPE = makeWithoutCaching(Map.class),
diff --git a/src/main/java/org/codehaus/groovy/ast/GenericsType.java b/src/main/java/org/codehaus/groovy/ast/GenericsType.java
index 1e68788..59e3168 100644
--- a/src/main/java/org/codehaus/groovy/ast/GenericsType.java
+++ b/src/main/java/org/codehaus/groovy/ast/GenericsType.java
@@ -36,7 +36,7 @@
*/
public class GenericsType extends ASTNode {
public static final GenericsType[] EMPTY_ARRAY = new GenericsType[0];
-
+
private final ClassNode[] upperBounds;
private final ClassNode lowerBound;
private ClassNode type;
diff --git a/src/main/java/org/codehaus/groovy/ast/ModuleNode.java b/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
index 7033169..4e1376e 100644
--- a/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
@@ -127,7 +127,7 @@
}
public void addImport(String alias, ClassNode type) {
- addImport(alias, type, new ArrayList<>());
+ addImport(alias, type, Collections.emptyList());
}
public void addImport(String alias, ClassNode type, List<AnnotationNode> annotations) {
diff --git a/src/main/java/org/codehaus/groovy/ast/VariableScope.java b/src/main/java/org/codehaus/groovy/ast/VariableScope.java
index 9a32e8e..4b0fbfc 100644
--- a/src/main/java/org/codehaus/groovy/ast/VariableScope.java
+++ b/src/main/java/org/codehaus/groovy/ast/VariableScope.java
@@ -24,15 +24,14 @@
import java.util.Map;
/**
- * Represents a variable scope. This is primarily used to determine variable sharing
- * across method and closure boundaries.
+ * Records declared and referenced variabes for a given scope. Helps determine
+ * variable sharing across closure and method boundaries.
*/
-public class VariableScope {
+public class VariableScope implements Cloneable {
private VariableScope parent;
private ClassNode classScope;
private boolean inStaticContext;
- private boolean resolvesDynamic;
private Map<String, Variable> declaredVariables = Collections.emptyMap();
private Map<String, Variable> referencedLocalVariables = Collections.emptyMap();
@@ -42,7 +41,7 @@
super();
}
- public VariableScope(VariableScope parent) {
+ public VariableScope(final VariableScope parent) {
this.parent = parent;
}
@@ -51,7 +50,7 @@
}
public boolean isRoot() {
- return parent == null;
+ return (parent == null);
}
/**
@@ -65,10 +64,10 @@
* Returns true iff this scope corresponds to a class; as opposed to a method, "if" statement, block statement, etc.
*/
public boolean isClassScope() {
- return classScope != null;
+ return (classScope != null);
}
- public void setClassScope(ClassNode classScope) {
+ public void setClassScope(final ClassNode classScope) {
this.classScope = classScope;
}
@@ -76,29 +75,29 @@
return inStaticContext;
}
- public void setInStaticContext(boolean inStaticContext) {
+ public void setInStaticContext(final boolean inStaticContext) {
this.inStaticContext = inStaticContext;
}
//
- public Variable getDeclaredVariable(String name) {
+ public Variable getDeclaredVariable(final String name) {
return declaredVariables.get(name);
}
- public Variable getReferencedLocalVariable(String name) {
+ public Variable getReferencedLocalVariable(final String name) {
return referencedLocalVariables.get(name);
}
- public Variable getReferencedClassVariable(String name) {
+ public Variable getReferencedClassVariable(final String name) {
return referencedClassVariables.get(name);
}
- public boolean isReferencedLocalVariable(String name) {
+ public boolean isReferencedLocalVariable(final String name) {
return referencedLocalVariables.containsKey(name);
}
- public boolean isReferencedClassVariable(String name) {
+ public boolean isReferencedClassVariable(final String name) {
return referencedClassVariables.containsKey(name);
}
@@ -159,25 +158,25 @@
return getReferencedClassVariables().values().iterator();
}
- public void putDeclaredVariable(Variable var) {
+ public void putDeclaredVariable(final Variable var) {
if (declaredVariables == Collections.EMPTY_MAP)
declaredVariables = new LinkedHashMap<>();
declaredVariables.put(var.getName(), var);
}
- public void putReferencedLocalVariable(Variable var) {
+ public void putReferencedLocalVariable(final Variable var) {
if (referencedLocalVariables == Collections.EMPTY_MAP)
referencedLocalVariables = new LinkedHashMap<>();
referencedLocalVariables.put(var.getName(), var);
}
- public void putReferencedClassVariable(Variable var) {
+ public void putReferencedClassVariable(final Variable var) {
if (referencedClassVariables == Collections.EMPTY_MAP)
referencedClassVariables = new LinkedHashMap<>();
referencedClassVariables.put(var.getName(), var);
}
- public Object removeReferencedClassVariable(String name) {
+ public Object removeReferencedClassVariable(final String name) {
if (referencedClassVariables.isEmpty()) {
return null;
} else {
@@ -189,19 +188,18 @@
// TODO: implement Cloneable and override Object.clone()
public VariableScope copy() {
- VariableScope copy = new VariableScope(parent);
- copy.classScope = classScope;
- copy.inStaticContext = inStaticContext;
- copy.resolvesDynamic = resolvesDynamic;
- if (!declaredVariables.isEmpty()) {
- copy.declaredVariables = new LinkedHashMap<>(declaredVariables);
+ VariableScope that = new VariableScope(parent);
+ that.classScope = this.classScope;
+ that.inStaticContext = this.inStaticContext;
+ if (!this.declaredVariables.isEmpty()) {
+ that.declaredVariables = new LinkedHashMap<>(this.declaredVariables);
}
- if (!referencedLocalVariables.isEmpty()) {
- copy.referencedLocalVariables = new LinkedHashMap<>(referencedLocalVariables);
+ if (!this.referencedLocalVariables.isEmpty()) {
+ that.referencedLocalVariables = new LinkedHashMap<>(this.referencedLocalVariables);
}
- if (!referencedClassVariables.isEmpty()) {
- copy.referencedClassVariables = new LinkedHashMap<>(referencedClassVariables);
+ if (!this.referencedClassVariables.isEmpty()) {
+ that.referencedClassVariables = new LinkedHashMap<>(this.referencedClassVariables);
}
- return copy;
+ return that;
}
}
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/ClosureExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/ClosureExpression.java
index ccdceed..c8d1025 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/ClosureExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/ClosureExpression.java
@@ -85,7 +85,7 @@
* @return {@code true} if one or more explicit parameters are supplied
*/
public boolean isParameterSpecified() {
- return parameters != null && parameters.length > 0;
+ return (parameters != null && parameters.length > 0);
}
public VariableScope getVariableScope() {
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/ConstantExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/ConstantExpression.java
index a9036a2..d958795 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/ConstantExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/ConstantExpression.java
@@ -22,7 +22,7 @@
import org.codehaus.groovy.ast.GroovyCodeVisitor;
/**
- * Represents a constant expression such as null, true, false
+ * Represents a constant expression such as null, true, false.
*/
public class ConstantExpression extends Expression {
// The following fields are only used internally; every occurrence of a user-defined expression of the same kind
@@ -92,7 +92,7 @@
}
public String getText() {
- return value == null ? "null" : value.toString();
+ return (value == null ? "null" : value.toString());
}
public String getConstantName() {
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/EmptyExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/EmptyExpression.java
index ae7d6c3..c877f56 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/EmptyExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/EmptyExpression.java
@@ -37,7 +37,9 @@
/**
* @see EmptyExpression#INSTANCE
*/
- public EmptyExpression() {}
+ public EmptyExpression() {
+ super();
+ }
@Override
public Expression transformExpression(ExpressionTransformer transformer) {
diff --git a/src/main/java/org/codehaus/groovy/ast/stmt/EmptyStatement.java b/src/main/java/org/codehaus/groovy/ast/stmt/EmptyStatement.java
index 1199e33..5365b88 100644
--- a/src/main/java/org/codehaus/groovy/ast/stmt/EmptyStatement.java
+++ b/src/main/java/org/codehaus/groovy/ast/stmt/EmptyStatement.java
@@ -21,7 +21,6 @@
import org.codehaus.groovy.ast.ASTNode;
import org.codehaus.groovy.ast.GroovyCodeVisitor;
-import java.util.Collections;
import java.util.Map;
public class EmptyStatement extends Statement {
@@ -29,10 +28,8 @@
/**
* @see EmptyStatement#INSTANCE
*/
- public EmptyStatement() {}
-
- protected EmptyStatement(Map<?, ?> metaDataMap) {
- super.setMetaDataMap(metaDataMap);
+ public EmptyStatement() {
+ super();
}
@Override
@@ -51,7 +48,7 @@
* Immutable singleton that is recommended for use when source range or any
* other occurrence-specific metadata is not needed.
*/
- public static final EmptyStatement INSTANCE = new EmptyStatement(Collections.EMPTY_MAP) {
+ public static final EmptyStatement INSTANCE = new EmptyStatement() {
private void throwUnsupportedOperationException() {
throw new UnsupportedOperationException("EmptyStatement.INSTANCE is immutable");
diff --git a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
index 1e084dc..e9a4d60b2 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
@@ -481,8 +481,10 @@
redirect = ClassHelper.OBJECT_TYPE;
}
if (redirect.isGenericsPlaceHolder()) {
+ // "T extends U" or "T super U"
type = redirect;
} else {
+ // "T" or "T extends Thing" or "T super Thing"
type = ClassHelper.makeWithoutCaching(name);
type.setGenericsPlaceHolder(true);
type.setRedirect(redirect);
diff --git a/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java b/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java
index 42eb463..3974262 100644
--- a/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/classgen/AnnotationVisitor.java
@@ -85,7 +85,7 @@
if (!checkIfValidEnumConstsAreUsed(node)) {
return node;
}
-
+
Map<String, Expression> attributes = node.getMembers();
for (Map.Entry<String, Expression> entry : attributes.entrySet()) {
String attrName = entry.getKey();
@@ -97,7 +97,7 @@
VMPluginFactory.getPlugin().configureAnnotation(node);
return this.annotation;
}
-
+
private boolean checkIfValidEnumConstsAreUsed(AnnotationNode node) {
Map<String, Expression> attributes = node.getMembers();
for (Map.Entry<String, Expression> entry : attributes.entrySet()) {
@@ -106,7 +106,7 @@
}
return true;
}
-
+
private boolean validateEnumConstant(Expression exp) {
if (exp instanceof PropertyExpression) {
PropertyExpression pe = (PropertyExpression) exp;
@@ -154,7 +154,7 @@
// if it is an error, we have to test it at another place. But size==0 is
// an error, because it means that no such attribute exists.
if (methods.isEmpty()) {
- addError("'" + attrName + "'is not part of the annotation " + classNode, node);
+ addError("'" + attrName + "'is not part of the annotation " + classNode.getNameWithoutPackage(), node);
return ClassHelper.OBJECT_TYPE;
}
MethodNode method = (MethodNode) methods.get(0);
@@ -236,14 +236,11 @@
} else {
addError(base, exp);
}
- return ConstantExpression.EMPTY_EXPRESSION;
+ ConstantExpression ret = new ConstantExpression(null);
+ ret.setSourcePosition(exp);
+ return ret;
}
- /**
- * @param attrName the name
- * @param expression the expression
- * @param attrType the type
- */
protected void visitAnnotationExpression(String attrName, AnnotationConstantExpression expression, ClassNode attrType) {
AnnotationNode annotationNode = (AnnotationNode) expression.getValue();
AnnotationVisitor visitor = new AnnotationVisitor(this.source, this.errorCollector);
@@ -310,5 +307,4 @@
checkCircularReference(searchClass, method.getReturnType(), code.getExpression());
}
}
-
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java b/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java
index 75fbf73..4377263 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/OptimizingStatementWriter.java
@@ -755,8 +755,8 @@
if (resultType != null) {
addMeta(expression).type = resultType;
opt.chainInvolvedType(resultType);
- opt.chainInvolvedType(leftType);
opt.chainInvolvedType(rightType);
+ opt.chainInvolvedType(leftType);
}
}
@@ -781,16 +781,15 @@
@Override
public void visitDeclarationExpression(final DeclarationExpression expression) {
- Expression right = expression.getRightExpression();
- right.visit(this);
+ Expression rightExpression = expression.getRightExpression();
+ rightExpression.visit(this);
ClassNode leftType = typeChooser.resolveType(expression.getLeftExpression(), node);
- Expression rightExpression = expression.getRightExpression();
ClassNode rightType = optimizeDivWithIntOrLongTarget(rightExpression, leftType);
- if (rightType == null) rightType = typeChooser.resolveType(expression.getRightExpression(), node);
+ if (rightType == null) rightType = typeChooser.resolveType(rightExpression, node);
if (isPrimitiveType(leftType) && isPrimitiveType(rightType)) {
// if right is a constant, then we optimize only if it makes a block complete, so we set a maybe
- if (right instanceof ConstantExpression) {
+ if (rightExpression instanceof ConstantExpression) {
opt.chainCanOptimize(true);
} else {
opt.chainShouldOptimize(true);
@@ -868,8 +867,7 @@
ClassNode originalResultType = typeChooser.resolveType(binExp, node);
if (!originalResultType.equals(BigDecimal_TYPE)
- || !(isLongCategory(assignmentTartgetType)
- || isFloatingCategory(assignmentTartgetType))) {
+ || !(isLongCategory(assignmentTartgetType) || isFloatingCategory(assignmentTartgetType))) {
return null;
}
diff --git a/src/main/java/org/codehaus/groovy/control/ProcessingUnit.java b/src/main/java/org/codehaus/groovy/control/ProcessingUnit.java
index af3f7c3..162fa6c 100644
--- a/src/main/java/org/codehaus/groovy/control/ProcessingUnit.java
+++ b/src/main/java/org/codehaus/groovy/control/ProcessingUnit.java
@@ -73,7 +73,7 @@
}
/**
- * Get the CompilerConfiguration for this ProcessingUnit.
+ * Gets the CompilerConfiguration for this ProcessingUnit.
*/
public CompilerConfiguration getConfiguration() {
return configuration;
diff --git a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
index 5230044..06e9df1 100644
--- a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
@@ -132,7 +132,7 @@
private static class ConstructedNestedClass extends ClassNode {
final ClassNode knownEnclosingType;
- public ConstructedNestedClass(ClassNode outer, String inner) {
+ public ConstructedNestedClass(final ClassNode outer, final String inner) {
super(outer.getName() + "$" + inner.replace('.', '$'), Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
this.knownEnclosingType = outer;
this.isPrimaryNode = false;
@@ -151,7 +151,7 @@
}
@Override
- public String setName(String name) {
+ public String setName(final String name) {
if (redirect() != this) {
return super.setName(name);
} else {
@@ -172,7 +172,7 @@
final String prefix;
String className;
- public ConstructedClassWithPackage(String pkg, String name) {
+ public ConstructedClassWithPackage(final String pkg, final String name) {
super(pkg + name, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
isPrimaryNode = false;
this.prefix = pkg;
@@ -194,7 +194,7 @@
}
@Override
- public String setName(String name) {
+ public String setName(final String name) {
if (redirect() != this) {
return super.setName(name);
} else {
@@ -216,7 +216,7 @@
private static class LowerCaseClass extends ClassNode {
final String className;
- public LowerCaseClass(String name) {
+ public LowerCaseClass(final String name) {
super(name, Opcodes.ACC_PUBLIC, ClassHelper.OBJECT_TYPE);
isPrimaryNode = false;
this.className = name;
@@ -237,7 +237,7 @@
}
@Override
- public String setName(String name) {
+ public String setName(final String name) {
if (redirect() != this) {
return super.setName(name);
} else {
@@ -246,18 +246,27 @@
}
}
- public ResolveVisitor(CompilationUnit compilationUnit) {
+ public ResolveVisitor(final CompilationUnit compilationUnit) {
this.compilationUnit = compilationUnit;
setClassNodeResolver(new ClassNodeResolver());
}
- public void startResolving(ClassNode node, SourceUnit source) {
+ public void setClassNodeResolver(final ClassNodeResolver classNodeResolver) {
+ this.classNodeResolver = classNodeResolver;
+ }
+
+ public void startResolving(final ClassNode node, final SourceUnit source) {
this.source = source;
visitClass(node);
}
@Override
- protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) {
+ protected SourceUnit getSourceUnit() {
+ return source;
+ }
+
+ @Override
+ protected void visitConstructorOrMethod(final MethodNode node, final boolean isConstructor) {
VariableScope oldScope = currentScope;
currentScope = node.getVariableScope();
Map<GenericsTypeName, GenericsType> oldPNames = genericParameterNames;
@@ -288,7 +297,7 @@
}
@Override
- public void visitField(FieldNode node) {
+ public void visitField(final FieldNode node) {
ClassNode t = node.getType();
if (!fieldTypesChecked.contains(node)) {
resolveOrFail(t, node);
@@ -297,7 +306,7 @@
}
@Override
- public void visitProperty(PropertyNode node) {
+ public void visitProperty(final PropertyNode node) {
Map<GenericsTypeName, GenericsType> oldPNames = genericParameterNames;
if (node.isStatic() && !Traits.isTrait(node.getDeclaringClass())) {
genericParameterNames = new HashMap<>();
@@ -311,7 +320,7 @@
genericParameterNames = oldPNames;
}
- private boolean resolveToInner(ClassNode type) {
+ private boolean resolveToInner(final ClassNode type) {
// we do not do our name mangling to find an inner class
// if the type is a ConstructedClassWithPackage, because in this case we
// are resolving the name at a different place already
@@ -331,7 +340,7 @@
return false;
}
- private void resolveOrFail(ClassNode type, String msg, ASTNode node) {
+ private void resolveOrFail(final ClassNode type, final String msg, final ASTNode node) {
if (resolve(type)) return;
if (resolveToInner(type)) return;
if (resolveToOuterNested(type)) return;
@@ -343,7 +352,7 @@
// if the type to resolve is an inner class and it is in an outer class which is not resolved,
// we set the resolved type to a placeholder class node, i.e. a ConstructedOuterNestedClass instance
// when resolving the outer class later, we set the resolved type of ConstructedOuterNestedClass instance to the actual inner class node(SEE GROOVY-7812(#2))
- private boolean resolveToOuterNested(ClassNode type) {
+ private boolean resolveToOuterNested(final ClassNode type) {
CompileUnit compileUnit = currentClass.getCompileUnit();
String typeName = type.getName();
@@ -398,7 +407,7 @@
return toResolveFurther;
}
- private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeViaStaticImport(CompileUnit compileUnit, ImportNode importNode, String typeName, BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
+ private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeViaStaticImport(final CompileUnit compileUnit, final ImportNode importNode, final String typeName, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
String importClassName = importNode.getClassName();
ClassNode outerClassNode = compileUnit.getClass(importClassName);
@@ -410,7 +419,7 @@
return constructedOuterNestedClassNode;
}
- private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNode(ClassNode type, ClassNode outerClassNode, BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
+ private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNode(final ClassNode type, final ClassNode outerClassNode, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
String outerClassName = outerClassNode.getName();
for (String typeName = type.getName(), ident = typeName; ident.indexOf('.') != -1; ) {
@@ -426,7 +435,7 @@
return null;
}
- private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeForBaseType(CompileUnit compileUnit, String typeName, ClassNode cn, BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
+ private ConstructedOuterNestedClassNode tryToConstructOuterNestedClassNodeForBaseType(final CompileUnit compileUnit, final String typeName, final ClassNode cn, final BiConsumer<ConstructedOuterNestedClassNode, ClassNode> setRedirectListener) {
if (!compileUnit.getClassesToCompile().containsValue(cn)) return null;
String outerNestedClassName = cn.getName() + "$" + typeName;
@@ -435,21 +444,21 @@
return constructedOuterNestedClassNode;
}
- private void resolveOrFail(ClassNode type, ASTNode node, boolean prefereImports) {
+ private void resolveOrFail(final ClassNode type, final ASTNode node, final boolean prefereImports) {
resolveGenericsTypes(type.getGenericsTypes());
if (prefereImports && resolveAliasFromModule(type)) return;
resolveOrFail(type, node);
}
- private void resolveOrFail(ClassNode type, ASTNode node) {
+ private void resolveOrFail(final ClassNode type, final ASTNode node) {
resolveOrFail(type, "", node);
}
- private boolean resolve(ClassNode type) {
+ protected boolean resolve(final ClassNode type) {
return resolve(type, true, true, true);
}
- private boolean resolve(ClassNode type, boolean testModuleImports, boolean testDefaultImports, boolean testStaticInnerClasses) {
+ protected boolean resolve(final ClassNode type, final boolean testModuleImports, final boolean testDefaultImports, final boolean testStaticInnerClasses) {
resolveGenericsTypes(type.getGenericsTypes());
if (type.isResolved() || type.isPrimaryClassNode()) return true;
if (type.isArray()) {
@@ -488,7 +497,7 @@
(testStaticInnerClasses && type.hasPackageName() && resolveFromStaticInnerClasses(type));
}
- private boolean resolveNestedClass(ClassNode type) {
+ protected boolean resolveNestedClass(final ClassNode type) {
if (type instanceof ConstructedNestedClass || type instanceof ConstructedClassWithPackage) return false;
// We have for example a class name A, are in class X
@@ -530,7 +539,7 @@
return false;
}
- private boolean setRedirect(ClassNode type, ClassNode classToCheck) {
+ private boolean setRedirect(final ClassNode type, final ClassNode classToCheck) {
String typeName = type.getName();
Predicate<ClassNode> resolver = (ClassNode maybeOuter) -> {
@@ -559,13 +568,13 @@
return false;
}
- private static String replaceLastPointWithDollar(String name) {
+ private static String replaceLastPointWithDollar(final String name) {
int lastPointIndex = name.lastIndexOf('.');
return name.substring(0, lastPointIndex) + "$" + name.substring(lastPointIndex + 1);
}
- private boolean resolveFromStaticInnerClasses(ClassNode type) {
+ protected boolean resolveFromStaticInnerClasses(final ClassNode type) {
// a class consisting of a vanilla name can never be
// a static inner class, because at least one dot is
// required for this. Example: foo.bar -> foo$bar
@@ -593,7 +602,7 @@
return false;
}
- private boolean resolveFromDefaultImports(ClassNode type) {
+ protected boolean resolveFromDefaultImports(final ClassNode type) {
// we do not resolve a vanilla name starting with a lower case letter
// try to resolve against a default import, because we know that the
// default packages do not contain classes like these
@@ -626,7 +635,7 @@
private static final EvictableCache<String, Set<String>> DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE = new UnlimitedConcurrentCache<>();
- private boolean resolveFromDefaultImports(ClassNode type, String[] packagePrefixes) {
+ protected boolean resolveFromDefaultImports(final ClassNode type, final String[] packagePrefixes) {
String typeName = type.getName();
for (String packagePrefix : packagePrefixes) {
@@ -652,7 +661,7 @@
return false;
}
- private boolean resolveFromCompileUnit(ClassNode type) {
+ protected boolean resolveFromCompileUnit(final ClassNode type) {
// look into the compile unit if there is a class with that name
CompileUnit compileUnit = currentClass.getCompileUnit();
if (compileUnit == null) return false;
@@ -664,7 +673,7 @@
return false;
}
- private void ambiguousClass(ClassNode type, ClassNode iType, String name) {
+ private void ambiguousClass(final ClassNode type, final ClassNode iType, final String name) {
if (type.getName().equals(iType.getName())) {
addError("reference to " + name + " is ambiguous, both class " + type.getName() + " and " + iType.getName() + " match", type);
} else {
@@ -672,7 +681,7 @@
}
}
- private boolean resolveAliasFromModule(ClassNode type) {
+ private boolean resolveAliasFromModule(final ClassNode type) {
// In case of getting a ConstructedClassWithPackage here we do not do checks for partial
// matches with imported classes. The ConstructedClassWithPackage is already a constructed
// node and any subclass resolving will then take place elsewhere
@@ -743,7 +752,7 @@
return false;
}
- private boolean resolveFromModule(ClassNode type, boolean testModuleImports) {
+ protected boolean resolveFromModule(final ClassNode type, final boolean testModuleImports) {
if (type instanceof ConstructedNestedClass) return false;
// we decided if we have a vanilla name starting with a lower case
@@ -840,7 +849,7 @@
return false;
}
- private boolean resolveToOuter(ClassNode type) {
+ protected boolean resolveToOuter(final ClassNode type) {
String name = type.getName();
// We do not need to check instances of LowerCaseClass
@@ -869,7 +878,8 @@
return false;
}
- public Expression transform(Expression exp) {
+ @Override
+ public Expression transform(final Expression exp) {
if (exp == null) return null;
Expression ret;
if (exp instanceof VariableExpression) {
@@ -898,7 +908,7 @@
return ret;
}
- private static String lookupClassName(PropertyExpression pe) {
+ private static String lookupClassName(final PropertyExpression pe) {
boolean doInitialClassTest = true;
StringBuilder name = new StringBuilder(32);
// this loop builds a name from right to left each name part
@@ -939,7 +949,7 @@
return name.toString();
}
- private static Tuple2<StringBuilder, Boolean> makeClassName(boolean doInitialClassTest, StringBuilder name, String varName) {
+ private static Tuple2<StringBuilder, Boolean> makeClassName(final boolean doInitialClassTest, final StringBuilder name, final String varName) {
if (doInitialClassTest) {
// we are at the first name part. This is the right most part.
// If this part is in lower case, then we do not need a class
@@ -948,23 +958,20 @@
// can still be resolved to the class foo.Bar and the static
// field bar.
if (!testVanillaNameForClass(varName)) {
- name = null;
+ return tuple(null, Boolean.TRUE);
} else {
- doInitialClassTest = false;
- name = new StringBuilder(varName);
+ return tuple(new StringBuilder(varName), Boolean.FALSE);
}
- } else {
- name.insert(0, varName + ".");
}
-
- return tuple(name, doInitialClassTest);
+ name.insert(0, varName + ".");
+ return tuple(name, Boolean.FALSE);
}
// iterate from the inner most to the outer and check for classes
// this check will ignore a .class property, for Example Integer.class will be
// a PropertyExpression with the ClassExpression of Integer as objectExpression
// and class as property
- private static Expression correctClassClassChain(PropertyExpression pe) {
+ private static Expression correctClassClassChain(final PropertyExpression pe) {
LinkedList<Expression> stack = new LinkedList<Expression>();
ClassExpression found = null;
for (Expression it = pe; it != null; it = ((PropertyExpression) it).getObjectExpression()) {
@@ -1019,8 +1026,7 @@
if (className != null) {
ClassNode type = ClassHelper.make(className);
if (resolve(type)) {
- Expression ret = new ClassExpression(type);
- return ret;
+ return new ClassExpression(type);
}
}
if (objectExpression instanceof ClassExpression && pe.getPropertyAsString() != null) {
@@ -1043,13 +1049,13 @@
return ret;
}
- private static boolean isVisibleNestedClass(ClassNode innerType, ClassNode outerType) {
+ private static boolean isVisibleNestedClass(final ClassNode innerType, final ClassNode outerType) {
int modifiers = innerType.getModifiers();
return Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers)
|| (!Modifier.isPrivate(modifiers) && Objects.equals(innerType.getPackageName(), outerType.getPackageName()));
}
- private boolean directlyImplementsTrait(ClassNode trait) {
+ private boolean directlyImplementsTrait(final ClassNode trait) {
ClassNode[] interfaces = currentClass.getInterfaces();
if (interfaces == null) {
return currentClass.getSuperClass().equals(trait);
@@ -1062,7 +1068,7 @@
return currentClass.getSuperClass().equals(trait);
}
- private void checkThisAndSuperAsPropertyAccess(PropertyExpression expression) {
+ private void checkThisAndSuperAsPropertyAccess(final PropertyExpression expression) {
if (expression.isImplicitThis()) return;
String prop = expression.getPropertyAsString();
if (prop == null) return;
@@ -1093,7 +1099,7 @@
}
}
- protected Expression transformVariableExpression(VariableExpression ve) {
+ protected Expression transformVariableExpression(final VariableExpression ve) {
visitAnnotations(ve);
Variable v = ve.getAccessedVariable();
@@ -1138,12 +1144,12 @@
return ve;
}
- private static boolean testVanillaNameForClass(String name) {
+ private static boolean testVanillaNameForClass(final String name) {
if (name == null || name.length() == 0) return false;
return !Character.isLowerCase(name.charAt(0));
}
- protected Expression transformBinaryExpression(BinaryExpression be) {
+ protected Expression transformBinaryExpression(final BinaryExpression be) {
Expression left = transform(be.getLeftExpression());
if (be.getOperation().isA(Types.ASSIGNMENT_OPERATOR) && left instanceof ClassExpression) {
ClassExpression ce = (ClassExpression) left;
@@ -1204,7 +1210,7 @@
return be;
}
- protected Expression transformClosureExpression(ClosureExpression ce) {
+ protected Expression transformClosureExpression(final ClosureExpression ce) {
boolean oldInClosure = inClosure;
inClosure = true;
for (Parameter para : getParametersSafe(ce)) {
@@ -1223,7 +1229,7 @@
return ce;
}
- protected Expression transformConstructorCallExpression(ConstructorCallExpression cce) {
+ protected Expression transformConstructorCallExpression(final ConstructorCallExpression cce) {
findPossibleOuterClassNodeForNonStaticInnerClassInstantiation(cce);
ClassNode type = cce.getType();
@@ -1235,7 +1241,7 @@
return cce.transformExpression(this);
}
- private void findPossibleOuterClassNodeForNonStaticInnerClassInstantiation(ConstructorCallExpression cce) {
+ private void findPossibleOuterClassNodeForNonStaticInnerClassInstantiation(final ConstructorCallExpression cce) {
// GROOVY-8947: Fail to resolve non-static inner class outside of outer class
// `new Computer().new Cpu(4)` will be parsed to `new Cpu(new Computer(), 4)`
// so non-static inner class instantiation expression's first argument is a constructor call of outer class
@@ -1257,11 +1263,11 @@
}
}
- private static String getDescription(ClassNode node) {
+ private static String getDescription(final ClassNode node) {
return (node.isInterface() ? "interface" : "class") + " '" + node.getName() + "'";
}
- protected Expression transformMethodCallExpression(MethodCallExpression mce) {
+ protected Expression transformMethodCallExpression(final MethodCallExpression mce) {
Expression args = transform(mce.getArguments());
Expression method = transform(mce.getMethod());
Expression object = transform(mce.getObjectExpression());
@@ -1277,7 +1283,7 @@
return ret;
}
- protected Expression transformDeclarationExpression(DeclarationExpression de) {
+ protected Expression transformDeclarationExpression(final DeclarationExpression de) {
visitAnnotations(de);
Expression oldLeft = de.getLeftExpression();
checkingVariableTypeInDeclaration = true;
@@ -1301,14 +1307,14 @@
return newDeclExpr;
}
- // TODO get normal resolving to set declaring class
- private void fixDeclaringClass(DeclarationExpression newDeclExpr) {
+ // TODO: get normal resolving to set declaring class
+ private void fixDeclaringClass(final DeclarationExpression newDeclExpr) {
if (newDeclExpr.getDeclaringClass() == null && currentMethod != null) {
newDeclExpr.setDeclaringClass(currentMethod.getDeclaringClass());
}
}
- protected Expression transformAnnotationConstantExpression(AnnotationConstantExpression ace) {
+ protected Expression transformAnnotationConstantExpression(final AnnotationConstantExpression ace) {
AnnotationNode an = (AnnotationNode) ace.getValue();
ClassNode type = an.getClassNode();
resolveOrFail(type, " for annotation", an);
@@ -1318,7 +1324,8 @@
return ace;
}
- public void visitAnnotations(AnnotatedNode node) {
+ @Override
+ public void visitAnnotations(final AnnotatedNode node) {
List<AnnotationNode> annotations = node.getAnnotations();
if (annotations.isEmpty()) return;
Map<String, AnnotationNode> tmpAnnotations = new HashMap<>();
@@ -1347,7 +1354,7 @@
}
}
- private boolean isRepeatable(Class<?> annTypeClass) {
+ private boolean isRepeatable(final Class<?> annTypeClass) {
Annotation[] annTypeAnnotations = annTypeClass.getAnnotations();
for (Annotation annTypeAnnotation : annTypeAnnotations) {
if (annTypeAnnotation.annotationType().getName().equals("java.lang.annotation.Repeatable")) {
@@ -1375,7 +1382,7 @@
return exp;
}
- private void checkAnnotationMemberValue(Expression newValue) {
+ private void checkAnnotationMemberValue(final Expression newValue) {
if (newValue instanceof PropertyExpression) {
PropertyExpression pe = (PropertyExpression) newValue;
if (!(pe.getObjectExpression() instanceof ClassExpression)) {
@@ -1389,7 +1396,8 @@
}
}
- public void visitClass(ClassNode node) {
+ @Override
+ public void visitClass(final ClassNode node) {
ClassNode oldNode = currentClass;
currentClass = node;
@@ -1468,7 +1476,7 @@
}
// GROOVY-7812(#2): Static inner classes cannot be accessed from other files when running by 'groovy' command
- private void resolveOuterNestedClassFurther(ClassNode node) {
+ private void resolveOuterNestedClassFurther(final ClassNode node) {
CompileUnit compileUnit = currentClass.getCompileUnit();
if (null == compileUnit) return;
@@ -1498,7 +1506,7 @@
}
}
- private void checkCyclicInheritance(ClassNode originalNode, ClassNode parentToCompare, ClassNode[] interfacesToCompare) {
+ private void checkCyclicInheritance(final ClassNode originalNode, final ClassNode parentToCompare, final ClassNode[] interfacesToCompare) {
if (!originalNode.isInterface()) {
if (parentToCompare == null) return;
if (originalNode == parentToCompare.redirect()) {
@@ -1532,7 +1540,8 @@
}
}
- public void visitCatchStatement(CatchStatement cs) {
+ @Override
+ public void visitCatchStatement(final CatchStatement cs) {
resolveOrFail(cs.getExceptionType(), cs);
if (cs.getExceptionType() == ClassHelper.DYNAMIC_TYPE) {
cs.getVariable().setType(ClassHelper.make(Exception.class));
@@ -1540,23 +1549,21 @@
super.visitCatchStatement(cs);
}
- public void visitForLoop(ForStatement forLoop) {
+ @Override
+ public void visitForLoop(final ForStatement forLoop) {
resolveOrFail(forLoop.getVariableType(), forLoop);
super.visitForLoop(forLoop);
}
- public void visitBlockStatement(BlockStatement block) {
+ @Override
+ public void visitBlockStatement(final BlockStatement block) {
VariableScope oldScope = currentScope;
currentScope = block.getVariableScope();
super.visitBlockStatement(block);
currentScope = oldScope;
}
- protected SourceUnit getSourceUnit() {
- return source;
- }
-
- private boolean resolveGenericsTypes(GenericsType[] types) {
+ private boolean resolveGenericsTypes(final GenericsType[] types) {
if (types == null) return true;
currentClass.setUsingGenerics(true);
boolean resolved = true;
@@ -1567,11 +1574,11 @@
return resolved;
}
- private void resolveGenericsHeader(GenericsType[] types) {
+ private void resolveGenericsHeader(final GenericsType[] types) {
resolveGenericsHeader(types, null, 0);
}
- private void resolveGenericsHeader(GenericsType[] types, GenericsType rootType, int level) {
+ private void resolveGenericsHeader(final GenericsType[] types, final GenericsType rootType, final int level) {
if (types == null) return;
currentClass.setUsingGenerics(true);
List<Tuple2<ClassNode, GenericsType>> upperBoundsWithGenerics = new LinkedList<>();
@@ -1638,7 +1645,7 @@
}
}
- private boolean resolveGenericsType(GenericsType genericsType) {
+ private boolean resolveGenericsType(final GenericsType genericsType) {
if (genericsType.isResolved()) return true;
currentClass.setUsingGenerics(true);
ClassNode type = genericsType.getType();
@@ -1674,11 +1681,7 @@
}
- public void setClassNodeResolver(ClassNodeResolver classNodeResolver) {
- this.classNodeResolver = classNodeResolver;
- }
-
- private static Map<String, ClassNode> findHierClasses(ClassNode currentClass) {
+ private static Map<String, ClassNode> findHierClasses(final ClassNode currentClass) {
Map<String, ClassNode> hierClasses = new LinkedHashMap<>();
for (ClassNode classToCheck = currentClass; classToCheck != ClassHelper.OBJECT_TYPE; classToCheck = classToCheck.getSuperClass()) {
if (classToCheck == null || hierClasses.containsKey(classToCheck.getName())) break;
diff --git a/src/main/java/org/codehaus/groovy/control/SourceUnit.java b/src/main/java/org/codehaus/groovy/control/SourceUnit.java
index f9b320c..7091222 100644
--- a/src/main/java/org/codehaus/groovy/control/SourceUnit.java
+++ b/src/main/java/org/codehaus/groovy/control/SourceUnit.java
@@ -254,14 +254,10 @@
String property = (String) AccessController.doPrivileged((PrivilegedAction) () -> System.getProperty("groovy.ast"));
if ("xml".equals(property)) {
- saveAsXML(name, ast);
+ XStreamUtils.serialize(name, ast);
}
}
- private static void saveAsXML(String name, ModuleNode ast) {
- XStreamUtils.serialize(name, ast);
- }
-
//---------------------------------------------------------------------------
// SOURCE SAMPLING
diff --git a/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java b/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java
index d1afa34..c2c508f 100644
--- a/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java
@@ -119,8 +119,6 @@
}
}
-
-
// 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()) {
@@ -204,7 +202,7 @@
compilationUnit.addPhaseOperation(new CompilationUnit.PrimaryClassNodeOperation() {
public void call(SourceUnit source, GeneratorContext context, ClassNode classNode) throws CompilationFailedException {
- ASTTransformationCollectorCodeVisitor collector =
+ ASTTransformationCollectorCodeVisitor collector =
new ASTTransformationCollectorCodeVisitor(source, compilationUnit.getTransformLoader());
collector.visitClass(classNode);
}
@@ -230,11 +228,11 @@
}
}
}
-
+
public static void addGlobalTransformsAfterGrab(ASTTransformationsContext context) {
doAddGlobalTransforms(context, false);
}
-
+
public static void addGlobalTransforms(ASTTransformationsContext context) {
doAddGlobalTransforms(context, true);
}
@@ -293,7 +291,6 @@
compilationUnit.getErrorCollector().addError(new SimpleMessage(
"IOException reading the service definition at "
+ service.toExternalForm() + " because of exception " + ioe.toString(), null));
- //noinspection UnnecessaryContinue
continue;
}
}
@@ -306,9 +303,9 @@
null));
}
- // record the transforms found in the first scan, so that in the 2nd scan, phase operations
- // can be added for only for new transforms that have come in
- if(isFirstScan) {
+ // record the transforms found in the first scan, so that in the 2nd scan, phase operations
+ // can be added for only for new transforms that have come in
+ if (isFirstScan) {
for (Map.Entry<String, URL> entry : transformNames.entrySet()) {
context.getGlobalTransformNames().add(entry.getKey());
}
@@ -319,14 +316,13 @@
addPhaseOperationsForGlobalTransforms(context.getCompilationUnit(), transformNames, isFirstScan);
}
}
-
+
private static void addPhaseOperationsForGlobalTransforms(CompilationUnit compilationUnit,
Map<String, URL> transformNames, boolean isFirstScan) {
GroovyClassLoader transformLoader = compilationUnit.getTransformLoader();
for (Map.Entry<String, URL> entry : transformNames.entrySet()) {
try {
Class gTransClass = transformLoader.loadClass(entry.getKey(), false, true, false);
- //no inspection unchecked
GroovyASTTransformation transformAnnotation = (GroovyASTTransformation) gTransClass.getAnnotation(GroovyASTTransformation.class);
if (transformAnnotation == null) {
compilationUnit.getErrorCollector().addWarning(new WarningMessage(
@@ -347,8 +343,8 @@
public void call(SourceUnit source) throws CompilationFailedException {
instance.visit(new ASTNode[] {source.getAST()}, source);
}
- };
- if(isFirstScan) {
+ };
+ if (isFirstScan) {
compilationUnit.addPhaseOperation(suOp, transformAnnotation.phase().getPhaseNumber());
} else {
compilationUnit.addNewPhaseOperation(suOp, transformAnnotation.phase().getPhaseNumber());
@@ -366,4 +362,3 @@
}
}
}
-
diff --git a/src/main/java/org/codehaus/groovy/transform/AnnotationCollectorTransform.java b/src/main/java/org/codehaus/groovy/transform/AnnotationCollectorTransform.java
index f41feac..bf94211 100644
--- a/src/main/java/org/codehaus/groovy/transform/AnnotationCollectorTransform.java
+++ b/src/main/java/org/codehaus/groovy/transform/AnnotationCollectorTransform.java
@@ -62,6 +62,7 @@
/**
* This class is the base for any annotation alias processor.
+ *
* @see AnnotationCollector
* @see AnnotationCollectorTransform#visit(AnnotationNode, AnnotationNode, AnnotatedNode, SourceUnit)
*/
diff --git a/src/main/java/org/codehaus/groovy/transform/LogASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/LogASTTransformation.java
index e0e3b20..16a85f8 100644
--- a/src/main/java/org/codehaus/groovy/transform/LogASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/LogASTTransformation.java
@@ -260,7 +260,6 @@
} catch (Exception e) {
return null;
}
-
}
diff --git a/src/main/java/org/codehaus/groovy/transform/NewifyASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/NewifyASTTransformation.java
index ae71b14..4cc060f 100644
--- a/src/main/java/org/codehaus/groovy/transform/NewifyASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/NewifyASTTransformation.java
@@ -345,7 +345,8 @@
private void checkDuplicateNameClashes(ListExpression list) {
final Set<String> seen = new HashSet<String>();
- @SuppressWarnings("unchecked") final List<ClassExpression> classes = (List) list.getExpressions();
+ @SuppressWarnings("unchecked")
+ List<ClassExpression> classes = (List) list.getExpressions();
for (ClassExpression ce : classes) {
final String name = ce.getType().getNameWithoutPackage();
if (seen.contains(name)) {
@@ -363,7 +364,8 @@
}
private void checkClassLevelClashes(ListExpression list) {
- @SuppressWarnings("unchecked") final List<ClassExpression> classes = (List) list.getExpressions();
+ @SuppressWarnings("unchecked")
+ List<ClassExpression> classes = (List) list.getExpressions();
for (ClassExpression ce : classes) {
final String name = ce.getType().getNameWithoutPackage();
if (findClassWithMatchingBasename(name)) {
@@ -373,10 +375,10 @@
}
}
-
private boolean isNewifyCandidate(MethodCallExpression mce) {
- return mce.getObjectExpression() == VariableExpression.THIS_EXPRESSION
- || (auto && isNewMethodStyle(mce));
+ return (auto && isNewMethodStyle(mce)) || (mce.isImplicitThis()
+ && mce.getObjectExpression() instanceof VariableExpression
+ && ((VariableExpression) mce.getObjectExpression()).isThisExpression());
}
private static boolean isNewMethodStyle(MethodCallExpression mce) {
@@ -428,7 +430,8 @@
}
if (classesToNewify != null) {
- @SuppressWarnings("unchecked") final List<ClassExpression> classes = (List) classesToNewify.getExpressions();
+ @SuppressWarnings("unchecked")
+ List<ClassExpression> classes = (List) classesToNewify.getExpressions();
for (ClassExpression ce : classes) {
if (ce.getType().getNameWithoutPackage().equals(nameWithoutPackage)) {
return true;
@@ -505,11 +508,10 @@
return source;
}
-
private static class NewifyClassData {
final String name;
final ClassNode type;
- List<ClassNode> types = null;
+ List<ClassNode> types;
public NewifyClassData(final String name, final ClassNode type) {
this.name = name;
@@ -524,6 +526,4 @@
types.add(additionalType);
}
}
-
-
}
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/AbstractExtensionMethodCache.java b/src/main/java/org/codehaus/groovy/transform/stc/AbstractExtensionMethodCache.java
index d65d9d4..df8f8b6 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/AbstractExtensionMethodCache.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/AbstractExtensionMethodCache.java
@@ -45,7 +45,7 @@
* @since 3.0.0
*/
public abstract class AbstractExtensionMethodCache {
- private final EvictableCache<ClassLoader, Map<String, List<MethodNode>>> cache = new StampedCommonCache<>(new WeakHashMap<>());
+ final EvictableCache<ClassLoader, Map<String, List<MethodNode>>> cache = new StampedCommonCache<>(new WeakHashMap<>());
public Map<String, List<MethodNode>> get(ClassLoader loader) {
return cache.getAndPut(loader, this::getMethodsFromClassLoader);
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
index 10de207..5c2823d 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -162,31 +162,31 @@
protected static final ExtensionMethodCache EXTENSION_METHOD_CACHE = ExtensionMethodCache.INSTANCE;
protected static final Map<ClassNode, Integer> NUMBER_TYPES = Maps.of(
- byte_TYPE, 0,
- Byte_TYPE, 0,
- short_TYPE, 1,
- Short_TYPE, 1,
- int_TYPE, 2,
+ byte_TYPE, 0,
+ Byte_TYPE, 0,
+ short_TYPE, 1,
+ Short_TYPE, 1,
+ int_TYPE, 2,
Integer_TYPE, 2,
- Long_TYPE, 3,
- long_TYPE, 3,
- float_TYPE, 4,
- Float_TYPE, 4,
- double_TYPE, 5,
- Double_TYPE, 5
+ Long_TYPE, 3,
+ long_TYPE, 3,
+ float_TYPE, 4,
+ Float_TYPE, 4,
+ double_TYPE, 5,
+ Double_TYPE, 5
);
protected static final Map<String, Integer> NUMBER_OPS = Maps.of(
- "plus", PLUS,
- "minus", MINUS,
- "multiply", MULTIPLY,
- "div", DIVIDE,
- "or", BITWISE_OR,
- "and", BITWISE_AND,
- "xor", BITWISE_XOR,
- "mod", MOD,
- "intdiv", INTDIV,
- "leftShift", LEFT_SHIFT,
+ "plus", PLUS,
+ "minus", MINUS,
+ "multiply", MULTIPLY,
+ "div", DIVIDE,
+ "or", BITWISE_OR,
+ "and", BITWISE_AND,
+ "xor", BITWISE_XOR,
+ "mod", MOD,
+ "intdiv", INTDIV,
+ "leftShift", LEFT_SHIFT,
"rightShift", RIGHT_SHIFT,
"rightShiftUnsigned", RIGHT_SHIFT_UNSIGNED
);
@@ -233,6 +233,10 @@
}
};
+ public static void clearExtensionMethodCache() {
+ EXTENSION_METHOD_CACHE.cache.clearAll();
+ }
+
/**
* Returns true for expressions of the form x[...]
*
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
index 8ca1c18..a12584c 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
@@ -219,8 +219,8 @@
for (final MethodNode methodNode : methods) {
boolean declared = methodNode.getDeclaringClass() == cNode;
if (declared) {
- if (!methodNode.isSynthetic() && (methodNode.isProtected() || methodNode.getModifiers()==0)) {
- unit.addError(new SyntaxException("Cannot have protected/package private method in a trait (" + cNode.getName() + "#" + methodNode.getTypeDescriptor() + ")",
+ if (!methodNode.isSynthetic() && (methodNode.isProtected() || (!methodNode.isPrivate() && !methodNode.isPublic()))) {
+ unit.addError(new SyntaxException("Cannot have protected/package-private method in a trait (" + cNode.getName() + "#" + methodNode.getTypeDescriptor() + ")",
methodNode.getLineNumber(), methodNode.getColumnNumber()));
return null;
}
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
index 8cb68af..b1b965d 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitReceiverTransformer.java
@@ -55,8 +55,9 @@
/**
* This expression transformer is used internally by the {@link org.codehaus.groovy.transform.trait.TraitASTTransformation
* trait} AST transformation to change the receiver of a message on "this" into a static method call on the trait helper
- * class. <p></p>
- * In a nutshell, code like the following method definition in a trait:<p></p> <code>void foo() { this.bar() }</code> is
+ * class.
+ * <p>
+ * In a nutshell, code like the following method definition in a trait: <code>void foo() { this.bar() }</code> is
* transformed into: <code>void foo() { TraitHelper$bar(this) }</code>
*
* @since 2.3.0
@@ -204,7 +205,7 @@
method,
ArgumentListExpression.EMPTY_ARGUMENTS
);
- mce.setSourcePosition(exp);
+ mce.setSourcePosition(exp instanceof PropertyExpression ? ((PropertyExpression) exp).getProperty() : exp);
mce.setImplicitThis(false);
return mce;
}
@@ -349,7 +350,6 @@
return transformed;
}
-
private Expression transformMethodCallOnThis(final MethodCallExpression call) {
Expression method = call.getMethod();
Expression arguments = call.getArguments();
diff --git a/src/test/gls/annotations/closures/AnnotationClosureThisObjectCallTest.groovy b/src/test/gls/annotations/closures/AnnotationClosureThisObjectCallTest.groovy
index 8761923..a3431e8 100644
--- a/src/test/gls/annotations/closures/AnnotationClosureThisObjectCallTest.groovy
+++ b/src/test/gls/annotations/closures/AnnotationClosureThisObjectCallTest.groovy
@@ -18,7 +18,8 @@
*/
package gls.annotations.closures
-class AnnotationClosureThisObjectCallTest extends AnnotationClosureExhaustiveTestSupport {
+final class AnnotationClosureThisObjectCallTest extends AnnotationClosureExhaustiveTestSupport {
+
Class getAnnotationClass() { AnnWithClassElement }
Class getAnnotatedClass() { CallOnThisObject }
@@ -33,6 +34,7 @@
@AnnWithClassElement(elem = { this.answer() })
class CallOnThisObject {
+
@AnnWithClassElement(elem = { this.answer() })
private aField
@@ -41,7 +43,8 @@
@AnnWithClassElement(elem = { this.answer() })
def aMethod(@AnnWithClassElement(elem = { this.answer() }) aParam) {
+
@AnnWithClassElement(elem = { this.answer() })
def aLocal
}
-}
\ No newline at end of file
+}
diff --git a/src/test/org/codehaus/groovy/runtime/powerassert/AssertionTestUtil.groovy b/src/test/org/codehaus/groovy/runtime/powerassert/AssertionTestUtil.groovy
index 0aac26a..c7c677b 100644
--- a/src/test/org/codehaus/groovy/runtime/powerassert/AssertionTestUtil.groovy
+++ b/src/test/org/codehaus/groovy/runtime/powerassert/AssertionTestUtil.groovy
@@ -18,21 +18,26 @@
*/
package org.codehaus.groovy.runtime.powerassert
+import groovy.transform.AutoFinal
import org.junit.Assert
/**
* Utility methods for testing power assertions.
*/
+@AutoFinal
+final class AssertionTestUtil {
-abstract class AssertionTestUtil {
- static fails(Closure assertion) {
+ private AssertionTestUtil() {
+ }
+
+ static fails(Closure<Void> assertion) {
try {
assertion.call();
Assert.fail("assertion should have failed but didn't")
} catch (PowerAssertionError expected) {}
}
- static isNotTransformed(Closure failingAssertion) {
+ static isNotTransformed(Closure<Void> failingAssertion) {
try {
failingAssertion()
throw new RuntimeException("assertion should have failed but didn't")
@@ -42,7 +47,7 @@
}
}
- static isRendered(String expectedRendering, Closure failingAssertion) {
+ static isRendered(String expectedRendering, Closure<Void> failingAssertion) {
try {
failingAssertion.call();
Assert.fail("assertion should have failed but didn't")
