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
`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
`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 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<java.lang.String,GenericsType>` `extractPlaceholders(ClassNode cn)`
`static void` `extractPlaceholders(ClassNode node, java.util.Map<java.lang.String,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` `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 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)`

### 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<java.lang.String,GenericsType> extractPlaceholders(ClassNode cn)

#### extractPlaceholders

    public static void extractPlaceholders(ClassNode node,
                                           java.util.Map<java.lang.String,GenericsType> map)

For a given classnode, fills in the supplied map with the parameterized types it defines.

Parameters:
  `node` -
  `map` -

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