Package org.codehaus.groovy.ast.tools

Class GenericsUtils

  • public class GenericsUtils
extends java.lang.Object
    Utility methods to deal with generic types.

    • Field Detail

      • EMPTY_GENERICS_ARRAY

        public static final GenericsType[] EMPTY_GENERICS_ARRAY

      • JAVA_LANG_OBJECT

        public static final java.lang.String JAVA_LANG_OBJECT
        See Also:
        Constant Field Values

    • Constructor Detail

      • GenericsUtils

        public GenericsUtils()

    • Method Detail

      • alignGenericTypes

        @Deprecated
public static GenericsType[] alignGenericTypes​(GenericsType[] redirectGenericTypes,
                                               GenericsType[] parameterizedTypes,
                                               GenericsType[] alignmentTarget)
        Deprecated.
        You shouldn't call this method because it is inherently unreliable
        Given a parameterized type and a generic type information, aligns actual type parameters. For example, if a class uses generic type 
        <T,U,V>
        (redirectGenericTypes), is used with actual type parameters 
        <java.lang.String, U,V>
        , then a class or interface using generic types 
        <T,V>
        will be aligned to 
        <java.lang.String,V>
        Parameters:
        redirectGenericTypes - the type arguments or the redirect class node
        parameterizedTypes - the actual type arguments used on this class node
        alignmentTarget - the generic type arguments to which we want to align to
        Returns:
        aligned type arguments

      • extractPlaceholders

        public static java.util.Map<GenericsType.GenericsTypeName,​GenericsType> extractPlaceholders​(ClassNode type)
        Returns the type parameter/argument relationships of the specified type.
        Parameters:
        type - the class node to check

      • extractPlaceholders

        public static void extractPlaceholders​(ClassNode type,
                                       java.util.Map<GenericsType.GenericsTypeName,​GenericsType> placeholders)
        Populates the supplied map with the type parameter/argument relationships of the specified type.
        Parameters:
        type - the class node to check
        placeholders - the generics type information collector

      • toGenericTypesString

        public static java.lang.String toGenericTypesString​(GenericsType[] genericsTypes)

      • parameterizeInterfaceGenerics

        @Deprecated
