You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by em...@apache.org on 2021/08/16 16:47:11 UTC
[groovy] branch master updated: groovy-eclipse patches and updates
This is an automated email from the ASF dual-hosted git repository.
emilles pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/groovy.git
The following commit(s) were added to refs/heads/master by this push:
new 7800156 groovy-eclipse patches and updates
7800156 is described below
commit 7800156a27c779ab67ddffc8bf44ab521e355740
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Mon Aug 16 11:33:56 2021 -0500
groovy-eclipse patches and updates
---
.../apache/groovy/parser/antlr4/AstBuilder.java | 20 +-
.../groovy/ast/ClassCodeVisitorSupport.java | 10 +-
.../java/org/codehaus/groovy/ast/ClassHelper.java | 10 +-
.../java/org/codehaus/groovy/ast/ClassNode.java | 18 +-
.../groovy/ast/GroovyCodeVisitorAdapter.java | 1 +
.../codehaus/groovy/ast/expr/RangeExpression.java | 27 +--
.../codehaus/groovy/control/CompilationUnit.java | 11 +-
.../codehaus/groovy/control/ErrorCollector.java | 8 +-
.../codehaus/groovy/control/ResolveVisitor.java | 44 ++--
.../org/codehaus/groovy/control/SourceUnit.java | 57 ++---
.../groovy/transform/ASTTransformationVisitor.java | 2 +-
.../groovy/transform/FieldASTTransformation.java | 16 +-
.../MethodCallExpressionTransformer.java | 5 +-
.../transform/stc/StaticTypeCheckingSupport.java | 10 +-
.../transform/stc/StaticTypeCheckingVisitor.java | 13 +-
.../groovy/transform/trait/TraitComposer.java | 2 +-
.../codehaus/groovy/transform/trait/Traits.java | 2 +-
.../org/codehaus/groovy/vmplugin/v8/Java8.java | 245 ++++++++++-----------
src/test/groovy/transform/stc/BugsSTCTest.groovy | 2 +-
.../groovy/ast/CodeVisitorSupportTest.groovy | 13 +-
20 files changed, 243 insertions(+), 273 deletions(-)
diff --git a/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
index 6852904..9a7aa5d 100644
--- a/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
+++ b/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -2199,12 +2199,12 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
@Override
- protected Statement createSetterBlock(PropertyNode propertyNode, FieldNode field) {
+ protected Statement createSetterBlock(final PropertyNode propertyNode, final FieldNode field) {
return stmt(assignX(varX(field), varX(VALUE_STR, field.getType())));
}
@Override
- protected Statement createGetterBlock(PropertyNode propertyNode, FieldNode field) {
+ protected Statement createGetterBlock(final PropertyNode propertyNode, final FieldNode field) {
return stmt(varX(field));
}
}
@@ -3721,8 +3721,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
final VariableExpression variableExpression = new VariableExpression(text);
- variableExpression.setNodeMetaData(IS_BUILT_IN_TYPE, true);
-
+ variableExpression.setNodeMetaData(IS_BUILT_IN_TYPE, Boolean.TRUE);
return configureAST(variableExpression, ctx);
}
@@ -3873,9 +3872,9 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
boolean isVariableExpression = value instanceof VariableExpression;
verbatimText.append(DOLLAR_STR);
- if (!isVariableExpression) verbatimText.append("{");
+ if (!isVariableExpression) verbatimText.append('{');
verbatimText.append(value.getText());
- if (!isVariableExpression) verbatimText.append("}");
+ if (!isVariableExpression) verbatimText.append('}');
}
return configureAST(new GStringExpression(verbatimText.toString(), stringLiteralList, values), ctx);
@@ -4235,10 +4234,9 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
if (!asBoolean(classNode)) {
- if (VOID_STR.equals(ctx.getText())) { // TODO refine error message for `void`
+ if (VOID_STR.equals(ctx.getText())) {
throw createParsingFailedException("void is not allowed here", ctx);
}
-
throw createParsingFailedException("Unsupported type: " + ctx.getText(), ctx);
}
@@ -4426,7 +4424,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
List<Tuple2<String, Expression>> annotationElementValues = this.visitElementValues(ctx.elementValues());
annotationElementValues.forEach(e -> annotationNode.addMember(e.getV1(), e.getV2()));
-
+ configureAST(annotationNode.getClassNode(), ctx.annotationName());
return configureAST(annotationNode, ctx);
}
@@ -4812,9 +4810,7 @@ public class AstBuilder extends GroovyParserBaseVisitor<Object> {
}
private boolean isBuiltInType(final Expression expression) {
- if (!(expression instanceof VariableExpression)) return false;
-
- return isTrue(expression, IS_BUILT_IN_TYPE);
+ return (expression instanceof VariableExpression && isTrue(expression, IS_BUILT_IN_TYPE));
}
private org.codehaus.groovy.syntax.Token createGroovyTokenByType(final Token token, final int type) {
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
index 13e476d..24a998f 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
@@ -54,10 +54,14 @@ public abstract class ClassCodeVisitorSupport extends CodeVisitorSupport impleme
}
public void visitAnnotations(AnnotatedNode node) {
- for (AnnotationNode annotation : node.getAnnotations()) {
+ visitAnnotations(node.getAnnotations());
+ }
+
+ protected final void visitAnnotations(Iterable<AnnotationNode> nodes) {
+ for (AnnotationNode node : nodes) {
// skip built-in properties
- if (!annotation.isBuiltIn()) {
- visitAnnotation(annotation);
+ if (!node.isBuiltIn()) {
+ visitAnnotation(node);
}
}
}
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
index 7af1576..6f56329 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
@@ -184,8 +184,8 @@ public class ClassHelper {
public static final String OBJECT = "java.lang.Object";
public static ClassNode makeCached(Class c) {
- final SoftReference<ClassNode> classNodeSoftReference = ClassHelperCache.classCache.get(c);
ClassNode classNode;
+ final SoftReference<ClassNode> classNodeSoftReference = ClassHelperCache.classCache.get(c);
if (classNodeSoftReference == null || (classNode = classNodeSoftReference.get()) == null) {
classNode = new ClassNode(c);
ClassHelperCache.classCache.put(c, new SoftReference<ClassNode>(classNode));
@@ -493,19 +493,19 @@ public class ClassHelper {
}
public static boolean isBigIntegerType(ClassNode type) {
- return type != null && type.redirect() == BigInteger_TYPE;
+ return BigInteger_TYPE.equals(type);
}
public static boolean isBigDecimalType(ClassNode type) {
- return type != null && type.redirect() == BigDecimal_TYPE;
+ return BigDecimal_TYPE.equals(type);
}
public static boolean isStringType(ClassNode type) {
- return type != null && type.redirect() == STRING_TYPE;
+ return STRING_TYPE.equals(type);
}
public static boolean isGStringType(ClassNode type) {
- return type != null && type.redirect() == GSTRING_TYPE;
+ return GSTRING_TYPE.equals(type);
}
public static boolean isObjectType(ClassNode type) {
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassNode.java b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
index d7d6c73..6981c90 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
@@ -46,9 +46,9 @@ import java.util.ListIterator;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
-import java.util.stream.Collectors;
import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toList;
import static org.apache.groovy.ast.tools.MethodNodeUtils.getCodeAsBlock;
import static org.codehaus.groovy.ast.ClassHelper.SEALED_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.isObjectType;
@@ -119,7 +119,6 @@ import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
* @see org.codehaus.groovy.ast.ClassHelper
*/
public class ClassNode extends AnnotatedNode {
- private static final String CLINIT = "<clinit>";
private static class MapOfLists {
Map<Object, List<MethodNode>> map;
@@ -147,7 +146,6 @@ public class ClassNode extends AnnotatedNode {
private int modifiers;
private boolean syntheticPublic;
private ClassNode[] interfaces;
- private List<ClassNode> permittedSubclasses = new ArrayList<>(4);
private MixinNode[] mixins;
private List<Statement> objectInitializers;
private List<ConstructorNode> constructors;
@@ -164,6 +162,7 @@ public class ClassNode extends AnnotatedNode {
private ClassNode superClass;
protected boolean isPrimaryNode;
protected List<InnerClassNode> innerClasses;
+ private List<ClassNode> permittedSubclasses = new ArrayList<>(4);
private List<AnnotationNode> typeAnnotations = Collections.emptyList();
/**
@@ -431,7 +430,7 @@ public class ClassNode extends AnnotatedNode {
*/
public List<MethodNode> getAbstractMethods() {
return getDeclaredMethodsMap().values().stream()
- .filter(MethodNode::isAbstract).collect(Collectors.toList());
+ .filter(MethodNode::isAbstract).collect(toList());
}
public List<MethodNode> getAllDeclaredMethods() {
@@ -816,9 +815,10 @@ public class ClassNode extends AnnotatedNode {
private MethodNode getOrAddStaticConstructorNode() {
MethodNode method;
- List<MethodNode> declaredMethods = getDeclaredMethods(CLINIT);
+ final String classInitializer = "<clinit>";
+ List<MethodNode> declaredMethods = getDeclaredMethods(classInitializer);
if (declaredMethods.isEmpty()) {
- method = addMethod(CLINIT, ACC_STATIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BlockStatement());
+ method = addMethod(classInitializer, ACC_STATIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BlockStatement());
method.setSynthetic(true);
} else {
method = declaredMethods.get(0);
@@ -1183,8 +1183,8 @@ public class ClassNode extends AnnotatedNode {
public MethodNode getSetterMethod(String setterName, boolean voidOnly) {
for (MethodNode method : getDeclaredMethods(setterName)) {
if (setterName.equals(method.getName())
- && (!voidOnly || isPrimitiveVoid(method.getReturnType()))
- && method.getParameters().length == 1) {
+ && method.getParameters().length == 1
+ && (!voidOnly || method.isVoidMethod())) {
return method;
}
}
@@ -1246,7 +1246,7 @@ public class ClassNode extends AnnotatedNode {
ret.append('>');
}
if (showRedirect && redirect != null) {
- ret.append(" -> ").append(redirect.toString());
+ ret.append(" -> ").append(redirect);
}
return ret.toString();
}
diff --git a/src/main/java/org/codehaus/groovy/ast/GroovyCodeVisitorAdapter.java b/src/main/java/org/codehaus/groovy/ast/GroovyCodeVisitorAdapter.java
index 91091ee..6da58a2 100644
--- a/src/main/java/org/codehaus/groovy/ast/GroovyCodeVisitorAdapter.java
+++ b/src/main/java/org/codehaus/groovy/ast/GroovyCodeVisitorAdapter.java
@@ -109,6 +109,7 @@ public class GroovyCodeVisitorAdapter implements GroovyCodeVisitor {
public void visitDoWhileLoop(DoWhileStatement statement) {
}
+ @Override
public void visitEmptyStatement(EmptyStatement statement) {
}
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/RangeExpression.java b/src/main/java/org/codehaus/groovy/ast/expr/RangeExpression.java
index b1aba80..87e600b 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/RangeExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/RangeExpression.java
@@ -32,29 +32,26 @@ public class RangeExpression extends Expression {
private final boolean exclusiveLeft;
private final boolean exclusiveRight;
- // Kept until sure this can be removed
- public RangeExpression(Expression from, Expression to, boolean inclusive) {
+ public RangeExpression(final Expression from, final Expression to, final boolean inclusive) {
this(from, to, false, !inclusive);
}
- // GROOVY-9649
- public RangeExpression(Expression from, Expression to, boolean exclusiveLeft, boolean exclusiveRight) {
- this.from = from;
- this.to = to;
+ public RangeExpression(final Expression from, final Expression to, final boolean exclusiveLeft, final boolean exclusiveRight) {
+ this.from = from; this.to = to;
this.exclusiveLeft = exclusiveLeft;
this.exclusiveRight = exclusiveRight;
- setType(ClassHelper.RANGE_TYPE);
- }
+ setType(ClassHelper.RANGE_TYPE.getPlainNodeReference());
+ }
@Override
- public void visit(GroovyCodeVisitor visitor) {
+ public void visit(final GroovyCodeVisitor visitor) {
visitor.visitRangeExpression(this);
}
@Override
- public Expression transformExpression(ExpressionTransformer transformer) {
- Expression ret = new RangeExpression(transformer.transform(from), transformer.transform(to), exclusiveLeft, exclusiveRight);
+ public Expression transformExpression(final ExpressionTransformer transformer) {
+ Expression ret = new RangeExpression(transformer.transform(getFrom()), transformer.transform(getTo()), isExclusiveLeft(), isExclusiveRight());
ret.setSourcePosition(this);
ret.copyNodeMetaData(this);
return ret;
@@ -82,10 +79,10 @@ public class RangeExpression extends Expression {
@Override
public String getText() {
- return "(" + from.getText() +
- (this.exclusiveLeft ? "<" : "") +
+ return "(" + getFrom().getText() +
+ (isExclusiveLeft() ? "<" : "") +
".." +
- (this.exclusiveRight ? "<" : "") +
- to.getText() + ")";
+ (isExclusiveRight() ? "<" : "") +
+ getTo().getText() + ")";
}
}
diff --git a/src/main/java/org/codehaus/groovy/control/CompilationUnit.java b/src/main/java/org/codehaus/groovy/control/CompilationUnit.java
index a903d34..7f5c178 100644
--- a/src/main/java/org/codehaus/groovy/control/CompilationUnit.java
+++ b/src/main/java/org/codehaus/groovy/control/CompilationUnit.java
@@ -113,12 +113,12 @@ public class CompilationUnit extends ProcessingUnit {
}
}
- /** Controls behavior of {@link #classgen} and other routines. */
+ /** Controls behavior of {@link #classgen()} and other routines. */
protected boolean debug;
/** True after the first {@link #configure(CompilerConfiguration)} operation. */
protected boolean configured;
- /** A callback for use during {@link #classgen} */
+ /** A callback for use during {@link #classgen()} */
protected ClassgenCallback classgenCallback;
/** A callback for use during {@link #compile()} */
protected ProgressCallback progressCallback;
@@ -625,9 +625,8 @@ public class CompilationUnit extends ProcessingUnit {
resolve.doPhaseOperation(this);
if (dequeued()) continue;
} else if (phase == Phases.CONVERSION) {
- Collection<SourceUnit> sourceUnits = sources.values();
- (sourceUnits.size() > 1 && Boolean.TRUE.equals(configuration.getOptimizationOptions().get(CompilerConfiguration.PARALLEL_PARSE))
- ? sourceUnits.parallelStream() : sourceUnits.stream()
+ (sources.size() > 1 && Boolean.TRUE.equals(configuration.getOptimizationOptions().get(CompilerConfiguration.PARALLEL_PARSE))
+ ? sources.values().parallelStream() : sources.values().stream()
).forEach(SourceUnit::buildAST);
}
@@ -726,7 +725,7 @@ public class CompilationUnit extends ProcessingUnit {
};
/**
- * Runs class generation on a single {@code ClassNode}.
+ * Runs {@link #classgen()} on a single {@code ClassNode}.
*/
private final IPrimaryClassNodeOperation classgen = new IPrimaryClassNodeOperation() {
@Override
diff --git a/src/main/java/org/codehaus/groovy/control/ErrorCollector.java b/src/main/java/org/codehaus/groovy/control/ErrorCollector.java
index 85bb723..86c25f6 100644
--- a/src/main/java/org/codehaus/groovy/control/ErrorCollector.java
+++ b/src/main/java/org/codehaus/groovy/control/ErrorCollector.java
@@ -95,11 +95,11 @@ public class ErrorCollector implements Serializable {
errors.add(message);
}
- public void addErrorAndContinue(String error, ASTNode node, SourceUnit source) {
+ public void addErrorAndContinue(final String error, final ASTNode node, final SourceUnit source) {
addErrorAndContinue(new SyntaxErrorMessage(
- new SyntaxException(error,
- node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()),
- source));
+ new SyntaxException(error, node.getLineNumber(), node.getColumnNumber(), node.getLastLineNumber(), node.getLastColumnNumber()),
+ source)
+ );
}
/**
diff --git a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
index fab333d..8d2c254 100644
--- a/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
+++ b/src/main/java/org/codehaus/groovy/control/ResolveVisitor.java
@@ -265,7 +265,7 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
}
@Override
- public void visitMethod(MethodNode node) {
+ public void visitMethod(final MethodNode node) {
super.visitMethod(node);
visitGenericsTypeAnnotations(node);
visitTypeAnnotations(node.getReturnType());
@@ -921,9 +921,8 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
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
- // separated by "."
- for (Expression expr = pe; expr != null; expr = ((PropertyExpression) expr).getObjectExpression()) {
+ // this loop builds a name from right to left each name part separated by "."
+ for (Expression expr = pe; expr != null && name != null; expr = ((PropertyExpression) expr).getObjectExpression()) {
if (expr instanceof VariableExpression) {
VariableExpression ve = (VariableExpression) expr;
// stop at super and this
@@ -951,11 +950,10 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
}
Tuple2<StringBuilder, Boolean> classNameInfo = makeClassName(doInitialClassTest, name, property);
name = classNameInfo.getV1();
- if (name == null) return null;
doInitialClassTest = classNameInfo.getV2();
}
- if (null == name || name.length() == 0) return null;
+ if (name == null || name.length() == 0) return null;
return name.toString();
}
@@ -1335,11 +1333,6 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
return ace;
}
- @Override
- public void visitAnnotations(final AnnotatedNode node) {
- visitAnnotations(node.getAnnotations());
- }
-
private void visitTypeAnnotations(final ClassNode node) {
visitAnnotations(node.getTypeAnnotations());
visitGenericsTypeAnnotations(node);
@@ -1365,19 +1358,14 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
}
}
- private void visitAnnotations(List<AnnotationNode> annotations) {
- if (annotations == null || annotations.isEmpty()) return;
- for (AnnotationNode an : annotations) {
- // skip built-in properties
- if (an.isBuiltIn()) continue;
- ClassNode annType = an.getClassNode();
- resolveOrFail(annType, " for annotation", an);
- for (Map.Entry<String, Expression> member : an.getMembers().entrySet()) {
- Expression newValue = transform(member.getValue());
- Expression adjusted = transformInlineConstants(newValue);
- member.setValue(adjusted);
- checkAnnotationMemberValue(adjusted);
- }
+ @Override
+ protected void visitAnnotation(final AnnotationNode node) {
+ resolveOrFail(node.getClassNode(), " for annotation", node);
+
+ for (Map.Entry<String, Expression> member : node.getMembers().entrySet()) {
+ Expression value = transformInlineConstants(transform(member.getValue()));
+ checkAnnotationMemberValue(value);
+ member.setValue(value);
}
}
@@ -1464,13 +1452,13 @@ public class ResolveVisitor extends ClassCodeExpressionTransformer {
}
for (ImportNode importNode : module.getStaticImports().values()) {
ClassNode type = importNode.getType();
- if (resolve(type, true, true, true)) continue;
- addError("unable to resolve class " + type.getName(), type);
+ if (!resolve(type, true, true, true))
+ addError("unable to resolve class " + type.getName(), type);
}
for (ImportNode importNode : module.getStaticStarImports().values()) {
ClassNode type = importNode.getType();
- if (resolve(type, true, true, true)) continue;
- addError("unable to resolve class " + type.getName(), type);
+ if (!resolve(type, true, true, true))
+ addError("unable to resolve class " + type.getName(), type);
}
module.setImportsResolved(true);
}
diff --git a/src/main/java/org/codehaus/groovy/control/SourceUnit.java b/src/main/java/org/codehaus/groovy/control/SourceUnit.java
index c23653b..2568d6b 100644
--- a/src/main/java/org/codehaus/groovy/control/SourceUnit.java
+++ b/src/main/java/org/codehaus/groovy/control/SourceUnit.java
@@ -18,11 +18,6 @@
*/
package org.codehaus.groovy.control;
-//import antlr.CharScanner;
-//import antlr.MismatchedCharException;
-//import antlr.MismatchedTokenException;
-//import antlr.NoViableAltException;
-//import antlr.NoViableAltForCharException;
import groovy.lang.GroovyClassLoader;
import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.ast.ASTNode;
@@ -31,7 +26,6 @@ import org.codehaus.groovy.control.io.FileReaderSource;
import org.codehaus.groovy.control.io.ReaderSource;
import org.codehaus.groovy.control.io.StringReaderSource;
import org.codehaus.groovy.control.io.URLReaderSource;
-import org.codehaus.groovy.control.messages.Message;
import org.codehaus.groovy.control.messages.SimpleMessage;
import org.codehaus.groovy.control.messages.SyntaxErrorMessage;
import org.codehaus.groovy.syntax.Reduction;
@@ -146,32 +140,34 @@ public class SourceUnit extends ProcessingUnit {
// to report an unexpected EOF. Perhaps this implementation misses some.
// If you find another way, please add it.
if (getErrorCollector().hasErrors()) {
+ /*
Message last = (Message) getErrorCollector().getLastError();
Throwable cause = null;
if (last instanceof SyntaxErrorMessage) {
cause = ((SyntaxErrorMessage) last).getCause().getCause();
}
-// if (cause != null) {
-// if (cause instanceof NoViableAltException) {
-// return isEofToken(((NoViableAltException) cause).token);
-// } else if (cause instanceof NoViableAltForCharException) {
-// char badChar = ((NoViableAltForCharException) cause).foundChar;
-// return badChar == CharScanner.EOF_CHAR;
-// } else if (cause instanceof MismatchedCharException) {
-// char badChar = (char) ((MismatchedCharException) cause).foundChar;
-// return badChar == CharScanner.EOF_CHAR;
-// } else if (cause instanceof MismatchedTokenException) {
-// return isEofToken(((MismatchedTokenException) cause).token);
-// }
-// }
+ if (cause != null) {
+ if (cause instanceof groovyjarjarantlr.NoViableAltException) {
+ return isEofToken(((groovyjarjarantlr.NoViableAltException) cause).token);
+ } else if (cause instanceof groovyjarjarantlr.NoViableAltForCharException) {
+ char badChar = ((groovyjarjarantlr.NoViableAltForCharException) cause).foundChar;
+ return badChar == groovyjarjarantlr.CharScanner.EOF_CHAR;
+ } else if (cause instanceof groovyjarjarantlr.MismatchedCharException) {
+ char badChar = (char) ((groovyjarjarantlr.MismatchedCharException) cause).foundChar;
+ return badChar == groovyjarjarantlr.CharScanner.EOF_CHAR;
+ } else if (cause instanceof groovyjarjarantlr.MismatchedTokenException) {
+ return isEofToken(((groovyjarjarantlr.MismatchedTokenException) cause).token);
+ }
+ }
+ */
return true;
}
return false;
}
-// protected boolean isEofToken(antlr.Token token) {
-// return token.getType() == antlr.Token.EOF_TYPE;
-// }
+ /*protected boolean isEofToken(groovyjarjarantlr.Token token) {
+ return token.getType() == groovyjarjarantlr.Token.EOF_TYPE;
+ }*/
//---------------------------------------------------------------------------
// FACTORIES
@@ -238,33 +234,28 @@ public class SourceUnit extends ProcessingUnit {
throw new GroovyBugError("SourceUnit not ready for convert()");
}
- //
- // Build the AST
buildAST();
- String property = (String) AccessController.doPrivileged((PrivilegedAction) () -> System.getProperty("groovy.ast"));
-
- if ("xml".equals(property)) {
+ if ("xml".equals(AccessController.doPrivileged((PrivilegedAction<String>) () -> System.getProperty("groovy.ast")))) {
XStreamUtils.serialize(name, ast);
}
}
+ /**
+ * Builds the AST.
+ */
public ModuleNode buildAST() {
- if (null != this.ast) {
- return this.ast;
- }
-
+ if (this.ast == null)
try {
this.ast = parserPlugin.buildAST(this, this.classLoader, this.cst);
this.ast.setDescription(this.name);
} catch (SyntaxException e) {
if (this.ast == null) {
- // Create a dummy ModuleNode to represent a failed parse - in case a later phase attempts to use the ast
+ // create an empty ModuleNode to represent a failed parse, in case a later phase attempts to use the AST
this.ast = new ModuleNode(this);
}
getErrorCollector().addError(new SyntaxErrorMessage(e, this));
}
-
return this.ast;
}
diff --git a/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java b/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java
index 1483d08..3da8f93 100644
--- a/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/ASTTransformationVisitor.java
@@ -273,8 +273,8 @@ public final class ASTTransformationVisitor extends ClassCodeVisitorSupport {
Enumeration<URL> globalServices = transformLoader.getResources("META-INF/services/org.codehaus.groovy.transform.ASTTransformation");
while (globalServices.hasMoreElements()) {
URL service = globalServices.nextElement();
- String className;
try (BufferedReader svcIn = new BufferedReader(new InputStreamReader(URLStreams.openUncachedStream(service), StandardCharsets.UTF_8))) {
+ String className;
try {
className = svcIn.readLine();
} catch (IOException ioe) {
diff --git a/src/main/java/org/codehaus/groovy/transform/FieldASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/FieldASTTransformation.java
index 72d4da1..a804be8 100644
--- a/src/main/java/org/codehaus/groovy/transform/FieldASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/FieldASTTransformation.java
@@ -126,26 +126,22 @@ public class FieldASTTransformation extends ClassCodeExpressionTransformer imple
));
}
- // GROOVY-4833 : annotations that are not Groovy transforms should be transferred to the generated field
- // GROOVY-6112 : also copy acceptable Groovy transforms
- final List<AnnotationNode> annotations = de.getAnnotations();
- for (AnnotationNode annotation : annotations) {
- // GROOVY-6337 HACK: in case newly created field is @Lazy
+ for (AnnotationNode annotation : de.getAnnotations()) {
+ // GROOVY-6337: in case newly created field is @Lazy
if (annotation.getClassNode().equals(LAZY_TYPE)) {
LazyASTTransformation.visitField(this, annotation, fieldNode);
}
- final ClassNode annotationClassNode = annotation.getClassNode();
- if (notTransform(annotationClassNode) || acceptableTransform(annotation)) {
+ // GROOVY-4833: copy annotations that are not Groovy transforms; GROOVY-6112: also copy acceptable Groovy transforms
+ if (notTransform(annotation.getClassNode()) || acceptableTransform(annotation)) {
fieldNode.addAnnotation(annotation);
}
}
super.visitClass(cNode);
- // GROOVY-5207 So that Closures can see newly added fields
+ // GROOVY-5207: So that Closures can see newly added fields
// (not super efficient for a very large class with many @Fields but we chose simplicity
// and understandability of this solution over more complex but efficient alternatives)
- VariableScopeVisitor scopeVisitor = new VariableScopeVisitor(source);
- scopeVisitor.visitClass(cNode);
+ new VariableScopeVisitor(source).visitClass(cNode);
}
}
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java
index 78c4086..ee43582 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/MethodCallExpressionTransformer.java
@@ -38,7 +38,6 @@ import org.codehaus.groovy.transform.stc.StaticTypesMarker;
import java.util.List;
-import static org.codehaus.groovy.ast.ClassHelper.isWrapperInteger;
import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
@@ -95,7 +94,7 @@ public class MethodCallExpressionTransformer {
// workaround for generated code in enums which use .next() returning a Number
indexType = ClassHelper.Integer_TYPE;
}
- if (argType != null && isWrapperInteger(indexType)) {
+ if (argType != null && ClassHelper.isWrapperInteger(indexType)) {
BinaryExpression binaryExpression = new BinaryExpression(
objectExpression,
Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()),
@@ -114,7 +113,7 @@ public class MethodCallExpressionTransformer {
Expression indexExpr = argList.get(0);
Expression objExpr = argList.get(1);
ClassNode argType = staticCompilationTransformer.getTypeChooser().resolveType(indexExpr, staticCompilationTransformer.getClassNode());
- if (argType != null && ClassHelper.Integer_TYPE.equals(ClassHelper.getWrapper(argType))) {
+ if (argType != null && ClassHelper.isWrapperInteger(ClassHelper.getWrapper(argType))) {
BinaryExpression arrayGet = new BinaryExpression(
objectExpression,
Token.newSymbol("[", indexExpr.getLineNumber(), indexExpr.getColumnNumber()),
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 818c184..fe45707 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -75,7 +75,6 @@ import static java.lang.Math.min;
import static org.apache.groovy.ast.tools.ClassNodeUtils.addGeneratedMethod;
import static org.apache.groovy.ast.tools.ClassNodeUtils.samePackageName;
import static org.apache.groovy.ast.tools.ExpressionUtils.isNullConstant;
-import static org.codehaus.groovy.ast.ClassHelper.BigDecimal_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.BigInteger_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.Byte_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.CLOSURE_TYPE;
@@ -103,6 +102,7 @@ import static org.codehaus.groovy.ast.ClassHelper.getUnwrapper;
import static org.codehaus.groovy.ast.ClassHelper.getWrapper;
import static org.codehaus.groovy.ast.ClassHelper.int_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.isBigDecimalType;
+import static org.codehaus.groovy.ast.ClassHelper.isBigIntegerType;
import static org.codehaus.groovy.ast.ClassHelper.isClassType;
import static org.codehaus.groovy.ast.ClassHelper.isGStringType;
import static org.codehaus.groovy.ast.ClassHelper.isGroovyObjectType;
@@ -177,7 +177,7 @@ public abstract class StaticTypeCheckingSupport {
protected static final ClassNode ArrayList_TYPE = makeWithoutCaching(ArrayList.class);
protected static final ClassNode BaseStream_TYPE = makeWithoutCaching(BaseStream.class);
protected static final ClassNode Collection_TYPE = COLLECTION_TYPE; // TODO: deprecate?
- protected static final ClassNode Deprecated_TYPE = DEPRECATED_TYPE;
+ protected static final ClassNode Deprecated_TYPE = DEPRECATED_TYPE; // TODO: deprecate?
protected static final ClassNode LinkedHashMap_TYPE = makeWithoutCaching(LinkedHashMap.class);
protected static final ClassNode LinkedHashSet_TYPE = makeWithoutCaching(LinkedHashSet.class);
@@ -701,11 +701,11 @@ public abstract class StaticTypeCheckingSupport {
if (rightRedirect == VOID_TYPE) return leftRedirect == void_WRAPPER_TYPE;
if (isNumberType(rightRedirect) || isNumberCategory(rightRedirect)) {
- if (BigDecimal_TYPE == leftRedirect || Number_TYPE == leftRedirect) {
+ if (isBigDecimalType(leftRedirect) || Number_TYPE.equals(leftRedirect)) {
// any number can be assigned to BigDecimal or Number
return true;
}
- if (BigInteger_TYPE == leftRedirect) {
+ if (isBigIntegerType(leftRedirect)) {
return isBigIntCategory(getUnwrapper(rightRedirect)) || rightRedirect.isDerivedFrom(BigInteger_TYPE);
}
}
@@ -720,7 +720,7 @@ public abstract class StaticTypeCheckingSupport {
}
// if left is an enum and right is String or GString we do valueOf
- if (leftRedirect.isDerivedFrom(Enum_Type) && (rightRedirect == STRING_TYPE || rightRedirect == GSTRING_TYPE)) {
+ if (leftRedirect.isDerivedFrom(Enum_Type) && (rightRedirect == STRING_TYPE || isGStringType(rightRedirect))) {
return true;
}
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index f0fbd9e..5b22d99 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -997,7 +997,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
Function<MethodNode, ClassNode> setterType = setter -> {
ClassNode type = setter.getParameters()[0].getOriginType();
- if (!setter.isStatic() && GenericsUtils.hasUnresolvedGenerics(type)) {
+ if (!setter.isStatic() && !(setter instanceof ExtensionMethodNode) && GenericsUtils.hasUnresolvedGenerics(type)) {
Map<GenericsTypeName, GenericsType> spec = extractPlaceHolders(null, setterInfo.receiverType, setter.getDeclaringClass());
type = applyGenericsContext(spec, type);
}
@@ -3368,7 +3368,12 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
objectExpression.visit(this);
call.getMethod().visit(this);
- ClassNode receiver = getType(objectExpression);
+ ClassNode receiver;
+ if (objectExpression instanceof VariableExpression && hasInferredReturnType(objectExpression)) {
+ receiver = getInferredReturnType(objectExpression);
+ } else {
+ receiver = getType(objectExpression);
+ }
// if it's a spread operator call, then make sure receiver is array or collection
if (call.isSpreadSafe()) {
if (!receiver.isArray() && !implementsInterfaceOrIsSubclassOf(receiver, Collection_TYPE)) {
@@ -4757,7 +4762,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
} else { // GROOVY-9890: always search for default methods
List<MethodNode> interfaceMethods = new ArrayList<>();
collectAllInterfaceMethodsByName(receiver, name, interfaceMethods);
- interfaceMethods.stream().filter(MethodNode::isDefault).forEach(methods::add);
+ interfaceMethods.stream().filter(mn -> mn.isDefault() || (mn.isPublic()
+ && !mn.isStatic() && !mn.isAbstract() && Traits.isTrait(mn.getDeclaringClass()))
+ ).forEach(methods::add);
}
if (receiver.isInterface()) {
methods.addAll(OBJECT_TYPE.getMethods(name));
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
index 57aca7d..c9db784 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
@@ -548,7 +548,7 @@ public abstract class TraitComposer {
args
);
Statement result;
- if (ClassHelper.isPrimitiveVoid(forwarderMethod.getReturnType())) {
+ if (forwarderMethod.isVoidMethod()) {
BlockStatement stmt = new BlockStatement();
stmt.addStatement(new ExpressionStatement(delegateCall));
stmt.addStatement(new ReturnStatement(new ConstantExpression(null)));
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/Traits.java b/src/main/java/org/codehaus/groovy/transform/trait/Traits.java
index 8edeb25..c10b410 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/Traits.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/Traits.java
@@ -161,7 +161,7 @@ public abstract class Traits {
throw new GroovyBugError("Couldn't find trait helper classes on compile classpath!",e);
}
}
- return new TraitHelpersTuple(helperClassNode, fieldHelperClassNode, staticFieldHelperClassNode);
+ return new TraitHelpersTuple(helperClassNode, fieldHelperClassNode, staticFieldHelperClassNode);
}
/**
diff --git a/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java b/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java
index 18fd483..9406d5d 100644
--- a/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java
+++ b/src/main/java/org/codehaus/groovy/vmplugin/v8/Java8.java
@@ -81,16 +81,11 @@ import java.util.stream.Collectors;
*/
public class Java8 implements VMPlugin {
- private static final Class<?>[] PLUGIN_DGM = {PluginDefaultGroovyMethods.class};
private static final Method[] EMPTY_METHOD_ARRAY = new Method[0];
private static final Annotation[] EMPTY_ANNOTATION_ARRAY = new Annotation[0];
private static final Permission ACCESS_PERMISSION = new ReflectPermission("suppressAccessChecks");
- public Java8() {
- super();
- }
-
- public static GenericsType configureTypeVariableDefinition(ClassNode base, ClassNode[] cBounds) {
+ public static GenericsType configureTypeVariableDefinition(final ClassNode base, final ClassNode[] cBounds) {
ClassNode redirect = base.redirect();
base.setRedirect(null);
GenericsType gt;
@@ -105,7 +100,7 @@ public class Java8 implements VMPlugin {
return gt;
}
- private static ClassNode configureClass(Class<?> c) {
+ private static ClassNode configureClass(final Class<?> c) {
if (c.isPrimitive()) {
return ClassHelper.make(c);
} else {
@@ -113,7 +108,7 @@ public class Java8 implements VMPlugin {
}
}
- public static ClassNode configureTypeVariableReference(String name) {
+ public static ClassNode configureTypeVariableReference(final String name) {
ClassNode cn = ClassHelper.makeWithoutCaching(name);
cn.setGenericsPlaceHolder(true);
ClassNode cn2 = ClassHelper.makeWithoutCaching(name);
@@ -124,7 +119,7 @@ public class Java8 implements VMPlugin {
return cn;
}
- private static void setRetentionPolicy(RetentionPolicy value, AnnotationNode node) {
+ private static void setRetentionPolicy(final RetentionPolicy value, final AnnotationNode node) {
switch (value) {
case RUNTIME:
node.setRuntimeRetention(true);
@@ -140,23 +135,20 @@ public class Java8 implements VMPlugin {
}
}
- private static void setMethodDefaultValue(MethodNode mn, Method m) {
+ private static void setMethodDefaultValue(final MethodNode mn, final Method m) {
ConstantExpression cExp = new ConstantExpression(m.getDefaultValue());
mn.setCode(new ReturnStatement(cExp));
mn.setAnnotationDefault(true);
}
- protected MethodHandles.Lookup newLookup(final Class<?> declaringClass) {
- return of(declaringClass);
- }
-
- private static Constructor<MethodHandles.Lookup> getLookupConstructor() {
- return LookupHolder.LOOKUP_Constructor;
+ @Override
+ public Class<?>[] getPluginDefaultGroovyMethods() {
+ return new Class[]{PluginDefaultGroovyMethods.class};
}
@Override
- public Class<?>[] getPluginDefaultGroovyMethods() {
- return PLUGIN_DGM;
+ public Class<?>[] getPluginStaticGroovyMethods() {
+ return MetaClassHelper.EMPTY_TYPE_ARRAY;
}
@Override
@@ -164,7 +156,7 @@ public class Java8 implements VMPlugin {
return 8;
}
- protected int getElementCode(ElementType value) {
+ protected int getElementCode(final ElementType value) {
switch (value) {
case TYPE:
return AnnotationNode.TYPE_TARGET;
@@ -186,63 +178,52 @@ public class Java8 implements VMPlugin {
return AnnotationNode.TYPE_PARAMETER_TARGET;
case TYPE_USE:
return AnnotationNode.TYPE_USE_TARGET;
+ default:
+ // falls through
}
- if ("MODULE".equals(value.name())) {
+ if ("MODULE".equals(value.name())) { // JDK 9+
return AnnotationNode.TYPE_TARGET;
} else {
throw new GroovyBugError("unsupported Target " + value);
}
}
- protected Parameter[] processParameters(CompileUnit compileUnit, Method m) {
- java.lang.reflect.Parameter[] parameters = m.getParameters();
- Type[] types = m.getGenericParameterTypes();
- Parameter[] params = Parameter.EMPTY_ARRAY;
- if (types.length > 0) {
- params = new Parameter[types.length];
- for (int i = 0; i < params.length; i++) {
- java.lang.reflect.Parameter p = parameters[i];
- String name = p.isNamePresent() ? p.getName() : "param" + i;
- params[i] = makeParameter(compileUnit, types[i], m.getParameterTypes()[i], m.getParameterAnnotations()[i], name);
- }
- }
- return params;
- }
-
@Override
- public void setAdditionalClassInformation(ClassNode cn) {
+ public void setAdditionalClassInformation(final ClassNode cn) {
setGenericsTypes(cn);
}
- private void setGenericsTypes(ClassNode cn) {
+ private void setGenericsTypes(final ClassNode cn) {
TypeVariable[] tvs = cn.getTypeClass().getTypeParameters();
GenericsType[] gts = configureTypeVariable(tvs);
cn.setGenericsTypes(gts);
}
- private GenericsType[] configureTypeVariable(TypeVariable[] tvs) {
- if (tvs.length == 0) return null;
- GenericsType[] gts = new GenericsType[tvs.length];
- for (int i = 0; i < tvs.length; i++) {
+ private GenericsType[] configureTypeVariable(final TypeVariable[] tvs) {
+ final int n = tvs.length;
+ if (n == 0) return null;
+ GenericsType[] gts = new GenericsType[n];
+ for (int i = 0; i < n; i += 1) {
gts[i] = configureTypeVariableDefinition(tvs[i]);
}
return gts;
}
- private GenericsType configureTypeVariableDefinition(TypeVariable tv) {
+ private GenericsType configureTypeVariableDefinition(final TypeVariable tv) {
return configureTypeVariableDefinition(configureTypeVariableReference(tv.getName()), configureTypes(tv.getBounds()));
}
- private ClassNode[] configureTypes(Type[] types) {
- if (types.length == 0) return null;
- ClassNode[] nodes = new ClassNode[types.length];
- for (int i = 0; i < types.length; i++) {
+ private ClassNode[] configureTypes(final Type[] types) {
+ final int n = types.length;
+ if (n == 0) return null;
+ ClassNode[] nodes = new ClassNode[n];
+ for (int i = 0; i < n; i += 1) {
nodes[i] = configureType(types[i]);
}
return nodes;
}
- private ClassNode configureType(Type type) {
+ private ClassNode configureType(final Type type) {
if (type instanceof WildcardType) {
return configureWildcardType((WildcardType) type);
} else if (type instanceof ParameterizedType) {
@@ -260,7 +241,7 @@ public class Java8 implements VMPlugin {
}
}
- private ClassNode configureGenericArray(GenericArrayType genericArrayType) {
+ private ClassNode configureGenericArray(final GenericArrayType genericArrayType) {
Type component = genericArrayType.getGenericComponentType();
ClassNode node = configureType(component);
return node.makeArray();
@@ -285,17 +266,18 @@ public class Java8 implements VMPlugin {
return wt;
}
- private ClassNode configureParameterizedType(ParameterizedType parameterizedType) {
+ private ClassNode configureParameterizedType(final ParameterizedType parameterizedType) {
ClassNode base = configureType(parameterizedType.getRawType());
GenericsType[] gts = configureTypeArguments(parameterizedType.getActualTypeArguments());
base.setGenericsTypes(gts);
return base;
}
- private GenericsType[] configureTypeArguments(Type[] ta) {
- if (ta.length == 0) return null;
- GenericsType[] gts = new GenericsType[ta.length];
- for (int i = 0; i < ta.length; i++) {
+ private GenericsType[] configureTypeArguments(final Type[] ta) {
+ final int n = ta.length;
+ if (n == 0) return null;
+ GenericsType[] gts = new GenericsType[n];
+ for (int i = 0; i < n; i += 1) {
ClassNode t = configureType(ta[i]);
if (ta[i] instanceof WildcardType) {
GenericsType[] gen = t.getGenericsTypes();
@@ -307,12 +289,7 @@ public class Java8 implements VMPlugin {
return gts;
}
- @Override
- public Class<?>[] getPluginStaticGroovyMethods() {
- return MetaClassHelper.EMPTY_TYPE_ARRAY;
- }
-
- private void setAnnotationMetaData(Annotation[] annotations, AnnotatedNode an) {
+ private void setAnnotationMetaData(final Annotation[] annotations, final AnnotatedNode an) {
for (Annotation annotation : annotations) {
AnnotationNode node = new AnnotationNode(ClassHelper.make(annotation.annotationType()));
configureAnnotation(node, annotation);
@@ -321,7 +298,7 @@ public class Java8 implements VMPlugin {
}
@Override
- public void configureAnnotationNodeFromDefinition(AnnotationNode definition, AnnotationNode root) {
+ public void configureAnnotationNodeFromDefinition(final AnnotationNode definition, final AnnotationNode root) {
ClassNode type = definition.getClassNode();
final String typeName = type.getName();
if ("java.lang.annotation.Retention".equals(typeName)) {
@@ -348,7 +325,7 @@ public class Java8 implements VMPlugin {
}
@Override
- public void configureAnnotation(AnnotationNode node) {
+ public void configureAnnotation(final AnnotationNode node) {
ClassNode type = node.getClassNode();
VMPlugin plugin = VMPluginFactory.getPlugin();
List<AnnotationNode> annotations = type.getAnnotations();
@@ -360,7 +337,7 @@ public class Java8 implements VMPlugin {
}
}
- private void configureAnnotation(AnnotationNode node, Annotation annotation) {
+ private void configureAnnotation(final AnnotationNode node, final Annotation annotation) {
Class<?> type = annotation.annotationType();
if (type == Retention.class) {
Retention r = (Retention) annotation;
@@ -398,7 +375,7 @@ public class Java8 implements VMPlugin {
}
}
- private Expression annotationValueToExpression (Object value) {
+ private Expression annotationValueToExpression(final Object value) {
if (value == null || value instanceof String || value instanceof Number || value instanceof Character || value instanceof Boolean)
return new ConstantExpression(value);
@@ -408,7 +385,7 @@ public class Java8 implements VMPlugin {
if (value.getClass().isArray()) {
ListExpression elementExprs = new ListExpression();
int len = Array.getLength(value);
- for (int i = 0; i != len; ++i)
+ for (int i = 0; i != len; i += 1)
elementExprs.addExpression(annotationValueToExpression(Array.get(value, i)));
return elementExprs;
}
@@ -417,7 +394,7 @@ public class Java8 implements VMPlugin {
}
@Override
- public void configureClassNode(CompileUnit compileUnit, ClassNode classNode) {
+ public void configureClassNode(final CompileUnit compileUnit, final ClassNode classNode) {
try {
Class<?> clazz = classNode.getTypeClass();
Field[] fields = clazz.getDeclaredFields();
@@ -430,7 +407,7 @@ public class Java8 implements VMPlugin {
Method[] methods = clazz.getDeclaredMethods();
for (Method m : methods) {
ClassNode ret = makeClassNode(compileUnit, m.getGenericReturnType(), m.getReturnType());
- Parameter[] params = processParameters(compileUnit, m);
+ Parameter[] params = makeParameters(compileUnit, m.getGenericParameterTypes(), m.getParameterTypes(), m.getParameterAnnotations(), m);
ClassNode[] exceptions = makeClassNodes(compileUnit, m.getGenericExceptionTypes(), m.getExceptionTypes());
MethodNode mn = new MethodNode(m.getName(), m.getModifiers(), ret, params, exceptions, null);
mn.setSynthetic(m.isSynthetic());
@@ -441,15 +418,7 @@ public class Java8 implements VMPlugin {
}
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor ctor : constructors) {
- Type[] types = ctor.getGenericParameterTypes();
- Parameter[] params1 = Parameter.EMPTY_ARRAY;
- if (types.length > 0) {
- params1 = new Parameter[types.length];
- for (int i = 0; i < params1.length; i++) {
- params1[i] = makeParameter(compileUnit, types[i], ctor.getParameterTypes()[i], getConstructorParameterAnnotations(ctor)[i], "param" + i);
- }
- }
- Parameter[] params = params1;
+ Parameter[] params = makeParameters(compileUnit, ctor.getGenericParameterTypes(), ctor.getParameterTypes(), getConstructorParameterAnnotations(ctor), ctor);
ClassNode[] exceptions = makeClassNodes(compileUnit, ctor.getGenericExceptionTypes(), ctor.getExceptionTypes());
ConstructorNode cn = classNode.addConstructor(ctor.getModifiers(), params, exceptions, null);
setAnnotationMetaData(ctor.getAnnotations(), cn);
@@ -466,9 +435,9 @@ public class Java8 implements VMPlugin {
setAnnotationMetaData(clazz.getPackage().getAnnotations(), packageNode);
}
} catch (NoClassDefFoundError e) {
- throw new NoClassDefFoundError("Unable to load class "+classNode.toString(false)+" due to missing dependency "+e.getMessage());
+ throw new NoClassDefFoundError("Unable to load class " + classNode.toString(false) + " due to missing dependency " + e.getMessage());
} catch (MalformedParameterizedTypeException e) {
- throw new RuntimeException("Unable to configure class node for class "+classNode.toString(false)+" due to malformed parameterized types", e);
+ throw new RuntimeException("Unable to configure class node for class " + classNode.toString(false) + " due to malformed parameterized types", e);
}
}
@@ -487,7 +456,7 @@ public class Java8 implements VMPlugin {
* @param constructor the Constructor for which to return parameter annotations
* @return array of arrays containing the annotations on the parameters of the given Constructor
*/
- private Annotation[][] getConstructorParameterAnnotations(Constructor<?> constructor) {
+ private Annotation[][] getConstructorParameterAnnotations(final Constructor<?> constructor) {
/*
* TODO: Remove after JDK9 is the minimum JDK supported
*
@@ -508,7 +477,7 @@ public class Java8 implements VMPlugin {
);
}
Annotation[][] adjusted = new Annotation[parameterCount][];
- for (int i = 0; i < diff; i++) {
+ for (int i = 0; i < diff; i += 1) {
adjusted[i] = EMPTY_ANNOTATION_ARRAY;
}
System.arraycopy(annotations, 0, adjusted, diff, annotations.length);
@@ -517,7 +486,7 @@ public class Java8 implements VMPlugin {
return annotations;
}
- private void makePermittedSubclasses(CompileUnit cu, ClassNode classNode, Class<?> clazz) {
+ private void makePermittedSubclasses(final CompileUnit cu, final ClassNode classNode, final Class<?> clazz) {
if (!ReflectionUtils.isSealed(clazz)) return;
List<ClassNode> permittedSubclasses = Arrays.stream(ReflectionUtils.getPermittedSubclasses(clazz))
.map(c -> makeClassNode(cu, c, c))
@@ -525,20 +494,20 @@ public class Java8 implements VMPlugin {
classNode.setPermittedSubclasses(permittedSubclasses);
}
- private void makeInterfaceTypes(CompileUnit cu, ClassNode classNode, Class<?> clazz) {
+ private void makeInterfaceTypes(final CompileUnit cu, final ClassNode classNode, final Class<?> clazz) {
Type[] interfaceTypes = clazz.getGenericInterfaces();
- if (interfaceTypes.length == 0) {
+ final int n = interfaceTypes.length;
+ if (n == 0) {
classNode.setInterfaces(ClassNode.EMPTY_ARRAY);
} else {
- ClassNode[] ret = new ClassNode[interfaceTypes.length];
- for (int i = 0; i < interfaceTypes.length; i++) {
+ ClassNode[] ret = new ClassNode[n];
+ for (int i = 0; i < n; i += 1) {
Type type = interfaceTypes[i];
while (!(type instanceof Class)) {
ParameterizedType pt = (ParameterizedType) type;
Type t2 = pt.getRawType();
- if (t2==type) {
- throw new GroovyBugError("Cannot transform generic signature of "+clazz+
- " with generic interface "+interfaceTypes[i]+" to a class.");
+ if (t2 == type) {
+ throw new GroovyBugError("Cannot transform generic signature of " + clazz + " with generic interface " + interfaceTypes[i] + " to a class.");
}
type = t2;
}
@@ -548,15 +517,16 @@ public class Java8 implements VMPlugin {
}
}
- private ClassNode[] makeClassNodes(CompileUnit cu, Type[] types, Class<?>[] cls) {
- ClassNode[] nodes = new ClassNode[types.length];
- for (int i = 0; i < nodes.length; i++) {
+ private ClassNode[] makeClassNodes(final CompileUnit cu, final Type[] types, final Class<?>[] cls) {
+ final int n = types.length;
+ ClassNode[] nodes = new ClassNode[n];
+ for (int i = 0; i < n; i += 1) {
nodes[i] = makeClassNode(cu, types[i], cls[i]);
}
return nodes;
}
- private ClassNode makeClassNode(CompileUnit cu, Type t, Class<?> c) {
+ private ClassNode makeClassNode(final CompileUnit cu, final Type t, final Class<?> c) {
ClassNode back = null;
if (cu != null) back = cu.getClass(c.getName());
if (back == null) back = ClassHelper.make(c);
@@ -568,11 +538,30 @@ public class Java8 implements VMPlugin {
return back.getPlainNodeReference();
}
- protected Parameter makeParameter(CompileUnit cu, Type type, Class<?> cl, Annotation[] annotations, String name) {
- ClassNode cn = makeClassNode(cu, type, cl);
- Parameter parameter = new Parameter(cn, name);
- setAnnotationMetaData(annotations, parameter);
- return parameter;
+ private Parameter[] makeParameters(final CompileUnit cu, final Type[] types, final Class<?>[] cls, final Annotation[][] parameterAnnotations, final java.lang.reflect.Member member) {
+ Parameter[] params = Parameter.EMPTY_ARRAY;
+ final int n = types.length;
+ if (n > 0) {
+ params = new Parameter[n];
+ String[] names = new String[n];
+ fillParameterNames(names, member);
+ for (int i = 0; i < n; i += 1) {
+ setAnnotationMetaData(parameterAnnotations[i],
+ params[i] = new Parameter(makeClassNode(cu, types[i], cls[i]), names[i]));
+ }
+ }
+ return params;
+ }
+
+ protected void fillParameterNames(final String[] names, final java.lang.reflect.Member member) {
+ try {
+ java.lang.reflect.Parameter[] parameters = ((java.lang.reflect.Executable) member).getParameters();
+ for (int i = 0, n = names.length; i < n; i += 1) {
+ names[i] = parameters[i].getName();
+ }
+ } catch (RuntimeException e) {
+ throw new GroovyBugError(e);
+ }
}
/**
@@ -585,7 +574,7 @@ public class Java8 implements VMPlugin {
* @return the check result
*/
@Override
- public boolean checkCanSetAccessible(AccessibleObject accessibleObject, Class<?> callerClass) {
+ public boolean checkCanSetAccessible(final AccessibleObject accessibleObject, final Class<?> callerClass) {
SecurityManager sm = System.getSecurityManager();
try {
if (sm != null) {
@@ -596,7 +585,7 @@ public class Java8 implements VMPlugin {
}
if (accessibleObject instanceof Constructor) {
- Constructor c = (Constructor) accessibleObject;
+ Constructor<?> c = (Constructor<?>) accessibleObject;
if (c.getDeclaringClass() == Class.class) {
return false; // Cannot make a java.lang.Class constructor accessible
}
@@ -606,12 +595,12 @@ public class Java8 implements VMPlugin {
}
@Override
- public boolean checkAccessible(Class<?> callerClass, Class<?> declaringClass, int memberModifiers, boolean allowIllegalAccess) {
+ public boolean checkAccessible(final Class<?> callerClass, final Class<?> declaringClass, final int memberModifiers, final boolean allowIllegalAccess) {
return true;
}
@Override
- public boolean trySetAccessible(AccessibleObject ao) {
+ public boolean trySetAccessible(final AccessibleObject ao) {
try {
ao.setAccessible(true);
return true;
@@ -623,12 +612,12 @@ public class Java8 implements VMPlugin {
}
@Override
- public MetaMethod transformMetaMethod(MetaClass metaClass, MetaMethod metaMethod, Class<?> caller) {
+ public MetaMethod transformMetaMethod(final MetaClass metaClass, final MetaMethod metaMethod, final Class<?> caller) {
return metaMethod;
}
@Override
- public MetaMethod transformMetaMethod(MetaClass metaClass, MetaMethod metaMethod) {
+ public MetaMethod transformMetaMethod(final MetaClass metaClass, final MetaMethod metaMethod) {
return transformMetaMethod(metaClass, metaMethod, null);
}
@@ -637,33 +626,26 @@ public class Java8 implements VMPlugin {
IndyInterface.invalidateSwitchPoints();
}
- protected MethodHandles.Lookup getLookup(Object receiver) {
- MethodHandles.Lookup lookup = null;
+ protected MethodHandles.Lookup getLookup(final Object receiver) {
+ Optional<MethodHandles.Lookup> lookup = Optional.empty();
if (receiver instanceof GroovyObject) {
- Optional<MethodHandles.Lookup> lookupOptional = GroovyObjectHelper.lookup((GroovyObject) receiver);
- if (lookupOptional.isPresent()) {
- lookup = lookupOptional.get();
- }
+ lookup = GroovyObjectHelper.lookup((GroovyObject) receiver);
}
- if (null == lookup) {
- final Class<?> receiverType = receiver.getClass();
- lookup = newLookup(receiverType);
- }
- return lookup;
+ return lookup.orElseGet(() -> newLookup(receiver.getClass()));
}
@Override
- public Object getInvokeSpecialHandle(Method method, Object receiver) {
+ public Object getInvokeSpecialHandle(final Method method, final Object receiver) {
try {
- MethodHandles.Lookup lookup = getLookup(receiver);
- Class<?> receiverType = receiver.getClass();
- return lookup.unreflectSpecial(method, receiverType).bindTo(receiver);
+ return getLookup(receiver)
+ .unreflectSpecial(method, receiver.getClass())
+ .bindTo(receiver);
} catch (ReflectiveOperationException e) {
return getInvokeSpecialHandleFallback(method, receiver);
}
}
- private Object getInvokeSpecialHandleFallback(Method method, Object receiver) {
+ private Object getInvokeSpecialHandleFallback(final Method method, final Object receiver) {
if (!method.isAccessible()) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.trySetAccessible(method);
@@ -672,23 +654,24 @@ public class Java8 implements VMPlugin {
}
Class<?> declaringClass = method.getDeclaringClass();
try {
- return newLookup(declaringClass).
- unreflectSpecial(method, declaringClass).
- bindTo(receiver);
+ return newLookup(declaringClass).unreflectSpecial(method, declaringClass).bindTo(receiver);
} catch (ReflectiveOperationException e) {
throw new GroovyBugError(e);
}
}
@Override
- public Object invokeHandle(Object handle, Object[] args) throws Throwable {
- MethodHandle mh = (MethodHandle) handle;
- return mh.invokeWithArguments(args);
+ public Object invokeHandle(final Object handle, final Object[] args) throws Throwable {
+ return ((MethodHandle) handle).invokeWithArguments(args);
+ }
+
+ protected MethodHandles.Lookup newLookup(final Class<?> declaringClass) {
+ return of(declaringClass);
}
public static MethodHandles.Lookup of(final Class<?> declaringClass) {
try {
- return getLookupConstructor().newInstance(declaringClass, MethodHandles.Lookup.PRIVATE).in(declaringClass);
+ return LookupHolder.LOOKUP_Constructor.newInstance(declaringClass, MethodHandles.Lookup.PRIVATE).in(declaringClass);
} catch (final IllegalAccessException | InstantiationException e) {
throw new IllegalArgumentException(e);
} catch (final InvocationTargetException e) {
@@ -703,21 +686,21 @@ public class Java8 implements VMPlugin {
Constructor<MethodHandles.Lookup> lookup;
try {
lookup = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, Integer.TYPE);
- } catch (final NoSuchMethodException ex) {
- throw new IllegalStateException("Incompatible JVM", ex);
+ } catch (final NoSuchMethodException e) {
+ throw new IllegalStateException("Incompatible JVM", e);
}
try {
if (!lookup.isAccessible()) {
- final Constructor tmp = lookup;
+ final Constructor<MethodHandles.Lookup> finalReference = lookup;
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
- ReflectionUtils.trySetAccessible(tmp);
+ ReflectionUtils.trySetAccessible(finalReference);
return null;
});
}
} catch (SecurityException ignore) {
lookup = null;
- } catch (RuntimeException re) {
- throw re;
+ } catch (RuntimeException e) {
+ throw e;
}
LOOKUP_Constructor = lookup;
}
diff --git a/src/test/groovy/transform/stc/BugsSTCTest.groovy b/src/test/groovy/transform/stc/BugsSTCTest.groovy
index 0781a77..a1ec9df 100644
--- a/src/test/groovy/transform/stc/BugsSTCTest.groovy
+++ b/src/test/groovy/transform/stc/BugsSTCTest.groovy
@@ -100,7 +100,7 @@ class BugsSTCTest extends StaticTypeCheckingTestCase {
x()
}
}
- ''', 'Cannot find matching method <UnionType:C+T>#x'
+ ''', 'Cannot find matching method T#x'
}
// GROOVY-10102
diff --git a/subprojects/groovy-astbuilder/src/test/groovy/org/codehaus/groovy/ast/CodeVisitorSupportTest.groovy b/subprojects/groovy-astbuilder/src/test/groovy/org/codehaus/groovy/ast/CodeVisitorSupportTest.groovy
index 8a57ffd..cc0f3bb 100644
--- a/subprojects/groovy-astbuilder/src/test/groovy/org/codehaus/groovy/ast/CodeVisitorSupportTest.groovy
+++ b/subprojects/groovy-astbuilder/src/test/groovy/org/codehaus/groovy/ast/CodeVisitorSupportTest.groovy
@@ -18,6 +18,8 @@
*/
package org.codehaus.groovy.ast
+import groovy.transform.AutoFinal
+import groovy.transform.CompileStatic
import groovy.transform.PackageScope
import org.codehaus.groovy.ast.builder.AstBuilder
import org.codehaus.groovy.ast.expr.BooleanExpression
@@ -113,35 +115,42 @@ final class CodeVisitorSupportTest {
* This would be better implemented using invokeMethod but it is called from Java so it
* won't dispatch correctly.
*/
-@PackageScope
+@AutoFinal @CompileStatic @PackageScope
class RecordingCodeVisitorSupport extends CodeVisitorSupport implements GroovyInterceptable {
- def history = []
+ List history = []
+
+ @Override
void visitBlockStatement(BlockStatement node) {
history << node.getClass()
super.visitBlockStatement(node)
}
+ @Override
void visitIfElse(IfStatement node) {
history << node.getClass()
super.visitIfElse(node)
}
+ @Override
void visitBooleanExpression(BooleanExpression node) {
history << node.getClass()
super.visitBooleanExpression(node)
}
+ @Override
void visitEmptyStatement(EmptyStatement node) {
history << EmptyStatement
super.visitEmptyStatement(node)
}
+ @Override
void visitTryCatchFinally(TryCatchStatement node) {
history << node.getClass()
super.visitTryCatchFinally(node);
}
+ @Override
void visitCatchStatement(CatchStatement node) {
history << node.getClass()
super.visitCatchStatement(node);