org.codehaus.groovy.ast.tools

## Class GenericsUtils

- java.lang.Object
- - org.codehaus.groovy.ast.tools.GenericsUtils

-     public class GenericsUtils
      extends java.lang.Object

  Utility methods to deal with generic types.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static GenericsType[]` | `EMPTY_GENERICS_ARRAY`
    `static java.lang.String` | `JAVA_LANG_OBJECT`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `GenericsUtils()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static java.util.Map<java.lang.String,ClassNode>` | `addMethodGenerics(MethodNode current, java.util.Map<java.lang.String,ClassNode> oldSpec)`
    `static GenericsType[]` | `alignGenericTypes(GenericsType[] redirectGenericTypes, GenericsType[] parameterizedTypes, GenericsType[] alignmentTarget)` Deprecated. You shouldn't call this method because it is inherently unreliable
    `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.
    `static GenericsType` | `buildWildcardType(ClassNode... types)` Generates a wildcard generic type in order to be used for checks against class nodes.
    `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
    `static ClassNode` | `correctToGenericsSpec(java.util.Map<java.lang.String,ClassNode> genericsSpec, ClassNode type)`
    `static ClassNode` | `correctToGenericsSpec(java.util.Map<java.lang.String,ClassNode> genericsSpec, GenericsType type)`
    `static MethodNode` | `correctToGenericsSpec(java.util.Map<java.lang.String,ClassNode> genericsSpec, MethodNode mn)`
    `static ClassNode` | `correctToGenericsSpecRecurse(java.util.Map<java.lang.String,ClassNode> genericsSpec, ClassNode type)`
    `static ClassNode[]` | `correctToGenericsSpecRecurse(java.util.Map<java.lang.String,ClassNode> genericsSpec, ClassNode[] types)`
    `static ClassNode` | `correctToGenericsSpecRecurse(java.util.Map<java.lang.String,ClassNode> genericsSpec, ClassNode type, java.util.List<java.lang.String> exclusions)`
    `static java.util.Map<java.lang.String,ClassNode>` | `createGenericsSpec(ClassNode current)`
    `static java.util.Map<java.lang.String,ClassNode>` | `createGenericsSpec(ClassNode current, java.util.Map<java.lang.String,ClassNode> oldSpec)`
    `static java.util.Map<GenericsType.GenericsTypeName,GenericsType>` | `extractPlaceholders(ClassNode cn)`
    `static void` | `extractPlaceholders(ClassNode node, java.util.Map<GenericsType.GenericsTypeName,GenericsType> map)` For a given classnode, fills in the supplied map with the parameterized types it defines.
    `static void` | `extractSuperClassGenerics(ClassNode type, ClassNode target, java.util.Map<java.lang.String,ClassNode> spec)`
    `static ClassNode` | `findActualTypeByGenericsPlaceholderName(java.lang.String placeholderName, java.util.Map<GenericsType,GenericsType> genericsPlaceholderAndTypeMap)` Get the actual type according to the placeholder name
    `static ClassNode` | `findParameterizedType(ClassNode genericsClass, ClassNode actualType)` Get the parameterized type by search the whole class hierarchy according to generics class and actual receiver.
    `static ClassNode` | `findParameterizedTypeFromCache(ClassNode genericsClass, ClassNode actualType)` Try to get the parameterized type from the cache.
    `static ClassNode` | `getSuperClass(ClassNode type, ClassNode target)`
    `static ClassNode` | `makeClassSafe(java.lang.Class klass)`
    `static ClassNode` | `makeClassSafe0(ClassNode type, GenericsType... genericTypes)`
    `static ClassNode` | `makeClassSafeWithGenerics(java.lang.Class klass, ClassNode genericsType)`
    `static ClassNode` | `makeClassSafeWithGenerics(ClassNode type, GenericsType... genericTypes)`
    `static java.util.Map<GenericsType,GenericsType>` | `makeDeclaringAndActualGenericsTypeMap(ClassNode declaringClass, ClassNode actualReceiver)` map declaring generics type to actual generics type, e.g.
    `static ClassNode` | `newClass(ClassNode type)`
    `static ClassNode` | `nonGeneric(ClassNode type)`
    `static ClassNode` | `parameterizeInterfaceGenerics(ClassNode hint, ClassNode target)` Deprecated. Use #parameterizeType instead
    `static ClassNode` | `parameterizeType(ClassNode hint, ClassNode target)` Interface class nodes retrieved from `ClassNode.getInterfaces()` or `ClassNode.getAllInterfaces()` are returned with generic type arguments.
    `static ClassNode[]` | `parseClassNodesFromString(java.lang.String option, SourceUnit sourceUnit, CompilationUnit compilationUnit, MethodNode mn, ASTNode usage)`
    `static java.lang.String` | `toGenericTypesString(GenericsType[] genericsTypes)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### 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

    - #### buildWildcardType

          public static GenericsType buildWildcardType(ClassNode... types)

      Generates a wildcard generic type in order to be used for checks against class nodes. See `GenericsType.isCompatibleWith(org.codehaus.groovy.ast.ClassNode)`.
      Parameters:
        `types` - the type to be used as the wildcard upper bound
      Returns:
        a wildcard generics type

    - #### extractPlaceholders

          public static java.util.Map<GenericsType.GenericsTypeName,GenericsType> extractPlaceholders(ClassNode cn)

    - #### extractPlaceholders

          public static void extractPlaceholders(ClassNode node,
                                                 java.util.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 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

    - #### nonGeneric

          public static ClassNode nonGeneric(ClassNode type)

    - #### newClass

          public static ClassNode newClass(ClassNode type)

    - #### makeClassSafe

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

    - #### makeClassSafeWithGenerics

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

    - #### makeClassSafe0

          public static ClassNode makeClassSafe0(ClassNode type,
                                                 GenericsType... genericTypes)

    - #### makeClassSafeWithGenerics

          public static ClassNode makeClassSafeWithGenerics(ClassNode type,
                                                            GenericsType... genericTypes)

    - #### 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)

    - #### getSuperClass

          public static ClassNode getSuperClass(ClassNode type,
                                                ClassNode target)

    - #### parseClassNodesFromString

          public static ClassNode[] parseClassNodesFromString(java.lang.String option,
                                                              SourceUnit sourceUnit,
                                                              CompilationUnit compilationUnit,
                                                              MethodNode mn,
                                                              ASTNode usage)

    - #### 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

    - #### findParameterizedTypeFromCache

          public static ClassNode findParameterizedTypeFromCache(ClassNode genericsClass,
                                                                 ClassNode actualType)

      Try to get the parameterized type from the cache. If no cached item found, cache and return the result of `findParameterizedType(ClassNode, ClassNode)`

    - #### 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 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

    - #### findActualTypeByGenericsPlaceholderName

          public static ClassNode findActualTypeByGenericsPlaceholderName(java.lang.String placeholderName,
                                                                          java.util.Map<GenericsType,GenericsType> genericsPlaceholderAndTypeMap)

      Get the actual type according to the placeholder name
      Parameters:
        `placeholderName` - the placeholder name, e.g. T, E
        `genericsPlaceholderAndTypeMap` - the result of `makeDeclaringAndActualGenericsTypeMap(ClassNode, ClassNode)`
      Returns:
        the actual type