minor items
diff --git a/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java b/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
index c5439e8..a62d6aa 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GeneralUtils.java
@@ -87,8 +87,6 @@
import java.util.function.Consumer;
import static org.codehaus.groovy.antlr.PrimitiveHelper.getDefaultValueForPrimitive;
-import static org.codehaus.groovy.ast.ClassHelper.isObjectType;
-import static org.codehaus.groovy.ast.tools.GenericsUtils.parameterizeType;
/**
* Handy methods when working with the Groovy AST
@@ -465,13 +463,12 @@
private static void addAllInterfaces(final Set<ClassNode> result, final ClassNode source) {
for (ClassNode in : source.getInterfaces()) {
- in = parameterizeType(source, in);
- if (result.add(in))
- addAllInterfaces(result, in);
+ in = GenericsUtils.parameterizeType(source, in);
+ if(result.add(in)) addAllInterfaces(result, in);
}
ClassNode sc = source.redirect().getUnresolvedSuperClass(false);
- if (sc != null && !isObjectType(sc)) {
- addAllInterfaces(result, parameterizeType(source, sc));
+ if (sc != null && !ClassHelper.isObjectType(sc)) {
+ addAllInterfaces(result, GenericsUtils.parameterizeType(source, sc));
}
}
@@ -484,7 +481,7 @@
public static List<FieldNode> getSuperNonPropertyFields(final ClassNode cNode) {
List<FieldNode> result;
- if (isObjectType(cNode)) {
+ if (ClassHelper.isObjectType(cNode)) {
result = new ArrayList<>();
} else {
result = getSuperNonPropertyFields(cNode.getSuperClass());
@@ -499,7 +496,7 @@
public static List<FieldNode> getSuperPropertyFields(final ClassNode cNode) {
List<FieldNode> result;
- if (isObjectType(cNode)) {
+ if (ClassHelper.isObjectType(cNode)) {
result = new ArrayList<>();
} else {
result = getSuperPropertyFields(cNode.getSuperClass());
@@ -524,7 +521,7 @@
final boolean includeFields, final boolean includePseudoGetters, final boolean includePseudoSetters,
final boolean traverseSuperClasses, final boolean skipReadonly, final boolean reverse, final boolean allNames, final boolean includeStatic) {
List<PropertyNode> result = new ArrayList<>();
- if (!(isObjectType(cNode)) && traverseSuperClasses && !reverse) {
+ if (!(ClassHelper.isObjectType(cNode)) && traverseSuperClasses && !reverse) {
result.addAll(getAllProperties(names, origType, cNode.getSuperClass(), includeProperties, includeFields, includePseudoGetters, includePseudoSetters, true, skipReadonly));
}
if (includeProperties) {
@@ -560,7 +557,7 @@
result.add(new PropertyNode(fNode, fNode.getModifiers() & 0x1F, null, null));
}
}
- if (!(isObjectType(cNode)) && traverseSuperClasses && reverse) {
+ if (!(ClassHelper.isObjectType(cNode)) && traverseSuperClasses && reverse) {
result.addAll(getAllProperties(names, origType, cNode.getSuperClass(), includeProperties, includeFields, includePseudoGetters, includePseudoSetters, true, skipReadonly));
}
return result;
@@ -881,6 +878,7 @@
//--------------------------------------------------------------------------
public static Parameter[] cloneParams(final Parameter[] parameters) {
+ if (parameters == null || parameters.length == 0) return parameters;
return Arrays.stream(parameters).map(p -> param(p.getOriginType(), p.getName())).toArray(Parameter[]::new);
}
diff --git a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
index 1572c25..7f2dfe5 100644
--- a/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
+++ b/src/main/java/org/codehaus/groovy/ast/tools/GenericsUtils.java
@@ -51,6 +51,7 @@
import java.util.Map;
import java.util.Objects;
import java.util.Set;
+import java.util.StringJoiner;
import java.util.function.Function;
import java.util.function.Predicate;
@@ -60,10 +61,18 @@
import static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.isUnboundedWildcard;
/**
- * Utility methods to deal with generic types.
+ * Utility methods to deal with parameterized types.
*/
public class GenericsUtils {
+
+ /**
+ * @since 2.0.0
+ */
public static final GenericsType[] EMPTY_GENERICS_ARRAY = GenericsType.EMPTY_ARRAY;
+
+ /**
+ * @since 3.0.0
+ */
public static final String JAVA_LANG_OBJECT = ClassHelper.OBJECT;
/**
@@ -76,7 +85,9 @@
* @param parameterizedTypes the actual type arguments used on this class node
* @param alignmentTarget the generic type arguments to which we want to align to
* @return aligned type arguments
- * @deprecated You shouldn't call this method because it is inherently unreliable
+ *
+ * @since 2.0.0
+ * @deprecated You shouldn't call this method because it is inherently unreliable.
*/
@Deprecated(forRemoval = true, since = "2.3.0")
public static GenericsType[] alignGenericTypes(final GenericsType[] redirectGenericTypes, final GenericsType[] parameterizedTypes, final GenericsType[] alignmentTarget) {
@@ -131,6 +142,8 @@
/**
* Generates a wildcard generic type in order to be used for checks against
* class nodes. See {@link GenericsType#isCompatibleWith(ClassNode)}.
+ *
+ * @since 2.0.0
*/
public static GenericsType buildWildcardType(final ClassNode... upperBounds) {
GenericsType gt = new GenericsType(ClassHelper.makeWithoutCaching("?"), upperBounds, null);
@@ -141,7 +154,7 @@
/**
* Returns the type parameter/argument relationships of the specified type.
*
- * @param type the class node to check
+ * @since 2.0.0
*/
public static Map<GenericsType.GenericsTypeName, GenericsType> extractPlaceholders(final ClassNode type) {
Map<GenericsType.GenericsTypeName, GenericsType> placeholders = new HashMap<>();
@@ -153,8 +166,7 @@
* Populates the supplied map with the type parameter/argument relationships
* of the specified type.
*
- * @param type the class node to check
- * @param placeholders the generics type information collector
+ * @since 2.0.0
*/
public static void extractPlaceholders(final ClassNode type, final Map<GenericsType.GenericsTypeName, GenericsType> placeholders) {
if (type == null) return;
@@ -216,17 +228,16 @@
}
}
- public static String toGenericTypesString(GenericsType[] genericsTypes) {
+ /**
+ * @since 3.0.0
+ */
+ public static String toGenericTypesString(final GenericsType[] genericsTypes) {
if (genericsTypes == null) return "";
- StringBuilder sb = new StringBuilder("<");
- for (int i = 0, n = genericsTypes.length; i < n; i++) {
- sb.append(genericsTypes[i].toString());
- if (i < n - 1) {
- sb.append(",");
- }
+ StringJoiner sj = new StringJoiner(",","<","> ");
+ for (GenericsType genericsType : genericsTypes) {
+ sj.add(genericsType.toString());
}
- sb.append("> ");
- return sb.toString();
+ return sj.toString();
}
/**
@@ -238,6 +249,8 @@
* @param hint the class node where generics types are parameterized
* @param target the interface we want to parameterize generics types
* @return a parameterized interface class node
+ *
+ * @since 2.0.0
* @deprecated Use #parameterizeType instead
*/
@Deprecated(forRemoval = true, since = "2.5.0")
@@ -254,6 +267,8 @@
* @param hint the ClassNode where generics types are parameterized
* @param target the interface we want to parameterize generics types
* @return a parameterized interface ClassNode
+ *
+ * @since 2.1.0
*/
public static ClassNode parameterizeType(ClassNode hint, final ClassNode target) {
if (hint.isArray()) {
@@ -294,6 +309,9 @@
return correctToGenericsSpecRecurse(gt, cn);
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode nonGeneric(final ClassNode type) {
int dims = 0;
ClassNode temp = type;
@@ -314,20 +332,32 @@
return type;
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode newClass(ClassNode type) {
return type.getPlainNodeReference();
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode makeClassSafe(Class klass) {
return makeClassSafeWithGenerics(ClassHelper.make(klass));
}
+ /**
+ * @since 2.4.0
+ */
public static ClassNode makeClassSafeWithGenerics(Class klass, ClassNode genericsType) {
GenericsType[] genericsTypes = new GenericsType[1];
genericsTypes[0] = new GenericsType(genericsType);
return makeClassSafeWithGenerics(ClassHelper.make(klass), genericsTypes);
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode makeClassSafe0(ClassNode type, GenericsType... genericTypes) {
ClassNode plainNodeReference = newClass(type);
if (genericTypes != null && genericTypes.length > 0) {
@@ -337,6 +367,9 @@
return plainNodeReference;
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode makeClassSafeWithGenerics(ClassNode type, GenericsType... genericTypes) {
if (type.isArray()) {
return makeClassSafeWithGenerics(type.getComponentType(), genericTypes).makeArray();
@@ -352,6 +385,9 @@
return makeClassSafe0(type, gTypes);
}
+ /**
+ * @since 2.3.0
+ */
public static MethodNode correctToGenericsSpec(Map<String, ClassNode> genericsSpec, MethodNode mn) {
if (genericsSpec == null) return mn;
if (mn.getGenericsTypes() != null) genericsSpec = addMethodGenerics(mn, genericsSpec);
@@ -367,6 +403,9 @@
return newMethod;
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode correctToGenericsSpecRecurse(Map<String, ClassNode> genericsSpec, ClassNode type) {
return correctToGenericsSpecRecurse(genericsSpec, type, Collections.emptyList());
}
@@ -386,6 +425,9 @@
return newTypes;
}
+ /**
+ * @since 2.4.1
+ */
public static ClassNode correctToGenericsSpecRecurse(Map<String, ClassNode> genericsSpec, ClassNode type, List<String> exclusions) {
if (type.isArray()) {
return correctToGenericsSpecRecurse(genericsSpec, type.getComponentType(), exclusions).makeArray();
@@ -442,6 +484,9 @@
return makeClassSafeWithGenerics(type, newgTypes);
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode correctToGenericsSpec(final Map<String, ClassNode> genericsSpec, final GenericsType type) {
ClassNode cn = null;
if (type.isPlaceholder()) {
@@ -459,6 +504,9 @@
return cn;
}
+ /**
+ * @since 2.3.0
+ */
public static ClassNode correctToGenericsSpec(final Map<String, ClassNode> genericsSpec, ClassNode type) {
if (type.isArray()) {
return correctToGenericsSpec(genericsSpec, type.getComponentType()).makeArray();
@@ -474,10 +522,16 @@
return type != null ? type : ClassHelper.OBJECT_TYPE.getPlainNodeReference();
}
+ /**
+ * @since 2.4.0
+ */
public static Map<String, ClassNode> createGenericsSpec(final ClassNode type) {
return createGenericsSpec(type, Collections.emptyMap());
}
+ /**
+ * @since 2.3.0
+ */
public static Map<String, ClassNode> createGenericsSpec(final ClassNode type, final Map<String, ClassNode> oldSpec) {
// Example:
// abstract class A<X,Y,Z> { ... }
@@ -495,6 +549,9 @@
return newSpec;
}
+ /**
+ * @since 2.4.1
+ */
public static Map<String, ClassNode> addMethodGenerics(final MethodNode node, final Map<String, ClassNode> oldSpec) {
Map<String, ClassNode> newSpec = new HashMap<>(oldSpec);
GenericsType[] tps = node.getGenericsTypes();
@@ -523,8 +580,11 @@
return newSpec;
}
- // TODO: this is very similar to StaticTypesCheckingSupport#extractGenericsConnections, using ClassNode instead of GenericsType
+ /**
+ * @since 2.3.1
+ */
public static void extractSuperClassGenerics(final ClassNode type, final ClassNode target, final Map<String, ClassNode> spec) {
+ // TODO: this is very similar to StaticTypesCheckingSupport#extractGenericsConnections, using ClassNode instead of GenericsType
if (target == null || target == type) return;
if (target.isGenericsPlaceHolder()) {
spec.put(target.getUnresolvedName(), type);
@@ -565,6 +625,9 @@
}
}
+ /**
+ * @since 3.0.0
+ */
public static ClassNode getSuperClass(final ClassNode type, final ClassNode target) {
return ClassHelper.getNextSuperClass(ClassHelper.isPrimitiveType(type) ? ClassHelper.getWrapper(type) : type, target);
}
@@ -614,7 +677,7 @@
}
}
- private static void extractSuperClassGenerics(ClassNode[] usage, ClassNode[] declaration, Map<String, ClassNode> spec) {
+ private static void extractSuperClassGenerics(final ClassNode[] usage, final ClassNode[] declaration, final Map<String, ClassNode> spec) {
if (usage == null || declaration == null || declaration.length == 0) return;
// both have generics
for (int i = 0; i < usage.length; i++) {
@@ -628,6 +691,9 @@
}
}
+ /**
+ * @since 2.4.0
+ */
public static ClassNode[] parseClassNodesFromString(final String option, final SourceUnit sourceUnit, final CompilationUnit compilationUnit, final MethodNode mn, final ASTNode usage) {
try {
ModuleNode moduleNode = ParserPlugin.buildAST("Dummy<" + option + "> dummy;", compilationUnit.getConfiguration(), compilationUnit.getClassLoader(), null);
@@ -685,6 +751,8 @@
* @param genericsSpec the generics context information spec
* @param oldPlaceHolders the old placeholders
* @return the new generics types
+ *
+ * @since 2.5.0
*/
public static GenericsType[] applyGenericsContextToPlaceHolders(Map<String, ClassNode> genericsSpec, GenericsType[] oldPlaceHolders) {
if (oldPlaceHolders == null || oldPlaceHolders.length == 0) return oldPlaceHolders;
@@ -729,15 +797,19 @@
/**
* Clears the parameterized type cache.
* <p>
- * It is useful to IDE as the type being compiled are continuously being edited/altered, see GROOVY-8675
+ * It is useful to IDE as the type being compiled are continuously being edited/altered; see GROOVY-8675
+ *
+ * @since 3.0.0
*/
public static void clearParameterizedTypeCache() {
PARAMETERIZED_TYPE_CACHE.clearAll();
}
/**
- * Convenience method for {@link #findParameterizedTypeFromCache(ClassNode, ClassNode, boolean)}
- * when the {@code tryToFindExactType} boolean is {@code false}.
+ * Convenience method for {@link #findParameterizedTypeFromCache(ClassNode,ClassNode,boolean)}
+ * with {@code tryToFindExactType} set to {@code false}.
+ *
+ * @since 3.0.0
*/
public static ClassNode findParameterizedTypeFromCache(final ClassNode genericsClass, final ClassNode actualType) {
return findParameterizedTypeFromCache(genericsClass, actualType, false);
@@ -746,7 +818,9 @@
/**
* Try to get the parameterized type from the cache.
* <p>
- * If no cached item found, cache and return the result of {@link #findParameterizedType(ClassNode,ClassNode,boolean)}
+ * If no cached item found, cache and return the result of {@link #findParameterizedType(ClassNode,ClassNode,boolean)}.
+ *
+ * @since 3.0.0
*/
public static ClassNode findParameterizedTypeFromCache(final ClassNode genericsClass, final ClassNode actualType, boolean tryToFindExactType) {
if (!PARAMETERIZED_TYPE_CACHE_ENABLED) {
@@ -761,7 +835,9 @@
}
/**
- * Convenience method for {@link #findParameterizedType(ClassNode,ClassNode,boolean)} when {@code tryToFindExactType} is {@code false}.
+ * Convenience method for {@link #findParameterizedType(ClassNode,ClassNode,boolean)} with {@code tryToFindExactType} set to {@code false}.
+ *
+ * @since 3.0.0
*/
public static ClassNode findParameterizedType(final ClassNode genericsClass, final ClassNode actualType) {
return findParameterizedType(genericsClass, actualType, false);
@@ -771,6 +847,8 @@
* Gets the parameterized type by searching the whole class hierarchy according to generics class and actual receiver.
* <p>
* {@link #findParameterizedTypeFromCache(ClassNode,ClassNode,boolean)} is strongly recommended for better performance.
+ *
+ * @since 3.0.0
*/
public static ClassNode findParameterizedType(final ClassNode genericsClass, final ClassNode actualType, final boolean tryToFindExactType) {
final GenericsType[] genericsTypes = genericsClass.getGenericsTypes();
@@ -828,6 +906,8 @@
*
* The resolved types can not help us to choose methods correctly if the argument is a string: T: Object, S: Serializable
* so we need actual types: T: String, S: Long
+ *
+ * @since 3.0.0
*/
public static Map<GenericsType, GenericsType> makeDeclaringAndActualGenericsTypeMap(final ClassNode declaringClass, final ClassNode actualReceiver) {
return correlateTypeParametersAndTypeArguments(declaringClass, actualReceiver, false);
@@ -917,6 +997,8 @@
/**
* Checks for any placeholder (aka unresolved) generics.
+ *
+ * @since 4.0.0
*/
public static boolean hasUnresolvedGenerics(final ClassNode type) {
if (type.isGenericsPlaceHolder()) return true;
@@ -982,7 +1064,9 @@
* Gets the actual type according to the placeholder name.
*
* @param placeholderName the placeholder name (i.e. "T", "E", etc.)
- * @param genericsPlaceholderAndTypeMap the result of {@link #makeDeclaringAndActualGenericsTypeMap(ClassNode, ClassNode)}
+ * @param genericsPlaceholderAndTypeMap the result of {@link #makeDeclaringAndActualGenericsTypeMap}
+ *
+ * @since 3.0.0
*/
public static ClassNode findActualTypeByGenericsPlaceholderName(final String placeholderName, final Map<GenericsType, GenericsType> genericsPlaceholderAndTypeMap) {
Function<GenericsType, ClassNode> resolver = gt -> {
