groovy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sun...@apache.org
Subject [groovy] 02/06: minor edits
Date Wed, 11 Dec 2019 10:44:37 GMT
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 <eric.milles@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) {
+    }
 }


Mime
View raw message