You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2019/12/11 10:44:37 UTC
[groovy] 02/06: minor edits
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch GROOVY_3_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit 1889669d1d802ab725fbc29e12be9bfbe4541797
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Tue Dec 10 11:14:30 2019 -0600
minor edits
(cherry picked from commit 14cf5a700c642ea1f1a67333f7112b580da61fe3)
---
.../transform/sc/StaticCompilationVisitor.java | 269 +++++++++++----------
1 file changed, 135 insertions(+), 134 deletions(-)
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
index f78f1c3..a331a58 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
@@ -61,19 +61,19 @@ import org.codehaus.groovy.control.CompilationUnit;
import org.codehaus.groovy.control.SourceUnit;
import org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport;
import org.codehaus.groovy.transform.stc.StaticTypeCheckingVisitor;
-import org.codehaus.groovy.transform.stc.StaticTypesMarker;
-import org.objectweb.asm.Opcodes;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
-import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.codehaus.groovy.ast.ClassHelper.Character_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.LIST_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.OBJECT_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.STRING_TYPE;
+import static org.codehaus.groovy.ast.ClassHelper.int_TYPE;
import static org.codehaus.groovy.ast.tools.GenericsUtils.addMethodGenerics;
import static org.codehaus.groovy.ast.tools.GenericsUtils.applyGenericsContextToPlaceHolders;
import static org.codehaus.groovy.ast.tools.GenericsUtils.correctToGenericsSpecRecurse;
@@ -81,11 +81,19 @@ import static org.codehaus.groovy.ast.tools.GenericsUtils.createGenericsSpec;
import static org.codehaus.groovy.ast.tools.GenericsUtils.extractSuperClassGenerics;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.BINARY_EXP_TARGET;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.COMPONENT_TYPE;
+import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.DYNAMIC_OUTER_NODE_CALLBACK;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.PRIVATE_BRIDGE_METHODS;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.PRIVATE_FIELDS_ACCESSORS;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.PRIVATE_FIELDS_MUTATORS;
+import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.PROPERTY_OWNER;
+import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.RECEIVER_OF_DYNAMIC_PROPERTY;
import static org.codehaus.groovy.transform.sc.StaticCompilationMetadataKeys.STATIC_COMPILE_NODE;
import static org.codehaus.groovy.transform.stc.StaticTypesMarker.DIRECT_METHOD_CALL_TARGET;
+import static org.codehaus.groovy.transform.stc.StaticTypesMarker.DYNAMIC_RESOLUTION;
+import static org.codehaus.groovy.transform.stc.StaticTypesMarker.INITIAL_EXPRESSION;
+import static org.codehaus.groovy.transform.stc.StaticTypesMarker.PV_FIELDS_ACCESS;
+import static org.codehaus.groovy.transform.stc.StaticTypesMarker.PV_FIELDS_MUTATION;
+import static org.codehaus.groovy.transform.stc.StaticTypesMarker.PV_METHODS_ACCESS;
import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
import static org.objectweb.asm.Opcodes.ACC_STATIC;
import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
@@ -100,16 +108,14 @@ import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC;
* visitor.
*/
public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
- private static final ClassNode TYPECHECKED_CLASSNODE = ClassHelper.make(TypeChecked.class);
- private static final ClassNode COMPILESTATIC_CLASSNODE = ClassHelper.make(CompileStatic.class);
- private static final ClassNode[] TYPECHECKED_ANNOTATIONS = {TYPECHECKED_CLASSNODE, COMPILESTATIC_CLASSNODE};
- public static final ClassNode ARRAYLIST_CLASSNODE = ClassHelper.make(ArrayList.class);
- public static final MethodNode ARRAYLIST_CONSTRUCTOR;
- public static final MethodNode ARRAYLIST_ADD_METHOD = ARRAYLIST_CLASSNODE.getMethod("add", new Parameter[]{new Parameter(ClassHelper.OBJECT_TYPE, "o")});
+ public static final ClassNode TYPECHECKED_CLASSNODE = ClassHelper.make(TypeChecked.class);
+ public static final ClassNode COMPILESTATIC_CLASSNODE = ClassHelper.make(CompileStatic.class);
+ public static final ClassNode ARRAYLIST_CLASSNODE = ClassHelper.make(ArrayList.class);
+ public static final MethodNode ARRAYLIST_ADD_METHOD = ARRAYLIST_CLASSNODE.getMethod("add", new Parameter[]{new Parameter(OBJECT_TYPE, "o")});
+ public static final MethodNode ARRAYLIST_CONSTRUCTOR = new ConstructorNode(ACC_PUBLIC, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, EmptyStatement.INSTANCE);
static {
- ARRAYLIST_CONSTRUCTOR = new ConstructorNode(ACC_PUBLIC, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, EmptyStatement.INSTANCE);
ARRAYLIST_CONSTRUCTOR.setDeclaringClass(StaticCompilationVisitor.ARRAYLIST_CLASSNODE);
}
@@ -123,33 +129,33 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
@Override
protected ClassNode[] getTypeCheckingAnnotations() {
- return TYPECHECKED_ANNOTATIONS;
+ return new ClassNode[]{TYPECHECKED_CLASSNODE, COMPILESTATIC_CLASSNODE};
}
- public static boolean isStaticallyCompiled(AnnotatedNode node) {
- if (node.getNodeMetaData(STATIC_COMPILE_NODE)!=null) return (Boolean)node.getNodeMetaData(STATIC_COMPILE_NODE);
+ public static boolean isStaticallyCompiled(final AnnotatedNode node) {
+ if (node.getNodeMetaData(STATIC_COMPILE_NODE) != null) {
+ return (Boolean) node.getNodeMetaData(STATIC_COMPILE_NODE);
+ }
if (node instanceof MethodNode) {
return isStaticallyCompiled(node.getDeclaringClass());
}
- if (node instanceof InnerClassNode) {
- return isStaticallyCompiled(((InnerClassNode)node).getOuterClass());
+ if (node instanceof ClassNode && ((ClassNode) node).getOuterClass() != null) {
+ return isStaticallyCompiled(((ClassNode) node).getOuterClass());
}
return false;
}
- private void addPrivateFieldAndMethodAccessors(ClassNode node) {
+ private void addPrivateFieldAndMethodAccessors(final ClassNode node) {
addPrivateBridgeMethods(node);
addPrivateFieldsAccessors(node);
- Iterator<InnerClassNode> it = node.getInnerClasses();
- while (it.hasNext()) {
+ for (Iterator<InnerClassNode> it = node.getInnerClasses(); it.hasNext(); ) {
addPrivateFieldAndMethodAccessors(it.next());
}
}
private void addDynamicOuterClassAccessorsCallback(final ClassNode outer) {
- if (outer != null && !isStaticallyCompiled(outer)
- && outer.getNodeMetaData(StaticCompilationMetadataKeys.DYNAMIC_OUTER_NODE_CALLBACK) == null) {
- outer.putNodeMetaData(StaticCompilationMetadataKeys.DYNAMIC_OUTER_NODE_CALLBACK, new CompilationUnit.PrimaryClassNodeOperation() {
+ if (outer != null && !isStaticallyCompiled(outer) && outer.getNodeMetaData(DYNAMIC_OUTER_NODE_CALLBACK) == null) {
+ outer.putNodeMetaData(DYNAMIC_OUTER_NODE_CALLBACK, new CompilationUnit.PrimaryClassNodeOperation() {
@Override
public void call(SourceUnit source, GeneratorContext context, ClassNode classNode) throws CompilationFailedException {
if (classNode == outer) {
@@ -167,13 +173,13 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
if (!skip && !anyMethodSkip(node)) {
node.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
}
- ClassNode oldCN = classNode;
- classNode = node;
- Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses();
- while (innerClasses.hasNext()) {
+
+ ClassNode previousClassNode = classNode; classNode = node;
+
+ for (Iterator<InnerClassNode> innerClasses = classNode.getInnerClasses(); innerClasses.hasNext(); ) {
InnerClassNode innerClassNode = innerClasses.next();
boolean innerStaticCompile = !(skip || isSkippedInnerClass(innerClassNode));
- innerClassNode.putNodeMetaData(STATIC_COMPILE_NODE, innerStaticCompile);
+ innerClassNode.putNodeMetaData(STATIC_COMPILE_NODE, Boolean.valueOf(innerStaticCompile));
innerClassNode.putNodeMetaData(WriterControllerFactory.class, node.getNodeMetaData(WriterControllerFactory.class));
if (innerStaticCompile && !anyMethodSkip(innerClassNode)) {
innerClassNode.putNodeMetaData(MopWriter.Factory.class, StaticCompilationMopWriter.FACTORY);
@@ -182,7 +188,8 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
super.visitClass(node);
addPrivateFieldAndMethodAccessors(node);
if (isStaticallyCompiled(node)) addDynamicOuterClassAccessorsCallback(node.getOuterClass());
- classNode = oldCN;
+
+ classNode = previousClassNode;
}
private boolean anyMethodSkip(final ClassNode node) {
@@ -199,17 +206,13 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
* a purely static constructor, so it may fail if it encounters dynamic
* code here. Thus we make this kind of code fail
*/
- private void checkForConstructorWithCSButClassWithout(MethodNode node) {
+ private void checkForConstructorWithCSButClassWithout(final MethodNode node) {
if (!(node instanceof ConstructorNode)) return;
- Object meta = node.getNodeMetaData(STATIC_COMPILE_NODE);
- if (!Boolean.TRUE.equals(meta)) return;
- ClassNode clz = typeCheckingContext.getEnclosingClassNode();
- meta = clz.getNodeMetaData(STATIC_COMPILE_NODE);
- if (Boolean.TRUE.equals(meta)) return;
- if ( clz.getObjectInitializerStatements().isEmpty() &&
- clz.getFields().isEmpty() &&
- clz.getProperties().isEmpty())
- {
+ if (!Boolean.TRUE.equals(node.getNodeMetaData(STATIC_COMPILE_NODE))) return;
+ ClassNode outerClass = typeCheckingContext.getEnclosingClassNode();
+ if (Boolean.TRUE.equals(outerClass.getNodeMetaData(STATIC_COMPILE_NODE))) return;
+ if (outerClass.getObjectInitializerStatements().isEmpty()
+ && outerClass.getFields().isEmpty() && outerClass.getProperties().isEmpty()) {
return;
}
@@ -219,7 +222,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
@Override
public void visitMethod(final MethodNode node) {
if (isSkipMode(node)) {
- node.putNodeMetaData(STATIC_COMPILE_NODE, false);
+ node.putNodeMetaData(STATIC_COMPILE_NODE, Boolean.FALSE);
}
super.visitMethod(node);
checkForConstructorWithCSButClassWithout(node);
@@ -227,99 +230,95 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
}
/**
- * Adds special accessors and mutators for private fields so that inner classes can get/set them
+ * Adds special accessors and mutators for private fields so that inner classes can get/set them.
*/
- @SuppressWarnings("unchecked")
- private static void addPrivateFieldsAccessors(ClassNode node) {
- Set<ASTNode> accessedFields = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_FIELDS_ACCESS);
- Set<ASTNode> mutatedFields = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_FIELDS_MUTATION);
+ private static void addPrivateFieldsAccessors(final ClassNode node) {
+ Set<ASTNode> accessedFields = node.getNodeMetaData(PV_FIELDS_ACCESS);
+ Set<ASTNode> mutatedFields = node.getNodeMetaData(PV_FIELDS_MUTATION);
if (accessedFields == null && mutatedFields == null) return;
- Map<String, MethodNode> privateFieldAccessors = (Map<String, MethodNode>) node.getNodeMetaData(PRIVATE_FIELDS_ACCESSORS);
- Map<String, MethodNode> privateFieldMutators = (Map<String, MethodNode>) node.getNodeMetaData(PRIVATE_FIELDS_MUTATORS);
+ Map<String, MethodNode> privateFieldAccessors = node.getNodeMetaData(PRIVATE_FIELDS_ACCESSORS);
+ Map<String, MethodNode> privateFieldMutators = node.getNodeMetaData(PRIVATE_FIELDS_MUTATORS);
if (privateFieldAccessors != null || privateFieldMutators != null) {
// already added
return;
}
int acc = -1;
- privateFieldAccessors = accessedFields != null ? new HashMap<String, MethodNode>() : null;
- privateFieldMutators = mutatedFields != null ? new HashMap<String, MethodNode>() : null;
- final int access = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC;
+ privateFieldAccessors = accessedFields != null ? new HashMap<>() : null;
+ privateFieldMutators = mutatedFields != null ? new HashMap<>() : null;
+ final int access = ACC_PUBLIC | ACC_STATIC | ACC_SYNTHETIC;
for (FieldNode fieldNode : node.getFields()) {
boolean generateAccessor = accessedFields != null && accessedFields.contains(fieldNode);
boolean generateMutator = mutatedFields != null && mutatedFields.contains(fieldNode);
if (generateAccessor) {
- acc++;
+ acc += 1;
Parameter param = new Parameter(node.getPlainNodeReference(), "$that");
Expression receiver = fieldNode.isStatic() ? new ClassExpression(node) : new VariableExpression(param);
- Statement stmt = new ExpressionStatement(new PropertyExpression(
- receiver,
- fieldNode.getName()
- ));
+ Statement stmt = new ExpressionStatement(new PropertyExpression(receiver, fieldNode.getName()));
MethodNode accessor = node.addMethod("pfaccess$" + acc, access, fieldNode.getOriginType(), new Parameter[]{param}, ClassNode.EMPTY_ARRAY, stmt);
privateFieldAccessors.put(fieldNode.getName(), accessor);
}
if (generateMutator) {
- //increment acc if it hasn't been incremented in the current iteration
- if (!generateAccessor) acc++;
+ // increment acc if it hasn't been incremented in the current iteration
+ if (!generateAccessor) acc += 1;
Parameter param = new Parameter(node.getPlainNodeReference(), "$that");
Expression receiver = fieldNode.isStatic() ? new ClassExpression(node) : new VariableExpression(param);
Parameter value = new Parameter(fieldNode.getOriginType(), "$value");
- Statement stmt = GeneralUtils.assignS(
- new PropertyExpression(receiver, fieldNode.getName()),
- new VariableExpression(value)
- );
+ Statement stmt = GeneralUtils.assignS(new PropertyExpression(receiver, fieldNode.getName()), new VariableExpression(value));
MethodNode mutator = node.addMethod("pfaccess$0" + acc, access, fieldNode.getOriginType(), new Parameter[]{param, value}, ClassNode.EMPTY_ARRAY, stmt);
privateFieldMutators.put(fieldNode.getName(), mutator);
}
}
- if (privateFieldAccessors != null) node.setNodeMetaData(PRIVATE_FIELDS_ACCESSORS, privateFieldAccessors);
- if (privateFieldMutators != null) node.setNodeMetaData(PRIVATE_FIELDS_MUTATORS, privateFieldMutators);
+ if (privateFieldAccessors != null) {
+ node.setNodeMetaData(PRIVATE_FIELDS_ACCESSORS, privateFieldAccessors);
+ }
+ if (privateFieldMutators != null) {
+ node.setNodeMetaData(PRIVATE_FIELDS_MUTATORS, privateFieldMutators);
+ }
}
/**
- * This method is used to add "bridge" methods for private methods of an inner/outer
- * class, so that the outer class is capable of calling them. It does basically
- * the same job as access$000 like methods in Java.
+ * Adds "bridge" methods for private methods of an inner/outer class so that
+ * the outer class is capable of calling them. It does basically the same
+ * job as access$000 like methods in Java.
*
* @param node an inner/outer class node for which to generate bridge methods
*/
- @SuppressWarnings("unchecked")
private static void addPrivateBridgeMethods(final ClassNode node) {
- Set<ASTNode> accessedMethods = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS);
- if (accessedMethods==null) return;
- List<MethodNode> methods = new ArrayList<MethodNode>(node.getAllDeclaredMethods());
+ Set<ASTNode> accessedMethods = node.getNodeMetaData(PV_METHODS_ACCESS);
+ if (accessedMethods == null) return;
+ List<MethodNode> methods = new ArrayList<>(node.getAllDeclaredMethods());
methods.addAll(node.getDeclaredConstructors());
- Map<MethodNode, MethodNode> privateBridgeMethods = (Map<MethodNode, MethodNode>) node.getNodeMetaData(PRIVATE_BRIDGE_METHODS);
- if (privateBridgeMethods!=null) {
+ Map<MethodNode, MethodNode> privateBridgeMethods = node.getNodeMetaData(PRIVATE_BRIDGE_METHODS);
+ if (privateBridgeMethods != null) {
// private bridge methods already added
return;
}
- privateBridgeMethods = new HashMap<MethodNode, MethodNode>();
- int i=-1;
- final int access = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC;
+ privateBridgeMethods = new HashMap<>();
+ int i = -1;
+ final int access = ACC_PUBLIC | ACC_STATIC | ACC_SYNTHETIC;
for (MethodNode method : methods) {
if (accessedMethods.contains(method)) {
List<String> methodSpecificGenerics = methodSpecificGenerics(method);
- i++;
+ i += 1;
ClassNode declaringClass = method.getDeclaringClass();
- Map<String,ClassNode> genericsSpec = createGenericsSpec(node);
+ Map<String, ClassNode> genericsSpec = createGenericsSpec(node);
genericsSpec = addMethodGenerics(method, genericsSpec);
extractSuperClassGenerics(node, declaringClass, genericsSpec);
Parameter[] methodParameters = method.getParameters();
- Parameter[] newParams = new Parameter[methodParameters.length+1];
- for (int j = 1; j < newParams.length; j++) {
- Parameter orig = methodParameters[j-1];
+ Parameter[] newParams = new Parameter[methodParameters.length + 1];
+ for (int j = 1; j < newParams.length; j += 1) {
+ Parameter orig = methodParameters[j - 1];
newParams[j] = new Parameter(
correctToGenericsSpecRecurse(genericsSpec, orig.getOriginType(), methodSpecificGenerics),
orig.getName()
);
}
Expression arguments;
- if (method.getParameters()==null || method.getParameters().length==0) {
+ if (method.getParameters() == null || method.getParameters().length == 0) {
arguments = ArgumentListExpression.EMPTY_ARGUMENTS;
} else {
- List<Expression> args = new LinkedList<Expression>();
+ List<Expression> args = new ArrayList<>();
for (Parameter parameter : methodParameters) {
args.add(new VariableExpression(parameter));
}
@@ -334,7 +333,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
if (innerClasses.hasNext()) {
thatType = innerClasses.next();
} else {
- thatType = new InnerClassNode(node.redirect(), node.getName() + "$1", ACC_STATIC | ACC_SYNTHETIC, ClassHelper.OBJECT_TYPE);
+ thatType = new InnerClassNode(node.redirect(), node.getName() + "$1", ACC_STATIC | ACC_SYNTHETIC, OBJECT_TYPE);
node.getModule().addClass(thatType);
}
newParams[0] = new Parameter(thatType.getPlainNodeReference(), "$that");
@@ -343,21 +342,21 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
bridge = node.addConstructor(ACC_SYNTHETIC, newParams, ClassNode.EMPTY_ARRAY, body);
} else {
newParams[0] = new Parameter(node.getPlainNodeReference(), "$that");
- Expression receiver = method.isStatic()?new ClassExpression(node):new VariableExpression(newParams[0]);
+ Expression receiver = method.isStatic() ? new ClassExpression(node) : new VariableExpression(newParams[0]);
MethodCallExpression mce = new MethodCallExpression(receiver, method.getName(), arguments);
mce.setMethodTarget(method);
ExpressionStatement returnStatement = new ExpressionStatement(mce);
bridge = node.addMethod(
- "access$"+i, access,
+ "access$" + i, access,
correctToGenericsSpecRecurse(genericsSpec, method.getReturnType(), methodSpecificGenerics),
newParams,
method.getExceptions(),
returnStatement);
}
GenericsType[] origGenericsTypes = method.getGenericsTypes();
- if (origGenericsTypes !=null) {
- bridge.setGenericsTypes(applyGenericsContextToPlaceHolders(genericsSpec,origGenericsTypes));
+ if (origGenericsTypes != null) {
+ bridge.setGenericsTypes(applyGenericsContextToPlaceHolders(genericsSpec, origGenericsTypes));
}
privateBridgeMethods.put(method, bridge);
bridge.addAnnotation(new AnnotationNode(COMPILESTATIC_CLASSNODE));
@@ -369,51 +368,46 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
}
private static List<String> methodSpecificGenerics(final MethodNode method) {
- List<String> genericTypeTokens = new ArrayList<String>();
- GenericsType[] candidateGenericsTypes = method.getGenericsTypes();
- if (candidateGenericsTypes != null) {
- for (GenericsType gt : candidateGenericsTypes) {
- genericTypeTokens.add(gt.getName());
+ List<String> genericTypeNames = new ArrayList<>();
+ GenericsType[] genericsTypes = method.getGenericsTypes();
+ if (genericsTypes != null) {
+ for (GenericsType gt : genericsTypes) {
+ genericTypeNames.add(gt.getName());
}
}
- return genericTypeTokens;
+ return genericTypeNames;
}
private static void memorizeInitialExpressions(final MethodNode node) {
// add node metadata for default parameters because they are erased by the Verifier
- if (node.getParameters()!=null) {
+ if (node.getParameters() != null) {
for (Parameter parameter : node.getParameters()) {
- parameter.putNodeMetaData(StaticTypesMarker.INITIAL_EXPRESSION, parameter.getInitialExpression());
+ parameter.putNodeMetaData(INITIAL_EXPRESSION, parameter.getInitialExpression());
}
}
}
@Override
- public void visitSpreadExpression(final SpreadExpression expression) {
- }
-
- @Override
public void visitMethodCallExpression(final MethodCallExpression call) {
super.visitMethodCallExpression(call);
- MethodNode target = (MethodNode) call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
- if (target!=null) {
+ MethodNode target = call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+ if (target != null) {
call.setMethodTarget(target);
memorizeInitialExpressions(target);
}
- if (call.getMethodTarget()==null && call.getLineNumber()>0) {
+ if (call.getMethodTarget() == null && call.getLineNumber() > 0) {
addError("Target method for method call expression hasn't been set", call);
}
-
}
@Override
public void visitConstructorCallExpression(final ConstructorCallExpression call) {
super.visitConstructorCallExpression(call);
- MethodNode target = (MethodNode) call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
- if (target==null && call.getLineNumber()>0) {
+ MethodNode target = call.getNodeMetaData(DIRECT_METHOD_CALL_TARGET);
+ if (target == null && call.getLineNumber() > 0) {
addError("Target constructor for constructor call expression hasn't been set", call);
} else {
if (target==null) {
@@ -421,7 +415,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
ArgumentListExpression argumentListExpression = InvocationWriter.makeArgumentList(call.getArguments());
List<Expression> expressions = argumentListExpression.getExpressions();
ClassNode[] args = new ClassNode[expressions.size()];
- for (int i = 0; i < args.length; i++) {
+ for (int i = 0, n = args.length; i < n; i += 1) {
args[i] = typeChooser.resolveType(expressions.get(i), classNode);
}
MethodNode constructor = findMethodOrFail(call, call.isSuperCall() ? classNode.getSuperClass() : classNode, "<init>", args);
@@ -429,18 +423,18 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
target = constructor;
}
}
- if (target!=null) {
+ if (target != null) {
memorizeInitialExpressions(target);
}
}
@Override
- public void visitForLoop(final ForStatement forLoop) {
- super.visitForLoop(forLoop);
- Expression collectionExpression = forLoop.getCollectionExpression();
+ public void visitForLoop(final ForStatement statement) {
+ super.visitForLoop(statement);
+ Expression collectionExpression = statement.getCollectionExpression();
if (!(collectionExpression instanceof ClosureListExpression)) {
- final ClassNode collectionType = getType(forLoop.getCollectionExpression());
- ClassNode forLoopVariableType = forLoop.getVariableType();
+ ClassNode forLoopVariableType = statement.getVariableType();
+ ClassNode collectionType = getType(collectionExpression);
ClassNode componentType;
if (Character_TYPE.equals(ClassHelper.getWrapper(forLoopVariableType)) && STRING_TYPE.equals(collectionType)) {
// we allow auto-coercion here
@@ -448,15 +442,15 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
} else {
componentType = inferLoopElementType(collectionType);
}
- forLoop.getVariable().setType(componentType);
+ statement.getVariable().setType(componentType);
}
}
@Override
protected MethodNode findMethodOrFail(final Expression expr, final ClassNode receiver, final String name, final ClassNode... args) {
MethodNode methodNode = super.findMethodOrFail(expr, receiver, name, args);
- if (expr instanceof BinaryExpression && methodNode!=null) {
- expr.putNodeMetaData(BINARY_EXP_TARGET, new Object[] {methodNode, name});
+ if (expr instanceof BinaryExpression && methodNode != null) {
+ expr.putNodeMetaData(BINARY_EXP_TARGET, new Object[]{methodNode, name});
}
return methodNode;
}
@@ -465,18 +459,19 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
protected boolean existsProperty(final PropertyExpression pexp, final boolean checkForReadOnly, final ClassCodeVisitorSupport visitor) {
Expression objectExpression = pexp.getObjectExpression();
ClassNode objectExpressionType = getType(objectExpression);
- final Reference<ClassNode> rType = new Reference<ClassNode>(objectExpressionType);
+ Reference<ClassNode> rType = new Reference<>(objectExpressionType);
ClassCodeVisitorSupport receiverMemoizer = new ClassCodeVisitorSupport() {
@Override
protected SourceUnit getSourceUnit() {
return null;
}
+ @Override
public void visitField(final FieldNode node) {
- if (visitor!=null) visitor.visitField(node);
+ if (visitor != null) visitor.visitField(node);
ClassNode declaringClass = node.getDeclaringClass();
- if (declaringClass!=null) {
- if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(declaringClass, ClassHelper.LIST_TYPE)) {
+ if (declaringClass != null) {
+ if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(declaringClass, LIST_TYPE)) {
boolean spread = declaringClass.getDeclaredField(node.getName()) != node;
pexp.setSpreadSafe(spread);
}
@@ -484,15 +479,16 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
}
}
+ @Override
public void visitMethod(final MethodNode node) {
- if (visitor!=null) visitor.visitMethod(node);
+ if (visitor != null) visitor.visitMethod(node);
ClassNode declaringClass = node.getDeclaringClass();
- if (declaringClass!=null){
- if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(declaringClass, ClassHelper.LIST_TYPE)) {
+ if (declaringClass != null) {
+ if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(declaringClass, LIST_TYPE)) {
List<MethodNode> properties = declaringClass.getDeclaredMethods(node.getName());
boolean spread = true;
for (MethodNode mn : properties) {
- if (node==mn) {
+ if (node == mn) {
spread = false;
break;
}
@@ -506,14 +502,14 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
@Override
public void visitProperty(final PropertyNode node) {
- if (visitor!=null) visitor.visitProperty(node);
+ if (visitor != null) visitor.visitProperty(node);
ClassNode declaringClass = node.getDeclaringClass();
- if (declaringClass!=null) {
- if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(declaringClass, ClassHelper.LIST_TYPE)) {
+ if (declaringClass != null) {
+ if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(declaringClass, LIST_TYPE)) {
List<PropertyNode> properties = declaringClass.getProperties();
boolean spread = true;
for (PropertyNode propertyNode : properties) {
- if (propertyNode==node) {
+ if (propertyNode == node) {
spread = false;
break;
}
@@ -525,24 +521,29 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
}
}
};
+
boolean exists = super.existsProperty(pexp, checkForReadOnly, receiverMemoizer);
if (exists) {
- if (objectExpression.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER)==null) {
- objectExpression.putNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER, rType.get());
+ if (objectExpression.getNodeMetaData(PROPERTY_OWNER) == null) {
+ objectExpression.putNodeMetaData(PROPERTY_OWNER, rType.get());
}
- if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(objectExpressionType, ClassHelper.LIST_TYPE)) {
- objectExpression.putNodeMetaData(COMPONENT_TYPE, inferComponentType(objectExpressionType, ClassHelper.int_TYPE));
+ if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(objectExpressionType, LIST_TYPE)) {
+ objectExpression.putNodeMetaData(COMPONENT_TYPE, inferComponentType(objectExpressionType, int_TYPE));
}
}
return exists;
}
@Override
- public void visitPropertyExpression(final PropertyExpression pexp) {
- super.visitPropertyExpression(pexp);
- Object dynamic = pexp.getNodeMetaData(StaticTypesMarker.DYNAMIC_RESOLUTION);
- if (dynamic !=null) {
- pexp.getObjectExpression().putNodeMetaData(StaticCompilationMetadataKeys.RECEIVER_OF_DYNAMIC_PROPERTY, dynamic);
+ public void visitPropertyExpression(final PropertyExpression expression) {
+ super.visitPropertyExpression(expression);
+ Object dynamic = expression.getNodeMetaData(DYNAMIC_RESOLUTION);
+ if (dynamic != null) {
+ expression.getObjectExpression().putNodeMetaData(RECEIVER_OF_DYNAMIC_PROPERTY, dynamic);
}
}
+
+ @Override
+ public void visitSpreadExpression(final SpreadExpression expression) {
+ }
}