Package org.codehaus.groovy.ast.tools

Class GenericsUtils

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

    • 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 void extractPlaceholders​(ClassNode node,
                                       Map<GenericsType.GenericsTypeName,​GenericsType> map)
        For a given classnode, fills in the supplied map with the parameterized types it defines.
        Parameters:
        node - the class node to check
        map - the generics type information collector

      • toGenericTypesString

        public static 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​(Class klass)

      • makeClassSafeWithGenerics

        public static ClassNode makeClassSafeWithGenerics​(Class klass,
                                                  ClassNode genericsType)

      • applyGenericsContextToPlaceHolders

        public static GenericsType[] applyGenericsContextToPlaceHolders​(Map<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

      • clearParameterizedTypeCache

        public static void clearParameterizedTypeCache()
        Clear the parameterized type cache It is useful to IDE as the type being compiled are continuously being edited/altered, see GROOVY-8675

      • makeDeclaringAndActualGenericsTypeMap

        public static 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