org.codehaus.groovy.transform.stc

## Class StaticTypeCheckingSupport

- java.lang.Object
- - org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport

-     public abstract class StaticTypeCheckingSupport
      extends java.lang.Object

  Static support methods for `StaticTypeCheckingVisitor`.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static ClassNode` | `ArrayList_TYPE`
    `protected static ClassNode` | `Collection_TYPE`
    `protected static ClassNode` | `Deprecated_TYPE`
    `protected static java.util.Comparator<MethodNode>` | `DGM_METHOD_NODE_COMPARATOR` This comparator is used when we return the list of methods from DGM which name correspond to a given name.
    `protected static org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.ExtensionMethodCache` | `EXTENSION_METHOD_CACHE`
    `protected static ClassNode` | `GSTRING_STRING_CLASSNODE`
    `protected static ClassNode` | `Matcher_TYPE`
    `protected static java.util.Map<java.lang.String,java.lang.Integer>` | `NUMBER_OPS`
    `protected static java.util.Map<ClassNode,java.lang.Integer>` | `NUMBER_TYPES`
    `protected static ClassNode` | `UNKNOWN_PARAMETER_TYPE` This is for internal use only.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `StaticTypeCheckingSupport()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static int` | `allParametersAndArgumentsMatch(Parameter[] params, ClassNode[] args)` Checks that arguments and parameter types match.
    `static boolean` | `checkCompatibleAssignmentTypes(ClassNode left, ClassNode right)` Returns true or false depending on whether the right classnode can be assigned to the left classnode.
    `static boolean` | `checkCompatibleAssignmentTypes(ClassNode left, ClassNode right, Expression rightExpression)`
    `static boolean` | `checkCompatibleAssignmentTypes(ClassNode left, ClassNode right, Expression rightExpression, boolean allowConstructorCoercion)`
    `static java.util.List<MethodNode>` | `chooseBestMethod(ClassNode receiver, java.util.Collection<MethodNode> methods, ClassNode... args)` Given a list of candidate methods, returns the one which best matches the argument types
    `static java.util.Set<ClassNode>` | `collectAllInterfaces(ClassNode node)` Collects all interfaces of a class node, including those defined by the super class.
    `static java.lang.Object` | `evaluateExpression(Expression expr, CompilerConfiguration config)` A helper method that can be used to evaluate expressions as found in annotation parameters.
    `static java.util.List<MethodNode>` | `findDGMMethodsByNameAndArguments(java.lang.ClassLoader loader, ClassNode receiver, java.lang.String name, ClassNode[] args)`
    `static java.util.List<MethodNode>` | `findDGMMethodsByNameAndArguments(java.lang.ClassLoader loader, ClassNode receiver, java.lang.String name, ClassNode[] args, java.util.List<MethodNode> methods)`
    `static java.util.List<MethodNode>` | `findDGMMethodsByNameAndArguments(ClassNode receiver, java.lang.String name, ClassNode[] args)` Deprecated. Use `findDGMMethodsByNameAndArguments(ClassLoader, org.codehaus.groovy.ast.ClassNode, String, org.codehaus.groovy.ast.ClassNode[], java.util.List)` instead
    `static java.util.List<MethodNode>` | `findDGMMethodsByNameAndArguments(ClassNode receiver, java.lang.String name, ClassNode[] args, java.util.List<MethodNode> methods)` Deprecated. Use `findDGMMethodsByNameAndArguments(ClassLoader, org.codehaus.groovy.ast.ClassNode, String, org.codehaus.groovy.ast.ClassNode[], List)` instead
    `protected static java.util.Set<MethodNode>` | `findDGMMethodsForClassNode(java.lang.ClassLoader loader, ClassNode clazz, java.lang.String name)`
    `protected static void` | `findDGMMethodsForClassNode(java.lang.ClassLoader loader, ClassNode clazz, java.lang.String name, java.util.TreeSet<MethodNode> accumulator)`
    `protected static java.util.Set<MethodNode>` | `findDGMMethodsForClassNode(ClassNode clazz, java.lang.String name)` Deprecated. Use `findDGMMethodsForClassNode(ClassLoader, ClassNode, String)` instead
    `protected static void` | `findDGMMethodsForClassNode(ClassNode clazz, java.lang.String name, java.util.TreeSet<MethodNode> accumulator)` Deprecated. Use `findDGMMethodsForClassNode(ClassLoader, ClassNode, String, TreeSet)` instead
    `static java.util.List<MethodNode>` | `findSetters(ClassNode cn, java.lang.String setterName, boolean voidOnly)`
    `protected static Variable` | `findTargetVariable(VariableExpression ve)` Given a variable expression, returns the ultimately accessed variable.
    `protected static GenericsType` | `fullyResolve(GenericsType gt, java.util.Map<java.lang.String,GenericsType> placeholders)` Given a generics type representing SomeClass<T,V> and a resolved placeholder map, returns a new generics type for which placeholders are resolved recursively.
    `protected static ClassNode` | `fullyResolveType(ClassNode type, java.util.Map<java.lang.String,GenericsType> placeholders)`
    `static ClassNode` | `getCorrectedClassNode(ClassNode type, ClassNode superClass, boolean handlingGenerics)`
    `static boolean` | `implementsInterfaceOrIsSubclassOf(ClassNode type, ClassNode superOrInterface)`
    `protected static boolean` | `isArrayAccessExpression(Expression expression)` Returns true for expressions of the form x[...]
    `static boolean` | `isAssignment(int op)`
    `static boolean` | `isBeingCompiled(ClassNode node)`
    `static boolean` | `isClassClassNodeWrappingConcreteType(ClassNode classNode)` Returns true if the class node represents a the class node for the Class class and if the parametrized type is a neither a placeholder or a wildcard.
    `static boolean` | `isCompareToBoolean(int op)`
    `static boolean` | `isGStringOrGStringStringLUB(ClassNode node)`
    `static boolean` | `isParameterizedWithGStringOrGStringString(ClassNode node)`
    `static boolean` | `isParameterizedWithString(ClassNode node)`
    `static ClassNode` | `isTraitSelf(VariableExpression vexp)`
    `static boolean` | `isUsingGenericsOrIsArrayUsingGenerics(ClassNode cn)` Returns true if a class node makes use of generic types.
    `static boolean` | `isUsingUncheckedGenerics(ClassNode node)` Returns true if the provided class node, when considered as a receiver of a message or as a parameter, is using a placeholder in its generics type.
    `static boolean` | `isWildcardLeftHandSide(ClassNode node)` Tells if a class is one of the "accept all" classes as the left hand side of an assignment.
    `static boolean` | `isWithCall(java.lang.String name, Expression callArguments)` Called on method call checks in order to determine if a method call corresponds to the idiomatic o.with { ...
    `static boolean` | `missesGenericsTypes(ClassNode cn)`
    `static Parameter[]` | `parameterizeArguments(ClassNode receiver, MethodNode m)` Given a receiver and a method node, parameterize the method arguments using available generic type information.
    `static ClassNode` | `resolveClassNodeGenerics(java.util.Map<java.lang.String,GenericsType> resolvedPlaceholders, java.util.Map<java.lang.String,GenericsType> placeholdersFromContext, ClassNode currentType)`
    `protected static boolean` | `typeCheckMethodArgumentWithGenerics(ClassNode parameterType, ClassNode argumentType, boolean lastArg)` Checks that the parameterized generics of an argument are compatible with the generics of the parameter.
    `protected static boolean` | `typeCheckMethodsWithGenerics(ClassNode receiver, ClassNode[] arguments, MethodNode candidateMethod)`

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

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

- - ### Field Detail

    - #### Collection_TYPE

          protected static final ClassNode Collection_TYPE

    - #### Deprecated_TYPE

          protected static final ClassNode Deprecated_TYPE

    - #### Matcher_TYPE

          protected static final ClassNode Matcher_TYPE

    - #### ArrayList_TYPE

          protected static final ClassNode ArrayList_TYPE

    - #### EXTENSION_METHOD_CACHE

          protected static final org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport.ExtensionMethodCache EXTENSION_METHOD_CACHE

    - #### NUMBER_TYPES

          protected static final java.util.Map<ClassNode,java.lang.Integer> NUMBER_TYPES

    - #### NUMBER_OPS

          protected static final java.util.Map<java.lang.String,java.lang.Integer> NUMBER_OPS

    - #### GSTRING_STRING_CLASSNODE

          protected static final ClassNode GSTRING_STRING_CLASSNODE

    - #### UNKNOWN_PARAMETER_TYPE

          protected static final ClassNode UNKNOWN_PARAMETER_TYPE

      This is for internal use only. When an argument method is null, we cannot determine its type, so we use this one as a wildcard.

    - #### DGM_METHOD_NODE_COMPARATOR

          protected static final java.util.Comparator<MethodNode> DGM_METHOD_NODE_COMPARATOR

      This comparator is used when we return the list of methods from DGM which name correspond to a given name. As we also lookup for DGM methods of superclasses or interfaces, it may be possible to find two methods which have the same name and the same arguments. In that case, we should not add the method from superclass or interface otherwise the system won't be able to select the correct method, resulting in an ambiguous method selection for similar methods.

  - ### Constructor Detail

    - #### StaticTypeCheckingSupport

          public StaticTypeCheckingSupport()

  - ### Method Detail

    - #### isArrayAccessExpression

          protected static boolean isArrayAccessExpression(Expression expression)

      Returns true for expressions of the form x[...]
      Parameters:
        `expression` - an expression
      Returns:
        true for array access expressions

    - #### isWithCall

          public static boolean isWithCall(java.lang.String name,
                                           Expression callArguments)

      Called on method call checks in order to determine if a method call corresponds to the idiomatic o.with { ... } structure
      Parameters:
        `name` - name of the method called
        `callArguments` - arguments of the method
      Returns:
        true if the name is "with" and arguments consist of a single closure

    - #### findTargetVariable

          protected static Variable findTargetVariable(VariableExpression ve)

      Given a variable expression, returns the ultimately accessed variable.
      Parameters:
        `ve` - a variable expression
      Returns:
        the target variable

    - #### findDGMMethodsForClassNode

          @Deprecated
          protected static java.util.Set<MethodNode> findDGMMethodsForClassNode(ClassNode clazz,
                                                                                             java.lang.String name)

      Deprecated. Use `findDGMMethodsForClassNode(ClassLoader, ClassNode, String)` instead

    - #### findDGMMethodsForClassNode

          protected static java.util.Set<MethodNode> findDGMMethodsForClassNode(java.lang.ClassLoader loader,
                                                                                ClassNode clazz,
                                                                                java.lang.String name)

    - #### findDGMMethodsForClassNode

          @Deprecated
          protected static void findDGMMethodsForClassNode(ClassNode clazz,
                                                                        java.lang.String name,
                                                                        java.util.TreeSet<MethodNode> accumulator)

      Deprecated. Use `findDGMMethodsForClassNode(ClassLoader, ClassNode, String, TreeSet)` instead

    - #### findDGMMethodsForClassNode

          protected static void findDGMMethodsForClassNode(java.lang.ClassLoader loader,
                                                           ClassNode clazz,
                                                           java.lang.String name,
                                                           java.util.TreeSet<MethodNode> accumulator)

    - #### allParametersAndArgumentsMatch

          public static int allParametersAndArgumentsMatch(Parameter[] params,
                                                           ClassNode[] args)

      Checks that arguments and parameter types match.
      Parameters:
        `params` - method parameters
        `args` - type arguments
      Returns:
        -1 if arguments do not match, 0 if arguments are of the exact type and >0 when one or more argument is not of the exact type but still match

    - #### isCompareToBoolean

          public static boolean isCompareToBoolean(int op)

    - #### isAssignment

          public static boolean isAssignment(int op)

    - #### checkCompatibleAssignmentTypes

          public static boolean checkCompatibleAssignmentTypes(ClassNode left,
                                                               ClassNode right)

      Returns true or false depending on whether the right classnode can be assigned to the left classnode. This method should not add errors by itself: we let the caller decide what to do if an incompatible assignment is found.
      Parameters:
        `left` - the class to be assigned to
        `right` - the assignee class
      Returns:
        false if types are incompatible

    - #### checkCompatibleAssignmentTypes

          public static boolean checkCompatibleAssignmentTypes(ClassNode left,
                                                               ClassNode right,
                                                               Expression rightExpression)

    - #### checkCompatibleAssignmentTypes

          public static boolean checkCompatibleAssignmentTypes(ClassNode left,
                                                               ClassNode right,
                                                               Expression rightExpression,
                                                               boolean allowConstructorCoercion)

    - #### isWildcardLeftHandSide

          public static boolean isWildcardLeftHandSide(ClassNode node)

      Tells if a class is one of the "accept all" classes as the left hand side of an assignment.
      Parameters:
        `node` - the classnode to test
      Returns:
        true if it's an Object, String, boolean, Boolean or Class.

    - #### isBeingCompiled

          public static boolean isBeingCompiled(ClassNode node)

    - #### implementsInterfaceOrIsSubclassOf

          public static boolean implementsInterfaceOrIsSubclassOf(ClassNode type,
                                                                  ClassNode superOrInterface)

    - #### findDGMMethodsByNameAndArguments

          @Deprecated
          public static java.util.List<MethodNode> findDGMMethodsByNameAndArguments(ClassNode receiver,
                                                                                                 java.lang.String name,
                                                                                                 ClassNode[] args)

      Deprecated. Use `findDGMMethodsByNameAndArguments(ClassLoader, org.codehaus.groovy.ast.ClassNode, String, org.codehaus.groovy.ast.ClassNode[], java.util.List)` instead

    - #### findDGMMethodsByNameAndArguments

          public static java.util.List<MethodNode> findDGMMethodsByNameAndArguments(java.lang.ClassLoader loader,
                                                                                    ClassNode receiver,
                                                                                    java.lang.String name,
                                                                                    ClassNode[] args)

    - #### findDGMMethodsByNameAndArguments

          @Deprecated
          public static java.util.List<MethodNode> findDGMMethodsByNameAndArguments(ClassNode receiver,
                                                                                                 java.lang.String name,
                                                                                                 ClassNode[] args,
                                                                                                 java.util.List<MethodNode> methods)

      Deprecated. Use `findDGMMethodsByNameAndArguments(ClassLoader, org.codehaus.groovy.ast.ClassNode, String, org.codehaus.groovy.ast.ClassNode[], List)` instead

    - #### findDGMMethodsByNameAndArguments

          public static java.util.List<MethodNode> findDGMMethodsByNameAndArguments(java.lang.ClassLoader loader,
                                                                                    ClassNode receiver,
                                                                                    java.lang.String name,
                                                                                    ClassNode[] args,
                                                                                    java.util.List<MethodNode> methods)

    - #### isUsingUncheckedGenerics

          public static boolean isUsingUncheckedGenerics(ClassNode node)

      Returns true if the provided class node, when considered as a receiver of a message or as a parameter, is using a placeholder in its generics type. In this case, we're facing unchecked generics and type checking is limited (ex: void foo(Set s) { s.keySet() }
      Parameters:
        `node` - the node to test
      Returns:
        true if it is using any placeholder in generics types

    - #### chooseBestMethod

          public static java.util.List<MethodNode> chooseBestMethod(ClassNode receiver,
                                                                    java.util.Collection<MethodNode> methods,
                                                                    ClassNode... args)

      Given a list of candidate methods, returns the one which best matches the argument types
      Parameters:
        `receiver` -
        `methods` - candidate methods
        `args` - argument types
      Returns:
        the list of methods which best matches the argument types. It is still possible that multiple methods match the argument types.

    - #### parameterizeArguments

          public static Parameter[] parameterizeArguments(ClassNode receiver,
                                                          MethodNode m)

      Given a receiver and a method node, parameterize the method arguments using available generic type information.
      Parameters:
        `receiver` - the class
        `m` - the method
      Returns:
        the parameterized arguments

    - #### isUsingGenericsOrIsArrayUsingGenerics

          public static boolean isUsingGenericsOrIsArrayUsingGenerics(ClassNode cn)

      Returns true if a class node makes use of generic types. If the class node represents an array type, then checks if the component type is using generics.
      Parameters:
        `cn` - a class node for which to check if it is using generics
      Returns:
        true if the type (or component type) is using generics

    - #### fullyResolve

          protected static GenericsType fullyResolve(GenericsType gt,
                                                     java.util.Map<java.lang.String,GenericsType> placeholders)

      Given a generics type representing SomeClass<T,V> and a resolved placeholder map, returns a new generics type for which placeholders are resolved recursively.

    - #### fullyResolveType

          protected static ClassNode fullyResolveType(ClassNode type,
                                                      java.util.Map<java.lang.String,GenericsType> placeholders)

    - #### typeCheckMethodArgumentWithGenerics

          protected static boolean typeCheckMethodArgumentWithGenerics(ClassNode parameterType,
                                                                       ClassNode argumentType,
                                                                       boolean lastArg)

      Checks that the parameterized generics of an argument are compatible with the generics of the parameter.
      Parameters:
        `parameterType` - the parameter type of a method
        `argumentType` - the type of the argument passed to the method

    - #### typeCheckMethodsWithGenerics

          protected static boolean typeCheckMethodsWithGenerics(ClassNode receiver,
                                                                ClassNode[] arguments,
                                                                MethodNode candidateMethod)

    - #### resolveClassNodeGenerics

          public static ClassNode resolveClassNodeGenerics(java.util.Map<java.lang.String,GenericsType> resolvedPlaceholders,
                                                           java.util.Map<java.lang.String,GenericsType> placeholdersFromContext,
                                                           ClassNode currentType)

    - #### getCorrectedClassNode

          public static ClassNode getCorrectedClassNode(ClassNode type,
                                                        ClassNode superClass,
                                                        boolean handlingGenerics)

    - #### isGStringOrGStringStringLUB

          public static boolean isGStringOrGStringStringLUB(ClassNode node)

      Returns:
        true if the class node is either a GString or the LUB of String and GString.

    - #### isParameterizedWithGStringOrGStringString

          public static boolean isParameterizedWithGStringOrGStringString(ClassNode node)

      Parameters:
        `node` - the node to be tested
      Returns:
        true if the node is using generics types and one of those types is a gstring or string/gstring lub

    - #### isParameterizedWithString

          public static boolean isParameterizedWithString(ClassNode node)

      Parameters:
        `node` - the node to be tested
      Returns:
        true if the node is using generics types and one of those types is a string

    - #### missesGenericsTypes

          public static boolean missesGenericsTypes(ClassNode cn)

    - #### evaluateExpression

          public static java.lang.Object evaluateExpression(Expression expr,
                                                            CompilerConfiguration config)

      A helper method that can be used to evaluate expressions as found in annotation parameters. For example, it will evaluate a constant, be it referenced directly as an integer or as a reference to a field.

      If this method throws an exception, then the expression cannot be evaluated on its own.

      Parameters:
        `expr` - the expression to be evaluated
        `config` - the compiler configuration
      Returns:
        the result of the expression

    - #### collectAllInterfaces

          public static java.util.Set<ClassNode> collectAllInterfaces(ClassNode node)

      Collects all interfaces of a class node, including those defined by the super class.
      Parameters:
        `node` - a class for which we want to retrieve all interfaces
      Returns:
        a set of interfaces implemented by this class node

    - #### isClassClassNodeWrappingConcreteType

          public static boolean isClassClassNodeWrappingConcreteType(ClassNode classNode)

      Returns true if the class node represents a the class node for the Class class and if the parametrized type is a neither a placeholder or a wildcard. For example, the class node Class<Foo> where Foo is a class would return true, but the class node for Class<?> would return false.
      Parameters:
        `classNode` - a class node to be tested
      Returns:
        true if it is the class node for Class and its generic type is a real class

    - #### findSetters

          public static java.util.List<MethodNode> findSetters(ClassNode cn,
                                                               java.lang.String setterName,
                                                               boolean voidOnly)

    - #### isTraitSelf

          public static ClassNode isTraitSelf(VariableExpression vexp)