This is an automated email from the ASF dual-hosted git repository.
emilles pushed a commit to branch GROOVY_2_5_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
The following commit(s) were added to refs/heads/GROOVY_2_5_X by this push:
new 5ec2aec minor edits
5ec2aec is described below
commit 5ec2aecf3d9bf5e1fee15d0818d9cdbb24b97e3a
Author: Eric Milles <[email protected]>
AuthorDate: Mon Feb 14 10:44:44 2022 -0600
minor edits
---
.../apache/groovy/ast/tools/ExpressionUtils.java | 2 +-
.../groovy/antlr/UnicodeEscapingReader.java | 11 +-
src/main/java/org/codehaus/groovy/ast/ASTNode.java | 2 +-
.../org/codehaus/groovy/ast/AnnotatedNode.java | 27 ++-
.../groovy/ast/ClassCodeVisitorSupport.java | 83 +++++---
.../java/org/codehaus/groovy/ast/ClassHelper.java | 6 +-
.../java/org/codehaus/groovy/ast/ClassNode.java | 120 +++++------
.../codehaus/groovy/ast/CodeVisitorSupport.java | 7 +-
.../java/org/codehaus/groovy/ast/CompileUnit.java | 67 +++---
.../java/org/codehaus/groovy/ast/GenericsType.java | 15 +-
.../java/org/codehaus/groovy/ast/ImportNode.java | 5 +-
.../java/org/codehaus/groovy/ast/MethodNode.java | 18 +-
.../java/org/codehaus/groovy/ast/ModuleNode.java | 232 +++++++++++----------
.../java/org/codehaus/groovy/ast/Parameter.java | 24 +--
.../groovy/ast/expr/ConstantExpression.java | 11 +-
.../groovy/ast/expr/ConstructorCallExpression.java | 1 +
.../codehaus/groovy/ast/expr/EmptyExpression.java | 11 +-
.../codehaus/groovy/ast/expr/FieldExpression.java | 52 +++--
.../groovy/ast/expr/MethodCallExpression.java | 14 +-
.../codehaus/groovy/ast/tools/GeneralUtils.java | 10 +-
.../codehaus/groovy/ast/tools/GenericsUtils.java | 40 ++--
.../groovy/ast/tools/WideningCategories.java | 6 +-
.../groovy/classgen/AnnotationVisitor.java | 18 +-
.../groovy/classgen/asm/BytecodeHelper.java | 5 +-
.../groovy/classgen/asm/ClosureWriter.java | 7 +-
.../codehaus/groovy/classgen/asm/CompileStack.java | 80 +++----
.../groovy/classgen/asm/InvocationWriter.java | 3 +-
.../classgen/asm/sc/StaticInvocationWriter.java | 15 +-
src/test/groovy/grape/GrapeClassLoaderTest.groovy | 9 +-
.../swingui/AstNodeToScriptAdapterTest.groovy | 4 +-
.../swingui/ScriptToTreeNodeAdapterTest.groovy | 2 +-
31 files changed, 446 insertions(+), 461 deletions(-)
diff --git a/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java
b/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java
index af20d2a..b48c009 100644
--- a/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java
+++ b/src/main/java/org/apache/groovy/ast/tools/ExpressionUtils.java
@@ -231,7 +231,7 @@ public final class ExpressionUtils {
Field field =
type.redirect().getTypeClass().getField(pe.getPropertyAsString());
if (field != null &&
Modifier.isStatic(field.getModifiers()) &&
Modifier.isFinal(field.getModifiers())) {
ConstantExpression ce3 = new
ConstantExpression(field.get(null), true);
- ce3.setSourcePosition(exp);
+ configure(exp, ce3);
return ce3;
}
} catch (Exception | LinkageError e) {
diff --git a/src/main/java/org/codehaus/groovy/antlr/UnicodeEscapingReader.java
b/src/main/java/org/codehaus/groovy/antlr/UnicodeEscapingReader.java
index aef7e7a..7809c52 100644
--- a/src/main/java/org/codehaus/groovy/antlr/UnicodeEscapingReader.java
+++ b/src/main/java/org/codehaus/groovy/antlr/UnicodeEscapingReader.java
@@ -44,6 +44,7 @@ public class UnicodeEscapingReader extends Reader {
private static class DummyLexer extends CharScanner {
private final Token t = new Token();
+ @Override
public Token nextToken() throws TokenStreamException {
return t;
}
@@ -56,7 +57,7 @@ public class UnicodeEscapingReader extends Reader {
return 0;
}
}
-
+
/**
* Constructor.
* @param reader The reader that this reader will filter over.
@@ -79,6 +80,7 @@ public class UnicodeEscapingReader extends Reader {
* Reads characters from the underlying reader.
* @see java.io.Reader#read(char[],int,int)
*/
+ @Override
public int read(char cbuf[], int off, int len) throws IOException {
int c = 0;
int count = 0;
@@ -94,6 +96,7 @@ public class UnicodeEscapingReader extends Reader {
* translating escapes as required.
* @see java.io.Reader#close()
*/
+ @Override
public int read() throws IOException {
if (hasNextChar) {
hasNextChar = false;
@@ -106,7 +109,7 @@ public class UnicodeEscapingReader extends Reader {
numUnicodeEscapesFoundOnCurrentLine = 0;
previousLine = lexer.getLine();
}
-
+
int c = reader.read();
if (c != '\\') {
write(c);
@@ -142,12 +145,13 @@ public class UnicodeEscapingReader extends Reader {
}
int rv = Integer.parseInt(charNum.toString(), 16);
write(rv);
-
+
numUnicodeEscapesFound += 4 + numberOfUChars;
numUnicodeEscapesFoundOnCurrentLine += 4 + numberOfUChars;
return rv;
}
+
private void write(int c) {
if (sourceBuffer != null) {sourceBuffer.write(c);}
}
@@ -184,6 +188,7 @@ public class UnicodeEscapingReader extends Reader {
*
* @see java.io.Reader#close()
*/
+ @Override
public void close() throws IOException {
reader.close();
}
diff --git a/src/main/java/org/codehaus/groovy/ast/ASTNode.java
b/src/main/java/org/codehaus/groovy/ast/ASTNode.java
index 598d9af..ed08e9f 100644
--- a/src/main/java/org/codehaus/groovy/ast/ASTNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ASTNode.java
@@ -100,10 +100,10 @@ public class ASTNode {
* @param node - the node used to configure the position information
*/
public void setSourcePosition(ASTNode node) {
+ this.lineNumber = node.getLineNumber();
this.columnNumber = node.getColumnNumber();
this.lastLineNumber = node.getLastLineNumber();
this.lastColumnNumber = node.getLastColumnNumber();
- this.lineNumber = node.getLineNumber();
}
/**
diff --git a/src/main/java/org/codehaus/groovy/ast/AnnotatedNode.java
b/src/main/java/org/codehaus/groovy/ast/AnnotatedNode.java
index 8f51f39..e3bb1ac 100644
--- a/src/main/java/org/codehaus/groovy/ast/AnnotatedNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/AnnotatedNode.java
@@ -26,10 +26,11 @@ import java.util.List;
* Base class for any AST node which is capable of being annotated
*/
public class AnnotatedNode extends ASTNode {
+
private List<AnnotationNode> annotations = Collections.emptyList();
+ private boolean hasNoRealSourcePositionFlag;
private boolean synthetic;
ClassNode declaringClass;
- private boolean hasNoRealSourcePositionFlag;
public AnnotatedNode() {
}
@@ -39,7 +40,7 @@ public class AnnotatedNode extends ASTNode {
}
public List<AnnotationNode> getAnnotations(ClassNode type) {
- List<AnnotationNode> ret = new
ArrayList<AnnotationNode>(annotations.size());
+ List<AnnotationNode> ret = new ArrayList<>(annotations.size());
for (AnnotationNode node: annotations) {
if (type.equals(node.getClassNode())) ret.add(node);
}
@@ -53,7 +54,7 @@ public class AnnotatedNode extends ASTNode {
private void checkInit() {
if (annotations == Collections.EMPTY_LIST)
- annotations = new ArrayList<AnnotationNode>(3);
+ annotations = new ArrayList<>(3);
}
public void addAnnotations(List<AnnotationNode> annotations) {
@@ -63,10 +64,10 @@ public class AnnotatedNode extends ASTNode {
}
/**
- * returns true if this node is added by the compiler.
- * <b>NOTE</b>:
+ * Returns true if this node is added by the compiler.
+ * <b>NOTE</b>:
* This method has nothing to do with the synthetic flag
- * for fields, methods or classes.
+ * for fields, methods or classes.
* @return true if this node is added by the compiler
*/
public boolean isSynthetic() {
@@ -74,10 +75,10 @@ public class AnnotatedNode extends ASTNode {
}
/**
- * sets this node as a node added by the compiler.
- * <b>NOTE</b>:
+ * Sets this node as a node added by the compiler.
+ * <b>NOTE</b>:
* This method has nothing to do with the synthetic flag
- * for fields, methods or classes.
+ * for fields, methods or classes.
* @param synthetic - if true this node is marked as
* added by the compiler
*/
@@ -89,16 +90,14 @@ public class AnnotatedNode extends ASTNode {
return declaringClass;
}
- /**
- * @param declaringClass - The declaringClass to set.
- */
public void setDeclaringClass(ClassNode declaringClass) {
this.declaringClass = declaringClass;
}
/**
- * Currently only ever returns true for default constructors
- * added by the compiler. See GROOVY-4161.
+ * Returns true for default constructors added by the compiler.
+ *
+ * @see https://issues.apache.org/jira/browse/GROOVY-4161
*/
public boolean hasNoRealSourcePosition() {
return hasNoRealSourcePositionFlag;
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
index 378d2be..9185b7f 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassCodeVisitorSupport.java
@@ -38,15 +38,12 @@ import org.codehaus.groovy.ast.stmt.ThrowStatement;
import org.codehaus.groovy.ast.stmt.TryCatchStatement;
import org.codehaus.groovy.ast.stmt.WhileStatement;
import org.codehaus.groovy.control.SourceUnit;
-import org.codehaus.groovy.control.messages.SyntaxErrorMessage;
import org.codehaus.groovy.syntax.SyntaxException;
import org.codehaus.groovy.transform.ErrorCollecting;
-import java.util.List;
-import java.util.Map;
-
public abstract class ClassCodeVisitorSupport extends CodeVisitorSupport
implements ErrorCollecting, GroovyClassVisitor {
+ @Override
public void visitClass(ClassNode node) {
visitAnnotations(node);
visitPackage(node.getPackage());
@@ -54,10 +51,10 @@ public abstract class ClassCodeVisitorSupport extends
CodeVisitorSupport impleme
node.visitContents(this);
visitObjectInitializerStatements(node);
}
-
+
protected void visitObjectInitializerStatements(ClassNode node) {
- for (Statement element : node.getObjectInitializerStatements()) {
- element.visit(this);
+ for (Statement stmt : node.getObjectInitializerStatements()) {
+ stmt.visit(this);
}
}
@@ -90,24 +87,19 @@ public abstract class ClassCodeVisitorSupport extends
CodeVisitorSupport impleme
}
public void visitAnnotations(AnnotatedNode node) {
- List<AnnotationNode> annotations = node.getAnnotations();
- if (annotations.isEmpty()) return;
- for (AnnotationNode an : annotations) {
- // skip built-in properties
+ for (AnnotationNode an : node.getAnnotations()) {
+ // skip built-in annotations
if (an.isBuiltIn()) continue;
- for (Map.Entry<String, Expression> member :
an.getMembers().entrySet()) {
- member.getValue().visit(this);
+
+ for (Expression expr : an.getMembers().values()) {
+ expr.visit(this);
}
}
}
- public void visitBlockStatement(BlockStatement block) {
- visitStatement(block);
- super.visitBlockStatement(block);
- }
-
protected void visitClassCodeContainer(Statement code) {
- if (code != null) code.visit(this);
+ if (code != null)
+ code.visit(this);
}
@Override
@@ -119,119 +111,142 @@ public abstract class ClassCodeVisitorSupport extends
CodeVisitorSupport impleme
protected void visitConstructorOrMethod(MethodNode node, boolean
isConstructor) {
visitAnnotations(node);
visitClassCodeContainer(node.getCode());
- for (Parameter param : node.getParameters()) {
- visitAnnotations(param);
+ for (Parameter p : node.getParameters()) {
+ visitAnnotations(p);
}
}
+ @Override
public void visitConstructor(ConstructorNode node) {
visitConstructorOrMethod(node, true);
}
+ @Override
public void visitMethod(MethodNode node) {
visitConstructorOrMethod(node, false);
}
+ @Override
public void visitField(FieldNode node) {
visitAnnotations(node);
Expression init = node.getInitialExpression();
- if (init != null) init.visit(this);
+ if (init != null)
+ init.visit(this);
}
+ @Override
public void visitProperty(PropertyNode node) {
visitAnnotations(node);
- Statement statement = node.getGetterBlock();
- visitClassCodeContainer(statement);
-
- statement = node.getSetterBlock();
- visitClassCodeContainer(statement);
-
+ visitClassCodeContainer(node.getGetterBlock());
+ visitClassCodeContainer(node.getSetterBlock());
Expression init = node.getInitialExpression();
- if (init != null) init.visit(this);
+ if (init != null)
+ init.visit(this);
}
- public void addError(String msg, ASTNode expr) {
- SourceUnit source = getSourceUnit();
- source.getErrorCollector().addErrorAndContinue(
- new SyntaxErrorMessage(new SyntaxException(msg + '\n',
expr.getLineNumber(), expr.getColumnNumber(), expr.getLastLineNumber(),
expr.getLastColumnNumber()), source)
- );
+ @Override
+ public void addError(String msg, ASTNode node) {
+ getSourceUnit().addErrorAndContinue(new SyntaxException(msg + '\n',
node));
}
protected abstract SourceUnit getSourceUnit();
+ // statements:
+
protected void visitStatement(Statement statement) {
}
+ @Override
public void visitAssertStatement(AssertStatement statement) {
visitStatement(statement);
super.visitAssertStatement(statement);
}
+ @Override
+ public void visitBlockStatement(BlockStatement block) {
+ visitStatement(block);
+ super.visitBlockStatement(block);
+ }
+
+ @Override
public void visitBreakStatement(BreakStatement statement) {
visitStatement(statement);
super.visitBreakStatement(statement);
}
+ @Override
public void visitCaseStatement(CaseStatement statement) {
visitStatement(statement);
super.visitCaseStatement(statement);
}
+ @Override
public void visitCatchStatement(CatchStatement statement) {
visitStatement(statement);
super.visitCatchStatement(statement);
}
+ @Override
public void visitContinueStatement(ContinueStatement statement) {
visitStatement(statement);
super.visitContinueStatement(statement);
}
+ @Override
public void visitDoWhileLoop(DoWhileStatement loop) {
visitStatement(loop);
super.visitDoWhileLoop(loop);
}
+ @Override
public void visitExpressionStatement(ExpressionStatement statement) {
visitStatement(statement);
super.visitExpressionStatement(statement);
}
+ @Override
public void visitForLoop(ForStatement forLoop) {
visitStatement(forLoop);
super.visitForLoop(forLoop);
}
+ @Override
public void visitIfElse(IfStatement ifElse) {
visitStatement(ifElse);
super.visitIfElse(ifElse);
}
+ @Override
public void visitReturnStatement(ReturnStatement statement) {
visitStatement(statement);
super.visitReturnStatement(statement);
}
+ @Override
public void visitSwitch(SwitchStatement statement) {
visitStatement(statement);
super.visitSwitch(statement);
}
+ @Override
public void visitSynchronizedStatement(SynchronizedStatement statement) {
visitStatement(statement);
super.visitSynchronizedStatement(statement);
}
+ @Override
public void visitThrowStatement(ThrowStatement statement) {
visitStatement(statement);
super.visitThrowStatement(statement);
}
+ @Override
public void visitTryCatchFinally(TryCatchStatement statement) {
visitStatement(statement);
super.visitTryCatchFinally(statement);
}
+ @Override
public void visitWhileLoop(WhileStatement loop) {
visitStatement(loop);
super.visitWhileLoop(loop);
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
index c2f76ce..f4876f8 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassHelper.java
@@ -132,15 +132,13 @@ 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));
-
VMPluginFactory.getPlugin().setAdditionalClassInformation(classNode);
}
-
return classNode;
}
@@ -205,7 +203,6 @@ public class ClassHelper {
}
}
-
/**
* Creates a ClassNode using a given class.
* Unlike make(String) this method will not use the cache
@@ -301,7 +298,6 @@ public class ClassHelper {
return cn;
}
-
/**
* Test to determine if a ClassNode is a primitive type.
* Note: this only works for ClassNodes created using a
diff --git a/src/main/java/org/codehaus/groovy/ast/ClassNode.java
b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
index 747c566..dff7f64 100644
--- a/src/main/java/org/codehaus/groovy/ast/ClassNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ClassNode.java
@@ -106,6 +106,7 @@ import java.util.Set;
public class ClassNode extends AnnotatedNode implements Opcodes {
private static class MapOfLists {
private Map<Object, List<MethodNode>> map;
+
public List<MethodNode> get(Object key) {
return map == null ? null : map.get(key);
}
@@ -170,18 +171,18 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
// clazz!=null when resolved
protected Class clazz;
// only false when this classNode is constructed from a class
- private volatile boolean lazyInitDone=true;
+ private volatile boolean lazyInitDone = true;
// not null if if the ClassNode is an array
- private ClassNode componentType = null;
+ private ClassNode componentType;
// if not null this instance is handled as proxy
// for the redirect
- private ClassNode redirect=null;
+ private ClassNode redirect;
// flag if the classes or its members are annotated
private boolean annotated;
// type spec for generics
- private GenericsType[] genericsTypes=null;
- private boolean usesGenerics=false;
+ private GenericsType[] genericsTypes;
+ private boolean usesGenerics;
// if set to true the name getGenericsTypes consists
// of 1 element describing the name of the placeholder
@@ -190,8 +191,8 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
/**
* Returns the ClassNode this ClassNode is redirecting to.
*/
- public ClassNode redirect(){
- if (redirect==null) return this;
+ public ClassNode redirect() {
+ if (redirect == null) return this;
return redirect.redirect();
}
@@ -257,12 +258,10 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
* ClassNode will not be a primary ClassNode.
*/
public ClassNode(Class c) {
- this(c.getName(), c.getModifiers(), null, null ,MixinNode.EMPTY_ARRAY);
- clazz=c;
- lazyInitDone=false;
- CompileUnit cu = getCompileUnit();
- if (cu!=null) cu.addClass(this);
- isPrimaryNode=false;
+ this(c.getName(), c.getModifiers(), null, null, MixinNode.EMPTY_ARRAY);
+ clazz = c;
+ lazyInitDone = false;
+ isPrimaryNode = false;
}
/**
@@ -364,7 +363,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
if (redirect!=null) return redirect().getFields();
lazyClassInit();
if (fields == null)
- fields = new LinkedList<FieldNode> ();
+ fields = new LinkedList<FieldNode>();
return fields;
}
@@ -412,20 +411,17 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
result.add(method);
}
}
-
- if (result.isEmpty()) {
- return null;
- } else {
+ if (!result.isEmpty()) {
return result;
}
-
+ return null;
}
public List<MethodNode> getAllDeclaredMethods() {
return new ArrayList<MethodNode>(getDeclaredMethodsMap().values());
}
- public Set<ClassNode> getAllInterfaces () {
+ public Set<ClassNode> getAllInterfaces() {
Set<ClassNode> res = new LinkedHashSet<ClassNode>();
getAllInterfaces(res);
return res;
@@ -476,7 +472,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
public List<PropertyNode> getProperties() {
final ClassNode r = redirect();
if (r.properties == null)
- r.properties = new ArrayList<PropertyNode> ();
+ r.properties = new ArrayList<PropertyNode>();
return r.properties;
}
@@ -484,7 +480,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
if (redirect != null) return redirect().getDeclaredConstructors();
lazyClassInit();
if (constructors == null)
- constructors = new ArrayList<ConstructorNode> ();
+ constructors = new ArrayList<ConstructorNode>();
return constructors;
}
@@ -552,12 +548,8 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
public void addProperty(PropertyNode node) {
node.setDeclaringClass(redirect());
- FieldNode field = node.getField();
- addField(field);
- final ClassNode r = redirect();
- if (r.properties == null)
- r.properties = new ArrayList<PropertyNode> ();
- r.properties.add(node);
+ getProperties().add(node);
+ addField(node.getField());
}
public PropertyNode addProperty(String name,
@@ -601,7 +593,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
node.setDeclaringClass(this);
final ClassNode r = redirect();
if (r.constructors == null)
- r.constructors = new ArrayList<ConstructorNode> ();
+ r.constructors = new ArrayList<ConstructorNode>();
r.constructors.add(node);
}
@@ -712,11 +704,12 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
}
}
- public boolean equals(Object o) {
- if (redirect!=null) return redirect().equals(o);
- if (!(o instanceof ClassNode)) return false;
- ClassNode cn = (ClassNode) o;
- return (cn.getText().equals(getText()));
+ public boolean equals(Object that) {
+ if (that == this) return true;
+ if (!(that instanceof ClassNode)) return false;
+ if (redirect != null) return redirect.equals(that);
+ if (componentType != null) return componentType.equals(((ClassNode)
that).componentType);
+ return ((ClassNode) that).getText().equals(getText()); // arrays could
be "T[]" or "[LT;"
}
public int hashCode() {
@@ -812,7 +805,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
public List<Statement> getObjectInitializerStatements() {
if (objectInitializers == null)
- objectInitializers = new LinkedList<Statement> ();
+ objectInitializers = new LinkedList<Statement>();
return objectInitializers;
}
@@ -1112,8 +1105,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
boolean booleanReturnOnly = getterName.startsWith("is");
for (MethodNode method : getDeclaredMethods(getterName)) {
if (getterName.equals(method.getName())
- && ClassHelper.VOID_TYPE!=method.getReturnType()
- && method.getParameters().length == 0
+ && method.getParameters().length == 0 &&
!method.isVoidMethod()
&& (!booleanReturnOnly ||
ClassHelper.Boolean_TYPE.equals(ClassHelper.getWrapper(method.getReturnType()))))
{
// GROOVY-7363: There can be multiple matches for a getter
returning a generic parameter type, due to
// the generation of a bridge method. The real getter is
really the non-bridge, non-synthetic one as it
@@ -1139,14 +1131,13 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
public MethodNode getSetterMethod(String setterName, boolean voidOnly) {
for (MethodNode method : getDeclaredMethods(setterName)) {
if (setterName.equals(method.getName())
- && (!voidOnly ||
ClassHelper.VOID_TYPE==method.getReturnType())
- && method.getParameters().length == 1) {
+ && method.getParameters().length == 1
+ && (!voidOnly || method.isVoidMethod())) {
return method;
}
}
ClassNode parent = getSuperClass();
- if (parent!=null) return parent.getSetterMethod(setterName, voidOnly);
- return null;
+ return (parent != null ? parent.getSetterMethod(setterName, voidOnly)
: null);
}
/**
@@ -1312,7 +1303,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
private boolean hasExactMatchingCompatibleType(MethodNode current,
MethodNode newCandidate, int i) {
int lastParamIndex = newCandidate.getParameters().length - 1;
return (i <= lastParamIndex &&
current.getParameters()[i].getType().equals(newCandidate.getParameters()[i].getType()))
- || (i >= lastParamIndex && isPotentialVarArg(newCandidate,
lastParamIndex) &&
current.getParameters()[i].getType().equals(newCandidate.getParameters()[lastParamIndex].getType().componentType));
+ || (i >= lastParamIndex && isPotentialVarArg(newCandidate,
lastParamIndex) &&
current.getParameters()[i].getType().equals(newCandidate.getParameters()[lastParamIndex].getType().getComponentType()));
}
private boolean hasCompatibleType(TupleExpression args, MethodNode method,
int i) {
@@ -1341,12 +1332,12 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
return ClassNodeUtils.hasPossibleStaticMethod(this, name, arguments,
false);
}
- public boolean isInterface(){
- return (getModifiers() & Opcodes.ACC_INTERFACE) > 0;
+ public boolean isInterface() {
+ return (getModifiers() & ACC_INTERFACE) != 0;
}
- public boolean isAbstract(){
- return (getModifiers() & Opcodes.ACC_ABSTRACT) > 0;
+ public boolean isAbstract() {
+ return (getModifiers() & ACC_ABSTRACT) != 0;
}
public boolean isResolved() {
@@ -1355,8 +1346,8 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
return componentType != null && componentType.isResolved();
}
- public boolean isArray(){
- return componentType!=null;
+ public boolean isArray() {
+ return (componentType != null);
}
public ClassNode getComponentType() {
@@ -1370,19 +1361,19 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
* a new class node using {@link #getPlainNodeReference()}.
* @return the class this classnode relates to. May return null.
*/
- public Class getTypeClass(){
+ public Class getTypeClass() {
if (clazz != null) return clazz;
if (redirect != null) return redirect.getTypeClass();
ClassNode component = redirect().componentType;
- if (component!=null && component.isResolved()){
+ if (component != null && component.isResolved()) {
return Array.newInstance(component.getTypeClass(), 0).getClass();
}
- throw new GroovyBugError("ClassNode#getTypeClass for "+getName()+" is
called before the type class is set ");
+ throw new GroovyBugError("ClassNode#getTypeClass for " + getName() + "
called before the type class is set");
}
- public boolean hasPackageName(){
- return redirect().name.indexOf('.')>0;
+ public boolean hasPackageName() {
+ return redirect().name.indexOf('.') > 0;
}
/**
@@ -1425,18 +1416,17 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
public ClassNode getPlainNodeReference() {
if (ClassHelper.isPrimitiveType(this)) return this;
- ClassNode n = new ClassNode(name, modifiers, superClass,null,null);
+ ClassNode n = new ClassNode(name, modifiers, superClass, null, null);
n.isPrimaryNode = false;
n.setRedirect(redirect());
if (isArray()) {
n.componentType = redirect().getComponentType();
- }
+ }
return n;
}
public boolean isAnnotationDefinition() {
- return /* redirect().isPrimaryNode && */
- isInterface() && (getModifiers() & Opcodes.ACC_ANNOTATION) !=
0;
+ return isInterface() && (getModifiers() & ACC_ANNOTATION) != 0;
}
public List<AnnotationNode> getAnnotations() {
@@ -1468,25 +1458,25 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
}
public void renameField(String oldName, String newName) {
- ClassNode r = redirect ();
+ ClassNode r = redirect();
if (r.fieldIndex == null)
- r.fieldIndex = new LinkedHashMap<String,FieldNode> ();
+ r.fieldIndex = new LinkedHashMap<String,FieldNode>();
final Map<String,FieldNode> index = r.fieldIndex;
index.put(newName, index.remove(oldName));
}
public void removeField(String oldName) {
- ClassNode r = redirect ();
+ ClassNode r = redirect();
if (r.fieldIndex == null)
- r.fieldIndex = new LinkedHashMap<String,FieldNode> ();
+ r.fieldIndex = new LinkedHashMap<String,FieldNode>();
final Map<String,FieldNode> index = r.fieldIndex;
r.fields.remove(index.get(oldName));
index.remove(oldName);
}
public boolean isEnum() {
- return (getModifiers()&Opcodes.ACC_ENUM) != 0;
- }
+ return (getModifiers() & ACC_ENUM) != 0;
+ }
/**
* @return iterator of inner classes defined inside this one
@@ -1496,7 +1486,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
}
private Map<CompilePhase, Map<Class<? extends ASTTransformation>,
Set<ASTNode>>> getTransformInstances() {
- if(transformInstances == null){
+ if (transformInstances == null) {
transformInstances = new EnumMap<CompilePhase, Map<Class <?
extends ASTTransformation>, Set<ASTNode>>>(CompilePhase.class);
for (CompilePhase phase : CompilePhase.values()) {
transformInstances.put(phase, new LinkedHashMap<Class <?
extends ASTTransformation>, Set<ASTNode>>());
@@ -1506,7 +1496,7 @@ public class ClassNode extends AnnotatedNode implements
Opcodes {
}
public boolean isRedirectNode() {
- return redirect!=null;
+ return (redirect != null);
}
@Override
diff --git a/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java
b/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java
index 3c9d111..0820d55 100644
--- a/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java
+++ b/src/main/java/org/codehaus/groovy/ast/CodeVisitorSupport.java
@@ -317,12 +317,7 @@ public abstract class CodeVisitorSupport implements
GroovyCodeVisitor {
protected void visitListOfExpressions(List<? extends Expression> list) {
if (list == null) return;
for (Expression expression : list) {
- if (expression instanceof SpreadExpression) {
- Expression spread = ((SpreadExpression)
expression).getExpression();
- spread.visit(this);
- } else {
- expression.visit(this);
- }
+ expression.visit(this);
}
}
diff --git a/src/main/java/org/codehaus/groovy/ast/CompileUnit.java
b/src/main/java/org/codehaus/groovy/ast/CompileUnit.java
index 5758fea..84c6be4 100644
--- a/src/main/java/org/codehaus/groovy/ast/CompileUnit.java
+++ b/src/main/java/org/codehaus/groovy/ast/CompileUnit.java
@@ -20,7 +20,6 @@ package org.codehaus.groovy.ast;
import groovy.lang.GroovyClassLoader;
import org.codehaus.groovy.GroovyBugError;
-import groovy.transform.Internal;
import org.codehaus.groovy.control.CompilerConfiguration;
import org.codehaus.groovy.control.SourceUnit;
import org.codehaus.groovy.control.messages.SyntaxErrorMessage;
@@ -46,16 +45,16 @@ import java.util.Map;
*/
public class CompileUnit {
- private final List<ModuleNode> modules = new ArrayList<ModuleNode>();
- private final Map<String, ClassNode> classes = new HashMap<String,
ClassNode>();
+ private final List<ModuleNode> modules = new ArrayList<>();
+ private final Map<String, ClassNode> classes = new HashMap<>();
private final CompilerConfiguration config;
private final GroovyClassLoader classLoader;
private final CodeSource codeSource;
- private final Map<String, ClassNode> classesToCompile = new
HashMap<String, ClassNode>();
- private final Map<String, SourceUnit> classNameToSource = new
HashMap<String, SourceUnit>();
- private final Map<String, InnerClassNode> generatedInnerClasses = new
HashMap();
- private final Map<String, ConstructedOuterNestedClassNode>
classesToResolve = new HashMap<>();
- private ListHashMap metaDataMap = null;
+ private final Map<String, ClassNode> classesToCompile = new HashMap<>();
+ private final Map<String, SourceUnit> classNameToSource = new HashMap<>();
+ private final Map<String, InnerClassNode> generatedInnerClasses = new
HashMap<>();
+
+ private ListHashMap metaDataMap;
public CompileUnit(GroovyClassLoader classLoader, CompilerConfiguration
config) {
this(classLoader, null, config);
@@ -171,49 +170,36 @@ public class CompileUnit {
classNameToSource.put(node.getName(), location);
}
- public SourceUnit getScriptSourceLocation(String className) {
- return classNameToSource.get(className);
+ @Deprecated
+ public Map<String, ClassNode> getClassesToCompile() {
+ return classesToCompile;
+ }
+
+ public Iterator<String> iterateClassNodeToCompile() {
+ return classesToCompile.keySet().iterator();
}
public boolean hasClassNodeToCompile() {
return !classesToCompile.isEmpty();
}
- public Iterator<String> iterateClassNodeToCompile() {
- return classesToCompile.keySet().iterator();
+ public void addGeneratedInnerClass(InnerClassNode icn) {
+ generatedInnerClasses.put(icn.getName(), icn);
}
public InnerClassNode getGeneratedInnerClass(String name) {
return generatedInnerClasses.get(name);
}
-
- public void addGeneratedInnerClass(InnerClassNode icn) {
- generatedInnerClasses.put(icn.getName(), icn);
- }
public Map<String, InnerClassNode> getGeneratedInnerClasses() {
return Collections.unmodifiableMap(generatedInnerClasses);
}
- public Map<String, ClassNode> getClassesToCompile() {
- return classesToCompile;
- }
-
- public Map<String, ConstructedOuterNestedClassNode> getClassesToResolve() {
- return classesToResolve;
+ public SourceUnit getScriptSourceLocation(String scriptClassName) {
+ return classNameToSource.get(scriptClassName);
}
/**
- * Add a constructed class node as a placeholder to resolve outer nested
class further.
- *
- * @param cn the constructed class node
- */
- public void addClassNodeToResolve(ConstructedOuterNestedClassNode cn) {
- classesToResolve.put(cn.getUnresolvedName(), cn);
- }
-
-
- /**
* Gets the node meta data for the provided key.
*
* @param key - the meta data key
@@ -288,12 +274,27 @@ public class CompileUnit {
return metaDataMap;
}
+
//--------------------------------------------------------------------------
+
+ private final Map<String, ConstructedOuterNestedClassNode>
classesToResolve = new HashMap<>();
+
+ /**
+ * Add a constructed class node as a placeholder to resolve outer nested
class further.
+ *
+ * @param cn the constructed class node
+ */
+ public void addClassNodeToResolve(ConstructedOuterNestedClassNode cn) {
+ classesToResolve.put(cn.getUnresolvedName(), cn);
+ }
+ public Map<String, ConstructedOuterNestedClassNode> getClassesToResolve() {
+ return classesToResolve;
+ }
/**
* Represents a resolved type as a placeholder, SEE GROOVY-7812
*/
- @Internal
+ @groovy.transform.Internal
public static class ConstructedOuterNestedClassNode extends ClassNode {
private final ClassNode enclosingClassNode;
diff --git a/src/main/java/org/codehaus/groovy/ast/GenericsType.java
b/src/main/java/org/codehaus/groovy/ast/GenericsType.java
index 276bfd8..c67db97 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 @@ import static
org.codehaus.groovy.ast.ClassHelper.GROOVY_OBJECT_TYPE;
*/
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;
@@ -62,13 +62,12 @@ public class GenericsType extends ASTNode {
return type;
}
- public void setType(final ClassNode type) {
- this.type = type;
+ public void setType(ClassNode type) {
+ this.type = type;
}
public String toString() {
- Set<String> visited = new HashSet<String>();
- return toString(visited);
+ return toString(new HashSet<String>());
}
private String toString(Set<String> visited) {
@@ -102,7 +101,6 @@ public class GenericsType extends ASTNode {
}
private String genericsBounds(ClassNode theType, Set<String> visited) {
-
StringBuilder ret = new StringBuilder();
if (theType.isArray()) {
@@ -344,7 +342,10 @@ public class GenericsType extends ASTNode {
// class node are not parameterized. This means
that we must create a
// new class node with the parameterized types
that the current class node
// has defined.
- ClassNode node =
GenericsUtils.parameterizeType(classNode, anInterface);
+ ClassNode node = anInterface;
+ if (node.getGenericsTypes() != null) {
+ node =
GenericsUtils.parameterizeType(classNode, node);
+ }
return compareGenericsWithBound(node, bound);
}
}
diff --git a/src/main/java/org/codehaus/groovy/ast/ImportNode.java
b/src/main/java/org/codehaus/groovy/ast/ImportNode.java
index b011104..df249bb 100644
--- a/src/main/java/org/codehaus/groovy/ast/ImportNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ImportNode.java
@@ -28,7 +28,6 @@ public class ImportNode extends AnnotatedNode implements
Opcodes {
private final ClassNode type;
private final String alias;
private final String fieldName;
- // TODO use PackageNode instead here?
private final String packageName;
private final boolean isStar;
private final boolean isStatic;
@@ -104,12 +103,12 @@ public class ImportNode extends AnnotatedNode implements
Opcodes {
return "import static " + typeName + ".*";
}
if (isStatic) {
- if (alias != null && alias.length() != 0 &&
!alias.equals(fieldName)) {
+ if (alias != null && !alias.isEmpty() && !alias.equals(fieldName))
{
return "import static " + typeName + "." + fieldName + " as "
+ alias;
}
return "import static " + typeName + "." + fieldName;
}
- if (alias == null || alias.length() == 0) {
+ if (alias == null || alias.isEmpty()) {
return "import " + typeName;
}
return "import " + typeName + " as " + alias;
diff --git a/src/main/java/org/codehaus/groovy/ast/MethodNode.java
b/src/main/java/org/codehaus/groovy/ast/MethodNode.java
index 8ce5415..aa844b5 100644
--- a/src/main/java/org/codehaus/groovy/ast/MethodNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/MethodNode.java
@@ -27,7 +27,7 @@ import java.lang.reflect.Modifier;
import java.util.List;
/**
- * Represents a method declaration
+ * Represents a method declaration.
*/
public class MethodNode extends AnnotatedNode implements Opcodes {
@@ -37,7 +37,7 @@ public class MethodNode extends AnnotatedNode implements
Opcodes {
private boolean syntheticPublic;
private ClassNode returnType;
private Parameter[] parameters;
- private boolean hasDefaultValue = false;
+ private boolean hasDefaultValue;
private Statement code;
private boolean dynamicReturnType;
private VariableScope variableScope;
@@ -45,7 +45,7 @@ public class MethodNode extends AnnotatedNode implements
Opcodes {
private boolean staticConstructor;
// type spec for generics
- private GenericsType[] genericsTypes = null;
+ private GenericsType[] genericsTypes;
private boolean hasDefault;
// cached data
@@ -56,12 +56,11 @@ public class MethodNode extends AnnotatedNode implements
Opcodes {
public MethodNode(String name, int modifiers, ClassNode returnType,
Parameter[] parameters, ClassNode[] exceptions, Statement code) {
this.name = name;
this.modifiers = modifiers;
+ this.exceptions = exceptions;
this.code = code;
setReturnType(returnType);
setParameters(parameters);
- this.hasDefault = false;
- this.exceptions = exceptions;
- this.staticConstructor = (name != null && name.equals("<clinit>"));
+ this.staticConstructor = "<clinit>".equals(name);
}
/**
@@ -83,7 +82,7 @@ public class MethodNode extends AnnotatedNode implements
Opcodes {
}
public boolean isVoidMethod() {
- return returnType == ClassHelper.VOID_TYPE;
+ return ClassHelper.VOID_TYPE.equals(getReturnType());
}
public Statement getCode() {
@@ -114,6 +113,7 @@ public class MethodNode extends AnnotatedNode implements
Opcodes {
public void setParameters(Parameter[] parameters) {
invalidateCachedData();
VariableScope scope = new VariableScope();
+ this.hasDefaultValue = false;
this.parameters = parameters;
if (parameters != null && parameters.length > 0) {
for (Parameter para : parameters) {
@@ -174,7 +174,7 @@ public class MethodNode extends AnnotatedNode implements
Opcodes {
}
public boolean isPackageScope() {
- return !(this.isPrivate() || this.isProtected() || this.isPublic());
+ return (modifiers & (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)) == 0;
}
public boolean hasDefaultValue() {
@@ -193,7 +193,7 @@ public class MethodNode extends AnnotatedNode implements
Opcodes {
* @see ModuleNode createStatementsClass().
*/
public void setIsScriptBody() {
- setNodeMetaData(SCRIPT_BODY_METHOD_KEY, true);
+ setNodeMetaData(SCRIPT_BODY_METHOD_KEY, Boolean.TRUE);
}
public String toString() {
diff --git a/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
b/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
index f5e68c5..88d16c1 100644
--- a/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
+++ b/src/main/java/org/codehaus/groovy/ast/ModuleNode.java
@@ -23,6 +23,7 @@ import org.codehaus.groovy.ast.expr.ArgumentListExpression;
import org.codehaus.groovy.ast.expr.ClassExpression;
import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
import org.codehaus.groovy.ast.expr.MethodCallExpression;
+import org.codehaus.groovy.ast.expr.StaticMethodCallExpression;
import org.codehaus.groovy.ast.expr.VariableExpression;
import org.codehaus.groovy.ast.stmt.BlockStatement;
import org.codehaus.groovy.ast.stmt.ExpressionStatement;
@@ -52,39 +53,32 @@ import java.util.Map;
*/
public class ModuleNode extends ASTNode implements Opcodes {
- private final BlockStatement statementBlock = new BlockStatement();
- List<ClassNode> classes = new LinkedList<ClassNode>();
- private final List<MethodNode> methods = new ArrayList<MethodNode>();
- private final Map<String, ImportNode> imports = new HashMap<String,
ImportNode>();
- private final List<ImportNode> starImports = new ArrayList<ImportNode>();
- private final Map<String, ImportNode> staticImports = new
LinkedHashMap<String, ImportNode>();
- private final Map<String, ImportNode> staticStarImports = new
LinkedHashMap<String, ImportNode>();
+ private List<ClassNode> classes = new LinkedList<>();
+ private final List<MethodNode> methods = new ArrayList<>();
+ private final Map<String, ImportNode> imports = new HashMap<>();
+ private final List<ImportNode> starImports = new ArrayList<>();
+ private final Map<String, ImportNode> staticImports = new
LinkedHashMap<>();
+ private final Map<String, ImportNode> staticStarImports = new
LinkedHashMap<>();
private CompileUnit unit;
private PackageNode packageNode;
private String description;
private boolean createClassForStatements = true;
private transient SourceUnit context;
- private boolean importsResolved = false;
+ private boolean importsResolved;
private ClassNode scriptDummy;
- private String mainClassName = null;
+ private String mainClassName;
+ private final BlockStatement statementBlock = new BlockStatement();
+
private final Parameter[] SCRIPT_CONTEXT_CTOR = {new
Parameter(ClassHelper.BINDING_TYPE, "context")};
- public ModuleNode (SourceUnit context ) {
+ public ModuleNode(SourceUnit context) {
this.context = context;
}
- public ModuleNode (CompileUnit unit) {
+ public ModuleNode(CompileUnit unit) {
this.unit = unit;
}
- public BlockStatement getStatementBlock() {
- return statementBlock;
- }
-
- public List<MethodNode> getMethods() {
- return methods;
- }
-
public List<ClassNode> getClasses() {
if (createClassForStatements && (!statementBlock.isEmpty() ||
!methods.isEmpty() || isPackageInfo())) {
ClassNode mainClass = createStatementsClass();
@@ -97,25 +91,33 @@ public class ModuleNode extends ASTNode implements Opcodes {
return classes;
}
- private boolean isPackageInfo() {
- return context != null && context.getName() != null &&
context.getName().endsWith("package-info.groovy");
+ public List<MethodNode> getMethods() {
+ return methods;
}
public List<ImportNode> getImports() {
- return new ArrayList<ImportNode>(imports.values());
+ return new ArrayList<>(imports.values());
}
public List<ImportNode> getStarImports() {
return starImports;
}
+ public Map<String, ImportNode> getStaticImports() {
+ return staticImports;
+ }
+
+ public Map<String, ImportNode> getStaticStarImports() {
+ return staticStarImports;
+ }
+
/**
* @param alias the name of interest
- * @return the class node for the given alias or null if none is available
+ * @return the import type for the given alias or null if none is available
*/
public ClassNode getImportType(String alias) {
ImportNode importNode = imports.get(alias);
- return importNode == null ? null : importNode.getType();
+ return (importNode != null ? importNode.getType() : null);
}
/**
@@ -127,33 +129,61 @@ public class ModuleNode extends ASTNode implements
Opcodes {
}
public void addImport(String alias, ClassNode type) {
- addImport(alias, type, new ArrayList<AnnotationNode>());
+ addImport(alias, type, Collections.<AnnotationNode>emptyList());
}
public void addImport(String alias, ClassNode type, List<AnnotationNode>
annotations) {
ImportNode importNode = new ImportNode(type, alias);
- imports.put(alias, importNode);
importNode.addAnnotations(annotations);
+ imports.put(alias, importNode);
+
storeLastAddedImportNode(importNode);
}
public void addStarImport(String packageName) {
- addStarImport(packageName, new ArrayList<AnnotationNode>());
+ addStarImport(packageName, Collections.<AnnotationNode>emptyList());
}
public void addStarImport(String packageName, List<AnnotationNode>
annotations) {
ImportNode importNode = new ImportNode(packageName);
importNode.addAnnotations(annotations);
starImports.add(importNode);
+
storeLastAddedImportNode(importNode);
}
+ public void addStaticImport(ClassNode type, String fieldName, String
alias) {
+ addStaticImport(type, fieldName, alias,
Collections.<AnnotationNode>emptyList());
+ }
+
+ public void addStaticImport(ClassNode type, String fieldName, String
alias, List<AnnotationNode> annotations) {
+ ImportNode node = new ImportNode(type, fieldName, alias);
+ node.addAnnotations(annotations);
+ ImportNode prev = staticImports.put(alias, node);
+ if (prev != null) staticImports.put(prev.toString(), prev);
+
+ storeLastAddedImportNode(node);
+ }
+
+ public void addStaticStarImport(String name, ClassNode type) {
+ addStaticStarImport(name, type,
Collections.<AnnotationNode>emptyList());
+ }
+
+ public void addStaticStarImport(String name, ClassNode type,
List<AnnotationNode> annotations) {
+ ImportNode node = new ImportNode(type);
+ node.addAnnotations(annotations);
+ staticStarImports.put(name, node);
+
+ storeLastAddedImportNode(node);
+ }
+
public void addStatement(Statement node) {
statementBlock.addStatement(node);
}
public void addClass(ClassNode node) {
- if(classes.isEmpty()) mainClassName = node.getName();
+ if (classes.isEmpty())
+ mainClassName = node.getName();
classes.add(node);
node.setModule(this);
addToCompileUnit(node);
@@ -174,46 +204,41 @@ public class ModuleNode extends ASTNode implements
Opcodes {
}
public String getPackageName() {
- return packageNode == null ? null : packageNode.getName();
+ return (hasPackage() ? packageNode.getName() : null);
}
public PackageNode getPackage() {
return packageNode;
}
- // TODO don't allow override?
public void setPackage(PackageNode packageNode) {
this.packageNode = packageNode;
}
- // TODO don't allow override?
public void setPackageName(String packageName) {
this.packageNode = new PackageNode(packageName);
}
- public boolean hasPackageName(){
- return packageNode != null && packageNode.getName() != null;
+ public boolean hasPackageName() {
+ return (packageNode != null && packageNode.getName() != null);
}
- public boolean hasPackage(){
- return this.packageNode != null;
+ public boolean hasPackage() {
+ return (packageNode != null);
}
- public SourceUnit getContext() {
- return context;
+ private boolean isPackageInfo() {
+ return (context != null && context.getName() != null &&
context.getName().endsWith("package-info.groovy"));
}
/**
* @return the underlying character stream description
*/
public String getDescription() {
- if( context != null )
- {
+ if (context != null) {
return context.getName();
- }
- else
- {
- return this.description;
+ } else {
+ return description;
}
}
@@ -221,6 +246,10 @@ public class ModuleNode extends ASTNode implements Opcodes
{
this.description = description;
}
+ public SourceUnit getContext() {
+ return context;
+ }
+
public CompileUnit getUnit() {
return unit;
}
@@ -230,7 +259,7 @@ public class ModuleNode extends ASTNode implements Opcodes {
}
public ClassNode getScriptClassDummy() {
- if (scriptDummy!=null) {
+ if (scriptDummy != null) {
setScriptBaseClassFromConfig(scriptDummy);
return scriptDummy;
}
@@ -275,6 +304,12 @@ public class ModuleNode extends ASTNode implements Opcodes
{
}
}
+ private static Parameter[] finalParam(final ClassNode type, final String
name) {
+ Parameter parameter = new Parameter(type, name);
+ parameter.setModifiers(ACC_FINAL);
+ return new Parameter[]{parameter};
+ }
+
protected ClassNode createStatementsClass() {
ClassNode classNode = getScriptClassDummy();
if (classNode.getName().endsWith("package-info")) {
@@ -283,21 +318,25 @@ public class ModuleNode extends ASTNode implements
Opcodes {
handleMainMethodIfPresent(methods);
- // return new Foo(new ShellContext(args)).run()
classNode.addMethod(
new MethodNode(
"main",
ACC_PUBLIC | ACC_STATIC,
ClassHelper.VOID_TYPE,
- new Parameter[] { new
Parameter(ClassHelper.STRING_TYPE.makeArray(), "args")},
+ finalParam(ClassHelper.STRING_TYPE.makeArray(), "args"),
ClassNode.EMPTY_ARRAY,
new ExpressionStatement(
- new MethodCallExpression(
- new
ClassExpression(ClassHelper.make(InvokerHelper.class)),
+ new StaticMethodCallExpression(
+ ClassHelper.make(InvokerHelper.class),
"runScript",
new ArgumentListExpression(
- new ClassExpression(classNode),
- new VariableExpression("args"))))));
+ new ClassExpression(classNode),
+ new VariableExpression("args")
+ )
+ )
+ )
+ )
+ );
MethodNode methodNode = new MethodNode("run", ACC_PUBLIC,
ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY,
statementBlock);
methodNode.setIsScriptBody();
@@ -306,12 +345,13 @@ public class ModuleNode extends ASTNode implements
Opcodes {
classNode.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY,
ClassNode.EMPTY_ARRAY, new BlockStatement());
Statement stmt;
- // A script's contextual constructor should call it's super class'
contextual constructor, if it has one.
+ // A script's contextual constructor should call its super class'
contextual constructor, if it has one.
// In practice this will always be true because currently this visitor
is run before the AST transformations
// (like @BaseScript) that could change this. But this is cautious
and anticipates possible compiler changes.
if
(classNode.getSuperClass().getDeclaredConstructor(SCRIPT_CONTEXT_CTOR) != null)
{
stmt = new ExpressionStatement(
- new ConstructorCallExpression(ClassNode.SUPER,
+ new ConstructorCallExpression(
+ ClassNode.SUPER,
new ArgumentListExpression(
new VariableExpression("context"))));
} else {
@@ -326,22 +366,16 @@ public class ModuleNode extends ASTNode implements
Opcodes {
classNode.addConstructor(
ACC_PUBLIC,
- new Parameter[] { new Parameter(ClassHelper.make(Binding.class),
"context")},
+ finalParam(ClassHelper.make(Binding.class), "context"),
ClassNode.EMPTY_ARRAY,
stmt);
- for (MethodNode node : methods) {
- int modifiers = node.getModifiers();
- if ((modifiers & ACC_ABSTRACT) != 0) {
- throw new RuntimeException(
- "Cannot use abstract methods in a script, they are only
available inside classes. Method: "
- + node.getName());
+ for (MethodNode method : methods) {
+ if (method.isAbstract()) {
+ throw new RuntimeException("Cannot use abstract methods in a
script" +
+ ", they are only available inside classes. Method: " +
method.getName());
}
- // br: the old logic seems to add static to all def f().... in a
script, which makes enclosing
- // inner classes (including closures) in a def function difficult.
Comment it out.
- node.setModifiers(modifiers /*| ACC_STATIC*/);
-
- classNode.addMethod(node);
+ classNode.addMethod(method);
}
return classNode;
}
@@ -349,11 +383,11 @@ public class ModuleNode extends ASTNode implements
Opcodes {
/*
* If a main method is provided by user, account for it under run() as
scripts generate their own 'main' so they can run.
*/
- private void handleMainMethodIfPresent(List methods) {
+ private void handleMainMethodIfPresent(List<MethodNode> methods) {
boolean found = false;
- for (Iterator iter = methods.iterator(); iter.hasNext();) {
- MethodNode node = (MethodNode) iter.next();
- if(node.getName().equals("main")) {
+ for (Iterator<MethodNode> iter = methods.iterator(); iter.hasNext(); )
{
+ MethodNode node = iter.next();
+ if (node.getName().equals("main")) {
if (node.isStatic() && node.getParameters().length == 1) {
boolean retTypeMatches, argTypeMatches;
ClassNode argType = node.getParameters()[0].getType();
@@ -368,7 +402,7 @@ public class ModuleNode extends ASTNode implements Opcodes {
found = true;
}
// if script has both loose statements as well as
main(), then main() is ignored
- if(statementBlock.isEmpty()) {
+ if (statementBlock.isEmpty()) {
addStatement(node.getCode());
}
iter.remove();
@@ -415,19 +449,18 @@ public class ModuleNode extends ASTNode implements
Opcodes {
public void sortClasses() {
if (isEmpty()) return;
- List<ClassNode> classes = getClasses();
- LinkedList<ClassNode> sorted = new LinkedList<ClassNode>();
- int level=1;
- while (!classes.isEmpty()) {
- for (Iterator<ClassNode> cni = classes.iterator(); cni.hasNext();)
{
- ClassNode cn = cni.next();
- ClassNode sn = cn;
- for (int i=0; sn!=null && i<level; i++) sn =
sn.getSuperClass();
- if (sn!=null && sn.isPrimaryClassNode()) continue;
- cni.remove();
- sorted.addLast(cn);
+ List<ClassNode> sorted = new LinkedList<>(), todo = getClasses();
+ int level = 1;
+ while (!todo.isEmpty()) {
+ for (Iterator<ClassNode> it = todo.iterator(); it.hasNext(); ) {
+ ClassNode cn = it.next(), sc = cn;
+
+ for (int i = 0; sc != null && i < level; i += 1) sc =
sc.getSuperClass();
+ if (sc != null && sc.isPrimaryClassNode()) continue;
+ sorted.add(cn);
+ it.remove();
}
- level++;
+ level += 1;
}
this.classes = sorted;
}
@@ -440,41 +473,10 @@ public class ModuleNode extends ASTNode implements
Opcodes {
this.importsResolved = importsResolved;
}
- public Map<String, ImportNode> getStaticImports() {
- return staticImports;
- }
-
- public Map<String, ImportNode> getStaticStarImports() {
- return staticStarImports;
- }
-
- public void addStaticImport(ClassNode type, String fieldName, String
alias) {
- addStaticImport(type, fieldName, alias,
Collections.<AnnotationNode>emptyList());
- }
-
- public void addStaticImport(ClassNode type, String fieldName, String
alias, List<AnnotationNode> annotations) {
- ImportNode node = new ImportNode(type, fieldName, alias);
- node.addAnnotations(annotations);
- ImportNode prev = staticImports.put(alias, node);
- if (prev != null) staticImports.put(prev.toString(), prev);
- storeLastAddedImportNode(node);
- }
-
- public void addStaticStarImport(String name, ClassNode type) {
- addStaticStarImport(name, type,
Collections.<AnnotationNode>emptyList());
- }
-
- public void addStaticStarImport(String name, ClassNode type,
List<AnnotationNode> annotations) {
- ImportNode node = new ImportNode(type);
- node.addAnnotations(annotations);
- staticStarImports.put(name, node);
- storeLastAddedImportNode(node);
- }
-
// This method only exists as a workaround for GROOVY-6094
// In order to keep binary compatibility
private void storeLastAddedImportNode(final ImportNode node) {
- if (getNodeMetaData(ImportNode.class)==ImportNode.class) {
+ if (getNodeMetaData(ImportNode.class) == ImportNode.class) {
putNodeMetaData(ImportNode.class, node);
}
}
@@ -482,4 +484,8 @@ public class ModuleNode extends ASTNode implements Opcodes {
public String getMainClassName() {
return mainClassName;
}
+
+ public BlockStatement getStatementBlock() {
+ return statementBlock;
+ }
}
diff --git a/src/main/java/org/codehaus/groovy/ast/Parameter.java
b/src/main/java/org/codehaus/groovy/ast/Parameter.java
index 102ec47..65bebe1 100644
--- a/src/main/java/org/codehaus/groovy/ast/Parameter.java
+++ b/src/main/java/org/codehaus/groovy/ast/Parameter.java
@@ -20,25 +20,23 @@ package org.codehaus.groovy.ast;
import org.codehaus.groovy.ast.expr.Expression;
-
/**
* Represents a parameter on a constructor or method call. The type name is
* optional - it defaults to java.lang.Object if unknown.
*/
public class Parameter extends AnnotatedNode implements Variable {
- public static final Parameter[] EMPTY_ARRAY = {
- };
+ public static final Parameter[] EMPTY_ARRAY = {};
private ClassNode type;
private final String name;
+ private ClassNode originType;
private boolean dynamicTyped;
+ private boolean closureShare;
private Expression defaultValue;
private boolean hasDefaultValue;
private boolean inStaticContext;
- private boolean closureShare=false;
private int modifiers;
- private ClassNode originType=ClassHelper.DYNAMIC_TYPE;
public Parameter(ClassNode type, String name) {
this.name = name;
@@ -46,7 +44,7 @@ public class Parameter extends AnnotatedNode implements
Variable {
this.originType = type;
this.hasDefaultValue = false;
}
-
+
public Parameter(ClassNode type, String name, Expression defaultValue) {
this(type,name);
this.defaultValue = defaultValue;
@@ -69,11 +67,11 @@ public class Parameter extends AnnotatedNode implements
Variable {
this.type = type;
dynamicTyped |= type==ClassHelper.DYNAMIC_TYPE;
}
-
+
public boolean hasInitialExpression() {
return this.hasDefaultValue;
}
-
+
/**
* @return the default value expression for this parameter or null if
* no default value is specified
@@ -81,16 +79,16 @@ public class Parameter extends AnnotatedNode implements
Variable {
public Expression getInitialExpression() {
return defaultValue;
}
-
+
public void setInitialExpression(Expression init) {
defaultValue = init;
hasDefaultValue = defaultValue != null;
}
-
+
public boolean isInStaticContext() {
return inStaticContext;
}
-
+
public void setInStaticContext(boolean inStaticContext) {
this.inStaticContext = inStaticContext;
}
@@ -104,7 +102,7 @@ public class Parameter extends AnnotatedNode implements
Variable {
}
public void setClosureSharedVariable(boolean inClosure) {
- closureShare = inClosure;
+ closureShare = inClosure;
}
public int getModifiers() {
@@ -114,7 +112,7 @@ public class Parameter extends AnnotatedNode implements
Variable {
public ClassNode getOriginType() {
return originType;
}
-
+
public void setOriginType(ClassNode cn) {
originType = cn;
}
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 1708c10..c4a7139 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.ClassHelper;
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
@@ -34,12 +34,11 @@ public class ConstantExpression extends Expression {
public static final ConstantExpression EMPTY_STRING = new
ConstantExpression("");
public static final ConstantExpression PRIM_TRUE = new
ConstantExpression(Boolean.TRUE, true);
public static final ConstantExpression PRIM_FALSE = new
ConstantExpression(Boolean.FALSE, true);
- //public static final Expression EMPTY_ARRAY = new PropertyExpression(new
ClassExpression(ArgumentListExpression.class.getName()), "EMPTY_ARRAY");
// the following fields are only used internally; there are no
user-defined expressions of the same kind
public static final ConstantExpression VOID = new
ConstantExpression(Void.class);
public static final ConstantExpression EMPTY_EXPRESSION = new
ConstantExpression(null);
-
+
private final Object value;
private String constantName;
@@ -74,7 +73,7 @@ public class ConstantExpression extends Expression {
}
public String toString() {
- return "ConstantExpression[" + value + "]";
+ return super.toString() + "[" + value + "]";
}
public void visit(GroovyCodeVisitor visitor) {
@@ -87,13 +86,13 @@ public class ConstantExpression extends Expression {
/**
* @return the value of this constant expression
- */
+ */
public Object getValue() {
return value;
}
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/ConstructorCallExpression.java
b/src/main/java/org/codehaus/groovy/ast/expr/ConstructorCallExpression.java
index cbd5c7b..11512fb 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/ConstructorCallExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/ConstructorCallExpression.java
@@ -34,6 +34,7 @@ public class ConstructorCallExpression extends Expression
implements MethodCall
super.setType(type);
if (!(arguments instanceof TupleExpression)) {
this.arguments = new TupleExpression(arguments);
+ this.arguments.setSourcePosition(arguments);
} else {
this.arguments = arguments;
}
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 21340d8..f5ecea7 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/EmptyExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/EmptyExpression.java
@@ -21,11 +21,12 @@ package org.codehaus.groovy.ast.expr;
import org.codehaus.groovy.ast.GroovyCodeVisitor;
/**
- * This class is a place holder for an empty expression.
- * Empty expression are used in closures lists like (;). During
- * class Generation this expression should be either ignored or
- * replace with a null value.
- *
+ * This class is a place holder for an empty expression.
+ * <p>
+ * Empty expressions are used in closures lists like (;). During
+ * class generation this expression should be either ignored or
+ * replaced with a null value.
+ *
* @see org.codehaus.groovy.ast.stmt.EmptyStatement
*/
public class EmptyExpression extends Expression {
diff --git a/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java
b/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java
index f0c362a..eb109f3 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/FieldExpression.java
@@ -29,53 +29,59 @@ public class FieldExpression extends Expression {
private final FieldNode field;
private boolean useRef;
-
- public FieldExpression(FieldNode field) {
+
+ public FieldExpression(final FieldNode field) {
this.field = field;
}
-
- public void visit(GroovyCodeVisitor visitor) {
+
+ @Override
+ public void visit(final GroovyCodeVisitor visitor) {
visitor.visitFieldExpression(this);
}
- public Expression transformExpression(ExpressionTransformer transformer) {
+ @Override
+ public Expression transformExpression(final ExpressionTransformer
transformer) {
return this;
}
-
- public String getFieldName() {
- return field.getName();
- }
public FieldNode getField() {
return field;
}
+ public String getFieldName() {
+ return field.getName();
+ }
+
+ @Override
public String getText() {
- return "this." + field.getName();
+ return "this." + getFieldName();
}
- public boolean isDynamicTyped() {
- return field.isDynamicTyped();
+ @Override
+ public ClassNode getType() {
+ return field.getType();
}
- public void setType(ClassNode type) {
+ @Override
+ public void setType(final ClassNode type) {
super.setType(type);
field.setType(type);
}
-
- public ClassNode getType() {
- return field.getType();
- }
-
- public void setUseReferenceDirectly(boolean useRef) {
- this.useRef = useRef;
+
+ public boolean isDynamicTyped() {
+ return field.isDynamicTyped();
}
-
+
public boolean isUseReferenceDirectly() {
return useRef;
}
-
+
+ public void setUseReferenceDirectly(final boolean useRef) {
+ this.useRef = useRef;
+ }
+
+ @Override
public String toString() {
- return "field("+getType()+" "+getFieldName()+")";
+ return "field(" + getType() + " " + getFieldName() + ")";
}
}
diff --git
a/src/main/java/org/codehaus/groovy/ast/expr/MethodCallExpression.java
b/src/main/java/org/codehaus/groovy/ast/expr/MethodCallExpression.java
index f0250a8..e7a6fd5 100644
--- a/src/main/java/org/codehaus/groovy/ast/expr/MethodCallExpression.java
+++ b/src/main/java/org/codehaus/groovy/ast/expr/MethodCallExpression.java
@@ -32,27 +32,27 @@ public class MethodCallExpression extends Expression
implements MethodCall {
private Expression objectExpression;
private Expression method;
private Expression arguments;
- private boolean spreadSafe = false;
- private boolean safe = false;
+ private boolean safe;
+ private boolean spreadSafe;
private boolean implicitThis;
-
+ private boolean usesGenerics;
// type spec for generics
- private GenericsType[] genericsTypes = null;
- private boolean usesGenerics = false;
+ private GenericsType[] genericsTypes;
private MethodNode target;
public static final Expression NO_ARGUMENTS = new TupleExpression();
public MethodCallExpression(Expression objectExpression, String method,
Expression arguments) {
- this(objectExpression,new ConstantExpression(method),arguments);
+ this(objectExpression, new ConstantExpression(method), arguments);
}
public MethodCallExpression(Expression objectExpression, Expression
method, Expression arguments) {
this.objectExpression = objectExpression;
this.method = method;
- if (!(arguments instanceof TupleExpression)){
+ if (!(arguments instanceof TupleExpression)) {
this.arguments = new TupleExpression(arguments);
+ this.arguments.setSourcePosition(arguments);
} else {
this.arguments = arguments;
}
diff --git a/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
b/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
index feacc0d..b42d95f 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
@@ -87,7 +87,7 @@ public class GeneralUtils {
public static final Token AND = Token.newSymbol(Types.LOGICAL_AND, -1, -1);
public static final Token OR = Token.newSymbol(Types.LOGICAL_OR, -1, -1);
public static final Token CMP = Token.newSymbol(Types.COMPARE_TO, -1, -1);
- private static final Token INSTANCEOF =
Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1);
+ public static final Token INSTANCEOF =
Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1);
private static final Token PLUS = Token.newSymbol(Types.PLUS, -1, -1);
private static final Token INDEX = Token.newSymbol("[", -1, -1);
@@ -743,6 +743,14 @@ public class GeneralUtils {
return new TryCatchStatement(tryStatement, finallyStatement);
}
+ public static TryCatchStatement tryCatchS(final Statement tryStatement,
final Statement finallyStatement, final CatchStatement... catchStatements) {
+ TryCatchStatement result = new TryCatchStatement(tryStatement,
finallyStatement);
+ for (CatchStatement catchStatement : catchStatements) {
+ result.addCatch(catchStatement);
+ }
+ return result;
+ }
+
public static VariableExpression varX(final String name) {
return new VariableExpression(name);
}
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 cdd3bb4..7bf9c84 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
@@ -57,7 +57,6 @@ import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicReference;
-import static org.codehaus.groovy.ast.GenericsType.GenericsTypeName;
import static org.codehaus.groovy.runtime.DefaultGroovyMethods.plus;
import static
org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.getCorrectedClassNode;
import static
org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf;
@@ -67,7 +66,7 @@ import static
org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.implem
*/
public class GenericsUtils {
public static final GenericsType[] EMPTY_GENERICS_ARRAY =
GenericsType.EMPTY_ARRAY;
- public static final String JAVA_LANG_OBJECT = "java.lang.Object";
+ public static final String JAVA_LANG_OBJECT = ClassHelper.OBJECT;
/**
* Given a parameterized type and a generic type information, aligns
actual type parameters. For example, if a
@@ -145,8 +144,8 @@ public class GenericsUtils {
return gt;
}
- public static Map<GenericsTypeName, GenericsType>
extractPlaceholders(ClassNode cn) {
- Map<GenericsTypeName, GenericsType> ret = new
HashMap<GenericsTypeName, GenericsType>();
+ public static Map<GenericsType.GenericsTypeName, GenericsType>
extractPlaceholders(ClassNode cn) {
+ Map<GenericsType.GenericsTypeName, GenericsType> ret = new HashMap<>();
extractPlaceholders(cn, ret);
return ret;
}
@@ -158,7 +157,7 @@ public class GenericsUtils {
* @param node the class node to check
* @param map the generics type information collector
*/
- public static void extractPlaceholders(ClassNode node,
Map<GenericsTypeName, GenericsType> map) {
+ public static void extractPlaceholders(ClassNode node,
Map<GenericsType.GenericsTypeName, GenericsType> map) {
if (node == null) return;
if (node.isArray()) {
@@ -184,7 +183,7 @@ public class GenericsUtils {
for (int i = 0; i < redirectGenericsTypes.length; i++) {
GenericsType redirectType = redirectGenericsTypes[i];
if (redirectType.isPlaceholder()) {
- GenericsTypeName name = new
GenericsTypeName(redirectType.getName());
+ GenericsType.GenericsTypeName name = new
GenericsType.GenericsTypeName(redirectType.getName());
if (!map.containsKey(name)) {
GenericsType value = parameterized[i];
map.put(name, value);
@@ -321,7 +320,7 @@ public class GenericsUtils {
if (type.isArray()) {
return makeClassSafeWithGenerics(type.getComponentType(),
genericTypes).makeArray();
}
- GenericsType[] gtypes = GenericsType.EMPTY_ARRAY;
+ GenericsType[] gtypes = EMPTY_GENERICS_ARRAY;
if (genericTypes != null) {
gtypes = new GenericsType[genericTypes.length];
System.arraycopy(genericTypes, 0, gtypes, 0, gtypes.length);
@@ -377,7 +376,7 @@ public class GenericsUtils {
}
if (type == null) type = ClassHelper.OBJECT_TYPE;
GenericsType[] oldgTypes = type.getGenericsTypes();
- GenericsType[] newgTypes = GenericsType.EMPTY_ARRAY;
+ GenericsType[] newgTypes = EMPTY_GENERICS_ARRAY;
if (oldgTypes != null) {
newgTypes = new GenericsType[oldgTypes.length];
for (int i = 0; i < newgTypes.length; i++) {
@@ -433,9 +432,8 @@ public class GenericsUtils {
return type;
}
- @SuppressWarnings("unchecked")
public static Map<String, ClassNode> createGenericsSpec(ClassNode current)
{
- return createGenericsSpec(current, Collections.EMPTY_MAP);
+ return createGenericsSpec(current,
Collections.<String,ClassNode>emptyMap());
}
public static Map<String, ClassNode> createGenericsSpec(ClassNode current,
Map<String, ClassNode> oldSpec) {
@@ -665,8 +663,9 @@ public class GenericsUtils {
}
/**
- * transforms generics types from an old context to a new context using
the given spec. This method assumes
- * all generics types will be placeholders. WARNING: The resulting
generics types may or may not be placeholders
+ * Transforms generics types from an old context to a new context using the
+ * given spec. This method assumes all generics types will be placeholders.
+ * WARNING: The resulting generics types may or may not be placeholders
* after the transformation.
*
* @param genericsSpec the generics context information spec
@@ -714,9 +713,7 @@ public class GenericsUtils {
return newTypes;
}
- private static final String TRUE_STR = "true";
- private static final boolean PARAMETERIZED_TYPE_CACHE_ENABLED =
-
TRUE_STR.equals(SystemUtil.getSystemPropertySafe("groovy.enable.parameterized.type.cache",
TRUE_STR));
+ private static final boolean PARAMETERIZED_TYPE_CACHE_ENABLED =
Boolean.parseBoolean(SystemUtil.getSystemPropertySafe("groovy.enable.parameterized.type.cache",
"true"));
/**
* Try to get the parameterized type from the cache.
@@ -853,11 +850,11 @@ public class GenericsUtils {
}
/**
- * Backported from 3.0.0
- *
* The method is similar with {@link
GenericsUtils#makeDeclaringAndActualGenericsTypeMap(ClassNode, ClassNode)},
* The main difference is that the method will try to map all placeholders
found to the relevant exact types,
* but the other will not try even if the parameterized type has
placeholders
+ * <p>
+ * Backported from 3.0.0
*
* @param declaringClass the generics class node declaring the generics
types
* @param actualReceiver the sub-class class node
@@ -888,12 +885,11 @@ public class GenericsUtils {
private static Tuple2<Map<GenericsType, GenericsType>, ClassNode>
doMakeDeclaringAndActualGenericsTypeMap(ClassNode declaringClass, ClassNode
actualReceiver, boolean tryToFindExactType) {
ClassNode parameterizedType =
findParameterizedTypeFromCache(declaringClass, actualReceiver,
tryToFindExactType);
- if (null == parameterizedType) {
+ if (parameterizedType == null) {
return new
Tuple2<>(Collections.<GenericsType,GenericsType>emptyMap(), parameterizedType);
}
Map<GenericsType, GenericsType> result = new LinkedHashMap<>();
-
result.putAll(makePlaceholderAndParameterizedTypeMap(declaringClass));
result.putAll(makePlaceholderAndParameterizedTypeMap(parameterizedType));
@@ -936,11 +932,11 @@ public class GenericsUtils {
}
private static boolean checkPlaceHolders(ClassNode parameterizedType,
Predicate<GenericsType> p) {
- if (null == parameterizedType) return false;
+ if (parameterizedType == null) return false;
GenericsType[] genericsTypes = parameterizedType.getGenericsTypes();
- if (null == genericsTypes) return false;
+ if (genericsTypes == null) return false;
for (GenericsType genericsType : genericsTypes) {
if (p.test(genericsType)) {
@@ -1003,6 +999,7 @@ public class GenericsUtils {
return genericsClass;
}
+ @SuppressWarnings("unused")
public void setGenericsClass(ClassNode genericsClass) {
this.genericsClass = genericsClass;
}
@@ -1011,6 +1008,7 @@ public class GenericsUtils {
return actualType;
}
+ @SuppressWarnings("unused")
public void setActualType(ClassNode actualType) {
this.actualType = actualType;
}
diff --git
a/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java
b/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java
index 4f3bba6..0bdc015 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/WideningCategories.java
@@ -52,7 +52,7 @@ import static
org.codehaus.groovy.ast.ClassHelper.isNumberType;
import static org.codehaus.groovy.ast.ClassHelper.isPrimitiveType;
import static org.codehaus.groovy.ast.ClassHelper.long_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.short_TYPE;
-import static org.codehaus.groovy.ast.GenericsType.GenericsTypeName;
+
/**
* This class provides helper methods to determine the type from a widening
* operation for example for a plus operation.
@@ -300,13 +300,13 @@ public class WideningCategories {
ClassNode superClass = source.getUnresolvedSuperClass();
// copy generic type information if available
if (superClass!=null && superClass.isUsingGenerics()) {
- Map<GenericsTypeName, GenericsType> genericsTypeMap =
GenericsUtils.extractPlaceholders(source);
+ Map<GenericsType.GenericsTypeName, GenericsType> genericsTypeMap =
GenericsUtils.extractPlaceholders(source);
GenericsType[] genericsTypes = superClass.getGenericsTypes();
if (genericsTypes!=null) {
GenericsType[] copyTypes = new
GenericsType[genericsTypes.length];
for (int i = 0; i < genericsTypes.length; i++) {
GenericsType genericsType = genericsTypes[i];
- GenericsTypeName gtn = new
GenericsTypeName(genericsType.getName());
+ GenericsType.GenericsTypeName gtn = new
GenericsType.GenericsTypeName(genericsType.getName());
if (genericsType.isPlaceholder() &&
genericsTypeMap.containsKey(gtn)) {
copyTypes[i] = genericsTypeMap.get(gtn);
} else {
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 @@ public class AnnotationVisitor {
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 @@ public class AnnotationVisitor {
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 @@ public class AnnotationVisitor {
}
return true;
}
-
+
private boolean validateEnumConstant(Expression exp) {
if (exp instanceof PropertyExpression) {
PropertyExpression pe = (PropertyExpression) exp;
@@ -154,7 +154,7 @@ public class AnnotationVisitor {
// 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 @@ public class AnnotationVisitor {
} 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 @@ public class AnnotationVisitor {
checkCircularReference(searchClass, method.getReturnType(),
code.getExpression());
}
}
-
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
b/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
index bf9238f..29a88b5 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/BytecodeHelper.java
@@ -225,7 +225,7 @@ public class BytecodeHelper implements Opcodes {
mv.visitLabel(endLabel);
}
- /* *
+ /**
* load a message on the stack and remove it right away. Good for put a
mark in the generated bytecode for debugging purpose.
*
* @param msg
@@ -497,8 +497,7 @@ public class BytecodeHelper implements Opcodes {
*/
@Deprecated
public static boolean box(MethodVisitor mv, ClassNode type) {
- if (type.isPrimaryClassNode()) return false;
- return box(mv, type.getTypeClass());
+ return ClassHelper.isPrimitiveType(type) && box(mv,
type.getTypeClass());
}
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/ClosureWriter.java
b/src/main/java/org/codehaus/groovy/classgen/asm/ClosureWriter.java
index b47ece8..07b8e3a 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/ClosureWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/ClosureWriter.java
@@ -32,7 +32,6 @@ import org.codehaus.groovy.ast.Variable;
import org.codehaus.groovy.ast.VariableScope;
import org.codehaus.groovy.ast.expr.ClassExpression;
import org.codehaus.groovy.ast.expr.ClosureExpression;
-import org.codehaus.groovy.ast.expr.ConstantExpression;
import org.codehaus.groovy.ast.expr.ConstructorCallExpression;
import org.codehaus.groovy.ast.expr.Expression;
import org.codehaus.groovy.ast.expr.FieldExpression;
@@ -54,6 +53,7 @@ import static org.codehaus.groovy.ast.tools.GeneralUtils.args;
import static org.codehaus.groovy.ast.tools.GeneralUtils.callThisX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.ctorSuperX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.fieldX;
+import static org.codehaus.groovy.ast.tools.GeneralUtils.nullX;
import static org.codehaus.groovy.ast.tools.GeneralUtils.param;
import static org.codehaus.groovy.ast.tools.GeneralUtils.returnS;
import static org.codehaus.groovy.ast.tools.GeneralUtils.stmt;
@@ -201,7 +201,7 @@ public class ClosureWriter {
parameters = Parameter.EMPTY_ARRAY;
} else if (parameters.length == 0) {
// let's create a default 'it' parameter
- Parameter it = param(ClassHelper.OBJECT_TYPE, "it",
ConstantExpression.NULL);
+ Parameter it = param(ClassHelper.OBJECT_TYPE, "it", nullX());
parameters = new Parameter[]{it};
Variable ref =
expression.getVariableScope().getDeclaredVariable("it");
if (ref != null)
it.setClosureSharedVariable(ref.isClosureSharedVariable());
@@ -215,7 +215,6 @@ public class ClosureWriter {
answer.setSynthetic(true);
answer.setUsingGenerics(outerClass.isUsingGenerics());
answer.setSourcePosition(expression);
-
if (staticMethodOrInStaticClass) {
answer.setStaticClass(true);
}
@@ -355,7 +354,7 @@ public class ClosureWriter {
operandStack.box();
arguments.getExpression(1).visit(acg);
operandStack.box();
- //TODO: replace with normal String, p not needed
+ // TODO: replace with normal String, p not needed
Parameter p = param(ClassHelper.OBJECT_TYPE, "_p");
String descriptor =
BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, new Parameter[]{p,
p});
mv.visitMethodInsn(INVOKESPECIAL,
BytecodeHelper.getClassInternalName(callNode), "<init>", descriptor, false);
diff --git a/src/main/java/org/codehaus/groovy/classgen/asm/CompileStack.java
b/src/main/java/org/codehaus/groovy/classgen/asm/CompileStack.java
index 3caafad..d15248b 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/CompileStack.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/CompileStack.java
@@ -25,6 +25,7 @@ import org.codehaus.groovy.ast.MethodNode;
import org.codehaus.groovy.ast.Parameter;
import org.codehaus.groovy.ast.Variable;
import org.codehaus.groovy.ast.VariableScope;
+import org.codehaus.groovy.classgen.AsmClassGenerator;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
@@ -38,11 +39,9 @@ import java.util.ListIterator;
import java.util.Map;
/**
- * This class is a helper for AsmClassGenerator. It manages
- * different aspects of the code of a code block like
- * handling labels, defining variables, and scopes.
- * After a MethodNode is visited clear should be called, for
- * initialization the method init should be used.
+ * Manages different aspects of the code of a code block like handling labels,
+ * defining variables, and scopes. After a MethodNode is visited clear should
be
+ * called, for initialization the method init should be used.
* <p>
* Some Notes:
* <ul>
@@ -65,17 +64,12 @@ import java.util.Map;
* or temporary variable is hidden or even removed. That must not happen!
* </ul>
*
- *
* @see org.codehaus.groovy.classgen.AsmClassGenerator
*/
public class CompileStack implements Opcodes {
- /**
- * TODO: remove optimization of this.foo -> this.@foo
- *
- */
// state flag
- private boolean clear=true;
+ private boolean clear = true;
// current scope
private VariableScope scope;
// current label for continue
@@ -99,23 +93,22 @@ public class CompileStack implements Opcodes {
// list containing finally blocks
// such a block is created by synchronized or finally and
// must be called for break/continue/return
- private LinkedList<BlockRecorder> finallyBlocks = new
LinkedList<BlockRecorder>();
- private final LinkedList<BlockRecorder> visitedBlocks = new
LinkedList<BlockRecorder>();
+ private LinkedList<BlockRecorder> finallyBlocks = new LinkedList<>();
+ private final LinkedList<BlockRecorder> visitedBlocks = new LinkedList<>();
private Label thisStartLabel, thisEndLabel;
-// private MethodVisitor mv;
-
// helper to handle different stack based variables
private final LinkedList stateStack = new LinkedList();
// handle different states for the implicit "this"
- private final LinkedList<Boolean> implicitThisStack = new
LinkedList<Boolean>();
+ private final LinkedList<Boolean> implicitThisStack = new LinkedList<>();
// handle different states for being on the left hand side
- private final LinkedList<Boolean> lhsStack = new LinkedList<Boolean>();
+ private final LinkedList<Boolean> lhsStack = new LinkedList<>();
+
{
- implicitThisStack.add(false);
- lhsStack.add(false);
+ implicitThisStack.add(Boolean.FALSE);
+ lhsStack.add(Boolean.FALSE);
}
// defines the first variable index usable after
@@ -128,8 +121,8 @@ public class CompileStack implements Opcodes {
// in a loop where foo is a label.
private final Map namedLoopContinueLabel = new HashMap();
private String className;
- private final LinkedList<ExceptionTableEntry> typedExceptions = new
LinkedList<ExceptionTableEntry>();
- private final LinkedList<ExceptionTableEntry> untypedExceptions = new
LinkedList<ExceptionTableEntry>();
+ private final LinkedList<ExceptionTableEntry> typedExceptions = new
LinkedList<>();
+ private final LinkedList<ExceptionTableEntry> untypedExceptions = new
LinkedList<>();
// stores if on left-hand-side during compilation
private boolean lhs;
// stores if implicit or explicit this is used.
@@ -147,7 +140,7 @@ public class CompileStack implements Opcodes {
public Runnable excludedStatement;
public final LinkedList<LabelRange> ranges;
public BlockRecorder() {
- ranges = new LinkedList<LabelRange>();
+ ranges = new LinkedList<>();
}
public BlockRecorder(Runnable excludedStatement) {
this();
@@ -356,58 +349,54 @@ public class CompileStack implements Opcodes {
}
clear = true;
MethodVisitor mv = controller.getMethodVisitor();
- // br experiment with local var table so debuggers can retrieve
variable names
- if (true) {//AsmClassGenerator.CREATE_DEBUG_INFO) {
- if (thisEndLabel==null) setEndLabels();
+ if (AsmClassGenerator.CREATE_DEBUG_INFO) {
+ if (thisEndLabel == null) setEndLabels();
if (!scope.isInStaticContext()) {
// write "this"
mv.visitLocalVariable("this", className, null, thisStartLabel,
thisEndLabel, 0);
}
- for (Iterator iterator = usedVariables.iterator();
iterator.hasNext();) {
+ for (Iterator iterator = usedVariables.iterator();
iterator.hasNext(); ) {
BytecodeVariable v = (BytecodeVariable) iterator.next();
ClassNode t = v.getType();
if (v.isHolder()) t = ClassHelper.REFERENCE_TYPE;
String type = BytecodeHelper.getTypeDescription(t);
Label start = v.getStartLabel();
Label end = v.getEndLabel();
- mv.visitLocalVariable(v.getName(), type, null, start, end,
v.getIndex());
+ if (start != null && end != null)
+ mv.visitLocalVariable(v.getName(), type, null, start, end,
v.getIndex());
}
}
- //exception table writing
+ // exception table writing
for (ExceptionTableEntry ep : typedExceptions) {
mv.visitTryCatchBlock(ep.start, ep.end, ep.goal, ep.sig);
}
- //exception table writing
for (ExceptionTableEntry ep : untypedExceptions) {
mv.visitTryCatchBlock(ep.start, ep.end, ep.goal, ep.sig);
}
-
- pop();
+ popState();
typedExceptions.clear();
untypedExceptions.clear();
stackVariables.clear();
usedVariables.clear();
- scope = null;
finallyBlocks.clear();
resetVariableIndex(false);
superBlockNamedLabels.clear();
currentBlockNamedLabels.clear();
namedLoopBreakLabel.clear();
namedLoopContinueLabel.clear();
- continueLabel=null;
- breakLabel=null;
- thisStartLabel=null;
- thisEndLabel=null;
- mv = null;
+ breakLabel = null;
+ continueLabel = null;
+ thisStartLabel = null;
+ thisEndLabel = null;
+ className = null;
+ scope = null;
}
- public void addExceptionBlock (Label start, Label end, Label goal,
- String sig)
- {
+ public void addExceptionBlock(Label start, Label end, Label goal, String
sig) {
// this code is in an extra method to avoid
// lazy initialization issues
ExceptionTableEntry ep = new ExceptionTableEntry();
@@ -431,10 +420,10 @@ public class CompileStack implements Opcodes {
*/
public void init(VariableScope el, Parameter[] parameters) {
if (!clear) throw new GroovyBugError("CompileStack#init called without
calling clear before");
- clear=false;
+ clear = false;
pushVariableScope(el);
- defineMethodVariables(parameters,el.isInStaticContext());
- this.className =
BytecodeHelper.getTypeDescription(controller.getClassNode());
+ defineMethodVariables(parameters, el.isInStaticContext());
+ className =
BytecodeHelper.getTypeDescription(controller.getClassNode());
}
/**
@@ -772,7 +761,6 @@ public class CompileStack implements Opcodes {
applyBlockRecorder(blocks);
}
-
private void applyBlockRecorder(List<BlockRecorder> blocks) {
if (blocks.isEmpty() || blocks.size() == visitedBlocks.size()) return;
@@ -828,10 +816,6 @@ public class CompileStack implements Opcodes {
}
}
-// public MethodVisitor getMethodVisitor() {
-// return mv;
-// }
-
public boolean isLHS() {
return lhs;
}
diff --git
a/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java
b/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java
index 9d442e8..4fc5732 100644
--- a/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java
+++ b/src/main/java/org/codehaus/groovy/classgen/asm/InvocationWriter.java
@@ -534,7 +534,6 @@ public class InvocationWriter {
&& (argumentList.size()>para.length ||
argumentList.size()==para.length-1 || !lastIsArray(argumentList,
para.length-1))) {
int stackLen = operandStack.getStackLength()+argumentList.size();
MethodVisitor mv = controller.getMethodVisitor();
- //mv = new org.objectweb.asm.util.TraceMethodVisitor(mv);
controller.setMethodVisitor(mv);
// varg call
// first parameters as usual
@@ -543,7 +542,7 @@ public class InvocationWriter {
operandStack.doGroovyCast(para[i].getType());
}
// last parameters wrapped in an array
- List<Expression> lastParams = new LinkedList<Expression>();
+ List<Expression> lastParams = new LinkedList<>();
for (int i=para.length-1; i<argumentList.size();i++) {
lastParams.add(argumentList.get(i));
}
diff --git
a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java
b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java
index 93940a9..a677315 100644
---
a/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java
+++
b/src/main/java/org/codehaus/groovy/classgen/asm/sc/StaticInvocationWriter.java
@@ -73,8 +73,6 @@ import java.util.concurrent.atomic.AtomicInteger;
import static org.apache.groovy.ast.tools.ClassNodeUtils.samePackageName;
import static org.codehaus.groovy.ast.ClassHelper.CLOSURE_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.OBJECT_TYPE;
-import static org.codehaus.groovy.ast.ClassHelper.getWrapper;
import static org.codehaus.groovy.ast.tools.GeneralUtils.nullX;
import static
org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.PRIVATE_BRIDGE_METHODS;
import static org.objectweb.asm.Opcodes.ACONST_NULL;
@@ -121,12 +119,12 @@ public class StaticInvocationWriter extends
InvocationWriter {
if (origin instanceof MethodCallExpression &&
receiver instanceof VariableExpression &&
((VariableExpression) receiver).isSuperExpression()) {
- ClassNode superClass =
receiver.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER);
- if (superClass!=null && !controller.getCompileStack().isLHS()) {
- // GROOVY-7300
- MethodCallExpression mce = (MethodCallExpression) origin;
- MethodNode node =
superClass.getDeclaredMethod(mce.getMethodAsString(), Parameter.EMPTY_ARRAY);
- mce.setMethodTarget(node);
+ MethodCallExpression mce = (MethodCallExpression) origin; //
GROOVY-7300
+ if (mce.getMethodTarget() == null &&
!controller.getCompileStack().isLHS()) {
+ ClassNode owner =
receiver.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER);
+ if (owner != null) {
+
mce.setMethodTarget(owner.getDeclaredMethod(mce.getMethodAsString(),
Parameter.EMPTY_ARRAY));
+ }
}
}
return super.makeDirectCall(origin, receiver, message, arguments,
adapter, implicitThis, containsSpreadExpression);
@@ -456,7 +454,6 @@ public class StaticInvocationWriter extends
InvocationWriter {
) {
int stackLen = operandStack.getStackLength() + argumentListSize;
MethodVisitor mv = controller.getMethodVisitor();
- //mv = new org.objectweb.asm.util.TraceMethodVisitor(mv);
controller.setMethodVisitor(mv);
// varg call
// first parameters as usual
diff --git a/src/test/groovy/grape/GrapeClassLoaderTest.groovy
b/src/test/groovy/grape/GrapeClassLoaderTest.groovy
index d70868c..9ae92ca 100644
--- a/src/test/groovy/grape/GrapeClassLoaderTest.groovy
+++ b/src/test/groovy/grape/GrapeClassLoaderTest.groovy
@@ -17,13 +17,8 @@
* under the License.
*/
package groovy.grape
-/**
- * Created by IntelliJ IDEA.
- * User: Danno
- * Date: Jan 20, 2008
- * Time: 5:14:11 PM
- */
-class GrapeClassLoaderTest extends GroovyTestCase {
+
+final class GrapeClassLoaderTest extends GroovyTestCase {
public GrapeClassLoaderTest() {
// insure files are installed locally
diff --git
a/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/AstNodeToScriptAdapterTest.groovy
b/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/AstNodeToScriptAdapterTest.groovy
index e42f173..46b62d6 100644
---
a/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/AstNodeToScriptAdapterTest.groovy
+++
b/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/AstNodeToScriptAdapterTest.groovy
@@ -43,12 +43,10 @@ class AstNodeToScriptAdapterTest extends GroovyTestCase {
}
void testScript() {
-
String result = compileToScript('true')
-
assert result =~ /public class script[0-9]* extends
groovy\.lang\.Script \{/
assert result =~ /public script[0-9]*\(\) \{\s*\}/
- assert result =~ /public script[0-9]*\(groovy.lang.Binding context\)
\{\s*super\(context\)\s*\}/
+ assert result =~ /public script[0-9]*\(final groovy.lang.Binding
context\) \{\s*super\(context\)\s*\}/
assert result =~ /public java.lang.Object run\(\) \{\s*true\s*\}/
}
diff --git
a/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/ScriptToTreeNodeAdapterTest.groovy
b/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/ScriptToTreeNodeAdapterTest.groovy
index 7893275..182895c 100644
---
a/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/ScriptToTreeNodeAdapterTest.groovy
+++
b/subprojects/groovy-console/src/test/groovy/groovy/inspect/swingui/ScriptToTreeNodeAdapterTest.groovy
@@ -284,7 +284,7 @@ class ScriptToTreeNodeAdapterTest extends GroovyTestCase {
eq('Methods'),
eq('MethodNode - main'),
startsWith('ExpressionStatement'), //notice, there is
only one ExpressionStatement
- startsWith('MethodCall'),
+ startsWith('StaticMethodCall'),
]
)
}
