groovy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pa...@apache.org
Subject [2/2] groovy git commit: formatting only
Date Thu, 12 Apr 2018 00:49:39 GMT
formatting only


Project: http://git-wip-us.apache.org/repos/asf/groovy/repo
Commit: http://git-wip-us.apache.org/repos/asf/groovy/commit/ef659512
Tree: http://git-wip-us.apache.org/repos/asf/groovy/tree/ef659512
Diff: http://git-wip-us.apache.org/repos/asf/groovy/diff/ef659512

Branch: refs/heads/GROOVY_2_6_X
Commit: ef659512a5eeeeca54ca120dc5e86d5fd0472b7e
Parents: 49a1c02
Author: Paul King <paulk@asert.com.au>
Authored: Thu Apr 12 10:12:09 2018 +1000
Committer: Paul King <paulk@asert.com.au>
Committed: Thu Apr 12 10:49:00 2018 +1000

----------------------------------------------------------------------
 .../groovy/ast/tools/GenericsUtils.java         | 122 ++--
 .../stc/StaticTypeCheckingSupport.java          | 380 ++++++-----
 .../stc/StaticTypeCheckingVisitor.java          | 672 ++++++++++---------
 3 files changed, 610 insertions(+), 564 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/groovy/blob/ef659512/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
----------------------------------------------------------------------
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 126ef42..b562ab8 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
@@ -52,9 +52,6 @@ import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.implem
 
 /**
  * Utility methods to deal with generic types.
- *
- * @author Cedric Champeau
- * @author Paul King
  */
 public class GenericsUtils {
     public static final GenericsType[] EMPTY_GENERICS_ARRAY = GenericsType.EMPTY_ARRAY;
@@ -65,28 +62,29 @@ public class GenericsUtils {
      * class uses generic type <pre>&lt;T,U,V&gt;</pre> (redirectGenericTypes), is used with actual type parameters
      * <pre>&lt;java.lang.String, U,V&gt;</pre>, then a class or interface using generic types <pre>&lt;T,V&gt;</pre>
      * will be aligned to <pre>&lt;java.lang.String,V&gt;</pre>
+     *
      * @param redirectGenericTypes the type arguments or the redirect class node
-     * @param parameterizedTypes the actual type arguments used on this class node
-     * @param alignmentTarget the generic type arguments to which we want to align to
+     * @param parameterizedTypes   the actual type arguments used on this class node
+     * @param alignmentTarget      the generic type arguments to which we want to align to
      * @return aligned type arguments
      * @deprecated You shouldn't call this method because it is inherently unreliable
      */
     @Deprecated
     public static GenericsType[] alignGenericTypes(final GenericsType[] redirectGenericTypes, final GenericsType[] parameterizedTypes, final GenericsType[] alignmentTarget) {
-        if (alignmentTarget==null) return EMPTY_GENERICS_ARRAY;
-        if (parameterizedTypes==null || parameterizedTypes.length==0) return alignmentTarget;
+        if (alignmentTarget == null) return EMPTY_GENERICS_ARRAY;
+        if (parameterizedTypes == null || parameterizedTypes.length == 0) return alignmentTarget;
         GenericsType[] generics = new GenericsType[alignmentTarget.length];
         for (int i = 0, scgtLength = alignmentTarget.length; i < scgtLength; i++) {
             final GenericsType currentTarget = alignmentTarget[i];
             GenericsType match = null;
-            if (redirectGenericTypes!=null) {
+            if (redirectGenericTypes != null) {
                 for (int j = 0; j < redirectGenericTypes.length && match == null; j++) {
                     GenericsType redirectGenericType = redirectGenericTypes[j];
                     if (redirectGenericType.isCompatibleWith(currentTarget.getType())) {
                         if (currentTarget.isPlaceholder() && redirectGenericType.isPlaceholder() && !currentTarget.getName().equals(redirectGenericType.getName())) {
                             // check if there's a potential better match
                             boolean skip = false;
-                            for (int k=j+1; k<redirectGenericTypes.length && !skip; k++) {
+                            for (int k = j + 1; k < redirectGenericTypes.length && !skip; k++) {
                                 GenericsType ogt = redirectGenericTypes[k];
                                 if (ogt.isPlaceholder() && ogt.isCompatibleWith(currentTarget.getType()) && ogt.getName().equals(currentTarget.getName())) {
                                     skip = true;
@@ -99,12 +97,12 @@ public class GenericsUtils {
                             // if alignment target is a wildcard type
                             // then we must make best effort to return a parameterized
                             // wildcard
-                            ClassNode lower = currentTarget.getLowerBound()!=null?match.getType():null;
+                            ClassNode lower = currentTarget.getLowerBound() != null ? match.getType() : null;
                             ClassNode[] currentUpper = currentTarget.getUpperBounds();
-                            ClassNode[] upper = currentUpper !=null?new ClassNode[currentUpper.length]:null;
-                            if (upper!=null) {
+                            ClassNode[] upper = currentUpper != null ? new ClassNode[currentUpper.length] : null;
+                            if (upper != null) {
                                 for (int k = 0; k < upper.length; k++) {
-                                    upper[k] = currentUpper[k].isGenericsPlaceHolder()?match.getType():currentUpper[k];
+                                    upper[k] = currentUpper[k].isGenericsPlaceHolder() ? match.getType() : currentUpper[k];
                                 }
                             }
                             match = new GenericsType(ClassHelper.makeWithoutCaching("?"), upper, lower);
@@ -116,7 +114,7 @@ public class GenericsUtils {
             if (match == null) {
                 match = currentTarget;
             }
-            generics[i]=match;
+            generics[i] = match;
         }
         return generics;
     }
@@ -124,6 +122,7 @@ public class GenericsUtils {
     /**
      * Generates a wildcard generic type in order to be used for checks against class nodes.
      * See {@link GenericsType#isCompatibleWith(org.codehaus.groovy.ast.ClassNode)}.
+     *
      * @param types the type to be used as the wildcard upper bound
      * @return a wildcard generics type
      */
@@ -143,8 +142,9 @@ public class GenericsUtils {
     /**
      * For a given classnode, fills in the supplied map with the parameterized
      * types it defines.
-     * @param node
-     * @param map
+     *
+     * @param node the class node to check
+     * @param map the generics type information collector
      */
     public static void extractPlaceholders(ClassNode node, Map<String, GenericsType> map) {
         if (node == null) return;
@@ -158,7 +158,7 @@ public class GenericsUtils {
         GenericsType[] parameterized = node.getGenericsTypes();
         if (parameterized == null || parameterized.length == 0) return;
         GenericsType[] redirectGenericsTypes = node.redirect().getGenericsTypes();
-        if (redirectGenericsTypes==null) redirectGenericsTypes = parameterized;
+        if (redirectGenericsTypes == null) redirectGenericsTypes = parameterized;
         for (int i = 0; i < redirectGenericsTypes.length; i++) {
             GenericsType redirectType = redirectGenericsTypes[i];
             if (redirectType.isPlaceholder()) {
@@ -168,11 +168,11 @@ public class GenericsUtils {
                     map.put(name, value);
                     if (value.isWildcard()) {
                         ClassNode lowerBound = value.getLowerBound();
-                        if (lowerBound!=null) {
+                        if (lowerBound != null) {
                             extractPlaceholders(lowerBound, map);
                         }
                         ClassNode[] upperBounds = value.getUpperBounds();
-                        if (upperBounds!=null) {
+                        if (upperBounds != null) {
                             for (ClassNode upperBound : upperBounds) {
                                 extractPlaceholders(upperBound, map);
                             }
@@ -190,7 +190,8 @@ public class GenericsUtils {
      * or {@link org.codehaus.groovy.ast.ClassNode#getAllInterfaces()} are returned with generic type
      * arguments. This method allows returning a parameterized interface given the parameterized class
      * node which implements this interface.
-     * @param hint the class node where generics types are parameterized
+     *
+     * @param hint   the class node where generics types are parameterized
      * @param target the interface we want to parameterize generics types
      * @return a parameterized interface class node
      * @deprecated Use #parameterizeType instead
@@ -205,7 +206,8 @@ public class GenericsUtils {
      * or {@link org.codehaus.groovy.ast.ClassNode#getAllInterfaces()} are returned with generic type
      * arguments. This method allows returning a parameterized interface given the parameterized class
      * node which implements this interface.
-     * @param hint the class node where generics types are parameterized
+     *
+     * @param hint   the class node where generics types are parameterized
      * @param target the interface we want to parameterize generics types
      * @return a parameterized interface class node
      */
@@ -282,7 +284,7 @@ public class GenericsUtils {
         return makeClassSafe0(type, gtypes);
     }
 
-    public static MethodNode correctToGenericsSpec(Map<String,ClassNode> genericsSpec, MethodNode mn) {
+    public static MethodNode correctToGenericsSpec(Map<String, ClassNode> genericsSpec, MethodNode mn) {
         ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, mn.getReturnType());
         Parameter[] origParameters = mn.getParameters();
         Parameter[] newParameters = new Parameter[origParameters.length];
@@ -293,26 +295,26 @@ public class GenericsUtils {
         return new MethodNode(mn.getName(), mn.getModifiers(), correctedType, newParameters, mn.getExceptions(), mn.getCode());
     }
 
-    public static ClassNode correctToGenericsSpecRecurse(Map<String,ClassNode> genericsSpec, ClassNode type) {
+    public static ClassNode correctToGenericsSpecRecurse(Map<String, ClassNode> genericsSpec, ClassNode type) {
         return correctToGenericsSpecRecurse(genericsSpec, type, new ArrayList<String>());
     }
 
     /**
      * @since 2.4.1
      */
-    public static ClassNode[] correctToGenericsSpecRecurse(Map<String,ClassNode> genericsSpec, ClassNode[] types) {
-        if (types==null || types.length==1) return types;
+    public static ClassNode[] correctToGenericsSpecRecurse(Map<String, ClassNode> genericsSpec, ClassNode[] types) {
+        if (types == null || types.length == 1) return types;
         ClassNode[] newTypes = new ClassNode[types.length];
         boolean modified = false;
-        for (int i=0; i<types.length; i++) {
+        for (int i = 0; i < types.length; i++) {
             newTypes[i] = correctToGenericsSpecRecurse(genericsSpec, types[i], new ArrayList<String>());
-            modified = modified || (types[i]!=newTypes[i]);
+            modified = modified || (types[i] != newTypes[i]);
         }
         if (!modified) return types;
         return newTypes;
     }
 
-    public static ClassNode correctToGenericsSpecRecurse(Map<String,ClassNode> genericsSpec, ClassNode type, List<String> exclusions) {
+    public static ClassNode correctToGenericsSpecRecurse(Map<String, ClassNode> genericsSpec, ClassNode type, List<String> exclusions) {
         if (type.isArray()) {
             return correctToGenericsSpecRecurse(genericsSpec, type.getComponentType(), exclusions).makeArray();
         }
@@ -332,21 +334,21 @@ public class GenericsUtils {
             newgTypes = new GenericsType[oldgTypes.length];
             for (int i = 0; i < newgTypes.length; i++) {
                 GenericsType oldgType = oldgTypes[i];
-                if (oldgType.isPlaceholder() ) {
-                    if (genericsSpec.get(oldgType.getName())!=null) {
+                if (oldgType.isPlaceholder()) {
+                    if (genericsSpec.get(oldgType.getName()) != null) {
                         newgTypes[i] = new GenericsType(genericsSpec.get(oldgType.getName()));
                     } else {
                         newgTypes[i] = new GenericsType(ClassHelper.OBJECT_TYPE);
                     }
                 } else if (oldgType.isWildcard()) {
                     ClassNode oldLower = oldgType.getLowerBound();
-                    ClassNode lower = oldLower!=null?correctToGenericsSpecRecurse(genericsSpec, oldLower, exclusions):null;
+                    ClassNode lower = oldLower != null ? correctToGenericsSpecRecurse(genericsSpec, oldLower, exclusions) : null;
                     ClassNode[] oldUpper = oldgType.getUpperBounds();
                     ClassNode[] upper = null;
-                    if (oldUpper!=null) {
+                    if (oldUpper != null) {
                         upper = new ClassNode[oldUpper.length];
                         for (int j = 0; j < oldUpper.length; j++) {
-                            upper[j] = correctToGenericsSpecRecurse(genericsSpec,oldUpper[j], exclusions);
+                            upper[j] = correctToGenericsSpecRecurse(genericsSpec, oldUpper[j], exclusions);
                         }
                     }
                     GenericsType fixed = new GenericsType(oldgType.getType(), upper, lower);
@@ -354,7 +356,7 @@ public class GenericsUtils {
                     fixed.setWildcard(true);
                     newgTypes[i] = fixed;
                 } else {
-                    newgTypes[i] = new GenericsType(correctToGenericsSpecRecurse(genericsSpec,correctToGenericsSpec(genericsSpec, oldgType), exclusions));
+                    newgTypes[i] = new GenericsType(correctToGenericsSpecRecurse(genericsSpec, correctToGenericsSpec(genericsSpec, oldgType), exclusions));
                 }
             }
         }
@@ -371,7 +373,7 @@ public class GenericsUtils {
         return ret;
     }
 
-    public static ClassNode correctToGenericsSpec(Map<String,ClassNode> genericsSpec, ClassNode type) {
+    public static ClassNode correctToGenericsSpec(Map<String, ClassNode> genericsSpec, ClassNode type) {
         if (type.isArray()) {
             return correctToGenericsSpec(genericsSpec, type.getComponentType()).makeArray();
         }
@@ -384,12 +386,12 @@ public class GenericsUtils {
     }
 
     @SuppressWarnings("unchecked")
-    public static Map<String,ClassNode> createGenericsSpec(ClassNode current) {
+    public static Map<String, ClassNode> createGenericsSpec(ClassNode current) {
         return createGenericsSpec(current, Collections.EMPTY_MAP);
     }
 
-    public static Map<String,ClassNode> createGenericsSpec(ClassNode current, Map<String,ClassNode> oldSpec) {
-        Map<String,ClassNode> ret = new HashMap<String,ClassNode>(oldSpec);
+    public static Map<String, ClassNode> createGenericsSpec(ClassNode current, Map<String, ClassNode> oldSpec) {
+        Map<String, ClassNode> ret = new HashMap<String, ClassNode>(oldSpec);
         // ret contains the type specs, what we now need is the type spec for the
         // current class. To get that we first apply the type parameters to the
         // current class and then use the type names of the current class to reset
@@ -416,8 +418,8 @@ public class GenericsUtils {
         return ret;
     }
 
-    public static Map<String,ClassNode> addMethodGenerics(MethodNode current, Map<String,ClassNode> oldSpec) {
-        Map<String,ClassNode> ret = new HashMap<String,ClassNode>(oldSpec);
+    public static Map<String, ClassNode> addMethodGenerics(MethodNode current, Map<String, ClassNode> oldSpec) {
+        Map<String, ClassNode> ret = new HashMap<String, ClassNode>(oldSpec);
         // ret starts with the original type specs, now add gts for the current method if any
         GenericsType[] sgts = current.getGenericsTypes();
         if (sgts != null) {
@@ -471,16 +473,16 @@ public class GenericsUtils {
 
     private static void extractSuperClassGenerics(GenericsType[] usage, GenericsType[] declaration, Map<String, ClassNode> spec) {
         // if declaration does not provide generics, there is no connection to make 
-        if (usage==null || declaration==null || declaration.length==0) return;
-        if (usage.length!=declaration.length) return;
+        if (usage == null || declaration == null || declaration.length == 0) return;
+        if (usage.length != declaration.length) return;
 
         // both have generics
-        for (int i=0; i<usage.length; i++) {
+        for (int i = 0; i < usage.length; i++) {
             GenericsType ui = usage[i];
             GenericsType di = declaration[i];
             if (di.isPlaceholder()) {
                 spec.put(di.getName(), ui.getType());
-            } else if (di.isWildcard()){
+            } else if (di.isWildcard()) {
                 if (ui.isWildcard()) {
                     extractSuperClassGenerics(ui.getLowerBound(), di.getLowerBound(), spec);
                     extractSuperClassGenerics(ui.getUpperBounds(), di.getUpperBounds(), spec);
@@ -488,7 +490,7 @@ public class GenericsUtils {
                     ClassNode cu = ui.getType();
                     extractSuperClassGenerics(cu, di.getLowerBound(), spec);
                     ClassNode[] upperBounds = di.getUpperBounds();
-                    if (upperBounds!=null) {
+                    if (upperBounds != null) {
                         for (ClassNode cn : upperBounds) {
                             extractSuperClassGenerics(cu, cn, spec);
                         }
@@ -501,14 +503,14 @@ public class GenericsUtils {
     }
 
     private static void extractSuperClassGenerics(ClassNode[] usage, ClassNode[] declaration, Map<String, ClassNode> spec) {
-        if (usage==null || declaration==null || declaration.length==0) return;
+        if (usage == null || declaration == null || declaration.length == 0) return;
         // both have generics
-        for (int i=0; i<usage.length; i++) {
+        for (int i = 0; i < usage.length; i++) {
             ClassNode ui = usage[i];
             ClassNode di = declaration[i];
             if (di.isGenericsPlaceHolder()) {
                 spec.put(di.getGenericsTypes()[0].getName(), di);
-            } else if (di.isUsingGenerics()){
+            } else if (di.isUsingGenerics()) {
                 extractSuperClassGenerics(ui.getGenericsTypes(), di.getGenericsTypes(), spec);
             }
         }
@@ -556,7 +558,7 @@ public class GenericsUtils {
     }
 
     private static ClassNode resolveClassNode(final SourceUnit sourceUnit, final CompilationUnit compilationUnit, final MethodNode mn, final ASTNode usage, final ClassNode parsedNode) {
-        ClassNode dummyClass = new ClassNode("dummy",0, ClassHelper.OBJECT_TYPE);
+        ClassNode dummyClass = new ClassNode("dummy", 0, ClassHelper.OBJECT_TYPE);
         dummyClass.setModule(new ModuleNode(sourceUnit));
         dummyClass.setGenericsTypes(mn.getDeclaringClass().getGenericsTypes());
         MethodNode dummyMN = new MethodNode(
@@ -583,19 +585,21 @@ 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
      * after the transformation.
-     * @param genericsSpec the generics context information spec
+     *
+     * @param genericsSpec    the generics context information spec
      * @param oldPlaceHolders the old placeholders
      * @return the new generics types
      */
     public static GenericsType[] applyGenericsContextToPlaceHolders(Map<String, ClassNode> genericsSpec, GenericsType[] oldPlaceHolders) {
-        if (oldPlaceHolders==null || oldPlaceHolders.length==0) return oldPlaceHolders;
+        if (oldPlaceHolders == null || oldPlaceHolders.length == 0) return oldPlaceHolders;
         if (genericsSpec.isEmpty()) return oldPlaceHolders;
         GenericsType[] newTypes = new GenericsType[oldPlaceHolders.length];
-        for (int i=0; i<oldPlaceHolders.length; i++) {
+        for (int i = 0; i < oldPlaceHolders.length; i++) {
             GenericsType old = oldPlaceHolders[i];
-            if (!old.isPlaceholder()) throw new GroovyBugError("Given generics type "+old+" must be a placeholder!");
+            if (!old.isPlaceholder())
+                throw new GroovyBugError("Given generics type " + old + " must be a placeholder!");
             ClassNode fromSpec = genericsSpec.get(old.getName());
-            if (fromSpec!=null) {
+            if (fromSpec != null) {
                 if (fromSpec.isGenericsPlaceHolder()) {
                     ClassNode[] upper = new ClassNode[]{fromSpec.redirect()};
                     newTypes[i] = new GenericsType(fromSpec, upper, null);
@@ -605,16 +609,16 @@ public class GenericsUtils {
             } else {
                 ClassNode[] upper = old.getUpperBounds();
                 ClassNode[] newUpper = upper;
-                if (upper!=null && upper.length>0) {
+                if (upper != null && upper.length > 0) {
                     ClassNode[] upperCorrected = new ClassNode[upper.length];
-                    for (int j=0;j<upper.length;j++) {
-                        upperCorrected[i] = correctToGenericsSpecRecurse(genericsSpec,upper[j]);
+                    for (int j = 0; j < upper.length; j++) {
+                        upperCorrected[i] = correctToGenericsSpecRecurse(genericsSpec, upper[j]);
                     }
                     upper = upperCorrected;
                 }
                 ClassNode lower = old.getLowerBound();
-                ClassNode newLower = correctToGenericsSpecRecurse(genericsSpec,lower);
-                if (lower==newLower && upper==newUpper) {
+                ClassNode newLower = correctToGenericsSpecRecurse(genericsSpec, lower);
+                if (lower == newLower && upper == newUpper) {
                     newTypes[i] = oldPlaceHolders[i];
                 } else {
                     ClassNode newPlaceHolder = ClassHelper.make(old.getName());

http://git-wip-us.apache.org/repos/asf/groovy/blob/ef659512/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
index f07dd97..fbc3624 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -169,38 +169,40 @@ public abstract class StaticTypeCheckingSupport {
                 private static final long serialVersionUID = 8841951852732042766L;
 
                 {
-                put(byte_TYPE, 0);
-                put(Byte_TYPE, 0);
-                put(short_TYPE, 1);
-                put(Short_TYPE, 1);
-                put(int_TYPE, 2);
-                put(Integer_TYPE, 2);
-                put(Long_TYPE, 3);
-                put(long_TYPE, 3);
-                put(float_TYPE, 4);
-                put(Float_TYPE, 4);
-                put(double_TYPE, 5);
-                put(Double_TYPE, 5);
-            }});
+                    put(byte_TYPE, 0);
+                    put(Byte_TYPE, 0);
+                    put(short_TYPE, 1);
+                    put(Short_TYPE, 1);
+                    put(int_TYPE, 2);
+                    put(Integer_TYPE, 2);
+                    put(Long_TYPE, 3);
+                    put(long_TYPE, 3);
+                    put(float_TYPE, 4);
+                    put(Float_TYPE, 4);
+                    put(double_TYPE, 5);
+                    put(Double_TYPE, 5);
+                }
+            });
 
     protected static final Map<String, Integer> NUMBER_OPS = Collections.unmodifiableMap(
             new HashMap<String, Integer>() {
                 private static final long serialVersionUID = 6951856193525808411L;
 
                 {
-                put("plus", PLUS);
-                put("minus", MINUS);
-                put("multiply", MULTIPLY);
-                put("div", DIVIDE);
-                put("or", BITWISE_OR);
-                put("and", BITWISE_AND);
-                put("xor", BITWISE_XOR);
-                put("mod", MOD);
-                put("intdiv", INTDIV);
-                put("leftShift", LEFT_SHIFT);
-                put("rightShift", RIGHT_SHIFT);
-                put("rightShiftUnsigned", RIGHT_SHIFT_UNSIGNED);
-            }});
+                    put("plus", PLUS);
+                    put("minus", MINUS);
+                    put("multiply", MULTIPLY);
+                    put("div", DIVIDE);
+                    put("or", BITWISE_OR);
+                    put("and", BITWISE_AND);
+                    put("xor", BITWISE_XOR);
+                    put("mod", MOD);
+                    put("intdiv", INTDIV);
+                    put("leftShift", LEFT_SHIFT);
+                    put("rightShift", RIGHT_SHIFT);
+                    put("rightShiftUnsigned", RIGHT_SHIFT_UNSIGNED);
+                }
+            });
 
     protected static final ClassNode GSTRING_STRING_CLASSNODE = WideningCategories.lowestUpperBound(
             STRING_TYPE,
@@ -246,6 +248,7 @@ public abstract class StaticTypeCheckingSupport {
 
     /**
      * Returns true for expressions of the form x[...]
+     *
      * @param expression an expression
      * @return true for array access expressions
      */
@@ -256,7 +259,8 @@ public abstract class StaticTypeCheckingSupport {
     /**
      * Called on method call checks in order to determine if a method call corresponds to the
      * idiomatic o.with { ... } structure
-     * @param name name of the method called
+     *
+     * @param name          name of the method called
      * @param callArguments arguments of the method
      * @return true if the name is "with" and arguments consist of a single closure
      */
@@ -272,6 +276,7 @@ public abstract class StaticTypeCheckingSupport {
 
     /**
      * Given a variable expression, returns the ultimately accessed variable.
+     *
      * @param ve a variable expression
      * @return the target variable
      */
@@ -286,11 +291,11 @@ public abstract class StaticTypeCheckingSupport {
 
 
     /**
-     * @deprecated Use {@link #findDGMMethodsForClassNode(ClassLoader, ClassNode,String)} instead
+     * @deprecated Use {@link #findDGMMethodsForClassNode(ClassLoader, ClassNode, String)} instead
      */
     @Deprecated
     protected static Set<MethodNode> findDGMMethodsForClassNode(ClassNode clazz, String name) {
-        return findDGMMethodsForClassNode(MetaClassRegistryImpl.class.getClassLoader(), clazz,  name);
+        return findDGMMethodsForClassNode(MetaClassRegistryImpl.class.getClassLoader(), clazz, name);
     }
 
     protected static Set<MethodNode> findDGMMethodsForClassNode(final ClassLoader loader, ClassNode clazz, String name) {
@@ -337,24 +342,25 @@ public abstract class StaticTypeCheckingSupport {
 
     /**
      * Checks that arguments and parameter types match.
+     *
      * @param params method parameters
-     * @param args type arguments
+     * @param args   type arguments
      * @return -1 if arguments do not match, 0 if arguments are of the exact type and >0 when one or more argument is
      * not of the exact type but still match
      */
     public static int allParametersAndArgumentsMatch(Parameter[] params, ClassNode[] args) {
-        if (params==null) {
+        if (params == null) {
             params = Parameter.EMPTY_ARRAY;
         }
         int dist = 0;
-        if (args.length<params.length) return -1;
+        if (args.length < params.length) return -1;
         // we already know there are at least params.length elements in both arrays
         for (int i = 0; i < params.length; i++) {
             ClassNode paramType = params[i].getType();
             ClassNode argType = args[i];
             if (!isAssignableTo(argType, paramType)) return -1;
             else {
-                if (!paramType.equals(argType)) dist+=getDistance(argType, paramType);
+                if (!paramType.equals(argType)) dist += getDistance(argType, paramType);
             }
         }
         return dist;
@@ -363,8 +369,9 @@ public abstract class StaticTypeCheckingSupport {
     /**
      * Checks that arguments and parameter types match, expecting that the number of parameters is strictly greater
      * than the number of arguments, allowing possible inclusion of default parameters.
+     *
      * @param params method parameters
-     * @param args type arguments
+     * @param args   type arguments
      * @return -1 if arguments do not match, 0 if arguments are of the exact type and >0 when one or more argument is
      * not of the exact type but still match
      */
@@ -372,19 +379,19 @@ public abstract class StaticTypeCheckingSupport {
         int dist = 0;
         ClassNode ptype = null;
         // we already know the lengths are equal
-        for (int i = 0, j=0; i < params.length; i++) {
+        for (int i = 0, j = 0; i < params.length; i++) {
             Parameter param = params[i];
             ClassNode paramType = param.getType();
-            ClassNode arg = j>=args.length?null:args[j];
-            if (arg==null || !isAssignableTo(arg, paramType)){
-                if (!param.hasInitialExpression() && (ptype==null || !ptype.equals(paramType))) {
+            ClassNode arg = j >= args.length ? null : args[j];
+            if (arg == null || !isAssignableTo(arg, paramType)) {
+                if (!param.hasInitialExpression() && (ptype == null || !ptype.equals(paramType))) {
                     return -1; // no default value
                 }
                 // a default value exists, we can skip this param
                 ptype = null;
             } else {
                 j++;
-                if (!paramType.equals(arg)) dist+=getDistance(arg, paramType);
+                if (!paramType.equals(arg)) dist += getDistance(arg, paramType);
                 if (param.hasInitialExpression()) {
                     ptype = arg;
                 } else {
@@ -397,6 +404,7 @@ public abstract class StaticTypeCheckingSupport {
 
     /**
      * Checks that excess arguments match the vararg signature parameter.
+     *
      * @param params
      * @param args
      * @return -1 if no match, 0 if all arguments matches the vararg type and >0 if one or more vararg argument is
@@ -409,7 +417,7 @@ public abstract class StaticTypeCheckingSupport {
         int dist = 0;
         ClassNode vargsBase = params[params.length - 1].getType().getComponentType();
         for (int i = params.length; i < args.length; i++) {
-            if (!isAssignableTo(args[i],vargsBase)) return -1;
+            if (!isAssignableTo(args[i], vargsBase)) return -1;
             else dist += getClassDistance(vargsBase, args[i]);
         }
         return dist;
@@ -417,6 +425,7 @@ public abstract class StaticTypeCheckingSupport {
 
     /**
      * Checks if the last argument matches the vararg type.
+     *
      * @param params
      * @param args
      * @return -1 if no match, 0 if the last argument is exactly the vararg type and 1 if of an assignable type
@@ -432,19 +441,20 @@ public abstract class StaticTypeCheckingSupport {
         ClassNode ptype = lastParamType.getComponentType();
         ClassNode arg = args[args.length - 1];
         if (isNumberType(ptype) && isNumberType(arg) && !ptype.equals(arg)) return -1;
-        return isAssignableTo(arg, ptype)?Math.min(getDistance(arg, lastParamType), getDistance(arg, ptype)):-1;
+        return isAssignableTo(arg, ptype) ? Math.min(getDistance(arg, lastParamType), getDistance(arg, ptype)) : -1;
     }
 
     /**
      * Checks if a class node is assignable to another. This is used for example in
      * assignment checks where you want to verify that the assignment is valid.
+     *
      * @param type
      * @param toBeAssignedTo
      * @return true if the class node is assignable to the other class node, false otherwise
      */
     static boolean isAssignableTo(ClassNode type, ClassNode toBeAssignedTo) {
-        if (UNKNOWN_PARAMETER_TYPE==type) return true;
-        if (type==toBeAssignedTo) return true;
+        if (UNKNOWN_PARAMETER_TYPE == type) return true;
+        if (type == toBeAssignedTo) return true;
         if (toBeAssignedTo.redirect() == STRING_TYPE && type.redirect() == GSTRING_TYPE) {
             return true;
         }
@@ -454,7 +464,7 @@ public abstract class StaticTypeCheckingSupport {
             return NUMBER_TYPES.get(type.redirect()) <= NUMBER_TYPES.get(toBeAssignedTo.redirect());
         }
         if (type.isArray() && toBeAssignedTo.isArray()) {
-            return isAssignableTo(type.getComponentType(),toBeAssignedTo.getComponentType());
+            return isAssignableTo(type.getComponentType(), toBeAssignedTo.getComponentType());
         }
         if (type.isDerivedFrom(GSTRING_TYPE) && STRING_TYPE.equals(toBeAssignedTo)) {
             return true;
@@ -666,29 +676,29 @@ public abstract class StaticTypeCheckingSupport {
     public static boolean checkCompatibleAssignmentTypes(ClassNode left, ClassNode right, Expression rightExpression, boolean allowConstructorCoercion) {
         ClassNode leftRedirect = left.redirect();
         ClassNode rightRedirect = right.redirect();
-        if (leftRedirect==rightRedirect) return true;
+        if (leftRedirect == rightRedirect) return true;
 
         if (leftRedirect.isArray() && rightRedirect.isArray()) {
             return checkCompatibleAssignmentTypes(leftRedirect.getComponentType(), rightRedirect.getComponentType(), rightExpression, false);
         }
 
-        if (right==VOID_TYPE||right==void_WRAPPER_TYPE) {
-            return left==VOID_TYPE||left==void_WRAPPER_TYPE;
+        if (right == VOID_TYPE || right == void_WRAPPER_TYPE) {
+            return left == VOID_TYPE || left == void_WRAPPER_TYPE;
         }
 
-        if ((isNumberType(rightRedirect)|| WideningCategories.isNumberCategory(rightRedirect))) {
-           if (BigDecimal_TYPE==leftRedirect) {
-               // any number can be assigned to a big decimal
-               return true;
-           }
-            if (BigInteger_TYPE==leftRedirect) {
+        if ((isNumberType(rightRedirect) || WideningCategories.isNumberCategory(rightRedirect))) {
+            if (BigDecimal_TYPE == leftRedirect) {
+                // any number can be assigned to a big decimal
+                return true;
+            }
+            if (BigInteger_TYPE == leftRedirect) {
                 return WideningCategories.isBigIntCategory(getUnwrapper(rightRedirect)) ||
                         rightRedirect.isDerivedFrom(BigInteger_TYPE);
             }
         }
 
         // if rightExpression is null and leftExpression is not a primitive type, it's ok
-        boolean rightExpressionIsNull = rightExpression instanceof ConstantExpression && ((ConstantExpression) rightExpression).getValue()==null;
+        boolean rightExpressionIsNull = rightExpression instanceof ConstantExpression && ((ConstantExpression) rightExpression).getValue() == null;
         if (rightExpressionIsNull && !isPrimitiveType(left)) {
             return true;
         }
@@ -701,14 +711,14 @@ public abstract class StaticTypeCheckingSupport {
                 && !(boolean_TYPE.equals(left) && rightExpressionIsNull)) return true;
 
         // char as left expression
-        if (leftRedirect == char_TYPE && rightRedirect==STRING_TYPE) {
+        if (leftRedirect == char_TYPE && rightRedirect == STRING_TYPE) {
             if (rightExpression instanceof ConstantExpression) {
                 String value = rightExpression.getText();
-                return value.length()==1;
+                return value.length() == 1;
             }
         }
-        if (leftRedirect == Character_TYPE && (rightRedirect==STRING_TYPE||rightExpressionIsNull)) {
-            return rightExpressionIsNull || (rightExpression instanceof ConstantExpression && rightExpression.getText().length()==1);
+        if (leftRedirect == Character_TYPE && (rightRedirect == STRING_TYPE || rightExpressionIsNull)) {
+            return rightExpressionIsNull || (rightExpression instanceof ConstantExpression && rightExpression.getText().length() == 1);
         }
 
         // if left is Enum and right is String or GString we do valueOf
@@ -748,7 +758,7 @@ public abstract class StaticTypeCheckingSupport {
         if (left.isGenericsPlaceHolder()) {
             // GROOVY-7307
             GenericsType[] genericsTypes = left.getGenericsTypes();
-            if (genericsTypes!=null && genericsTypes.length==1) {
+            if (genericsTypes != null && genericsTypes.length == 1) {
                 // should always be the case, but safe guard is better
                 return genericsTypes[0].isCompatibleWith(right);
             }
@@ -768,15 +778,16 @@ public abstract class StaticTypeCheckingSupport {
     /**
      * Tells if a class is one of the "accept all" classes as the left hand side of an
      * assignment.
+     *
      * @param node the classnode to test
      * @return true if it's an Object, String, boolean, Boolean or Class.
      */
     public static boolean isWildcardLeftHandSide(final ClassNode node) {
         if (OBJECT_TYPE.equals(node) ||
-            STRING_TYPE.equals(node) ||
-            boolean_TYPE.equals(node) ||
-            Boolean_TYPE.equals(node) ||
-            CLASS_Type.equals(node)) {
+                STRING_TYPE.equals(node) ||
+                boolean_TYPE.equals(node) ||
+                Boolean_TYPE.equals(node) ||
+                CLASS_Type.equals(node)) {
             return true;
         }
         return false;
@@ -875,7 +886,7 @@ public abstract class StaticTypeCheckingSupport {
 
     static String prettyPrintType(ClassNode type) {
         if (type.isArray()) {
-            return prettyPrintType(type.getComponentType())+"[]";
+            return prettyPrintType(type.getComponentType()) + "[]";
         }
         return type.toString(false);
     }
@@ -926,13 +937,13 @@ public abstract class StaticTypeCheckingSupport {
         ClassNode unwrapCompare = getUnwrapper(compare);
         if (isPrimitiveType(unwrapReceiver)
                 && isPrimitiveType(unwrapCompare)
-                && unwrapReceiver!=unwrapCompare) {
+                && unwrapReceiver != unwrapCompare) {
             dist = getPrimitiveDistance(unwrapReceiver, unwrapCompare);
         }
         // Add a penalty against boxing or unboxing, to get a resolution similar to JLS 15.12.2
         // (http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2).
         if (isPrimitiveType(receiver) ^ isPrimitiveType(compare)) {
-            dist = (dist+1)<<1;
+            dist = (dist + 1) << 1;
         }
         if (unwrapCompare.equals(unwrapReceiver)) return dist;
         if (receiver.isArray() && !compare.isArray()) {
@@ -945,7 +956,7 @@ public abstract class StaticTypeCheckingSupport {
         }
 
         ClassNode ref = receiver;
-        while (ref!=null) {
+        while (ref != null) {
             if (compare.equals(ref)) {
                 break;
             }
@@ -955,8 +966,8 @@ public abstract class StaticTypeCheckingSupport {
             }
             ref = ref.getSuperClass();
             dist++;
-            if (ref == null) dist++ ;
-            dist = (dist+1)<<1;
+            if (ref == null) dist++;
+            dist = (dist + 1) << 1;
         }
         return dist;
     }
@@ -976,7 +987,7 @@ public abstract class StaticTypeCheckingSupport {
             // we want to add one, because there is an interface between
             // the interface we search for and the interface we are in.
             if (sub != -1) {
-                sub+=1;
+                sub += 1;
             }
             // we are interested in the longest path only
             max = Math.max(max, sub);
@@ -1019,6 +1030,7 @@ public abstract class StaticTypeCheckingSupport {
      * Returns true if the provided class node, when considered as a receiver of a message or as a parameter,
      * is using a placeholder in its generics type. In this case, we're facing unchecked generics and type
      * checking is limited (ex: void foo(Set s) { s.keySet() }
+     *
      * @param node the node to test
      * @return true if it is using any placeholder in generics types
      */
@@ -1026,7 +1038,7 @@ public abstract class StaticTypeCheckingSupport {
         if (node.isArray()) return isUsingUncheckedGenerics(node.getComponentType());
         if (node.isUsingGenerics()) {
             GenericsType[] genericsTypes = node.getGenericsTypes();
-            if (genericsTypes!=null) {
+            if (genericsTypes != null) {
                 for (GenericsType genericsType : genericsTypes) {
                     if (genericsType.isPlaceholder()) {
                         return true;
@@ -1047,8 +1059,8 @@ public abstract class StaticTypeCheckingSupport {
      * Given a list of candidate methods, returns the one which best matches the argument types
      *
      * @param receiver
-     * @param methods candidate methods
-     * @param args argument types
+     * @param methods  candidate methods
+     * @param args     argument types
      * @return the list of methods which best matches the argument types. It is still possible that multiple
      * methods match the argument types.
      */
@@ -1068,7 +1080,7 @@ public abstract class StaticTypeCheckingSupport {
             ClassNode[] safeArgs = args;
             boolean isExtensionMethodNode = candidateNode instanceof ExtensionMethodNode;
             if (isExtensionMethodNode) {
-                safeArgs = new ClassNode[args.length+1];
+                safeArgs = new ClassNode[args.length + 1];
                 System.arraycopy(args, 0, safeArgs, 1, args.length);
                 safeArgs[0] = receiver;
                 safeNode = ((ExtensionMethodNode) candidateNode).getExtensionMethodNode();
@@ -1099,7 +1111,7 @@ public abstract class StaticTypeCheckingSupport {
                 }
             }
         }
-        if (bestChoices.size()>1) {
+        if (bestChoices.size() > 1) {
             // GROOVY-6849: prefer extension methods in case of ambiguity
             List<MethodNode> onlyExtensionMethods = new LinkedList<MethodNode>();
             for (MethodNode choice : bestChoices) {
@@ -1107,7 +1119,7 @@ public abstract class StaticTypeCheckingSupport {
                     onlyExtensionMethods.add(choice);
                 }
             }
-            if (onlyExtensionMethods.size()==1) {
+            if (onlyExtensionMethods.size() == 1) {
                 return onlyExtensionMethods;
             }
         }
@@ -1177,9 +1189,9 @@ public abstract class StaticTypeCheckingSupport {
 
     private static Parameter[] makeRawTypes(Parameter[] params) {
         Parameter[] newParam = new Parameter[params.length];
-        for (int i=0; i<params.length; i++) {
+        for (int i = 0; i < params.length; i++) {
             Parameter oldP = params[i];
-            Parameter newP = new Parameter(makeRawType(oldP.getType()),oldP.getName());
+            Parameter newP = new Parameter(makeRawType(oldP.getType()), oldP.getName());
             newParam[i] = newP;
         }
         return newParam;
@@ -1206,7 +1218,7 @@ public abstract class StaticTypeCheckingSupport {
                 MethodNode two = list.get(j);
                 if (toBeRemoved.contains(two)) continue;
                 if (one.getParameters().length == two.getParameters().length) {
-                    if (areOverloadMethodsInSameClass(one,two)) {
+                    if (areOverloadMethodsInSameClass(one, two)) {
                         if (ParameterUtils.parametersEqual(one.getParameters(), two.getParameters())) {
                             removeMethodWithSuperReturnType(toBeRemoved, one, two);
                         } else {
@@ -1279,7 +1291,7 @@ public abstract class StaticTypeCheckingSupport {
      * available generic type information.
      *
      * @param receiver the class
-     * @param m the method
+     * @param m        the method
      * @return the parameterized arguments
      */
     public static Parameter[] parameterizeArguments(final ClassNode receiver, final MethodNode m) {
@@ -1297,14 +1309,15 @@ public abstract class StaticTypeCheckingSupport {
 
     /**
      * Given a parameter, builds a new parameter for which the known generics placeholders are resolved.
-     * @param genericFromReceiver resolved generics from the receiver of the message
+     *
+     * @param genericFromReceiver      resolved generics from the receiver of the message
      * @param placeholdersFromContext, resolved generics from the method context
-     * @param methodParameter the method parameter for which we want to resolve generic types
-     * @param paramType the (unresolved) type of the method parameter
+     * @param methodParameter          the method parameter for which we want to resolve generic types
+     * @param paramType                the (unresolved) type of the method parameter
      * @return a new parameter with the same name and type as the original one, but with resolved generic types
      */
     private static Parameter buildParameter(final Map<String, GenericsType> genericFromReceiver, final Map<String, GenericsType> placeholdersFromContext, final Parameter methodParameter, final ClassNode paramType) {
-        if (genericFromReceiver.isEmpty() && (placeholdersFromContext==null||placeholdersFromContext.isEmpty())) {
+        if (genericFromReceiver.isEmpty() && (placeholdersFromContext == null || placeholdersFromContext.isEmpty())) {
             return methodParameter;
         }
         if (paramType.isArray()) {
@@ -1321,6 +1334,7 @@ public abstract class StaticTypeCheckingSupport {
     /**
      * Returns true if a class node makes use of generic types. If the class node represents an
      * array type, then checks if the component type is using generics.
+     *
      * @param cn a class node for which to check if it is using generics
      * @return true if the type (or component type) is using generics
      */
@@ -1328,7 +1342,7 @@ public abstract class StaticTypeCheckingSupport {
         if (cn.isArray()) {
             return isUsingGenericsOrIsArrayUsingGenerics(cn.getComponentType());
         }
-        return (cn.isUsingGenerics() && cn.getGenericsTypes()!=null);
+        return (cn.isUsingGenerics() && cn.getGenericsTypes() != null);
     }
 
     /**
@@ -1337,7 +1351,7 @@ public abstract class StaticTypeCheckingSupport {
      */
     protected static GenericsType fullyResolve(GenericsType gt, Map<String, GenericsType> placeholders) {
         GenericsType fromMap = placeholders.get(gt.getName());
-        if (gt.isPlaceholder() && fromMap!=null) {
+        if (gt.isPlaceholder() && fromMap != null) {
             gt = fromMap;
         }
 
@@ -1478,7 +1492,7 @@ public abstract class StaticTypeCheckingSupport {
         } else {
             classGTs = GenericsUtils.extractPlaceholders(receiver);
         }
-        if (parameters.length > arguments.length || parameters.length==0) {
+        if (parameters.length > arguments.length || parameters.length == 0) {
             // this is a limitation that must be removed in a future version
             // we cannot check generic type arguments if there are default parameters!
             return true;
@@ -1490,12 +1504,12 @@ public abstract class StaticTypeCheckingSupport {
         // the non-hidden ones.
         Map<String, GenericsType> resolvedMethodGenerics = new HashMap<String, GenericsType>();
         if (!skipBecauseOfInnerClassNotReceiver) {
-            addMethodLevelDeclaredGenerics(candidateMethod,resolvedMethodGenerics);
+            addMethodLevelDeclaredGenerics(candidateMethod, resolvedMethodGenerics);
         }
         // so first we remove hidden generics
-        for (String key: resolvedMethodGenerics.keySet()) classGTs.remove(key);
+        for (String key : resolvedMethodGenerics.keySet()) classGTs.remove(key);
         // then we use the remaining information to refine the given generics
-        applyGenericsConnections(classGTs,resolvedMethodGenerics);
+        applyGenericsConnections(classGTs, resolvedMethodGenerics);
         // and then start our checks with the receiver
         if (!skipBecauseOfInnerClassNotReceiver) {
             failure |= inferenceCheck(Collections.EMPTY_SET, resolvedMethodGenerics, candidateMethod.getDeclaringClass(), receiver, false);
@@ -1512,16 +1526,17 @@ public abstract class StaticTypeCheckingSupport {
             ClassNode wrappedArgument = arguments[i];
             ClassNode type = parameters[pindex].getOriginType();
 
-            failure |= inferenceCheck(fixedGenericsPlaceHolders, resolvedMethodGenerics, type, wrappedArgument,i >= parameters.length - 1);
+            failure |= inferenceCheck(fixedGenericsPlaceHolders, resolvedMethodGenerics, type, wrappedArgument, i >= parameters.length - 1);
 
             // set real fixed generics for extension methods
-            if (isExtensionMethod && i==0) fixedGenericsPlaceHolders = extractResolvedPlaceHolders(resolvedMethodGenerics);
+            if (isExtensionMethod && i == 0)
+                fixedGenericsPlaceHolders = extractResolvedPlaceHolders(resolvedMethodGenerics);
         }
         return !failure;
     }
 
     private static boolean isOuterClassOf(ClassNode receiver, ClassNode type) {
-        if (implementsInterfaceOrIsSubclassOf(receiver,type)) return false;
+        if (implementsInterfaceOrIsSubclassOf(receiver, type)) return false;
         return true;
     }
 
@@ -1572,25 +1587,23 @@ public abstract class StaticTypeCheckingSupport {
         return gt;
     }
 
-    private static boolean compatibleConnections(Map<String, GenericsType> connections, Map<String, GenericsType> resolvedMethodGenerics, Set<String> fixedGenericsPlaceHolders)
-    {
+    private static boolean compatibleConnections(Map<String, GenericsType> connections, Map<String, GenericsType> resolvedMethodGenerics, Set<String> fixedGenericsPlaceHolders) {
         for (Entry<String, GenericsType> entry : connections.entrySet()) {
             GenericsType resolved = resolvedMethodGenerics.get(entry.getKey());
-            if (resolved==null) continue;
+            if (resolved == null) continue;
             GenericsType connection = entry.getValue();
             if (connection.isPlaceholder() && !hasNonTrivialBounds(connection)) {
                 continue;
             }
-            if (!compatibleConnection(resolved,connection)) {
-                if (    !(resolved.isPlaceholder() || resolved.isWildcard()) &&
+            if (!compatibleConnection(resolved, connection)) {
+                if (!(resolved.isPlaceholder() || resolved.isWildcard()) &&
                         !fixedGenericsPlaceHolders.contains(entry.getKey()) &&
-                        compatibleConnection(connection,resolved))
-                {
+                        compatibleConnection(connection, resolved)) {
                     // we did for example find T=String and now check against
                     // T=Object, which fails the first compatibleConnection check
                     // but since T=Object works for both, the second one will pass
                     // and we need to change the type for T to the more general one
-                    resolvedMethodGenerics.put(entry.getKey(),connection);
+                    resolvedMethodGenerics.put(entry.getKey(), connection);
                 } else {
                     return false;
                 }
@@ -1602,10 +1615,9 @@ public abstract class StaticTypeCheckingSupport {
     private static boolean compatibleConnection(GenericsType resolved, GenericsType connection) {
         GenericsType gt = connection;
         if (!connection.isWildcard()) gt = buildWildcardType(connection);
-        if (    resolved.isPlaceholder() && resolved.getUpperBounds()!=null &&
-                resolved.getUpperBounds().length==1 && !resolved.getUpperBounds()[0].isGenericsPlaceHolder() &&
-                resolved.getUpperBounds()[0].getName().equals("java.lang.Object"))
-        {
+        if (resolved.isPlaceholder() && resolved.getUpperBounds() != null &&
+                resolved.getUpperBounds().length == 1 && !resolved.getUpperBounds()[0].isGenericsPlaceHolder() &&
+                resolved.getUpperBounds()[0].getName().equals("java.lang.Object")) {
             return true;
         }
         ClassNode compareNode;
@@ -1627,7 +1639,7 @@ public abstract class StaticTypeCheckingSupport {
             if (resolved.containsKey(entry.getKey())) continue;
             GenericsType gt = entry.getValue();
             ClassNode cn = gt.getType();
-            if (cn.redirect()==UNKNOWN_PARAMETER_TYPE) continue;
+            if (cn.redirect() == UNKNOWN_PARAMETER_TYPE) continue;
             resolved.put(entry.getKey(), gt);
         }
     }
@@ -1635,10 +1647,10 @@ public abstract class StaticTypeCheckingSupport {
     public static ClassNode resolveClassNodeGenerics(Map<String, GenericsType> resolvedPlaceholders, final Map<String, GenericsType> placeholdersFromContext, ClassNode currentType) {
         ClassNode target = currentType.redirect();
         resolvedPlaceholders = new HashMap<String, GenericsType>(resolvedPlaceholders);
-        applyContextGenerics(resolvedPlaceholders,placeholdersFromContext);
+        applyContextGenerics(resolvedPlaceholders, placeholdersFromContext);
 
-        Map<String, GenericsType> connections  = new HashMap<String, GenericsType>();
-        extractGenericsConnections(connections, currentType,target);
+        Map<String, GenericsType> connections = new HashMap<String, GenericsType>();
+        extractGenericsConnections(connections, currentType, target);
         applyGenericsConnections(connections, resolvedPlaceholders);
         currentType = applyGenericsContext(resolvedPlaceholders, currentType);
         return currentType;
@@ -1648,19 +1660,19 @@ public abstract class StaticTypeCheckingSupport {
             Map<String, GenericsType> connections,
             Map<String, GenericsType> resolvedPlaceholders
     ) {
-        if (connections==null) return;
+        if (connections == null) return;
         int count = 0;
-        while (count<10000) {
+        while (count < 10000) {
             count++;
-            boolean checkForMorePlaceHolders=false;
-            for (Entry<String, GenericsType> entry: resolvedPlaceholders.entrySet()){
+            boolean checkForMorePlaceHolders = false;
+            for (Entry<String, GenericsType> entry : resolvedPlaceholders.entrySet()) {
                 String name = entry.getKey();
                 GenericsType replacement = connections.get(name);
-                if (replacement==null) {
+                if (replacement == null) {
                     GenericsType value = entry.getValue();
                     GenericsType newValue = applyGenericsContext(connections, value);
                     entry.setValue(newValue);
-                    checkForMorePlaceHolders = checkForMorePlaceHolders || !equalIncludingGenerics(value,newValue);
+                    checkForMorePlaceHolders = checkForMorePlaceHolders || !equalIncludingGenerics(value, newValue);
                     continue;
                 }
                 GenericsType original = entry.getValue();
@@ -1670,7 +1682,7 @@ public abstract class StaticTypeCheckingSupport {
                 boolean placeholderReplacement = replacement.isPlaceholder();
                 if (placeholderReplacement) {
                     GenericsType connectedType = resolvedPlaceholders.get(replacement.getName());
-                    if (replacement==connectedType) continue;
+                    if (replacement == connectedType) continue;
                 }
                 // GROOVY-6787: Don't override the original if the replacement placeholder doesn't respect the bounds,
                 // otherwise the original bounds are lost which can result in accepting an incompatible type as an
@@ -1679,13 +1691,14 @@ public abstract class StaticTypeCheckingSupport {
                 if (original.isCompatibleWith(replacementType)) {
                     entry.setValue(replacement);
                     if (placeholderReplacement) {
-                        checkForMorePlaceHolders = checkForMorePlaceHolders || !equalIncludingGenerics(original,replacement);
+                        checkForMorePlaceHolders = checkForMorePlaceHolders || !equalIncludingGenerics(original, replacement);
                     }
                 }
             }
             if (!checkForMorePlaceHolders) break;
         }
-        if  (count>=10000) throw new GroovyBugError("unable to handle generics in "+resolvedPlaceholders+" with connections "+connections);
+        if (count >= 10000)
+            throw new GroovyBugError("unable to handle generics in " + resolvedPlaceholders + " with connections " + connections);
     }
 
     private static ClassNode extractType(GenericsType gt) {
@@ -1707,13 +1720,13 @@ public abstract class StaticTypeCheckingSupport {
     }
 
     private static boolean equalIncludingGenerics(GenericsType orig, GenericsType copy) {
-        if (orig==copy) return true;
-        if (orig.isPlaceholder()!=copy.isPlaceholder()) return false;
-        if (orig.isWildcard()!=copy.isWildcard()) return false;
+        if (orig == copy) return true;
+        if (orig.isPlaceholder() != copy.isPlaceholder()) return false;
+        if (orig.isWildcard() != copy.isWildcard()) return false;
         if (!equalIncludingGenerics(orig.getType(), copy.getType())) return false;
         ClassNode lower1 = orig.getLowerBound();
         ClassNode lower2 = copy.getLowerBound();
-        if ((lower1 == null) ^ (lower2 ==null)) return false;
+        if ((lower1 == null) ^ (lower2 == null)) return false;
         if (lower1 != lower2) {
             if (!equalIncludingGenerics(lower1, lower2)) return false;
         }
@@ -1730,12 +1743,12 @@ public abstract class StaticTypeCheckingSupport {
     }
 
     private static boolean equalIncludingGenerics(ClassNode orig, ClassNode copy) {
-        if (orig==copy) return true;
-        if (orig.isGenericsPlaceHolder()!=copy.isGenericsPlaceHolder()) return false;
+        if (orig == copy) return true;
+        if (orig.isGenericsPlaceHolder() != copy.isGenericsPlaceHolder()) return false;
         if (!orig.equals(copy)) return false;
         GenericsType[] gt1 = orig.getGenericsTypes();
         GenericsType[] gt2 = orig.getGenericsTypes();
-        if ((gt1==null) ^ (gt2==null)) return false;
+        if ((gt1 == null) ^ (gt2 == null)) return false;
         if (gt1 != gt2) {
             if (gt1.length != gt2.length) return false;
             for (int i = 0; i < gt1.length; i++) {
@@ -1749,13 +1762,13 @@ public abstract class StaticTypeCheckingSupport {
      * use supplied type to make a connection from usage to declaration
      * The method operates in two modes.
      * * For type !instanceof target a structural compare will be done
-     *   (for example Dummy&lt;T&gt; and List&lt;R&gt; to get T=R)
+     * (for example Dummy&lt;T&gt; and List&lt;R&gt; to get T=R)
      * * If type equals target, a structural match is done as well
-     *   (for example Colection&lt;U&gt; and Collection&lt;E&gt; to get U=E)
+     * (for example Colection&lt;U&gt; and Collection&lt;E&gt; to get U=E)
      * * otherwise we climb the hierarchy to find a case of type equals target
-     *   to then execute the structural match, while applying possibly existing
-     *   generics contexts on the way (for example for IntRange and Collection&lt;E&gt;
-     *   to get E=Integer, since IntRange is an AbstractList&lt;Integer&gt;)
+     * to then execute the structural match, while applying possibly existing
+     * generics contexts on the way (for example for IntRange and Collection&lt;E&gt;
+     * to get E=Integer, since IntRange is an AbstractList&lt;Integer&gt;)
      * Should the target not have any generics this method does nothing.
      */
     static void extractGenericsConnections(Map<String, GenericsType> connections, ClassNode type, ClassNode target) {
@@ -1796,16 +1809,16 @@ public abstract class StaticTypeCheckingSupport {
 
     private static void extractGenericsConnections(Map<String, GenericsType> connections, GenericsType[] usage, GenericsType[] declaration) {
         // if declaration does not provide generics, there is no connection to make 
-        if (usage==null || declaration==null || declaration.length==0) return;
-        if (usage.length!=declaration.length) return;
+        if (usage == null || declaration == null || declaration.length == 0) return;
+        if (usage.length != declaration.length) return;
 
         // both have generics
-        for (int i=0; i<usage.length; i++) {
+        for (int i = 0; i < usage.length; i++) {
             GenericsType ui = usage[i];
             GenericsType di = declaration[i];
             if (di.isPlaceholder()) {
                 connections.put(di.getName(), ui);
-            } else if (di.isWildcard()){
+            } else if (di.isWildcard()) {
                 if (ui.isWildcard()) {
                     extractGenericsConnections(connections, ui.getLowerBound(), di.getLowerBound());
                     extractGenericsConnections(connections, ui.getUpperBounds(), di.getUpperBounds());
@@ -1813,7 +1826,7 @@ public abstract class StaticTypeCheckingSupport {
                     ClassNode cu = ui.getType();
                     extractGenericsConnections(connections, cu, di.getLowerBound());
                     ClassNode[] upperBounds = di.getUpperBounds();
-                    if (upperBounds!=null) {
+                    if (upperBounds != null) {
                         for (ClassNode cn : upperBounds) {
                             extractGenericsConnections(connections, cu, cn);
                         }
@@ -1826,16 +1839,16 @@ public abstract class StaticTypeCheckingSupport {
     }
 
     private static void extractGenericsConnections(Map<String, GenericsType> connections, ClassNode[] usage, ClassNode[] declaration) {
-        if (usage==null || declaration==null || declaration.length==0) return;
+        if (usage == null || declaration == null || declaration.length == 0) return;
         // both have generics
-        for (int i=0; i<usage.length; i++) {
+        for (int i = 0; i < usage.length; i++) {
             ClassNode ui = usage[i];
             ClassNode di = declaration[i];
             if (di.isGenericsPlaceHolder()) {
                 GenericsType gt = new GenericsType(di);
                 gt.setPlaceholder(di.isGenericsPlaceHolder());
                 connections.put(di.getGenericsTypes()[0].getName(), gt);
-            } else if (di.isUsingGenerics()){
+            } else if (di.isUsingGenerics()) {
                 extractGenericsConnections(connections, ui.getGenericsTypes(), di.getGenericsTypes());
             }
         }
@@ -1850,7 +1863,7 @@ public abstract class StaticTypeCheckingSupport {
             Map<String, GenericsType> spec, ClassNode parameterUsage
     ) {
         GenericsType[] gts = parameterUsage.getGenericsTypes();
-        if (gts==null) return Collections.EMPTY_MAP;
+        if (gts == null) return Collections.EMPTY_MAP;
 
         GenericsType[] newGTs = applyGenericsContext(spec, gts);
         ClassNode newTarget = parameterUsage.redirect().getPlainNodeReference();
@@ -1861,9 +1874,9 @@ public abstract class StaticTypeCheckingSupport {
     private static GenericsType[] applyGenericsContext(
             Map<String, GenericsType> spec, GenericsType[] gts
     ) {
-        if (gts==null) return null;
+        if (gts == null) return null;
         GenericsType[] newGTs = new GenericsType[gts.length];
-        for (int i=0; i<gts.length; i++) {
+        for (int i = 0; i < gts.length; i++) {
             GenericsType gt = gts[i];
             newGTs[i] = applyGenericsContext(spec, gt);
         }
@@ -1874,7 +1887,7 @@ public abstract class StaticTypeCheckingSupport {
         if (gt.isPlaceholder()) {
             String name = gt.getName();
             GenericsType specType = spec.get(name);
-            if (specType!=null) return specType;
+            if (specType != null) return specType;
             if (hasNonTrivialBounds(gt)) {
                 GenericsType newGT = new GenericsType(gt.getType(), applyGenericsContext(spec, gt.getUpperBounds()), applyGenericsContext(spec, gt.getLowerBound()));
                 newGT.setPlaceholder(true);
@@ -1887,7 +1900,7 @@ public abstract class StaticTypeCheckingSupport {
             return newGT;
         }
         ClassNode type = gt.getType();
-        if (type.getGenericsTypes()==null) return gt;
+        if (type.getGenericsTypes() == null) return gt;
         ClassNode newType = type.getPlainNodeReference();
         newType.setGenericsPlaceHolder(type.isGenericsPlaceHolder());
         newType.setGenericsTypes(applyGenericsContext(spec, type.getGenericsTypes()));
@@ -1907,10 +1920,10 @@ public abstract class StaticTypeCheckingSupport {
     private static ClassNode[] applyGenericsContext(
             Map<String, GenericsType> spec, ClassNode[] bounds
     ) {
-        if (bounds==null) return null;
+        if (bounds == null) return null;
         ClassNode[] newBounds = new ClassNode[bounds.length];
-        for(int i=0; i<bounds.length; i++) {
-            newBounds[i] = applyGenericsContext(spec,bounds[i]);
+        for (int i = 0; i < bounds.length; i++) {
+            newBounds[i] = applyGenericsContext(spec, bounds[i]);
         }
         return newBounds;
     }
@@ -1918,15 +1931,15 @@ public abstract class StaticTypeCheckingSupport {
     static ClassNode applyGenericsContext(
             Map<String, GenericsType> spec, ClassNode bound
     ) {
-        if (bound==null) return null;
+        if (bound == null) return null;
         if (bound.isArray()) {
-            return applyGenericsContext(spec,bound.getComponentType()).makeArray();
+            return applyGenericsContext(spec, bound.getComponentType()).makeArray();
         }
         if (!bound.isUsingGenerics()) return bound;
         ClassNode newBound = bound.getPlainNodeReference();
         newBound.setGenericsTypes(applyGenericsContext(spec, bound.getGenericsTypes()));
         if (bound.isGenericsPlaceHolder()) {
-            GenericsType[] gt= newBound.getGenericsTypes();
+            GenericsType[] gt = newBound.getGenericsTypes();
             boolean hasBounds = hasNonTrivialBounds(gt[0]);
             if (hasBounds || !gt[0].isPlaceholder()) return getCombinedBoundType(gt[0]);
             String placeHolderName = newBound.getGenericsTypes()[0].getName();
@@ -1947,31 +1960,31 @@ public abstract class StaticTypeCheckingSupport {
         // representing the combination of all bounds. The code here, just picks
         // something out to be able to proceed and is not actually correct
         if (hasNonTrivialBounds(genericsType)) {
-            if (genericsType.getLowerBound()!=null) return genericsType.getLowerBound();
-            if (genericsType.getUpperBounds()!=null) return genericsType.getUpperBounds()[0];
+            if (genericsType.getLowerBound() != null) return genericsType.getLowerBound();
+            if (genericsType.getUpperBounds() != null) return genericsType.getUpperBounds()[0];
         }
         return genericsType.getType();
     }
 
     private static void applyContextGenerics(Map<String, GenericsType> resolvedPlaceholders, Map<String, GenericsType> placeholdersFromContext) {
-        if (placeholdersFromContext==null) return;
+        if (placeholdersFromContext == null) return;
         for (Entry<String, GenericsType> entry : resolvedPlaceholders.entrySet()) {
             GenericsType gt = entry.getValue();
             if (gt.isPlaceholder()) {
                 String name = gt.getName();
                 GenericsType outer = placeholdersFromContext.get(name);
-                if (outer==null) continue;
+                if (outer == null) continue;
                 entry.setValue(outer);
             }
         }
     }
 
     private static Map<String, GenericsType> getGenericsParameterMapOfThis(ClassNode cn) {
-        if (cn==null) return null;
+        if (cn == null) return null;
         Map<String, GenericsType> map = null;
-        if (cn.getEnclosingMethod()!=null) {
+        if (cn.getEnclosingMethod() != null) {
             map = extractGenericsParameterMapOfThis(cn.getEnclosingMethod());
-        } else if (cn.getOuterClass()!=null) {
+        } else if (cn.getOuterClass() != null) {
             map = getGenericsParameterMapOfThis(cn.getOuterClass());
         }
         map = mergeGenerics(map, cn.getGenericsTypes());
@@ -2041,7 +2054,7 @@ public abstract class StaticTypeCheckingSupport {
 
     private static Map<String, GenericsType> mergeGenerics(Map<String, GenericsType> current, GenericsType[] newGenerics) {
         if (newGenerics == null || newGenerics.length == 0) return current;
-        if (current==null) current = new HashMap<String, GenericsType>();
+        if (current == null) current = new HashMap<String, GenericsType>();
         for (GenericsType gt : newGenerics) {
             if (!gt.isPlaceholder()) continue;
             String name = gt.getName();
@@ -2058,7 +2071,8 @@ public abstract class StaticTypeCheckingSupport {
         public static <T> T getAt(T[] arr, int index) {
             return null == arr ? null : arr[index];
         }
-        public static <T,U extends T> void putAt(T[] arr, int index, U object) {
+
+        public static <T, U extends T> void putAt(T[] arr, int index, U object) {
             if (null == arr) {
                 return;
             }
@@ -2071,6 +2085,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Boolean getAt(boolean[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(boolean[] arr, int index, boolean object) {
             if (null == arr) {
                 return;
@@ -2084,6 +2099,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Character getAt(char[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(char[] arr, int index, char object) {
             if (null == arr) {
                 return;
@@ -2097,6 +2113,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Byte getAt(byte[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(byte[] arr, int index, byte object) {
             if (null == arr) {
                 return;
@@ -2110,6 +2127,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Short getAt(short[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(short[] arr, int index, short object) {
             if (null == arr) {
                 return;
@@ -2123,6 +2141,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Integer getAt(int[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(int[] arr, int index, int object) {
             if (null == arr) {
                 return;
@@ -2136,6 +2155,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Long getAt(long[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(long[] arr, int index, long object) {
             if (null == arr) {
                 return;
@@ -2149,6 +2169,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Float getAt(float[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(float[] arr, int index, float object) {
             if (null == arr) {
                 return;
@@ -2162,6 +2183,7 @@ public abstract class StaticTypeCheckingSupport {
         public static Double getAt(double[] arr, int index) {
             return null == arr ? null : arr[index];
         }
+
         public static void putAt(double[] arr, int index, double object) {
             if (null == arr) {
                 return;
@@ -2215,12 +2237,13 @@ public abstract class StaticTypeCheckingSupport {
          * Returns a map which contains, as the key, the name of a class. The value
          * consists of a list of MethodNode, one for each default groovy method found
          * which is applicable for this class.
-         * @return
+         *
          * @param modules
+         * @return
          */
         private static Map<String, List<MethodNode>> getDGMMethods(List<ExtensionModule> modules) {
-           Set<Class> instanceExtClasses = new LinkedHashSet<Class>();
-           Set<Class> staticExtClasses = new LinkedHashSet<Class>();
+            Set<Class> instanceExtClasses = new LinkedHashSet<Class>();
+            Set<Class> staticExtClasses = new LinkedHashSet<Class>();
             for (ExtensionModule module : modules) {
                 if (module instanceof MetaInfExtensionModule) {
                     MetaInfExtensionModule extensionModule = (MetaInfExtensionModule) module;
@@ -2253,7 +2276,7 @@ public abstract class StaticTypeCheckingSupport {
         }
 
         private static void scanClassesForDGMMethods(Map<String, List<MethodNode>> accumulator,
-                                                    Iterable<Class> allClasses, boolean isStatic) {
+                                                     Iterable<Class> allClasses, boolean isStatic) {
             for (Class dgmLikeClass : allClasses) {
                 ClassNode cn = makeWithoutCaching(dgmLikeClass, true);
                 for (MethodNode metaMethod : cn.getMethods()) {
@@ -2303,7 +2326,7 @@ public abstract class StaticTypeCheckingSupport {
         if (node.isArray()) return isParameterizedWithGStringOrGStringString(node.getComponentType());
         if (node.isUsingGenerics()) {
             GenericsType[] genericsTypes = node.getGenericsTypes();
-            if (genericsTypes!=null) {
+            if (genericsTypes != null) {
                 for (GenericsType genericsType : genericsTypes) {
                     if (isGStringOrGStringStringLUB(genericsType.getType())) return true;
                 }
@@ -2320,7 +2343,7 @@ public abstract class StaticTypeCheckingSupport {
         if (node.isArray()) return isParameterizedWithString(node.getComponentType());
         if (node.isUsingGenerics()) {
             GenericsType[] genericsTypes = node.getGenericsTypes();
-            if (genericsTypes!=null) {
+            if (genericsTypes != null) {
                 for (GenericsType genericsType : genericsTypes) {
                     if (STRING_TYPE.equals(genericsType.getType())) return true;
                 }
@@ -2333,8 +2356,8 @@ public abstract class StaticTypeCheckingSupport {
         if (cn.isArray()) return missesGenericsTypes(cn.getComponentType());
         GenericsType[] cnTypes = cn.getGenericsTypes();
         GenericsType[] rnTypes = cn.redirect().getGenericsTypes();
-        if (rnTypes!=null && cnTypes==null) return true;
-        if (cnTypes!=null) {
+        if (rnTypes != null && cnTypes == null) return true;
+        if (cnTypes != null) {
             for (GenericsType genericsType : cnTypes) {
                 if (genericsType.isPlaceholder()) return true;
             }
@@ -2346,10 +2369,10 @@ public abstract class StaticTypeCheckingSupport {
      * A helper method that can be used to evaluate expressions as found in annotation
      * parameters. For example, it will evaluate a constant, be it referenced directly as
      * an integer or as a reference to a field.
-     *
+     * <p>
      * If this method throws an exception, then the expression cannot be evaluated on its own.
      *
-     * @param expr the expression to be evaluated
+     * @param expr   the expression to be evaluated
      * @param config the compiler configuration
      * @return the result of the expression
      */
@@ -2357,13 +2380,13 @@ public abstract class StaticTypeCheckingSupport {
         String className = "Expression$" + UUID.randomUUID().toString().replace('-', '$');
         ClassNode node = new ClassNode(className, Opcodes.ACC_PUBLIC, OBJECT_TYPE);
         ReturnStatement code = new ReturnStatement(expr);
-        node.addMethod(new MethodNode("eval", Opcodes.ACC_PUBLIC+ Opcodes.ACC_STATIC, OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, code));
+        node.addMethod(new MethodNode("eval", Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, code));
         CompilerConfiguration copyConf = new CompilerConfiguration(config);
         CompilationUnit cu = new CompilationUnit(copyConf);
         cu.addClassNode(node);
         cu.compile(Phases.CLASS_GENERATION);
         @SuppressWarnings("unchecked")
-        List<GroovyClass> classes = (List<GroovyClass>)cu.getClasses();
+        List<GroovyClass> classes = (List<GroovyClass>) cu.getClasses();
         Class aClass = cu.getClassLoader().defineClass(className, classes.get(0).getBytes());
         try {
             return aClass.getMethod("eval").invoke(null);
@@ -2379,6 +2402,7 @@ public abstract class StaticTypeCheckingSupport {
     /**
      * Collects all interfaces of a class node, including those defined by the
      * super class.
+     *
      * @param node a class for which we want to retrieve all interfaces
      * @return a set of interfaces implemented by this class node
      */
@@ -2391,11 +2415,12 @@ public abstract class StaticTypeCheckingSupport {
     /**
      * Collects all interfaces of a class node, including those defined by the
      * super class.
+     *
      * @param node a class for which we want to retrieve all interfaces
-     * @param out the set where to collect interfaces
+     * @param out  the set where to collect interfaces
      */
     private static void collectAllInterfaces(final ClassNode node, final Set<ClassNode> out) {
-        if (node==null) return;
+        if (node == null) return;
         Set<ClassNode> allInterfaces = node.getAllInterfaces();
         out.addAll(allInterfaces);
         collectAllInterfaces(node.getSuperClass(), out);
@@ -2406,6 +2431,7 @@ public abstract class StaticTypeCheckingSupport {
      * and if the parametrized type is a neither a placeholder or a wildcard. For example,
      * the class node Class&lt;Foo&gt; where Foo is a class would return true, but the class
      * node for Class&lt;?&gt; would return false.
+     *
      * @param classNode a class node to be tested
      * @return true if it is the class node for Class and its generic type is a real class
      */
@@ -2413,7 +2439,7 @@ public abstract class StaticTypeCheckingSupport {
         GenericsType[] genericsTypes = classNode.getGenericsTypes();
         return CLASS_Type.equals(classNode)
                 && classNode.isUsingGenerics()
-                && genericsTypes!=null
+                && genericsTypes != null
                 && !genericsTypes[0].isPlaceholder()
                 && !genericsTypes[0].isWildcard();
     }
@@ -2422,15 +2448,15 @@ public abstract class StaticTypeCheckingSupport {
         List<MethodNode> result = null;
         for (MethodNode method : cn.getDeclaredMethods(setterName)) {
             if (setterName.equals(method.getName())
-                    && (!voidOnly || VOID_TYPE==method.getReturnType())
+                    && (!voidOnly || VOID_TYPE == method.getReturnType())
                     && method.getParameters().length == 1) {
-                if (result==null) {
+                if (result == null) {
                     result = new LinkedList<MethodNode>();
                 }
                 result.add(method);
             }
         }
-        if (result==null) {
+        if (result == null) {
             ClassNode parent = cn.getSuperClass();
             if (parent != null) {
                 return findSetters(parent, setterName, voidOnly);
@@ -2443,7 +2469,7 @@ public abstract class StaticTypeCheckingSupport {
     public static ClassNode isTraitSelf(VariableExpression vexp) {
         if (Traits.THIS_OBJECT.equals(vexp.getName())) {
             Variable accessedVariable = vexp.getAccessedVariable();
-            ClassNode type = accessedVariable!=null?accessedVariable.getType():null;
+            ClassNode type = accessedVariable != null ? accessedVariable.getType() : null;
             if (accessedVariable instanceof Parameter
                     && Traits.isTrait(type)) {
                 return type;


Mime
View raw message