public static ClassNode parameterizeInterfaceGenerics​(ClassNode hint,
                                                      ClassNode target)
        Deprecated.
        Use #parameterizeType instead
        Interface class nodes retrieved from ClassNode.getInterfaces() or ClassNode.getAllInterfaces() are returned with generic type arguments. This method allows returning a parameterized interface given the parameterized class node which implements this interface.
        Parameters:
        hint - the class node where generics types are parameterized
        target - the interface we want to parameterize generics types
        Returns:
        a parameterized interface class node

      • parameterizeType

        public static ClassNode parameterizeType​(ClassNode hint,
                                         ClassNode target)
        Interface class nodes retrieved from ClassNode.getInterfaces() or ClassNode.getAllInterfaces() are returned with generic type arguments. This method allows returning a parameterized interface given the parameterized class node which implements this interface.
        Parameters:
        hint - the class node where generics types are parameterized
        target - the interface we want to parameterize generics types
        Returns:
        a parameterized interface class node

      • makeClassSafe

        public static ClassNode makeClassSafe​(java.lang.Class klass)

      • makeClassSafeWithGenerics

        public static ClassNode makeClassSafeWithGenerics​(java.lang.Class klass,
                                                  ClassNode genericsType)

      • correctToGenericsSpec

        public static MethodNode correctToGenericsSpec​(java.util.Map<java.lang.String,​ClassNode> genericsSpec,
                                               MethodNode mn)

      • correctToGenericsSpecRecurse

        public static ClassNode correctToGenericsSpecRecurse​(java.util.Map<java.lang.String,​ClassNode> genericsSpec,
                                                     ClassNode type)

      • correctToGenericsSpecRecurse

        public static ClassNode[] correctToGenericsSpecRecurse​(java.util.Map<java.lang.String,​ClassNode> genericsSpec,
                                                       ClassNode[] types)
        Since:
        2.4.1

      • correctToGenericsSpecRecurse

        public static ClassNode correctToGenericsSpecRecurse​(java.util.Map<java.lang.String,​ClassNode> genericsSpec,
                                                     ClassNode type,
                                                     java.util.List<java.lang.String> exclusions)

      • correctToGenericsSpec

        public static ClassNode correctToGenericsSpec​(java.util.Map<java.lang.String,​ClassNode> genericsSpec,
                                              GenericsType type)

      • correctToGenericsSpec

        public static ClassNode correctToGenericsSpec​(java.util.Map<java.lang.String,​ClassNode> genericsSpec,
                                              ClassNode type)

      • createGenericsSpec

        public static java.util.Map<java.lang.String,​ClassNode> createGenericsSpec​(ClassNode current)

      • createGenericsSpec

        public static java.util.Map<java.lang.String,​ClassNode> createGenericsSpec​(ClassNode current,
                                                                                 java.util.Map<java.lang.String,​ClassNode> oldSpec)

      • addMethodGenerics

        public static java.util.Map<java.lang.String,​ClassNode> addMethodGenerics​(MethodNode current,
                                                                                java.util.Map<java.lang.String,​ClassNode> oldSpec)

      • extractSuperClassGenerics

        public static void extractSuperClassGenerics​(ClassNode type,
                                             ClassNode target,
                                             java.util.Map<java.lang.String,​ClassNode> spec)

      • applyGenericsContextToPlaceHolders

        public static GenericsType[] applyGenericsContextToPlaceHolders​(java.util.Map<java.lang.String,​ClassNode> genericsSpec,
                                                                GenericsType[] oldPlaceHolders)
        Transforms generics types from an old context to a new context using the given spec. This method assumes all generics types will be placeholders. WARNING: The resulting generics types may or may not be placeholders after the transformation.
        Parameters:
        genericsSpec - the generics context information spec
        oldPlaceHolders - the old placeholders
        Returns:
        the new generics types

      • findParameterizedType

        public static ClassNode findParameterizedType​(ClassNode genericsClass,
                                              ClassNode actualType)
        Get the parameterized type by search the whole class hierarchy according to generics class and actual receiver. findParameterizedTypeFromCache(ClassNode, ClassNode) is strongly recommended for better performance.
        Parameters:
        genericsClass - the generics class
        actualType - the actual type
        Returns:
        the parameterized type

      • hasUnresolvedGenerics

        public static boolean hasUnresolvedGenerics​(ClassNode type)
        Checks for any placeholder (aka unresolved) generics.

        Backported from 3.0.8

      • makeDeclaringAndActualGenericsTypeMap

        public static java.util.Map<GenericsType,​GenericsType> makeDeclaringAndActualGenericsTypeMap​(ClassNode declaringClass,
                                                                                                   ClassNode actualReceiver)
        map declaring generics type to actual generics type, e.g. GROOVY-7204: declaring generics types: T, S extends Serializable actual generics types : String, Long the result map is [ T: String, S: Long ] 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

      • makeDeclaringAndActualGenericsTypeMapOfExactType

        public static java.util.Map<GenericsType,​GenericsType> makeDeclaringAndActualGenericsTypeMapOfExactType​(ClassNode declaringClass,
                                                                                                              ClassNode actualReceiver)
        The method is similar with makeDeclaringAndActualGenericsTypeMap(ClassNode, ClassNode), The main difference is that the method will try to map all placeholders found to the relevant exact types, but the other will not try even if the parameterized type has placeholders

        Backported from 3.0.0

        Parameters:
        declaringClass - the generics class node declaring the generics types
        actualReceiver - the sub-class class node
        Returns:
        the placeholder-to-actualtype mapping
        Since:
        2.5.9

      • hasPlaceHolders

        public static boolean hasPlaceHolders​(ClassNode type)
        Checks if the type has any placeholder (aka unresolved) generics.

        Backported from 3.0.0

        Since:
        2.5.10

      • findActualTypeByGenericsPlaceholderName

        public static ClassNode findActualTypeByGenericsPlaceholderName​(java.lang.String placeholderName,
                                                                java.util.Map<GenericsType,​GenericsType> genericsPlaceholderAndTypeMap)
        Gets the actual type according to the placeholder name.
        Parameters:
        placeholderName - the placeholder name (i.e. "T", "E", etc.)
        genericsPlaceholderAndTypeMap - the result of makeDeclaringAndActualGenericsTypeMap(ClassNode, ClassNode)
        Returns:
        the actual type

      • clearParameterizedTypeCache

        public static void clearParameterizedTypeCache()
        Clears the parameterized type cache.

        It is useful to IDE as the type being compiled are continuously being edited/altered, see GROOVY-8675