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 2018/08/25 17:03:45 UTC
[2/8] groovy git commit: Revert "Minor refactoring: Explicit type can
be replaced with <>"
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java
index 6e99694..d421a47 100644
--- a/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/TupleConstructorASTTransformation.java
@@ -97,7 +97,7 @@ public class TupleConstructorASTTransformation extends AbstractASTTransformation
static {
final ConstantExpression zero = constX(0);
final ConstantExpression zeroDecimal = constX(.0);
- primitivesInitialValues = new HashMap<>();
+ primitivesInitialValues = new HashMap<Class<?>, Expression>();
primitivesInitialValues.put(int.class, zero);
primitivesInitialValues.put(long.class, zero);
primitivesInitialValues.put(short.class, zero);
@@ -171,12 +171,12 @@ public class TupleConstructorASTTransformation extends AbstractASTTransformation
boolean callSuper = xform.memberHasValue(anno, "callSuper", true);
boolean force = xform.memberHasValue(anno, "force", true);
boolean defaults = !xform.memberHasValue(anno, "defaults", false);
- Set<String> names = new HashSet<>();
+ Set<String> names = new HashSet<String>();
List<PropertyNode> superList;
if (includeSuperProperties || includeSuperFields) {
superList = getAllProperties(names, cNode.getSuperClass(), includeSuperProperties, includeSuperFields, false, allProperties, true, true);
} else {
- superList = new ArrayList<>();
+ superList = new ArrayList<PropertyNode>();
}
List<PropertyNode> list = getAllProperties(names, cNode, includeProperties, includeFields, false, allProperties, false, true);
@@ -188,8 +188,8 @@ public class TupleConstructorASTTransformation extends AbstractASTTransformation
// no processing if existing constructors found unless forced or ImmutableBase in play
if (hasExplicitConstructor(null, cNode) && !force && !makeImmutable) return;
- final List<Parameter> params = new ArrayList<>();
- final List<Expression> superParams = new ArrayList<>();
+ final List<Parameter> params = new ArrayList<Parameter>();
+ final List<Expression> superParams = new ArrayList<Expression>();
final BlockStatement preBody = new BlockStatement();
boolean superInPre = false;
if (pre != null) {
@@ -202,7 +202,7 @@ public class TupleConstructorASTTransformation extends AbstractASTTransformation
final BlockStatement body = new BlockStatement();
- List<PropertyNode> tempList = new ArrayList<>(list);
+ List<PropertyNode> tempList = new ArrayList<PropertyNode>(list);
tempList.addAll(superList);
if (!handler.validateProperties(xform, body, cNode, tempList)) {
return;
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/sc/ListOfExpressionsExpression.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/ListOfExpressionsExpression.java b/src/main/java/org/codehaus/groovy/transform/sc/ListOfExpressionsExpression.java
index 355ff66..0c4a56c 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/ListOfExpressionsExpression.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/ListOfExpressionsExpression.java
@@ -36,7 +36,7 @@ public class ListOfExpressionsExpression extends Expression {
private final List<Expression> expressions;
public ListOfExpressionsExpression() {
- expressions = new LinkedList<>();
+ expressions = new LinkedList<Expression>();
}
public ListOfExpressionsExpression(final List<Expression> expressions) {
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
index 39972d3..f66b24a 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/StaticCompilationVisitor.java
@@ -241,8 +241,8 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
return;
}
int acc = -1;
- privateFieldAccessors = accessedFields != null ? new HashMap<>() : null;
- privateFieldMutators = mutatedFields != null ? new HashMap<>() : null;
+ privateFieldAccessors = accessedFields != null ? new HashMap<String, MethodNode>() : null;
+ privateFieldMutators = mutatedFields != null ? new HashMap<String, MethodNode>() : null;
final int access = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC;
for (FieldNode fieldNode : node.getFields()) {
boolean generateAccessor = accessedFields != null && accessedFields.contains(fieldNode);
@@ -288,14 +288,14 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
private static void addPrivateBridgeMethods(final ClassNode node) {
Set<ASTNode> accessedMethods = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS);
if (accessedMethods==null) return;
- List<MethodNode> methods = new ArrayList<>(node.getAllDeclaredMethods());
+ List<MethodNode> methods = new ArrayList<MethodNode>(node.getAllDeclaredMethods());
methods.addAll(node.getDeclaredConstructors());
Map<MethodNode, MethodNode> privateBridgeMethods = (Map<MethodNode, MethodNode>) node.getNodeMetaData(PRIVATE_BRIDGE_METHODS);
if (privateBridgeMethods!=null) {
// private bridge methods already added
return;
}
- privateBridgeMethods = new HashMap<>();
+ privateBridgeMethods = new HashMap<MethodNode, MethodNode>();
int i=-1;
final int access = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC;
for (MethodNode method : methods) {
@@ -319,7 +319,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
if (method.getParameters()==null || method.getParameters().length==0) {
arguments = ArgumentListExpression.EMPTY_ARGUMENTS;
} else {
- List<Expression> args = new LinkedList<>();
+ List<Expression> args = new LinkedList<Expression>();
for (Parameter parameter : methodParameters) {
args.add(new VariableExpression(parameter));
}
@@ -369,7 +369,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
}
private static List<String> methodSpecificGenerics(final MethodNode method) {
- List<String> genericTypeTokens = new ArrayList<>();
+ List<String> genericTypeTokens = new ArrayList<String>();
GenericsType[] candidateGenericsTypes = method.getGenericsTypes();
if (candidateGenericsTypes != null) {
for (GenericsType gt : candidateGenericsTypes) {
@@ -459,7 +459,7 @@ public class StaticCompilationVisitor extends StaticTypeCheckingVisitor {
protected boolean existsProperty(final PropertyExpression pexp, final boolean checkForReadOnly, final ClassCodeVisitorSupport visitor) {
Expression objectExpression = pexp.getObjectExpression();
ClassNode objectExpressionType = getType(objectExpression);
- final Reference<ClassNode> rType = new Reference<>(objectExpressionType);
+ final Reference<ClassNode> rType = new Reference<ClassNode>(objectExpressionType);
ClassCodeVisitorSupport receiverMemoizer = new ClassCodeVisitorSupport() {
@Override
protected SourceUnit getSourceUnit() {
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java
index 6cd5b69..d726ee8 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/BinaryExpressionTransformer.java
@@ -225,8 +225,8 @@ public class BinaryExpressionTransformer {
// next = tmp1
// result = tmp2
int size = rightExpressions.size();
- List<Expression> tmpAssignments = new ArrayList<>(size);
- List<Expression> finalAssignments = new ArrayList<>(size);
+ List<Expression> tmpAssignments = new ArrayList<Expression>(size);
+ List<Expression> finalAssignments = new ArrayList<Expression>(size);
for (int i = 0; i < Math.min(size, leftExpressions.size()); i++) {
Expression left = leftIt.next();
Expression right = rightIt.next();
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/sc/transformers/ListExpressionTransformer.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/sc/transformers/ListExpressionTransformer.java b/src/main/java/org/codehaus/groovy/transform/sc/transformers/ListExpressionTransformer.java
index 59fcd65..a415d05 100644
--- a/src/main/java/org/codehaus/groovy/transform/sc/transformers/ListExpressionTransformer.java
+++ b/src/main/java/org/codehaus/groovy/transform/sc/transformers/ListExpressionTransformer.java
@@ -72,7 +72,7 @@ public class ListExpressionTransformer {
private List<Expression> transformArguments(final ListExpression expr) {
List<Expression> expressions = expr.getExpressions();
- List<Expression> transformedArgs = new LinkedList<>();
+ List<Expression> transformedArgs = new LinkedList<Expression>();
for (Expression expression : expressions) {
transformedArgs.add(transformer.transform(expression));
}
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/AbstractTypeCheckingExtension.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/AbstractTypeCheckingExtension.java b/src/main/java/org/codehaus/groovy/transform/stc/AbstractTypeCheckingExtension.java
index 81f333b..d6cae87 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/AbstractTypeCheckingExtension.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/AbstractTypeCheckingExtension.java
@@ -60,8 +60,8 @@ import java.util.logging.Logger;
public class AbstractTypeCheckingExtension extends TypeCheckingExtension {
private static final Logger LOG = Logger.getLogger(GroovyTypeCheckingExtensionSupport.class.getName());
protected final TypeCheckingContext context;
- private final Set<MethodNode> generatedMethods = new LinkedHashSet<>();
- private final LinkedList<TypeCheckingScope> scopeData = new LinkedList<>();
+ private final Set<MethodNode> generatedMethods = new LinkedHashSet<MethodNode>();
+ private final LinkedList<TypeCheckingScope> scopeData = new LinkedList<TypeCheckingScope>();
// this boolean is used through setHandled(boolean)
protected boolean handled = false;
protected boolean debug = false;
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/DefaultTypeCheckingExtension.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/DefaultTypeCheckingExtension.java b/src/main/java/org/codehaus/groovy/transform/stc/DefaultTypeCheckingExtension.java
index aae9e5d..e17d8d4 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/DefaultTypeCheckingExtension.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/DefaultTypeCheckingExtension.java
@@ -48,7 +48,7 @@ import java.util.List;
* @since 2.1.0
*/
public class DefaultTypeCheckingExtension extends TypeCheckingExtension {
- protected final List<TypeCheckingExtension> handlers = new LinkedList<>();
+ protected final List<TypeCheckingExtension> handlers = new LinkedList<TypeCheckingExtension>();
public DefaultTypeCheckingExtension(final StaticTypeCheckingVisitor typeCheckingVisitor) {
super(typeCheckingVisitor);
@@ -110,7 +110,7 @@ public class DefaultTypeCheckingExtension extends TypeCheckingExtension {
}
public List<MethodNode> handleMissingMethod(final ClassNode receiver, final String name, final ArgumentListExpression argumentList, final ClassNode[] argumentTypes, final MethodCall call) {
- List<MethodNode> result = new LinkedList<>();
+ List<MethodNode> result = new LinkedList<MethodNode>();
for (TypeCheckingExtension handler : handlers) {
List<MethodNode> handlerResult = handler.handleMissingMethod(receiver, name, argumentList, argumentTypes, call);
for (MethodNode mn : handlerResult) {
@@ -178,7 +178,7 @@ public class DefaultTypeCheckingExtension extends TypeCheckingExtension {
@Override
public void setup() {
- ArrayList<TypeCheckingExtension> copy = new ArrayList<>(handlers);
+ ArrayList<TypeCheckingExtension> copy = new ArrayList<TypeCheckingExtension>(handlers);
// we're using a copy here because new extensions can be added during the "setup" phase
for (TypeCheckingExtension handler : copy) {
handler.setup();
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/GroovyTypeCheckingExtensionSupport.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/GroovyTypeCheckingExtensionSupport.java b/src/main/java/org/codehaus/groovy/transform/stc/GroovyTypeCheckingExtensionSupport.java
index d2a9623..6d8b36c 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/GroovyTypeCheckingExtensionSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/GroovyTypeCheckingExtensionSupport.java
@@ -89,7 +89,7 @@ public class GroovyTypeCheckingExtensionSupport extends AbstractTypeCheckingExte
);
// the following fields are closures executed in event-based methods
- private final Map<String, List<Closure>> eventHandlers = new HashMap<>();
+ private final Map<String, List<Closure>> eventHandlers = new HashMap<String, List<Closure>>();
private final String scriptPath;
@@ -352,7 +352,7 @@ public class GroovyTypeCheckingExtensionSupport extends AbstractTypeCheckingExte
@SuppressWarnings("unchecked")
public List<MethodNode> handleMissingMethod(final ClassNode receiver, final String name, final ArgumentListExpression argumentList, final ClassNode[] argumentTypes, final MethodCall call) {
List<Closure> onMethodSelection = eventHandlers.get("handleMissingMethod");
- List<MethodNode> methodList = new LinkedList<>();
+ List<MethodNode> methodList = new LinkedList<MethodNode>();
if (onMethodSelection != null) {
for (Closure closure : onMethodSelection) {
Object result = safeCall(closure, receiver, name, argumentList, argumentTypes, call);
@@ -384,7 +384,7 @@ public class GroovyTypeCheckingExtensionSupport extends AbstractTypeCheckingExte
if (result instanceof MethodNode) {
methodList = Collections.singletonList((MethodNode) result);
} else if (result instanceof Collection) {
- methodList = new LinkedList<>((Collection<? extends MethodNode>) result);
+ methodList = new LinkedList<MethodNode>((Collection<? extends MethodNode>) result);
} else {
throw new GroovyBugError("Type checking extension returned unexpected method list: " + result);
}
@@ -444,7 +444,7 @@ public class GroovyTypeCheckingExtensionSupport extends AbstractTypeCheckingExte
}
List<Closure> closures = extension.eventHandlers.get(methodName);
if (closures == null) {
- closures = new LinkedList<>();
+ closures = new LinkedList<Closure>();
extension.eventHandlers.put(methodName, closures);
}
closures.add((Closure) argsArray[0]);
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/Receiver.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/Receiver.java b/src/main/java/org/codehaus/groovy/transform/stc/Receiver.java
index 8e6efd9..ad934ee 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/Receiver.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/Receiver.java
@@ -26,7 +26,7 @@ public class Receiver<T> {
private final T data;
public static <T> Receiver<T> make(final ClassNode type) {
- return new Receiver<>(type == null ? ClassHelper.OBJECT_TYPE : type);
+ return new Receiver<T>(type==null?ClassHelper.OBJECT_TYPE:type);
}
public Receiver(final ClassNode type) {
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/SharedVariableCollector.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/SharedVariableCollector.java b/src/main/java/org/codehaus/groovy/transform/stc/SharedVariableCollector.java
index 3d980ad..b8fccb2 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/SharedVariableCollector.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/SharedVariableCollector.java
@@ -31,7 +31,7 @@ import java.util.Set;
*/
public class SharedVariableCollector extends ClassCodeVisitorSupport {
private final SourceUnit unit;
- private final Set<VariableExpression> closureSharedExpressions = new LinkedHashSet<>();
+ private final Set<VariableExpression> closureSharedExpressions = new LinkedHashSet<VariableExpression>();
private boolean visited = false;
public SharedVariableCollector(final SourceUnit unit) {
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/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 b70f6de..061cfb7 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingSupport.java
@@ -301,7 +301,7 @@ public abstract class StaticTypeCheckingSupport {
}
protected static Set<MethodNode> findDGMMethodsForClassNode(final ClassLoader loader, ClassNode clazz, String name) {
- TreeSet<MethodNode> accumulator = new TreeSet<>(DGM_METHOD_NODE_COMPARATOR);
+ TreeSet<MethodNode> accumulator = new TreeSet<MethodNode>(DGM_METHOD_NODE_COMPARATOR);
findDGMMethodsForClassNode(loader, clazz, name, accumulator);
return accumulator;
}
@@ -1008,7 +1008,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<>());
+ return findDGMMethodsByNameAndArguments(loader, receiver, name, args, new LinkedList<MethodNode>());
}
/**
@@ -1072,7 +1072,7 @@ public abstract class StaticTypeCheckingSupport {
ClassNode raw = makeRawType(receiver);
return chooseBestMethod(raw, methods, args);
}
- List<MethodNode> bestChoices = new LinkedList<>();
+ List<MethodNode> bestChoices = new LinkedList<MethodNode>();
int bestDist = Integer.MAX_VALUE;
Collection<MethodNode> choicesLeft = removeCovariantsAndInterfaceEquivalents(methods);
for (MethodNode candidateNode : choicesLeft) {
@@ -1116,7 +1116,7 @@ public abstract class StaticTypeCheckingSupport {
}
if (bestChoices.size() > 1) {
// GROOVY-6849: prefer extension methods in case of ambiguity
- List<MethodNode> onlyExtensionMethods = new LinkedList<>();
+ List<MethodNode> onlyExtensionMethods = new LinkedList<MethodNode>();
for (MethodNode choice : bestChoices) {
if (choice instanceof ExtensionMethodNode) {
onlyExtensionMethods.add(choice);
@@ -1215,8 +1215,8 @@ public abstract class StaticTypeCheckingSupport {
private static Collection<MethodNode> removeCovariantsAndInterfaceEquivalents(Collection<MethodNode> collection) {
if (collection.size() <= 1) return collection;
- List<MethodNode> toBeRemoved = new LinkedList<>();
- List<MethodNode> list = new LinkedList<>(new LinkedHashSet<>(collection));
+ List<MethodNode> toBeRemoved = new LinkedList<MethodNode>();
+ List<MethodNode> list = new LinkedList<MethodNode>(new LinkedHashSet<MethodNode>(collection));
for (int i = 0; i < list.size() - 1; i++) {
MethodNode one = list.get(i);
if (toBeRemoved.contains(one)) continue;
@@ -1241,7 +1241,7 @@ public abstract class StaticTypeCheckingSupport {
}
}
if (toBeRemoved.isEmpty()) return list;
- List<MethodNode> result = new LinkedList<>(list);
+ List<MethodNode> result = new LinkedList<MethodNode>(list);
result.removeAll(toBeRemoved);
return result;
}
@@ -1508,7 +1508,7 @@ public abstract class StaticTypeCheckingSupport {
// 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 non-hidden ones.
- Map<GenericsTypeName, GenericsType> resolvedMethodGenerics = new HashMap<>();
+ Map<GenericsTypeName, GenericsType> resolvedMethodGenerics = new HashMap<GenericsTypeName, GenericsType>();
if (!skipBecauseOfInnerClassNotReceiver) {
addMethodLevelDeclaredGenerics(candidateMethod, resolvedMethodGenerics);
}
@@ -1548,7 +1548,7 @@ 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<>();
+ Set<GenericsTypeName> result = new HashSet<GenericsTypeName>();
for (Entry<GenericsTypeName, GenericsType> entry : resolvedMethodGenerics.entrySet()) {
GenericsType value = entry.getValue();
if (value.isPlaceholder()) continue;
@@ -1558,7 +1558,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<>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
if (isPrimitiveType(wrappedArgument)) wrappedArgument = getWrapper(wrappedArgument);
// the context we compare with in the end is the one of the callsite
// so far we specified the context of the method declaration only
@@ -1652,10 +1652,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<>(resolvedPlaceholders);
+ resolvedPlaceholders = new HashMap<GenericsTypeName, GenericsType>(resolvedPlaceholders);
applyContextGenerics(resolvedPlaceholders, placeholdersFromContext);
- Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
extractGenericsConnections(connections, currentType, target);
applyGenericsConnections(connections, resolvedPlaceholders);
currentType = applyGenericsContext(resolvedPlaceholders, currentType);
@@ -2060,7 +2060,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<>();
+ if (current == null) current = new HashMap<GenericsTypeName, GenericsType>();
for (GenericsType gt : newGenerics) {
if (!gt.isPlaceholder()) continue;
GenericsTypeName name = new GenericsTypeName(gt.getName());
@@ -2207,7 +2207,7 @@ public abstract class StaticTypeCheckingSupport {
* a method lookup.
*/
private static class ExtensionMethodCache {
- private final EvictableCache<ClassLoader, Map<String, List<MethodNode>>> cache = new StampedCommonCache<>(new WeakHashMap<>());
+ private final EvictableCache<ClassLoader, Map<String, List<MethodNode>>> cache = new StampedCommonCache<ClassLoader, Map<String, List<MethodNode>>>(new WeakHashMap<ClassLoader, Map<String, List<MethodNode>>>());
public Map<String, List<MethodNode>> getExtensionMethods(ClassLoader loader) {
return cache.getAndPut(
@@ -2215,7 +2215,7 @@ public abstract class StaticTypeCheckingSupport {
new EvictableCache.ValueProvider<ClassLoader, Map<String, List<MethodNode>>>() {
@Override
public Map<String, List<MethodNode>> provide(final ClassLoader key) {
- final List<ExtensionModule> modules = new LinkedList<>();
+ final List<ExtensionModule> modules = new LinkedList<ExtensionModule>();
ExtensionModuleScanner scanner =
new ExtensionModuleScanner(
new ExtensionModuleScanner.ExtensionModuleListener() {
@@ -2248,8 +2248,8 @@ public abstract class StaticTypeCheckingSupport {
* @return
*/
private static Map<String, List<MethodNode>> getDGMMethods(List<ExtensionModule> modules) {
- Set<Class> instanceExtClasses = new LinkedHashSet<>();
- Set<Class> staticExtClasses = new LinkedHashSet<>();
+ Set<Class> instanceExtClasses = new LinkedHashSet<Class>();
+ Set<Class> staticExtClasses = new LinkedHashSet<Class>();
for (ExtensionModule module : modules) {
if (module instanceof MetaInfExtensionModule) {
MetaInfExtensionModule extensionModule = (MetaInfExtensionModule) module;
@@ -2257,7 +2257,7 @@ public abstract class StaticTypeCheckingSupport {
staticExtClasses.addAll(extensionModule.getStaticMethodsExtensionClasses());
}
}
- Map<String, List<MethodNode>> methods = new HashMap<>();
+ Map<String, List<MethodNode>> methods = new HashMap<String, List<MethodNode>>();
Collections.addAll(instanceExtClasses, DefaultGroovyMethods.DGM_LIKE_CLASSES);
Collections.addAll(instanceExtClasses, DefaultGroovyMethods.ADDITIONAL_CLASSES);
staticExtClasses.add(DefaultGroovyStaticMethods.class);
@@ -2306,7 +2306,7 @@ public abstract class StaticTypeCheckingSupport {
List<MethodNode> nodes = accumulator.get(declaringClassName);
if (nodes == null) {
- nodes = new LinkedList<>();
+ nodes = new LinkedList<MethodNode>();
accumulator.put(declaringClassName, nodes);
}
nodes.add(node);
@@ -2409,7 +2409,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<>();
+ Set<ClassNode> result = new HashSet<ClassNode>();
collectAllInterfaces(node, result);
return result;
}
@@ -2453,7 +2453,7 @@ public abstract class StaticTypeCheckingSupport {
&& (!voidOnly || VOID_TYPE == method.getReturnType())
&& method.getParameters().length == 1) {
if (result == null) {
- result = new LinkedList<>();
+ result = new LinkedList<MethodNode>();
}
result.add(method);
}
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
----------------------------------------------------------------------
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 b1f9237..2f48985 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/StaticTypeCheckingVisitor.java
@@ -389,7 +389,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
typeCheckingContext.pushEnclosingClassNode(node);
Set<MethodNode> oldVisitedMethod = typeCheckingContext.alreadyVisitedMethods;
- typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<>();
+ typeCheckingContext.alreadyVisitedMethods = new LinkedHashSet<MethodNode>();
super.visitClass(node);
Iterator<InnerClassNode> innerClasses = node.getInnerClasses();
while (innerClasses.hasNext()) {
@@ -478,7 +478,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static void addPrivateFieldOrMethodAccess(Expression source, ClassNode cn, StaticTypesMarker type, ASTNode accessedMember) {
Set<ASTNode> set = (Set<ASTNode>) cn.getNodeMetaData(type);
if (set == null) {
- set = new LinkedHashSet<>();
+ set = new LinkedHashSet<ASTNode>();
cn.putNodeMetaData(type, set);
}
set.add(accessedMember);
@@ -561,7 +561,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
ClassNode current = typeCheckingContext.getEnclosingClassNode();
LinkedList<MethodNode> list = current.getNodeMetaData(StaticTypesMarker.SUPER_MOP_METHOD_REQUIRED);
if (list == null) {
- list = new LinkedList<>();
+ list = new LinkedList<MethodNode>();
current.putNodeMetaData(StaticTypesMarker.SUPER_MOP_METHOD_REQUIRED, list);
}
list.add(directCallTarget);
@@ -900,7 +900,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
VariableExpression var = (VariableExpression) accessedVariable;
List<ClassNode> types = typeCheckingContext.ifElseForWhileAssignmentTracker.get(var);
if (types == null) {
- types = new LinkedList<>();
+ types = new LinkedList<ClassNode>();
ClassNode type = var.getNodeMetaData(StaticTypesMarker.INFERRED_TYPE);
types.add(type);
typeCheckingContext.ifElseForWhileAssignmentTracker.put(var, types);
@@ -1071,7 +1071,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
Object key = extractTemporaryTypeInfoKey(objectOfInstanceOf);
List<ClassNode> potentialTypes = tempo.get(key);
if (potentialTypes == null) {
- potentialTypes = new LinkedList<>();
+ potentialTypes = new LinkedList<ClassNode>();
tempo.put(key, potentialTypes);
}
potentialTypes.add(typeExpression.getType());
@@ -1277,7 +1277,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<>();
+ AtomicReference<ClassNode> lookup = new AtomicReference<ClassNode>();
PropertyExpression pexp = new PropertyExpression(varX("_", receiverType), keyExpr.getText());
boolean hasProperty = existsProperty(pexp, false, new PropertyLookupVisitor(lookup));
if (!hasProperty) {
@@ -1437,16 +1437,16 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
boolean foundGetterOrSetter = false;
- List<Receiver<String>> receivers = new LinkedList<>();
+ List<Receiver<String>> receivers = new LinkedList<Receiver<String>>();
List<Receiver<String>> owners = makeOwnerList(objectExpression);
addReceivers(receivers, owners, pexp.isImplicitThis());
String capName = capitalize(propertyName);
boolean isAttributeExpression = pexp instanceof AttributeExpression;
- HashSet<ClassNode> handledNodes = new HashSet<>();
+ HashSet<ClassNode> handledNodes = new HashSet<ClassNode>();
for (Receiver<String> receiver : receivers) {
ClassNode testClass = receiver.getType();
- LinkedList<ClassNode> queue = new LinkedList<>();
+ LinkedList<ClassNode> queue = new LinkedList<ClassNode>();
queue.add(testClass);
if (isPrimitiveType(testClass)) {
queue.add(getWrapper(testClass));
@@ -1551,7 +1551,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
}
// GROOVY-5568, the property may be defined by DGM
- List<ClassNode> dgmReceivers = new ArrayList<>(2);
+ List<ClassNode> dgmReceivers = new ArrayList<ClassNode>(2);
dgmReceivers.add(testClass);
if (isPrimitiveType(testClass)) dgmReceivers.add(getWrapper(testClass));
for (ClassNode dgmReceiver : dgmReceivers) {
@@ -1615,7 +1615,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<>();
+ AtomicReference<ClassNode> result = new AtomicReference<ClassNode>();
if (existsProperty(subExp, true, new PropertyLookupVisitor(result))) {
ClassNode intf = LIST_TYPE.getPlainNodeReference();
intf.setGenericsTypes(new GenericsType[]{new GenericsType(getWrapper(result.get()))});
@@ -1631,7 +1631,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<>();
+ AtomicReference<ClassNode> result = new AtomicReference<ClassNode>();
if (existsProperty(subExp, true, new PropertyLookupVisitor(result))) {
intf = LIST_TYPE.getPlainNodeReference();
ClassNode itemType = result.get();
@@ -1753,7 +1753,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (propertyName == null) return null;
Expression objectExpression = pexp.getObjectExpression();
- List<Receiver<String>> receivers = new LinkedList<>();
+ List<Receiver<String>> receivers = new LinkedList<Receiver<String>>();
List<Receiver<String>> owners = makeOwnerList(objectExpression);
addReceivers(receivers, owners, pexp.isImplicitThis());
@@ -1762,7 +1762,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
for (Receiver<String> receiver : receivers) {
ClassNode testClass = receiver.getType();
- LinkedList<ClassNode> queue = new LinkedList<>();
+ LinkedList<ClassNode> queue = new LinkedList<ClassNode>();
queue.add(testClass);
if (testClass.isInterface()) {
queue.addAll(testClass.getAllInterfaces());
@@ -1828,7 +1828,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<>();
+ final Map<VariableExpression, ClassNode> varOrigType = new HashMap<VariableExpression, ClassNode>();
forLoop.getLoopBlock().visit(new VariableExpressionTypeMemoizer(varOrigType));
// visit body
@@ -2235,7 +2235,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<>(classNodes.size() + 1);
+ ArrayList<ClassNode> arr = new ArrayList<ClassNode>(classNodes.size() + 1);
if (result != null && !classNodes.contains(result)) arr.add(result);
arr.addAll(classNodes);
// GROOVY-7333: filter out Object
@@ -2264,7 +2264,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<>();
+ final Map<VariableExpression, ClassNode> varOrigType = new HashMap<VariableExpression, ClassNode>();
Statement code = expression.getCode();
code.visit(new VariableExpressionTypeMemoizer(varOrigType));
Map<VariableExpression, List<ClassNode>> oldTracker = pushAssignmentTracking();
@@ -2275,7 +2275,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
Set<VariableExpression> closureSharedExpressions = collector.getClosureSharedExpressions();
Map<VariableExpression, ListHashMap> typesBeforeVisit = null;
if (!closureSharedExpressions.isEmpty()) {
- typesBeforeVisit = new HashMap<>();
+ typesBeforeVisit = new HashMap<VariableExpression, ListHashMap>();
saveVariableExpressionMetadata(closureSharedExpressions, typesBeforeVisit);
}
@@ -2351,7 +2351,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);
- ListHashMap<StaticTypesMarker, Object> metadata = new ListHashMap<>();
+ ListHashMap<StaticTypesMarker, Object> metadata = new ListHashMap<StaticTypesMarker, Object>();
for (StaticTypesMarker marker : StaticTypesMarker.values()) {
Object value = ve.getNodeMetaData(marker);
if (value != null) {
@@ -2497,7 +2497,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<>();
+ List<Receiver<String>> receivers = new LinkedList<Receiver<String>>();
addReceivers(receivers, makeOwnerList(new ClassExpression(receiver)), false);
List<MethodNode> mn = null;
Receiver<String> chosenReceiver = null;
@@ -2581,7 +2581,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<>(arguments.getExpressions());
+ List<Expression> expressions = new LinkedList<Expression>(arguments.getExpressions());
if (selectedMethod instanceof ExtensionMethodNode) {
params = ((ExtensionMethodNode) selectedMethod).getExtensionMethodNode().getParameters();
expressions.add(0, varX("$self", receiver));
@@ -2656,7 +2656,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<>();
+ Map<GenericsTypeName, GenericsType> targetMethodDeclarationClassConnections = new HashMap<GenericsTypeName, GenericsType>();
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();
@@ -2677,7 +2677,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<>();
+ Map<GenericsTypeName, GenericsType> SAMTypeConnections = new HashMap<GenericsTypeName, GenericsType>();
ClassNode classForSAM = paramTypeWithReceiverInformation.redirect();
extractGenericsConnections(SAMTypeConnections, paramTypeWithReceiverInformation, classForSAM);
@@ -2770,7 +2770,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private void doInferClosureParameterTypes(final ClassNode receiver, final Expression arguments, final ClosureExpression expression, final MethodNode selectedMethod, final Expression hintClass, Expression resolverClass, final Expression options) {
List<ClassNode[]> closureSignatures = getSignaturesFromHint(expression, selectedMethod, hintClass, options);
- List<ClassNode[]> candidates = new LinkedList<>();
+ List<ClassNode[]> candidates = new LinkedList<ClassNode[]>();
Parameter[] closureParams = expression.getParameters();
for (ClassNode[] signature : closureSignatures) {
// in order to compute the inferred types of the closure parameters, we're using the following trick:
@@ -2929,7 +2929,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
if (options instanceof ListExpression) {
List<Expression> list = ((ListExpression) options).getExpressions();
- List<String> result = new ArrayList<>(list.size());
+ List<String> result = new ArrayList<String>(list.size());
for (Expression expression : list) {
result.add(expression.getText());
}
@@ -3075,9 +3075,9 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private static void doAddDelegateReceiver(final List<Receiver<String>> receivers, final StringBuilder path, final ClassNode delegate) {
- receivers.add(new Receiver<>(delegate, path.toString()));
+ receivers.add(new Receiver<String>(delegate, path.toString()));
if (isTraitHelper(delegate)) {
- receivers.add(new Receiver<>(delegate.getOuterClass(), path.toString()));
+ receivers.add(new Receiver<String>(delegate.getOuterClass(), path.toString()));
}
}
@@ -3206,7 +3206,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<>();
+ List<Receiver<String>> receivers = new LinkedList<Receiver<String>>();
List<Receiver<String>> owners = makeOwnerList(objectExpression);
addReceivers(receivers, owners, call.isImplicitThis());
List<MethodNode> mn = null;
@@ -3226,8 +3226,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<>();
- List<MethodNode> inaccessibleMethods = new LinkedList<>();
+ List<MethodNode> accessibleMethods = new LinkedList<MethodNode>();
+ List<MethodNode> inaccessibleMethods = new LinkedList<MethodNode>();
for (final MethodNode node : mn) {
if (node.isStatic()
|| (!typeCheckingContext.isInStaticContext && implementsInterfaceOrIsSubclassOf(receiverType, node.getDeclaringClass()))) {
@@ -3331,7 +3331,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (objectExpression instanceof VariableExpression) {
VariableExpression var = (VariableExpression) objectExpression;
if (var.isClosureSharedVariable()) {
- SecondPassExpression<ClassNode[]> wrapper = new SecondPassExpression<>(
+ SecondPassExpression<ClassNode[]> wrapper = new SecondPassExpression<ClassNode[]>(
call,
args
);
@@ -3411,7 +3411,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<>();
+ List<ClassNode> nodes = new LinkedList<ClassNode>();
Collections.addAll(nodes, receiver.getInterfaces());
for (ClassNode arg : args) {
if (isClassClassNodeWrappingConcreteType(arg)) {
@@ -3478,7 +3478,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<>();
+ List<Receiver<String>> owners = new LinkedList<Receiver<String>>();
owners.add(Receiver.<String>make(receiver));
if (isClassClassNodeWrappingConcreteType(receiver)) {
GenericsType clazzGT = receiver.getGenericsTypes()[0];
@@ -3506,7 +3506,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private static void addSelfTypes(final ClassNode receiver, final List<Receiver<String>> owners) {
- LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<>();
+ LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<ClassNode>();
for (ClassNode selfType : Traits.collectSelfTypes(receiver, selfTypes)) {
owners.add(Receiver.<String>make(selfType));
}
@@ -3755,13 +3755,13 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
protected Map<VariableExpression, ClassNode> popAssignmentTracking(final Map<VariableExpression, List<ClassNode>> oldTracker) {
- Map<VariableExpression, ClassNode> assignments = new HashMap<>();
+ Map<VariableExpression, ClassNode> assignments = new HashMap<VariableExpression, ClassNode>();
if (!typeCheckingContext.ifElseForWhileAssignmentTracker.isEmpty()) {
for (Map.Entry<VariableExpression, List<ClassNode>> entry : typeCheckingContext.ifElseForWhileAssignmentTracker.entrySet()) {
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<>(allValues.size());
+ List<ClassNode> nonNullValues = new ArrayList<ClassNode>(allValues.size());
for (ClassNode value : allValues) {
if (value != null) nonNullValues.add(value);
}
@@ -3777,7 +3777,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<>();
+ typeCheckingContext.ifElseForWhileAssignmentTracker = new HashMap<VariableExpression, List<ClassNode>>();
return oldTracker;
}
@@ -3979,7 +3979,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
if (var.isClosureSharedVariable() && cn != null) {
List<ClassNode> assignedTypes = typeCheckingContext.closureSharedVariablesAssignmentTypes.get(var);
if (assignedTypes == null) {
- assignedTypes = new LinkedList<>();
+ assignedTypes = new LinkedList<ClassNode>();
typeCheckingContext.closureSharedVariablesAssignmentTypes.put(var, assignedTypes);
}
assignedTypes.add(cn);
@@ -4148,7 +4148,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<>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
extractGenericsConnections(connections, getInferredReturnType(closureExpression), sam.getReturnType());
// next we get the block parameter types and set the generics
@@ -4235,7 +4235,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private List<MethodNode> disambiguateMethods(List<MethodNode> methods, ClassNode receiver, ClassNode[] argTypes, final Expression call) {
if (methods.size() > 1 && receiver != null && argTypes != null) {
- List<MethodNode> filteredWithGenerics = new LinkedList<>();
+ List<MethodNode> filteredWithGenerics = new LinkedList<MethodNode>();
for (MethodNode methodNode : methods) {
if (typeCheckMethodsWithGenerics(receiver, argTypes, methodNode)) {
filteredWithGenerics.add(methodNode);
@@ -4316,7 +4316,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<>();
+ List<MethodNode> result = new LinkedList<MethodNode>();
for (MethodNode method : methods) {
result.add(method);
Parameter[] parameters = method.getParameters();
@@ -4375,7 +4375,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<>(receiver.getDeclaredConstructors()));
+ methods = addGeneratedMethods(receiver, new ArrayList<MethodNode>(receiver.getDeclaredConstructors()));
if (methods.isEmpty()) {
MethodNode node = new ConstructorNode(Opcodes.ACC_PUBLIC, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, GENERATED_EMPTY_STATEMENT);
node.setDeclaringClass(receiver);
@@ -4759,7 +4759,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
*/
private ClassNode getGenericsResolvedTypeOfFieldOrProperty(AnnotatedNode an, ClassNode type) {
if (!type.isUsingGenerics()) return type;
- Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
//TODO: inner classes mean a different this-type. This is ignored here!
extractGenericsConnections(connections, typeCheckingContext.getEnclosingClassNode(), an.getDeclaringClass());
type = applyGenericsContext(connections, type);
@@ -4790,7 +4790,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
private static ClassNode makeSelf(ClassNode trait) {
ClassNode ret = trait;
- LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<>();
+ LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<ClassNode>();
Traits.collectSelfTypes(ret, selfTypes);
if (!selfTypes.isEmpty()) {
selfTypes.add(ret);
@@ -4839,7 +4839,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<>();
+ List<ClassNode> nodes = new LinkedList<ClassNode>();
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
@@ -4871,8 +4871,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<>();
- List<ClassNode> valueTypes = new LinkedList<>();
+ List<ClassNode> keyTypes = new LinkedList<ClassNode>();
+ List<ClassNode> valueTypes = new LinkedList<ClassNode>();
for (MapEntryExpression entryExpression : entryExpressions) {
keyTypes.add(getType(entryExpression.getKeyExpression()));
valueTypes.add(getType(entryExpression.getValueExpression()));
@@ -4985,7 +4985,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
actualType = wrapTypeIfNecessary(actualType);
- Map<GenericsTypeName, GenericsType> connections = new HashMap<>();
+ Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>();
extractGenericsConnections(connections, actualType, type);
extractGenericsConnectionsForSuperClassAndInterfaces(resolvedPlaceholders, connections);
applyGenericsConnections(connections, resolvedPlaceholders);
@@ -5010,10 +5010,10 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
}
private static void extractGenericsConnectionsForSuperClassAndInterfaces(final Map<GenericsTypeName, GenericsType> resolvedPlaceholders, final Map<GenericsTypeName, GenericsType> connections) {
- for (GenericsType value : new HashSet<>(connections.values())) {
+ for (GenericsType value : new HashSet<GenericsType>(connections.values())) {
if (!value.isPlaceholder() && !value.isWildcard()) {
ClassNode valueType = value.getType();
- List<ClassNode> deepNodes = new LinkedList<>();
+ List<ClassNode> deepNodes = new LinkedList<ClassNode>();
ClassNode unresolvedSuperClass = valueType.getUnresolvedSuperClass();
if (unresolvedSuperClass != null && unresolvedSuperClass.isUsingGenerics()) {
deepNodes.add(unresolvedSuperClass);
@@ -5078,7 +5078,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<>();
+ List<ClassNode[]> genericsToConnect = new LinkedList<ClassNode[]>();
Parameter[] closureParams = ((ClosureExpression) expression).getParameters();
ClassNode[] closureParamTypes = extractTypesFromParameters(closureParams);
if (expression.getNodeMetaData(StaticTypesMarker.CLOSURE_ARGUMENTS) != null) {
@@ -5165,7 +5165,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<>();
+ Map<GenericsTypeName, GenericsType> resolvedPlaceholders = new HashMap<GenericsTypeName, GenericsType>();
if (method != null) addMethodLevelDeclaredGenerics(method, resolvedPlaceholders);
return resolvedPlaceholders;
}
@@ -5185,7 +5185,7 @@ public class StaticTypeCheckingVisitor extends ClassCodeVisitorSupport {
while (current != null) {
boolean continueLoop = true;
//extract the place holders
- Map<GenericsTypeName, GenericsType> currentPlaceHolders = new HashMap<>();
+ Map<GenericsTypeName, GenericsType> currentPlaceHolders = new HashMap<GenericsTypeName, GenericsType>();
if (isGenericsPlaceHolderOrArrayOf(declaringClass) || declaringClass.equals(current)) {
extractGenericsConnections(currentPlaceHolders, current, declaringClass);
if (method != null) addMethodLevelDeclaredGenerics(method, currentPlaceHolders);
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java b/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java
index 8b77468..7922770 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/TraitTypeCheckingExtension.java
@@ -109,7 +109,7 @@ public class TraitTypeCheckingExtension extends AbstractTypeCheckingExtension {
private List<MethodNode> convertToDynamicCall(MethodCall call, ClassNode receiver, String[] decomposed, ClassNode[] argumentTypes) {
String traitName = decomposed[0];
String name = decomposed[1];
- LinkedHashSet<ClassNode> traitsAsList = Traits.collectAllInterfacesReverseOrder(receiver, new LinkedHashSet<>());
+ LinkedHashSet<ClassNode> traitsAsList = Traits.collectAllInterfacesReverseOrder(receiver, new LinkedHashSet<ClassNode>());
ClassNode[] implementedTraits = traitsAsList.toArray(ClassNode.EMPTY_ARRAY);
ClassNode nextTrait = null;
for (int i = 0; i < implementedTraits.length - 1; i++) {
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java b/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java
index 70ef404..77cb289 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/TypeCheckingContext.java
@@ -52,18 +52,18 @@ public class TypeCheckingContext {
protected Set<MethodNode> methodsToBeVisited = Collections.emptySet();
protected boolean isInStaticContext = false;
- protected final LinkedList<ErrorCollector> errorCollectors = new LinkedList<>();
- protected final LinkedList<ClassNode> enclosingClassNodes = new LinkedList<>();
- protected final LinkedList<MethodNode> enclosingMethods = new LinkedList<>();
- protected final LinkedList<Expression> enclosingMethodCalls = new LinkedList<>();
- protected final LinkedList<ConstructorCallExpression> enclosingConstructorCalls = new LinkedList<>();
- protected final LinkedList<BlockStatement> enclosingBlocks = new LinkedList<>();
- protected final LinkedList<ReturnStatement> enclosingReturnStatements = new LinkedList<>();
- protected final LinkedList<PropertyExpression> enclosingPropertyExpressions = new LinkedList<>();
+ protected final LinkedList<ErrorCollector> errorCollectors = new LinkedList<ErrorCollector>();
+ protected final LinkedList<ClassNode> enclosingClassNodes = new LinkedList<ClassNode>();
+ protected final LinkedList<MethodNode> enclosingMethods = new LinkedList<MethodNode>();
+ protected final LinkedList<Expression> enclosingMethodCalls = new LinkedList<Expression>();
+ protected final LinkedList<ConstructorCallExpression> enclosingConstructorCalls = new LinkedList<ConstructorCallExpression>();
+ protected final LinkedList<BlockStatement> enclosingBlocks = new LinkedList<BlockStatement>();
+ protected final LinkedList<ReturnStatement> enclosingReturnStatements = new LinkedList<ReturnStatement>();
+ protected final LinkedList<PropertyExpression> enclosingPropertyExpressions = new LinkedList<PropertyExpression>();
// used for closure return type inference
- protected final LinkedList<EnclosingClosure> enclosingClosures = new LinkedList<>();
+ protected final LinkedList<EnclosingClosure> enclosingClosures = new LinkedList<EnclosingClosure>();
// whenever a method using a closure as argument (typically, "with") is detected, this list is updated
// with the receiver type of the with method
@@ -89,34 +89,34 @@ public class TypeCheckingContext {
* }
* // Here var1 instance of Runnable
*/
- protected final IdentityHashMap<BlockStatement, Map<VariableExpression, List<ClassNode>>> blockStatements2Types = new IdentityHashMap<>();
+ protected final IdentityHashMap<BlockStatement, Map<VariableExpression, List<ClassNode>>> blockStatements2Types = new IdentityHashMap<BlockStatement, Map<VariableExpression, List<ClassNode>>>();
/**
* Stores information which is only valid in the "if" branch of an if-then-else statement. This is used when the if
* condition expression makes use of an instanceof check
*/
- protected Stack<Map<Object, List<ClassNode>>> temporaryIfBranchTypeInformation = new Stack<>();
- protected Set<MethodNode> alreadyVisitedMethods = new HashSet<>();
+ protected Stack<Map<Object, List<ClassNode>>> temporaryIfBranchTypeInformation = new Stack<Map<Object, List<ClassNode>>>();
+ protected Set<MethodNode> alreadyVisitedMethods = new HashSet<MethodNode>();
/**
* Some expressions need to be visited twice, because type information may be insufficient at some point. For
* example, for closure shared variables, we need a first pass to collect every type which is assigned to a closure
* shared variable, then a second pass to ensure that every method call on such a variable is made on a LUB.
*/
- protected final LinkedHashSet<SecondPassExpression> secondPassExpressions = new LinkedHashSet<>();
+ protected final LinkedHashSet<SecondPassExpression> secondPassExpressions = new LinkedHashSet<SecondPassExpression>();
/**
* A map used to store every type used in closure shared variable assignments. In a second pass, we will compute the
* LUB of each type and check that method calls on those variables are valid.
*/
- protected final Map<VariableExpression, List<ClassNode>> closureSharedVariablesAssignmentTypes = new HashMap<>();
- protected Map<Parameter, ClassNode> controlStructureVariables = new HashMap<>();
+ protected final Map<VariableExpression, List<ClassNode>> closureSharedVariablesAssignmentTypes = new HashMap<VariableExpression, List<ClassNode>>();
+ protected Map<Parameter, ClassNode> controlStructureVariables = new HashMap<Parameter, ClassNode>();
// this map is used to ensure that two errors are not reported on the same line/column
- protected final Set<Long> reportedErrors = new TreeSet<>();
+ protected final Set<Long> reportedErrors = new TreeSet<Long>();
// stores the current binary expression. This is used when assignments are made with a null object, for type
// inference
- protected final LinkedList<BinaryExpression> enclosingBinaryExpressions = new LinkedList<>();
+ protected final LinkedList<BinaryExpression> enclosingBinaryExpressions = new LinkedList<BinaryExpression>();
protected final StaticTypeCheckingVisitor visitor;
@@ -294,7 +294,7 @@ public class TypeCheckingContext {
}
public void pushTemporaryTypeInfo() {
- Map<Object, List<ClassNode>> potentialTypes = new HashMap<>();
+ Map<Object, List<ClassNode>> potentialTypes = new HashMap<Object, List<ClassNode>>();
temporaryIfBranchTypeInformation.push(potentialTypes);
}
@@ -460,7 +460,7 @@ public class TypeCheckingContext {
public EnclosingClosure(final ClosureExpression closureExpression) {
this.closureExpression = closureExpression;
- this.returnTypes = new LinkedList<>();
+ this.returnTypes = new LinkedList<ClassNode>();
}
public ClosureExpression getClosureExpression() {
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/stc/UnionTypeClassNode.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/stc/UnionTypeClassNode.java b/src/main/java/org/codehaus/groovy/transform/stc/UnionTypeClassNode.java
index a576b19..1513421 100644
--- a/src/main/java/org/codehaus/groovy/transform/stc/UnionTypeClassNode.java
+++ b/src/main/java/org/codehaus/groovy/transform/stc/UnionTypeClassNode.java
@@ -165,7 +165,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<MethodNode> getAbstractMethods() {
- List<MethodNode> allMethods = new LinkedList<>();
+ List<MethodNode> allMethods = new LinkedList<MethodNode>();
for (ClassNode delegate : delegates) {
allMethods.addAll(delegate.getAbstractMethods());
}
@@ -174,7 +174,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<MethodNode> getAllDeclaredMethods() {
- List<MethodNode> allMethods = new LinkedList<>();
+ List<MethodNode> allMethods = new LinkedList<MethodNode>();
for (ClassNode delegate : delegates) {
allMethods.addAll(delegate.getAllDeclaredMethods());
}
@@ -183,7 +183,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public Set<ClassNode> getAllInterfaces() {
- Set<ClassNode> allMethods = new HashSet<>();
+ Set<ClassNode> allMethods = new HashSet<ClassNode>();
for (ClassNode delegate : delegates) {
allMethods.addAll(delegate.getAllInterfaces());
}
@@ -192,7 +192,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<AnnotationNode> getAnnotations() {
- List<AnnotationNode> nodes = new LinkedList<>();
+ List<AnnotationNode> nodes = new LinkedList<AnnotationNode>();
for (ClassNode delegate : delegates) {
List<AnnotationNode> annotations = delegate.getAnnotations();
if (annotations != null) nodes.addAll(annotations);
@@ -202,7 +202,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<AnnotationNode> getAnnotations(final ClassNode type) {
- List<AnnotationNode> nodes = new LinkedList<>();
+ List<AnnotationNode> nodes = new LinkedList<AnnotationNode>();
for (ClassNode delegate : delegates) {
List<AnnotationNode> annotations = delegate.getAnnotations(type);
if (annotations != null) nodes.addAll(annotations);
@@ -217,7 +217,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<ConstructorNode> getDeclaredConstructors() {
- List<ConstructorNode> nodes = new LinkedList<>();
+ List<ConstructorNode> nodes = new LinkedList<ConstructorNode>();
for (ClassNode delegate : delegates) {
nodes.addAll(delegate.getDeclaredConstructors());
}
@@ -244,7 +244,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<MethodNode> getDeclaredMethods(final String name) {
- List<MethodNode> nodes = new LinkedList<>();
+ List<MethodNode> nodes = new LinkedList<MethodNode>();
for (ClassNode delegate : delegates) {
List<MethodNode> methods = delegate.getDeclaredMethods(name);
if (methods != null) nodes.addAll(methods);
@@ -273,7 +273,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<FieldNode> getFields() {
- List<FieldNode> nodes = new LinkedList<>();
+ List<FieldNode> nodes = new LinkedList<FieldNode>();
for (ClassNode delegate : delegates) {
List<FieldNode> fields = delegate.getFields();
if (fields != null) nodes.addAll(fields);
@@ -288,7 +288,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public ClassNode[] getInterfaces() {
- Set<ClassNode> nodes = new LinkedHashSet<>();
+ Set<ClassNode> nodes = new LinkedHashSet<ClassNode>();
for (ClassNode delegate : delegates) {
ClassNode[] interfaces = delegate.getInterfaces();
if (interfaces != null) Collections.addAll(nodes, interfaces);
@@ -298,7 +298,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<MethodNode> getMethods() {
- List<MethodNode> nodes = new LinkedList<>();
+ List<MethodNode> nodes = new LinkedList<MethodNode>();
for (ClassNode delegate : delegates) {
List<MethodNode> methods = delegate.getMethods();
if (methods != null) nodes.addAll(methods);
@@ -308,7 +308,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public List<PropertyNode> getProperties() {
- List<PropertyNode> nodes = new LinkedList<>();
+ List<PropertyNode> nodes = new LinkedList<PropertyNode>();
for (ClassNode delegate : delegates) {
List<PropertyNode> properties = delegate.getProperties();
if (properties != null) nodes.addAll(properties);
@@ -323,7 +323,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public ClassNode[] getUnresolvedInterfaces() {
- Set<ClassNode> nodes = new LinkedHashSet<>();
+ Set<ClassNode> nodes = new LinkedHashSet<ClassNode>();
for (ClassNode delegate : delegates) {
ClassNode[] interfaces = delegate.getUnresolvedInterfaces();
if (interfaces != null) Collections.addAll(nodes, interfaces);
@@ -333,7 +333,7 @@ class UnionTypeClassNode extends ClassNode {
@Override
public ClassNode[] getUnresolvedInterfaces(final boolean useRedirect) {
- Set<ClassNode> nodes = new LinkedHashSet<>();
+ Set<ClassNode> nodes = new LinkedHashSet<ClassNode>();
for (ClassNode delegate : delegates) {
ClassNode[] interfaces = delegate.getUnresolvedInterfaces(useRedirect);
if (interfaces != null) Collections.addAll(nodes, interfaces);
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
index 4610dd9..1dbbe96 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitASTTransformation.java
@@ -182,8 +182,8 @@ public class TraitASTTransformation extends AbstractASTTransformation implements
generatePropertyMethods(cNode);
// prepare fields
- List<FieldNode> fields = new ArrayList<>();
- Set<String> fieldNames = new HashSet<>();
+ List<FieldNode> fields = new ArrayList<FieldNode>();
+ Set<String> fieldNames = new HashSet<String>();
boolean hasStatic = false;
for (FieldNode field : cNode.getFields()) {
if (!"metaClass".equals(field.getName()) && (!field.isSynthetic() || field.getName().indexOf('$') < 0)) {
@@ -214,8 +214,8 @@ public class TraitASTTransformation extends AbstractASTTransformation implements
}
// add methods
- List<MethodNode> methods = new ArrayList<>(cNode.getMethods());
- List<MethodNode> nonPublicAPIMethods = new LinkedList<>();
+ List<MethodNode> methods = new ArrayList<MethodNode>(cNode.getMethods());
+ List<MethodNode> nonPublicAPIMethods = new LinkedList<MethodNode>();
for (final MethodNode methodNode : methods) {
boolean declared = methodNode.getDeclaringClass() == cNode;
if (declared) {
@@ -250,7 +250,7 @@ public class TraitASTTransformation extends AbstractASTTransformation implements
// copy annotations
copyClassAnnotations(cNode, helper);
- fields = new ArrayList<>(cNode.getFields()); // reuse the full list of fields
+ fields = new ArrayList<FieldNode>(cNode.getFields()); // reuse the full list of fields
for (FieldNode field : fields) {
cNode.removeField(field.getName());
}
@@ -513,8 +513,8 @@ public class TraitASTTransformation extends AbstractASTTransformation implements
null
);
// copy annotations from field to dummy field
- List<AnnotationNode> copied = new LinkedList<>();
- List<AnnotationNode> notCopied = new LinkedList<>();
+ List<AnnotationNode> copied = new LinkedList<AnnotationNode>();
+ List<AnnotationNode> notCopied = new LinkedList<AnnotationNode>();
GeneralUtils.copyAnnotatedNodeAnnotations(field, copied, notCopied);
dummyField.addAnnotations(copied);
fieldHelper.addField(dummyField);
@@ -531,8 +531,8 @@ public class TraitASTTransformation extends AbstractASTTransformation implements
null
);
// copy annotations from field to legacy dummy field
- copied = new LinkedList<>();
- notCopied = new LinkedList<>();
+ copied = new LinkedList<AnnotationNode>();
+ notCopied = new LinkedList<AnnotationNode>();
GeneralUtils.copyAnnotatedNodeAnnotations(field, copied, notCopied);
dummyField.addAnnotations(copied);
fieldHelper.addField(dummyField);
@@ -569,7 +569,7 @@ public class TraitASTTransformation extends AbstractASTTransformation implements
}
private static List<AnnotationNode> filterAnnotations(List<AnnotationNode> annotations) {
- List<AnnotationNode> result = new ArrayList<>(annotations.size());
+ List<AnnotationNode> result = new ArrayList<AnnotationNode>(annotations.size());
for (AnnotationNode annotation : annotations) {
if (!OVERRIDE_CLASSNODE.equals(annotation.getClassNode())) {
result.add(annotation);
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
index 6195ae9..f7a57f8 100644
--- a/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
+++ b/src/main/java/org/codehaus/groovy/transform/trait/TraitComposer.java
@@ -120,9 +120,9 @@ public abstract class TraitComposer {
}
private static List<ClassNode> findTraits(ClassNode cNode) {
- LinkedHashSet<ClassNode> interfaces = new LinkedHashSet<>();
+ LinkedHashSet<ClassNode> interfaces = new LinkedHashSet<ClassNode>();
Traits.collectAllInterfacesReverseOrder(cNode, interfaces);
- List<ClassNode> traits = new LinkedList<>();
+ List<ClassNode> traits = new LinkedList<ClassNode>();
for (ClassNode candidate : interfaces) {
if (Traits.isAnnotatedWithTrait(candidate)) {
traits.add(candidate);
@@ -156,7 +156,7 @@ public abstract class TraitComposer {
Parameter[] origParams = new Parameter[helperMethodParams.length - 1];
Parameter[] params = new Parameter[helperMethodParams.length - 1];
System.arraycopy(methodNode.getParameters(), 1, params, 0, params.length);
- Map<String,ClassNode> methodGenericsSpec = new LinkedHashMap<>(genericsSpec);
+ Map<String,ClassNode> methodGenericsSpec = new LinkedHashMap<String, ClassNode>(genericsSpec);
MethodNode originalMethod = trait.getMethod(name, params);
// Original method may be null for the case of private or static methods
if (originalMethod!=null) {
@@ -167,8 +167,8 @@ public abstract class TraitComposer {
ClassNode originType = parameter.getOriginType();
ClassNode fixedType = correctToGenericsSpecRecurse(methodGenericsSpec, originType);
Parameter newParam = new Parameter(fixedType, "arg" + i);
- List<AnnotationNode> copied = new LinkedList<>();
- List<AnnotationNode> notCopied = new LinkedList<>();
+ List<AnnotationNode> copied = new LinkedList<AnnotationNode>();
+ List<AnnotationNode> notCopied = new LinkedList<AnnotationNode>();
GeneralUtils.copyAnnotatedNodeAnnotations(parameter, copied, notCopied);
newParam.addAnnotations(copied);
params[i - 1] = newParam;
@@ -200,7 +200,7 @@ public abstract class TraitComposer {
// we should implement the field helper interface too
cNode.addInterface(fieldHelperClassNode);
// implementation of methods
- List<MethodNode> declaredMethods = new LinkedList<>();
+ List<MethodNode> declaredMethods = new LinkedList<MethodNode>();
for (MethodNode declaredMethod : fieldHelperClassNode.getAllDeclaredMethods()) {
if (declaredMethod.getName().endsWith(Traits.DIRECT_GETTER_SUFFIX)) {
declaredMethods.add(0, declaredMethod);
@@ -267,8 +267,8 @@ public abstract class TraitComposer {
if (getter) {
// add field
if (helperField!=null) {
- List<AnnotationNode> copied = new LinkedList<>();
- List<AnnotationNode> notCopied = new LinkedList<>();
+ List<AnnotationNode> copied = new LinkedList<AnnotationNode>();
+ List<AnnotationNode> notCopied = new LinkedList<AnnotationNode>();
GeneralUtils.copyAnnotatedNodeAnnotations(helperField, copied, notCopied);
FieldNode fieldNode = cNode.addField(fieldName, fieldMods, returnType, null);
fieldNode.addAnnotations(copied);
@@ -369,7 +369,7 @@ public abstract class TraitComposer {
exceptionNodes,
new ExpressionStatement(forwardExpression)
);
- List<AnnotationNode> copied = new LinkedList<>();
+ List<AnnotationNode> copied = new LinkedList<AnnotationNode>();
List<AnnotationNode> notCopied = Collections.emptyList(); // at this point, should *always* stay empty
GeneralUtils.copyAnnotatedNodeAnnotations(helperMethod, copied, notCopied);
if (!copied.isEmpty()) {
@@ -383,7 +383,7 @@ public abstract class TraitComposer {
// null indicates a static method which may still need generics correction
GenericsType[] genericsTypes = helperMethod.getGenericsTypes();
if (genericsTypes != null) {
- Map<String, ClassNode> methodSpec = new HashMap<>();
+ Map<String, ClassNode> methodSpec = new HashMap<String, ClassNode>();
methodSpec = GenericsUtils.addMethodGenerics(helperMethod, methodSpec);
GenericsType[] newGt = GenericsUtils.applyGenericsContextToPlaceHolders(methodSpec, helperMethod.getGenericsTypes());
forwarder.setGenericsTypes(newGt);
@@ -444,7 +444,7 @@ public abstract class TraitComposer {
private static GenericsType[] removeNonPlaceHolders(GenericsType[] oldTypes) {
if (oldTypes==null || oldTypes.length==0) return oldTypes;
- ArrayList<GenericsType> l = new ArrayList<>(Arrays.asList(oldTypes));
+ ArrayList<GenericsType> l = new ArrayList<GenericsType>(Arrays.asList(oldTypes));
Iterator<GenericsType> it = l.iterator();
boolean modified = false;
while (it.hasNext()) {
@@ -465,11 +465,11 @@ public abstract class TraitComposer {
* @param genericsSpec
*/
private static void createSuperForwarder(ClassNode targetNode, MethodNode forwarder, final Map<String,ClassNode> genericsSpec) {
- List<ClassNode> interfaces = new ArrayList<>(Traits.collectAllInterfacesReverseOrder(targetNode, new LinkedHashSet<>()));
+ List<ClassNode> interfaces = new ArrayList<ClassNode>(Traits.collectAllInterfacesReverseOrder(targetNode, new LinkedHashSet<ClassNode>()));
String name = forwarder.getName();
Parameter[] forwarderParameters = forwarder.getParameters();
- LinkedHashSet<ClassNode> traits = new LinkedHashSet<>();
- List<MethodNode> superForwarders = new LinkedList<>();
+ LinkedHashSet<ClassNode> traits = new LinkedHashSet<ClassNode>();
+ List<MethodNode> superForwarders = new LinkedList<MethodNode>();
for (ClassNode node : interfaces) {
if (Traits.isTrait(node)) {
MethodNode method = node.getDeclaredMethod(name, forwarderParameters);
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/util/LazyReference.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/util/LazyReference.java b/src/main/java/org/codehaus/groovy/util/LazyReference.java
index fc8677c..a8abc15 100644
--- a/src/main/java/org/codehaus/groovy/util/LazyReference.java
+++ b/src/main/java/org/codehaus/groovy/util/LazyReference.java
@@ -51,7 +51,7 @@ public abstract class LazyReference<T> extends LockableObject {
if (res == null) {
reference = NULL_REFERENCE;
} else {
- reference = new ManagedReference<>(bundle, res);
+ reference = new ManagedReference<T>(bundle,res);
}
return res;
} finally {
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/util/ListHashMap.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/util/ListHashMap.java b/src/main/java/org/codehaus/groovy/util/ListHashMap.java
index 12a9a9a..b1a141b 100644
--- a/src/main/java/org/codehaus/groovy/util/ListHashMap.java
+++ b/src/main/java/org/codehaus/groovy/util/ListHashMap.java
@@ -207,7 +207,7 @@ public class ListHashMap<K,V> implements Map<K,V> {
public Collection<V> values() {
if (innerMap == null) {
- List<V> list = new ArrayList<>(size);
+ List<V> list = new ArrayList<V>(size);
for (int i = 0; i < size; i++) {
list.add((V) listValues[i]);
}
http://git-wip-us.apache.org/repos/asf/groovy/blob/6ef32353/src/main/java/org/codehaus/groovy/util/ManagedConcurrentLinkedQueue.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/codehaus/groovy/util/ManagedConcurrentLinkedQueue.java b/src/main/java/org/codehaus/groovy/util/ManagedConcurrentLinkedQueue.java
index c507cff..ab98f72 100644
--- a/src/main/java/org/codehaus/groovy/util/ManagedConcurrentLinkedQueue.java
+++ b/src/main/java/org/codehaus/groovy/util/ManagedConcurrentLinkedQueue.java
@@ -50,7 +50,7 @@ public class ManagedConcurrentLinkedQueue<T> implements Iterable<T> {
*/
public ManagedConcurrentLinkedQueue(ReferenceBundle bundle) {
this.bundle = bundle;
- this.queue = new ConcurrentLinkedQueue<>();
+ this.queue = new ConcurrentLinkedQueue<Element<T>>();
}
/**
@@ -59,7 +59,7 @@ public class ManagedConcurrentLinkedQueue<T> implements Iterable<T> {
* @param value the value to add
*/
public void add(T value) {
- Element<T> e = new Element<>(value);
+ Element<T> e = new Element<T>(value);
queue.offer(e);
}
@@ -90,7 +90,7 @@ public class ManagedConcurrentLinkedQueue<T> implements Iterable<T> {
* sequence they were added.
*/
public List<T> values() {
- List<T> result = new ArrayList<>();
+ List<T> result = new ArrayList<T>();
for (Iterator<T> itr = iterator(); itr.hasNext(); ) {
result.add(itr.next());
}