You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@groovy.apache.org by su...@apache.org on 2019/11/17 08:53:59 UTC
[groovy] 04/18: minor edits
This is an automated email from the ASF dual-hosted git repository.
sunlan pushed a commit to branch GROOVY_3_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git
commit bc6ee3b67ece69c091c8e557c9b8898874868546
Author: Eric Milles <er...@thomsonreuters.com>
AuthorDate: Thu Nov 14 12:41:43 2019 -0600
minor edits
(cherry picked from commit f22d47964cceca8d30dbda178768c7cfcd37844c)
---
.../transform/stc/StaticTypeCheckingSupport.java | 179 ++++++++-----------
.../transform/stc/StaticTypeCheckingVisitor.java | 189 ++++++++++-----------
.../groovy/classgen/asm/sc/bugs/Groovy7276.groovy | 20 ++-
3 files changed, 171 insertions(+), 217 deletions(-)
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 f27988a..10de207 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -16,9 +16,9 @@
* specific language governing permissions and limitations
* under the License.
*/
-
package org.codehaus.groovy.transform.stc;
+import org.apache.groovy.util.Maps;
import org.codehaus.groovy.GroovyBugError;
import org.codehaus.groovy.ast.ClassHelper;
import org.codehaus.groovy.ast.ClassNode;
@@ -45,6 +45,7 @@ import org.codehaus.groovy.control.CompilationUnit;
import org.codehaus.groovy.control.CompilerConfiguration;
import org.codehaus.groovy.control.Phases;
import org.codehaus.groovy.runtime.metaclass.MetaClassRegistryImpl;
+import org.codehaus.groovy.syntax.Types;
import org.codehaus.groovy.tools.GroovyClass;
import org.codehaus.groovy.transform.trait.Traits;
import org.objectweb.asm.Opcodes;
@@ -61,7 +62,6 @@ import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
@@ -107,7 +107,6 @@ import static org.codehaus.groovy.ast.ClassHelper.short_TYPE;
import static org.codehaus.groovy.ast.ClassHelper.void_WRAPPER_TYPE;
import static org.codehaus.groovy.ast.tools.GenericsUtils.getSuperClass;
import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asBoolean;
-import static org.codehaus.groovy.syntax.Types.ASSIGN;
import static org.codehaus.groovy.syntax.Types.BITWISE_AND;
import static org.codehaus.groovy.syntax.Types.BITWISE_AND_EQUAL;
import static org.codehaus.groovy.syntax.Types.BITWISE_OR;
@@ -135,9 +134,7 @@ import static org.codehaus.groovy.syntax.Types.LEFT_SHIFT;
import static org.codehaus.groovy.syntax.Types.LEFT_SHIFT_EQUAL;
import static org.codehaus.groovy.syntax.Types.LEFT_SQUARE_BRACKET;
import static org.codehaus.groovy.syntax.Types.LOGICAL_AND;
-import static org.codehaus.groovy.syntax.Types.LOGICAL_AND_EQUAL;
import static org.codehaus.groovy.syntax.Types.LOGICAL_OR;
-import static org.codehaus.groovy.syntax.Types.LOGICAL_OR_EQUAL;
import static org.codehaus.groovy.syntax.Types.MATCH_REGEX;
import static org.codehaus.groovy.syntax.Types.MINUS;
import static org.codehaus.groovy.syntax.Types.MINUS_EQUAL;
@@ -153,55 +150,46 @@ import static org.codehaus.groovy.syntax.Types.RIGHT_SHIFT;
import static org.codehaus.groovy.syntax.Types.RIGHT_SHIFT_EQUAL;
import static org.codehaus.groovy.syntax.Types.RIGHT_SHIFT_UNSIGNED;
import static org.codehaus.groovy.syntax.Types.RIGHT_SHIFT_UNSIGNED_EQUAL;
+
/**
* Static support methods for {@link StaticTypeCheckingVisitor}.
*/
public abstract class StaticTypeCheckingSupport {
- protected static final ClassNode
- Collection_TYPE = makeWithoutCaching(Collection.class);
- protected static final ClassNode Deprecated_TYPE = makeWithoutCaching(Deprecated.class);
protected static final ClassNode Matcher_TYPE = makeWithoutCaching(Matcher.class);
protected static final ClassNode ArrayList_TYPE = makeWithoutCaching(ArrayList.class);
- protected static final AbstractExtensionMethodCache EXTENSION_METHOD_CACHE = ExtensionMethodCache.INSTANCE;
- protected static final Map<ClassNode, Integer> NUMBER_TYPES = Collections.unmodifiableMap(
- new HashMap<ClassNode, Integer>() {
- 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);
- }
- });
-
- 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);
- }
- });
+ protected static final ClassNode Collection_TYPE = makeWithoutCaching(Collection.class);
+ protected static final ClassNode Deprecated_TYPE = makeWithoutCaching(Deprecated.class);
+ protected static final ExtensionMethodCache EXTENSION_METHOD_CACHE = ExtensionMethodCache.INSTANCE;
+
+ protected static final Map<ClassNode, Integer> NUMBER_TYPES = Maps.of(
+ byte_TYPE, 0,
+ Byte_TYPE, 0,
+ short_TYPE, 1,
+ Short_TYPE, 1,
+ int_TYPE, 2,
+ Integer_TYPE, 2,
+ Long_TYPE, 3,
+ long_TYPE, 3,
+ float_TYPE, 4,
+ Float_TYPE, 4,
+ double_TYPE, 5,
+ Double_TYPE, 5
+ );
+
+ protected static final Map<String, Integer> NUMBER_OPS = Maps.of(
+ "plus", PLUS,
+ "minus", MINUS,
+ "multiply", MULTIPLY,
+ "div", DIVIDE,
+ "or", BITWISE_OR,
+ "and", BITWISE_AND,
+ "xor", BITWISE_XOR,
+ "mod", MOD,
+ "intdiv", INTDIV,
+ "leftShift", LEFT_SHIFT,
+ "rightShift", RIGHT_SHIFT,
+ "rightShiftUnsigned", RIGHT_SHIFT_UNSIGNED
+ );
protected static final ClassNode GSTRING_STRING_CLASSNODE = WideningCategories.lowestUpperBound(
STRING_TYPE,
@@ -298,12 +286,11 @@ public abstract class StaticTypeCheckingSupport {
}
public static Set<MethodNode> findDGMMethodsForClassNode(final ClassLoader loader, ClassNode clazz, String name) {
- TreeSet<MethodNode> accumulator = new TreeSet<MethodNode>(DGM_METHOD_NODE_COMPARATOR);
+ TreeSet<MethodNode> accumulator = new TreeSet<>(DGM_METHOD_NODE_COMPARATOR);
findDGMMethodsForClassNode(loader, clazz, name, accumulator);
return accumulator;
}
-
/**
* @deprecated Use {@link #findDGMMethodsForClassNode(ClassLoader, ClassNode, String, TreeSet)} instead
*/
@@ -633,27 +620,7 @@ public abstract class StaticTypeCheckingSupport {
}
public static boolean isAssignment(int op) {
- switch (op) {
- case ASSIGN:
- case LOGICAL_OR_EQUAL:
- case LOGICAL_AND_EQUAL:
- case PLUS_EQUAL:
- case MINUS_EQUAL:
- case MULTIPLY_EQUAL:
- case DIVIDE_EQUAL:
- case INTDIV_EQUAL:
- case MOD_EQUAL:
- case POWER_EQUAL:
- case LEFT_SHIFT_EQUAL:
- case RIGHT_SHIFT_EQUAL:
- case RIGHT_SHIFT_UNSIGNED_EQUAL:
- case BITWISE_OR_EQUAL:
- case BITWISE_AND_EQUAL:
- case BITWISE_XOR_EQUAL:
- return true;
- default:
- return false;
- }
+ return Types.isAssignment(op);
}
/**
@@ -978,7 +945,7 @@ public abstract class StaticTypeCheckingSupport {
if (c.equals(interfaceClass)) return 0;
ClassNode[] interfaces = c.getInterfaces();
int max = -1;
- for (final ClassNode anInterface : interfaces) {
+ for (ClassNode anInterface : interfaces) {
int sub = getMaximumInterfaceDistance(anInterface, interfaceClass);
// we need to keep the -1 to track the mismatch, a +1
// by any means could let it look like a direct match
@@ -1004,7 +971,7 @@ public abstract class StaticTypeCheckingSupport {
}
public static List<MethodNode> findDGMMethodsByNameAndArguments(final ClassLoader loader, final ClassNode receiver, final String name, final ClassNode[] args) {
- return findDGMMethodsByNameAndArguments(loader, receiver, name, args, new LinkedList<MethodNode>());
+ return findDGMMethodsByNameAndArguments(loader, receiver, name, args, new LinkedList<>());
}
/**
@@ -1068,7 +1035,7 @@ public abstract class StaticTypeCheckingSupport {
ClassNode raw = makeRawType(receiver);
return chooseBestMethod(raw, methods, args);
}
- List<MethodNode> bestChoices = new LinkedList<MethodNode>();
+ List<MethodNode> bestChoices = new LinkedList<>();
int bestDist = Integer.MAX_VALUE;
Collection<MethodNode> choicesLeft = removeCovariantsAndInterfaceEquivalents(methods);
for (MethodNode candidateNode : choicesLeft) {
@@ -1112,7 +1079,7 @@ public abstract class StaticTypeCheckingSupport {
}
if (bestChoices.size() > 1) {
// GROOVY-6849: prefer extension methods in case of ambiguity
- List<MethodNode> onlyExtensionMethods = new LinkedList<MethodNode>();
+ List<MethodNode> onlyExtensionMethods = new LinkedList<>();
for (MethodNode choice : bestChoices) {
if (choice instanceof ExtensionMethodNode) {
onlyExtensionMethods.add(choice);
@@ -1190,7 +1157,7 @@ public abstract class StaticTypeCheckingSupport {
return Arrays.stream(params).map(param -> {
String name = param.getType().getUnresolvedName();
Optional<GenericsType> value = genericsPlaceholderAndTypeMap.entrySet().stream()
- .filter(e -> e.getKey().getName().equals(name)).findFirst().map(Entry::getValue);
+ .filter(e -> e.getKey().getName().equals(name)).findFirst().map(Map.Entry::getValue);
ClassNode type = value.map(GenericsType::getType).orElseGet(() -> makeRawType(param.getType()));
return new Parameter(type, param.getName());
@@ -1209,8 +1176,8 @@ public abstract class StaticTypeCheckingSupport {
private static Collection<MethodNode> removeCovariantsAndInterfaceEquivalents(Collection<MethodNode> collection) {
if (collection.size() <= 1) return collection;
- List<MethodNode> toBeRemoved = new LinkedList<MethodNode>();
- List<MethodNode> list = new LinkedList<MethodNode>(new LinkedHashSet<MethodNode>(collection));
+ List<MethodNode> toBeRemoved = new LinkedList<>();
+ List<MethodNode> list = new LinkedList<>(new LinkedHashSet<>(collection));
for (int i = 0; i < list.size() - 1; i++) {
MethodNode one = list.get(i);
if (toBeRemoved.contains(one)) continue;
@@ -1235,7 +1202,7 @@ public abstract class StaticTypeCheckingSupport {
}
}
if (toBeRemoved.isEmpty()) return list;
- List<MethodNode> result = new LinkedList<MethodNode>(list);
+ List<MethodNode> result = new LinkedList<>(list);
result.removeAll(toBeRemoved);
return result;
}
@@ -1479,7 +1446,7 @@ public abstract class StaticTypeCheckingSupport {
boolean failure = false;
// correct receiver for inner class
- // we assume the receiver is an instance of the declaring class of the
+ // we assume the receiver is an instance of the declaring class of the
// candidate method, but findMethod returns also outer class methods
// for that receiver. For now we skip receiver based checks in that case
// TODO: correct generics for when receiver is to be skipped
@@ -1488,7 +1455,7 @@ public abstract class StaticTypeCheckingSupport {
Parameter[] parameters = candidateMethod.getParameters();
Map<GenericsTypeName, GenericsType> classGTs;
if (skipBecauseOfInnerClassNotReceiver) {
- classGTs = Collections.EMPTY_MAP;
+ classGTs = Collections.emptyMap();
} else {
classGTs = GenericsUtils.extractPlaceholders(receiver);
}
@@ -1500,7 +1467,7 @@ public abstract class StaticTypeCheckingSupport {
// we have here different generics contexts we have to deal with.
// There is firstly the context given through the class, and the method.
- // The method context may hide generics given through the class, but use
+ // The method context may hide generics given through the class, but use
// the non-hidden ones.
Map<GenericsTypeName, GenericsType> resolvedMethodGenerics = new HashMap<GenericsTypeName, GenericsType>();
if (!skipBecauseOfInnerClassNotReceiver) {
@@ -1512,13 +1479,13 @@ public abstract class StaticTypeCheckingSupport {
applyGenericsConnections(classGTs, resolvedMethodGenerics);
// and then start our checks with the receiver
if (!skipBecauseOfInnerClassNotReceiver) {
- failure |= inferenceCheck(Collections.EMPTY_SET, resolvedMethodGenerics, candidateMethod.getDeclaringClass(), receiver, false);
+ failure |= inferenceCheck(Collections.emptySet(), resolvedMethodGenerics, candidateMethod.getDeclaringClass(), receiver, false);
}
// the outside context parts till now define placeholder we are not allowed to
// generalize, thus we save that for later use...
- // extension methods are special, since they set the receiver as
+ // extension methods are special, since they set the receiver as
// first parameter. While we normally allow generalization for the first
- // parameter, in case of an extension method we must not.
+ // parameter, in case of an extension method we must not.
Set<GenericsTypeName> fixedGenericsPlaceHolders = extractResolvedPlaceHolders(resolvedMethodGenerics);
for (int i = 0; i < arguments.length; i++) {
@@ -1541,9 +1508,9 @@ public abstract class StaticTypeCheckingSupport {
}
private static Set<GenericsTypeName> extractResolvedPlaceHolders(Map<GenericsTypeName, GenericsType> resolvedMethodGenerics) {
- if (resolvedMethodGenerics.isEmpty()) return Collections.EMPTY_SET;
- Set<GenericsTypeName> result = new HashSet<GenericsTypeName>();
- for (Entry<GenericsTypeName, GenericsType> entry : resolvedMethodGenerics.entrySet()) {
+ if (resolvedMethodGenerics.isEmpty()) return Collections.emptySet();
+ Set<GenericsTypeName> result = new HashSet<>();
+ for (Map.Entry<GenericsTypeName, GenericsType> entry : resolvedMethodGenerics.entrySet()) {
GenericsType value = entry.getValue();
if (value.isPlaceholder()) continue;
result.add(entry.getKey());
@@ -1552,7 +1519,7 @@ public abstract class StaticTypeCheckingSupport {
}
private static boolean inferenceCheck(Set<GenericsTypeName> fixedGenericsPlaceHolders, Map<GenericsTypeName, GenericsType> resolvedMethodGenerics, ClassNode type, ClassNode wrappedArgument, boolean lastArg) {
- Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
if (isPrimitiveType(wrappedArgument)) wrappedArgument = getWrapper(wrappedArgument);
if (lastArg &&
@@ -1573,7 +1540,7 @@ public abstract class StaticTypeCheckingSupport {
// information. This way the method level information slowly turns
// into information for the callsite
applyGenericsConnections(connections, resolvedMethodGenerics);
- // since it is possible that the callsite uses some generics as well,
+ // since it is possible that the callsite uses some generics as well,
// we may have to add additional elements here
addMissingEntries(connections, resolvedMethodGenerics);
// to finally see if the parameter and the argument fit together,
@@ -1597,7 +1564,7 @@ public abstract class StaticTypeCheckingSupport {
}
private static boolean compatibleConnections(Map<GenericsTypeName, GenericsType> connections, Map<GenericsTypeName, GenericsType> resolvedMethodGenerics, Set<GenericsTypeName> fixedGenericsPlaceHolders) {
- for (Entry<GenericsTypeName, GenericsType> entry : connections.entrySet()) {
+ for (Map.Entry<GenericsTypeName, GenericsType> entry : connections.entrySet()) {
GenericsType resolved = resolvedMethodGenerics.get(entry.getKey());
if (resolved == null) continue;
GenericsType connection = entry.getValue();
@@ -1644,7 +1611,7 @@ public abstract class StaticTypeCheckingSupport {
}
private static void addMissingEntries(Map<GenericsTypeName, GenericsType> connections, Map<GenericsTypeName, GenericsType> resolved) {
- for (Entry<GenericsTypeName, GenericsType> entry : connections.entrySet()) {
+ for (Map.Entry<GenericsTypeName, GenericsType> entry : connections.entrySet()) {
if (resolved.containsKey(entry.getKey())) continue;
GenericsType gt = entry.getValue();
ClassNode cn = gt.getType();
@@ -1655,10 +1622,10 @@ public abstract class StaticTypeCheckingSupport {
public static ClassNode resolveClassNodeGenerics(Map<GenericsTypeName, GenericsType> resolvedPlaceholders, final Map<GenericsTypeName, GenericsType> placeholdersFromContext, ClassNode currentType) {
ClassNode target = currentType.redirect();
- resolvedPlaceholders = new HashMap<GenericsTypeName, GenericsType>(resolvedPlaceholders);
+ resolvedPlaceholders = new HashMap<>(resolvedPlaceholders);
applyContextGenerics(resolvedPlaceholders, placeholdersFromContext);
- Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
extractGenericsConnections(connections, currentType, target);
applyGenericsConnections(connections, resolvedPlaceholders);
currentType = applyGenericsContext(resolvedPlaceholders, currentType);
@@ -1672,9 +1639,9 @@ public abstract class StaticTypeCheckingSupport {
if (connections == null) return;
int count = 0;
while (count < 10000) {
- count++;
+ count += 1;
boolean checkForMorePlaceHolders = false;
- for (Entry<GenericsTypeName, GenericsType> entry : resolvedPlaceholders.entrySet()) {
+ for (Map.Entry<GenericsTypeName, GenericsType> entry : resolvedPlaceholders.entrySet()) {
GenericsTypeName name = entry.getKey();
GenericsType replacement = connections.get(name);
if (replacement == null) {
@@ -1800,7 +1767,7 @@ public abstract class StaticTypeCheckingSupport {
ClassNode corrected = getCorrectedClassNode(type, superClass, true);
extractGenericsConnections(connections, corrected, target);
} else {
- // if we reach here, we have an unhandled case
+ // if we reach here, we have an unhandled case
throw new GroovyBugError("The type " + type + " seems not to normally extend " + target + ". Sorry, I cannot handle this.");
}
}
@@ -1817,7 +1784,7 @@ public abstract class StaticTypeCheckingSupport {
}
private static void extractGenericsConnections(Map<GenericsTypeName, GenericsType> connections, GenericsType[] usage, GenericsType[] declaration) {
- // if declaration does not provide generics, there is no connection to make
+ // 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;
@@ -1872,7 +1839,7 @@ public abstract class StaticTypeCheckingSupport {
Map<GenericsTypeName, GenericsType> spec, ClassNode parameterUsage
) {
GenericsType[] gts = parameterUsage.getGenericsTypes();
- if (gts == null) return Collections.EMPTY_MAP;
+ if (gts == null) return Collections.emptyMap();
GenericsType[] newGTs = applyGenericsContext(spec, gts);
ClassNode newTarget = parameterUsage.redirect().getPlainNodeReference();
@@ -1981,7 +1948,7 @@ public abstract class StaticTypeCheckingSupport {
private static void applyContextGenerics(Map<GenericsTypeName, GenericsType> resolvedPlaceholders, Map<GenericsTypeName, GenericsType> placeholdersFromContext) {
if (placeholdersFromContext == null) return;
- for (Entry<GenericsTypeName, GenericsType> entry : resolvedPlaceholders.entrySet()) {
+ for (Map.Entry<GenericsTypeName, GenericsType> entry : resolvedPlaceholders.entrySet()) {
GenericsType gt = entry.getValue();
if (gt.isPlaceholder()) {
GenericsTypeName name = new GenericsTypeName(gt.getName());
@@ -2067,7 +2034,7 @@ public abstract class StaticTypeCheckingSupport {
private static Map<GenericsTypeName, GenericsType> mergeGenerics(Map<GenericsTypeName, GenericsType> current, GenericsType[] newGenerics) {
if (newGenerics == null || newGenerics.length == 0) return current;
- if (current == null) current = new HashMap<GenericsTypeName, GenericsType>();
+ if (current == null) current = new HashMap<>();
for (GenericsType gt : newGenerics) {
if (!gt.isPlaceholder()) continue;
GenericsTypeName name = new GenericsTypeName(gt.getName());
@@ -2274,7 +2241,6 @@ public abstract class StaticTypeCheckingSupport {
}
}
-
/**
* @return true if the class node is either a GString or the LUB of String and GString.
*/
@@ -2349,9 +2315,8 @@ public abstract class StaticTypeCheckingSupport {
CompilationUnit cu = new CompilationUnit(copyConf);
cu.addClassNode(node);
cu.compile(Phases.CLASS_GENERATION);
- @SuppressWarnings("unchecked")
- List<GroovyClass> classes = (List<GroovyClass>) cu.getClasses();
- Class aClass = cu.getClassLoader().defineClass(className, classes.get(0).getBytes());
+ List<GroovyClass> classes = cu.getClasses();
+ Class<?> aClass = cu.getClassLoader().defineClass(className, classes.get(0).getBytes());
try {
return aClass.getMethod("eval").invoke(null);
} catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
@@ -2367,7 +2332,7 @@ public abstract class StaticTypeCheckingSupport {
* @return a set of interfaces implemented by this class node
*/
public static Set<ClassNode> collectAllInterfaces(ClassNode node) {
- Set<ClassNode> result = new HashSet<ClassNode>();
+ Set<ClassNode> result = new HashSet<>();
collectAllInterfaces(node, result);
return result;
}
@@ -2411,7 +2376,7 @@ public abstract class StaticTypeCheckingSupport {
&& (!voidOnly || VOID_TYPE == method.getReturnType())
&& method.getParameters().length == 1) {
if (result == null) {
- result = new LinkedList<MethodNode>();
+ result = new LinkedList<>();
}
result.add(method);
}
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
index b032191..0447f9f 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -129,6 +129,7 @@ import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Queue;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
@@ -405,7 +406,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
typeCheckingContext.pushEnclosingClassNode(node);
Set<MethodNode> oldVisitedMethod = typeCheckingContext.alreadyVisitedMethods;
- typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<MethodNode>();
+ typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<>();
super.visitClass(node);
Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
while (innerClasses.hasNext()) {
@@ -489,14 +490,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
}
- private static void addPrivateFieldOrMethodAccess(Expression source, ClassNode cn, StaticTypesMarker type, ASTNode accessedMember) {
- Set<ASTNode> set = cn.<Set<ASTNode>>getNodeMetaData(type);
- if (set == null) {
- set = new LinkedHashSet<ASTNode>();
- cn.putNodeMetaData(type, set);
- }
- set.add(accessedMember);
- source.putNodeMetaData(type, accessedMember);
+ private static void addPrivateFieldOrMethodAccess(Expression source, ClassNode cn, StaticTypesMarker key, ASTNode accessedMember) {
+ cn.getNodeMetaData(key, x -> new LinkedHashSet<>()).add(accessedMember);
+ source.putNodeMetaData(key, accessedMember);
}
/**
@@ -569,12 +565,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
Expression objectExpression = ((MethodCallExpression) call).getObjectExpression();
if (isSuperExpression(objectExpression)) {
ClassNode current = typeCheckingContext.getEnclosingClassNode();
- LinkedList<MethodNode> list = current.getNodeMetaData(SUPER_MOP_METHOD_REQUIRED);
- if (list == null) {
- list = new LinkedList<MethodNode>();
- current.putNodeMetaData(SUPER_MOP_METHOD_REQUIRED, list);
- }
- list.add(directCallTarget);
+ current.getNodeMetaData(SUPER_MOP_METHOD_REQUIRED, x -> new LinkedList<>()).add(directCallTarget);
call.putNodeMetaData(SUPER_MOP_METHOD_REQUIRED, current);
}
}
@@ -761,8 +752,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private boolean isLHSOfEnclosingAssignment(final Expression expression) {
- BinaryExpression ec = typeCheckingContext.getEnclosingBinaryExpression();
- return ec != null && ec.getLeftExpression() == expression && isAssignment(ec.getOperation().getType());
+ return Optional.ofNullable(typeCheckingContext.getEnclosingBinaryExpression())
+ .filter(be -> be.getLeftExpression() == expression && isAssignment(be.getOperation().getType())).isPresent();
}
@Override
@@ -868,7 +859,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (leftVar.isClosureSharedVariable()) {
// if left expression is a closure shared variable, we should check it twice
// see GROOVY-5874
- typeCheckingContext.secondPassExpressions.add(new SecondPassExpression<Void>(expression));
+ typeCheckingContext.secondPassExpressions.add(new SecondPassExpression<>(expression));
}
}
@@ -938,7 +929,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
VariableExpression var = (VariableExpression) accessedVariable;
List<ClassNode> types = typeCheckingContext.ifElseForWhileAssignmentTracker.get(var);
if (types == null) {
- types = new LinkedList<ClassNode>();
+ types = new LinkedList<>();
ClassNode type = var.getNodeMetaData(INFERRED_TYPE);
types.add(type);
typeCheckingContext.ifElseForWhileAssignmentTracker.put(var, types);
@@ -1142,9 +1133,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
* @param typeExpression the expression which represents the target type
*/
protected void pushInstanceOfTypeInfo(final Expression objectOfInstanceOf, final Expression typeExpression) {
- final Map<Object, List<ClassNode>> tempo = typeCheckingContext.temporaryIfBranchTypeInformation.peek();
+ Map<Object, List<ClassNode>> tempo = typeCheckingContext.temporaryIfBranchTypeInformation.peek();
Object key = extractTemporaryTypeInfoKey(objectOfInstanceOf);
- List<ClassNode> potentialTypes = tempo.computeIfAbsent(key, k -> new LinkedList<ClassNode>());
+ List<ClassNode> potentialTypes = tempo.computeIfAbsent(key, k -> new LinkedList<>());
potentialTypes.add(typeExpression.getType());
}
@@ -1389,7 +1380,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (!(keyExpr instanceof ConstantExpression)) {
addStaticTypeError("Dynamic keys in map-style constructors are unsupported in static type checking", keyExpr);
} else {
- AtomicReference<ClassNode> lookup = new AtomicReference<ClassNode>();
+ AtomicReference<ClassNode> lookup = new AtomicReference<>();
PropertyExpression pexp = new PropertyExpression(varX("_", receiverType), keyExpr.getText());
boolean hasProperty = existsProperty(pexp, false, new PropertyLookupVisitor(lookup));
if (!hasProperty) {
@@ -1766,7 +1757,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
ClassNode contentType = OBJECT_TYPE;
if (types != null && types.length == 1) contentType = types[0].getType();
PropertyExpression subExp = new PropertyExpression(varX("{}", contentType), pexp.getPropertyAsString());
- AtomicReference<ClassNode> result = new AtomicReference<ClassNode>();
+ AtomicReference<ClassNode> result = new AtomicReference<>();
if (existsProperty(subExp, true, new PropertyLookupVisitor(result))) {
ClassNode intf = LIST_TYPE.getPlainNodeReference();
intf.setGenericsTypes(new GenericsType[]{new GenericsType(getWrapper(result.get()))});
@@ -1782,7 +1773,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (types == null || types.length != 1) return OBJECT_TYPE;
PropertyExpression subExp = new PropertyExpression(varX("{}", types[0].getType()), pexp.getPropertyAsString());
- AtomicReference<ClassNode> result = new AtomicReference<ClassNode>();
+ AtomicReference<ClassNode> result = new AtomicReference<>();
if (existsProperty(subExp, true, new PropertyLookupVisitor(result))) {
intf = LIST_TYPE.getPlainNodeReference();
ClassNode itemType = result.get();
@@ -1939,7 +1930,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
@Override
public void visitForLoop(final ForStatement forLoop) {
// collect every variable expression used in the loop body
- final Map<VariableExpression, ClassNode> varOrigType = new HashMap<VariableExpression, ClassNode>();
+ final Map<VariableExpression, ClassNode> varOrigType = new HashMap<>();
forLoop.getLoopBlock().visit(new VariableExpressionTypeMemoizer(varOrigType));
// visit body
@@ -2078,72 +2069,72 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
@Override
public void visitPostfixExpression(final PostfixExpression expression) {
super.visitPostfixExpression(expression);
- Expression inner = expression.getExpression();
- int op = expression.getOperation().getType();
- visitPrefixOrPostifExpression(expression, inner, op);
+ Expression operand = expression.getExpression();
+ int operator = expression.getOperation().getType();
+ visitPrefixOrPostifExpression(expression, operand, operator);
}
@Override
public void visitPrefixExpression(final PrefixExpression expression) {
super.visitPrefixExpression(expression);
- Expression inner = expression.getExpression();
- int type = expression.getOperation().getType();
- visitPrefixOrPostifExpression(expression, inner, type);
+ Expression operand = expression.getExpression();
+ int operator = expression.getOperation().getType();
+ visitPrefixOrPostifExpression(expression, operand, operator);
}
- private static ClassNode getMathWideningClassNode(ClassNode type) {
- if (byte_TYPE.equals(type) || short_TYPE.equals(type) || int_TYPE.equals(type)) {
- return int_TYPE;
- }
- if (Byte_TYPE.equals(type) || Short_TYPE.equals(type) || Integer_TYPE.equals(type)) {
- return Integer_TYPE;
- }
- if (float_TYPE.equals(type)) return double_TYPE;
- if (Float_TYPE.equals(type)) return Double_TYPE;
- return type;
- }
-
- private void visitPrefixOrPostifExpression(final Expression origin, final Expression innerExpression, final int operationType) {
+ private void visitPrefixOrPostifExpression(final Expression origin, final Expression operand, final int operator) {
boolean isPostfix = origin instanceof PostfixExpression;
- ClassNode exprType = getType(innerExpression);
- String name = operationType == PLUS_PLUS ? "next" : operationType == MINUS_MINUS ? "previous" : null;
- if (isPrimitiveType(exprType) || isPrimitiveType(getUnwrapper(exprType))) {
- if (operationType == PLUS_PLUS || operationType == MINUS_MINUS) {
- if (!isPrimitiveType(exprType)) {
- MethodNode node = findMethodOrFail(varX("_dummy_", exprType), exprType, name);
- if (node != null) {
- storeTargetMethod(origin, node);
- storeType(origin,
- isPostfix ? exprType : getMathWideningClassNode(exprType));
- return;
- }
+ ClassNode exprType = getType(operand);
+ String name = operator == PLUS_PLUS ? "next" : operator == MINUS_MINUS ? "previous" : null;
+
+ if (name != null && isNumberType(exprType)) {
+ if (!isPrimitiveType(exprType)) {
+ MethodNode node = findMethodOrFail(varX("_dummy_", exprType), exprType, name);
+ if (node != null) {
+ storeTargetMethod(origin, node);
+ storeType(origin, isPostfix ? exprType : getMathWideningClassNode(exprType));
+ return;
}
- storeType(origin, exprType);
- return;
}
- addUnsupportedPreOrPostfixExpressionError(origin);
+ storeType(origin, exprType);
return;
- } else if (implementsInterfaceOrIsSubclassOf(exprType, Number_TYPE) && (operationType == PLUS_PLUS || operationType == MINUS_MINUS)) {
+ }
+ if (name != null && exprType.isDerivedFrom(Number_TYPE)) {
// special case for numbers, improve type checking as we can expect ++ and -- to return the same type
- MethodNode node = findMethodOrFail(innerExpression, exprType, name);
+ MethodNode node = findMethodOrFail(operand, exprType, name);
if (node != null) {
storeTargetMethod(origin, node);
storeType(origin, getMathWideningClassNode(exprType));
return;
}
}
- // not a primitive type. We must find a method which is called next
if (name == null) {
addUnsupportedPreOrPostfixExpressionError(origin);
return;
}
- MethodNode node = findMethodOrFail(innerExpression, exprType, name);
+ MethodNode node = findMethodOrFail(operand, exprType, name);
if (node != null) {
storeTargetMethod(origin, node);
storeType(origin, isPostfix ? exprType : inferReturnTypeGenerics(exprType, node, ArgumentListExpression.EMPTY_ARGUMENTS));
}
}
+ private static ClassNode getMathWideningClassNode(ClassNode type) {
+ if (byte_TYPE.equals(type) || short_TYPE.equals(type) || int_TYPE.equals(type)) {
+ return int_TYPE;
+ }
+ if (Byte_TYPE.equals(type) || Short_TYPE.equals(type) || Integer_TYPE.equals(type)) {
+ return Integer_TYPE;
+ }
+ if (float_TYPE.equals(type)) {
+ return double_TYPE;
+ }
+ if (Float_TYPE.equals(type)) {
+ return Double_TYPE;
+ }
+ return type;
+ }
+
private void negativeOrPositiveUnary(Expression expression, String name) {
ClassNode type = getType(expression);
ClassNode typeRe = type.redirect();
@@ -2338,7 +2329,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (exp instanceof VariableExpression && info != null) {
List<ClassNode> classNodes = getTemporaryTypesForExpression(exp);
if (classNodes != null && !classNodes.isEmpty()) {
- ArrayList<ClassNode> arr = new ArrayList<ClassNode>(classNodes.size() + 1);
+ ArrayList<ClassNode> arr = new ArrayList<>(classNodes.size() + 1);
if (result != null && !classNodes.contains(result)) arr.add(result);
arr.addAll(classNodes);
// GROOVY-7333: filter out Object
@@ -2361,7 +2352,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
typeCheckingContext.isInStaticContext = false;
// collect every variable expression used in the loop body
- final Map<VariableExpression, ClassNode> varOrigType = new HashMap<VariableExpression, ClassNode>();
+ final Map<VariableExpression, ClassNode> varOrigType = new HashMap<>();
Statement code = expression.getCode();
code.visit(new VariableExpressionTypeMemoizer(varOrigType));
Map<VariableExpression, List<ClassNode>> oldTracker = pushAssignmentTracking();
@@ -2452,7 +2443,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// GROOVY-6921: We must force a call to getType in order to update closure shared variable whose
// types are inferred thanks to closure parameter type inference
getType(ve);
- Map<StaticTypesMarker, Object> metadata = new ListHashMap<StaticTypesMarker, Object>();
+ Map<StaticTypesMarker, Object> metadata = new ListHashMap<>();
for (StaticTypesMarker marker : StaticTypesMarker.values()) {
Object value = ve.getNodeMetaData(marker);
if (value != null) {
@@ -2468,8 +2459,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
protected boolean shouldSkipMethodNode(final MethodNode node) {
- Object type = node.getNodeMetaData(StaticTypeCheckingVisitor.class);
- return Boolean.TRUE.equals(type);
+ return Boolean.TRUE.equals(node.getNodeMetaData(StaticTypeCheckingVisitor.class));
}
@Override
@@ -2598,7 +2588,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// - the actual receiver as found in the method call expression
// - any of the potential receivers found in the instanceof temporary table
// in that order
- List<Receiver<String>> receivers = new LinkedList<Receiver<String>>();
+ List<Receiver<String>> receivers = new LinkedList<>();
addReceivers(receivers, makeOwnerList(new ClassExpression(receiver)), false);
List<MethodNode> mn = null;
Receiver<String> chosenReceiver = null;
@@ -2680,7 +2670,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
protected void visitMethodCallArguments(final ClassNode receiver, ArgumentListExpression arguments, boolean visitClosures, final MethodNode selectedMethod) {
Parameter[] params = selectedMethod != null ? selectedMethod.getParameters() : Parameter.EMPTY_ARRAY;
- List<Expression> expressions = new LinkedList<Expression>(arguments.getExpressions());
+ List<Expression> expressions = new LinkedList<>(arguments.getExpressions());
if (selectedMethod instanceof ExtensionMethodNode) {
params = ((ExtensionMethodNode) selectedMethod).getExtensionMethodNode().getParameters();
expressions.add(0, varX("$self", receiver));
@@ -2716,7 +2706,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private void checkNamedParamsAnnotation(Parameter param, MapExpression args) {
if (!isOrImplements(param.getType(), MAP_TYPE)) return;
List<MapEntryExpression> entryExpressions = args.getMapEntryExpressions();
- Map<Object, Expression> entries = new LinkedHashMap<Object, Expression>();
+ Map<Object, Expression> entries = new LinkedHashMap<>();
for (MapEntryExpression entry : entryExpressions) {
Object key = entry.getKeyExpression();
if (key instanceof ConstantExpression) {
@@ -2732,7 +2722,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
an = next;
}
}
- List<String> collectedNames = new ArrayList<String>();
+ List<String> collectedNames = new ArrayList<>();
if (an != null) {
Expression value = an.getMember("value");
if (value instanceof AnnotationConstantExpression) {
@@ -2834,7 +2824,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// First we try to get as much information about the declaration
// class through the receiver
- Map<GenericsTypeName, GenericsType> targetMethodDeclarationClassConnections = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> targetMethodDeclarationClassConnections = new HashMap<>();
extractGenericsConnections(targetMethodDeclarationClassConnections, receiver, receiver.redirect());
// then we use the method with the SAM parameter to get more information about the declaration
Parameter[] parametersOfMethodContainingSAM = methodWithSAMParameter.getParameters();
@@ -2855,7 +2845,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// to replace the generics in the SAM type parameter of the target
// method and than that to make the connections to the SAM type generics
ClassNode paramTypeWithReceiverInformation = applyGenericsContext(targetMethodDeclarationClassConnections, param.getOriginType());
- Map<GenericsTypeName, GenericsType> SAMTypeConnections = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> SAMTypeConnections = new HashMap<>();
ClassNode classForSAM = paramTypeWithReceiverInformation.redirect();
extractGenericsConnections(SAMTypeConnections, paramTypeWithReceiverInformation, classForSAM);
@@ -3275,9 +3265,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private static void addDelegateReceiver(final List<Receiver<String>> receivers, final ClassNode delegate, final String path) {
- receivers.add(new Receiver<String>(delegate, path));
+ receivers.add(new Receiver<>(delegate, path));
if (Traits.isTrait(delegate.getOuterClass())) {
- receivers.add(new Receiver<String>(delegate.getOuterClass(), path));
+ receivers.add(new Receiver<>(delegate.getOuterClass(), path));
}
}
@@ -3407,7 +3397,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// - the actual receiver as found in the method call expression
// - any of the potential receivers found in the instanceof temporary table
// in that order
- List<Receiver<String>> receivers = new LinkedList<Receiver<String>>();
+ List<Receiver<String>> receivers = new LinkedList<>();
List<Receiver<String>> owners = makeOwnerList(objectExpression);
addReceivers(receivers, owners, call.isImplicitThis());
List<MethodNode> mn = null;
@@ -3427,8 +3417,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// a nice error message to the user
// a method is accessible if it is static, or if we are not in a static context and it is
// declared by the current receiver or a superclass
- List<MethodNode> accessibleMethods = new LinkedList<MethodNode>();
- List<MethodNode> inaccessibleMethods = new LinkedList<MethodNode>();
+ List<MethodNode> accessibleMethods = new LinkedList<>();
+ List<MethodNode> inaccessibleMethods = new LinkedList<>();
for (final MethodNode node : mn) {
if (node.isStatic()
|| (!typeCheckingContext.isInStaticContext && implementsInterfaceOrIsSubclassOf(receiverType, node.getDeclaringClass()))) {
@@ -3517,10 +3507,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (objectExpression instanceof VariableExpression) {
VariableExpression var = (VariableExpression) objectExpression;
if (var.isClosureSharedVariable()) {
- SecondPassExpression<ClassNode[]> wrapper = new SecondPassExpression<ClassNode[]>(
- call,
- args
- );
+ SecondPassExpression<ClassNode[]> wrapper = new SecondPassExpression<>(call, args);
typeCheckingContext.secondPassExpressions.add(wrapper);
}
}
@@ -3651,7 +3638,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (directMethodCallCandidate instanceof ExtensionMethodNode) {
ExtensionMethodNode emn = (ExtensionMethodNode) directMethodCallCandidate;
if ("withTraits".equals(emn.getName()) && "DefaultGroovyMethods".equals(emn.getExtensionMethodNode().getDeclaringClass().getNameWithoutPackage())) {
- List<ClassNode> nodes = new LinkedList<ClassNode>();
+ List<ClassNode> nodes = new LinkedList<>();
Collections.addAll(nodes, receiver.getInterfaces());
for (ClassNode arg : args) {
if (isClassClassNodeWrappingConcreteType(arg)) {
@@ -3718,7 +3705,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
*/
protected List<Receiver<String>> makeOwnerList(final Expression objectExpression) {
final ClassNode receiver = getType(objectExpression);
- List<Receiver<String>> owners = new LinkedList<Receiver<String>>();
+ List<Receiver<String>> owners = new LinkedList<>();
owners.add(Receiver.<String>make(receiver));
if (isClassClassNodeWrappingConcreteType(receiver)) {
GenericsType clazzGT = receiver.getGenericsTypes()[0];
@@ -3754,7 +3741,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private static void addSelfTypes(final ClassNode receiver, final List<Receiver<String>> owners) {
- LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<ClassNode>();
+ LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<>();
for (ClassNode selfType : Traits.collectSelfTypes(receiver, selfTypes)) {
owners.add(Receiver.<String>make(selfType));
}
@@ -4011,7 +3998,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
VariableExpression key = entry.getKey();
List<ClassNode> allValues = entry.getValue();
// GROOVY-6099: First element of the list may be null, if no assignment was made before the branch
- List<ClassNode> nonNullValues = new ArrayList<ClassNode>(allValues.size());
+ List<ClassNode> nonNullValues = new ArrayList<>(allValues.size());
for (ClassNode value : allValues) {
if (value != null) nonNullValues.add(value);
}
@@ -4027,7 +4014,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
protected Map<VariableExpression, List<ClassNode>> pushAssignmentTracking() {
// memorize current assignment context
Map<VariableExpression, List<ClassNode>> oldTracker = typeCheckingContext.ifElseForWhileAssignmentTracker;
- typeCheckingContext.ifElseForWhileAssignmentTracker = new HashMap<VariableExpression, List<ClassNode>>();
+ typeCheckingContext.ifElseForWhileAssignmentTracker = new HashMap<>();
return oldTracker;
}
@@ -4401,7 +4388,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (samGt == null || closureGt == null) return samUsage;
// extract the generics from the return type
- Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
extractGenericsConnections(connections, getInferredReturnType(closureExpression), sam.getReturnType());
// next we get the block parameter types and set the generics
@@ -4573,7 +4560,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static List<MethodNode> addGeneratedMethods(final ClassNode receiver, final List<MethodNode> methods) {
// using a comparator of parameters
- List<MethodNode> result = new LinkedList<MethodNode>();
+ List<MethodNode> result = new LinkedList<>();
for (MethodNode method : methods) {
result.add(method);
Parameter[] parameters = method.getParameters();
@@ -4632,7 +4619,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (isPrimitiveType(receiver)) receiver = getWrapper(receiver);
List<MethodNode> methods;
if (!receiver.isInterface() && "<init>".equals(name)) {
- methods = addGeneratedMethods(receiver, new ArrayList<MethodNode>(receiver.getDeclaredConstructors()));
+ methods = addGeneratedMethods(receiver, new ArrayList<>(receiver.getDeclaredConstructors()));
if (methods.isEmpty()) {
MethodNode node = new ConstructorNode(Opcodes.ACC_PUBLIC, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, GENERATED_EMPTY_STATEMENT);
node.setDeclaringClass(receiver);
@@ -4956,7 +4943,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
*/
private ClassNode getGenericsResolvedTypeOfFieldOrProperty(AnnotatedNode an, ClassNode type) {
if (!type.isUsingGenerics()) return type;
- Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
//TODO: inner classes mean a different this-type. This is ignored here!
extractGenericsConnections(connections, typeCheckingContext.getEnclosingClassNode(), an.getDeclaringClass());
type = applyGenericsContext(connections, type);
@@ -4987,7 +4974,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static ClassNode makeSelf(ClassNode trait) {
ClassNode ret = trait;
- LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<ClassNode>();
+ LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<>();
Traits.collectSelfTypes(ret, selfTypes);
if (!selfTypes.isEmpty()) {
selfTypes.add(ret);
@@ -5036,7 +5023,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
|| (genericsTypes.length == 1 && OBJECT_TYPE.equals(genericsTypes[0].getType())))
&& (!expressions.isEmpty())) {
// maybe we can infer the component type
- List<ClassNode> nodes = new LinkedList<ClassNode>();
+ List<ClassNode> nodes = new LinkedList<>();
for (Expression expression : expressions) {
if (isNullConstant(expression)) {
// a null element is found in the list, skip it because we'll use the other elements from the list
@@ -5076,8 +5063,8 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (genericsTypes == null
|| genericsTypes.length < 2
|| (genericsTypes.length == 2 && OBJECT_TYPE.equals(genericsTypes[0].getType()) && OBJECT_TYPE.equals(genericsTypes[1].getType()))) {
- List<ClassNode> keyTypes = new LinkedList<ClassNode>();
- List<ClassNode> valueTypes = new LinkedList<ClassNode>();
+ List<ClassNode> keyTypes = new LinkedList<>();
+ List<ClassNode> valueTypes = new LinkedList<>();
for (MapEntryExpression entryExpression : entryExpressions) {
keyTypes.add(getType(entryExpression.getKeyExpression()));
valueTypes.add(getType(entryExpression.getValueExpression()));
@@ -5190,7 +5177,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
actualType = wrapTypeIfNecessary(actualType);
- Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
extractGenericsConnections(connections, actualType, type);
extractGenericsConnectionsForSuperClassAndInterfaces(resolvedPlaceholders, connections);
applyGenericsConnections(connections, resolvedPlaceholders);
@@ -5218,7 +5205,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
for (GenericsType value : new HashSet<GenericsType>(connections.values())) {
if (!value.isPlaceholder() && !value.isWildcard()) {
ClassNode valueType = value.getType();
- List<ClassNode> deepNodes = new LinkedList<ClassNode>();
+ List<ClassNode> deepNodes = new LinkedList<>();
ClassNode unresolvedSuperClass = valueType.getUnresolvedSuperClass();
if (unresolvedSuperClass != null && unresolvedSuperClass.isUsingGenerics()) {
deepNodes.add(unresolvedSuperClass);
@@ -5283,7 +5270,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
// now repeat the same for each parameter given in the ClosureExpression
if (expression instanceof ClosureExpression && sam.getParameters().length > 0) {
- List<ClassNode[]> genericsToConnect = new LinkedList<ClassNode[]>();
+ List<ClassNode[]> genericsToConnect = new LinkedList<>();
Parameter[] closureParams = ((ClosureExpression) expression).getParameters();
ClassNode[] closureParamTypes = extractTypesFromParameters(closureParams);
if (expression.getNodeMetaData(CLOSURE_ARGUMENTS) != null) {
@@ -5369,7 +5356,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static Map<GenericsTypeName, GenericsType> extractPlaceHolders(MethodNode method, ClassNode receiver, ClassNode declaringClass) {
if (declaringClass.equals(OBJECT_TYPE)) {
- Map<GenericsTypeName, GenericsType> resolvedPlaceholders = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> resolvedPlaceholders = new HashMap<>();
if (method != null) addMethodLevelDeclaredGenerics(method, resolvedPlaceholders);
return resolvedPlaceholders;
}
@@ -5389,7 +5376,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
while (current != null) {
boolean continueLoop = true;
//extract the place holders
- Map<GenericsTypeName, GenericsType> currentPlaceHolders = new HashMap<GenericsTypeName, GenericsType>();
+ Map<GenericsTypeName, GenericsType> currentPlaceHolders = new HashMap<>();
if (isGenericsPlaceHolderOrArrayOf(declaringClass) || declaringClass.equals(current)) {
extractGenericsConnections(currentPlaceHolders, current, declaringClass);
if (method != null) addMethodLevelDeclaredGenerics(method, currentPlaceHolders);
diff --git a/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7276.groovy b/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7276.groovy
index 97d8529..1bd307d 100644
--- a/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7276.groovy
+++ b/src/test/org/codehaus/groovy/classgen/asm/sc/bugs/Groovy7276.groovy
@@ -71,14 +71,16 @@ final class Groovy7276 extends StaticTypeCheckingTestCase implements StaticCompi
@NotYetImplemented // GROOVY-7304
void testShouldGoThroughPrivateBridgeAccessorWithWriteAccess() {
- assertScript '''
- class Foo {
- private int i = 1
- def m() { new String().with { ++i } }
- }
- assert new Foo().m() == 2
- class Bar extends Foo {}
- assert new Bar().m() == 2
- '''
+ ['++i', 'i++', 'i+=1', 'i=i+1'].each {
+ assertScript """
+ class Foo {
+ private int i = 1
+ def m() { new String().with { $it } }
+ }
+ assert new Foo().m() == 2
+ class Bar extends Foo {}
+ assert new Bar().m() == 2
+ """
+ }
}
}