groovy.transform.stc

## Class SingleSignatureClosureHint

- java.lang.Object
- - groovy.transform.stc.ClosureSignatureHint
  - - groovy.transform.stc.SingleSignatureClosureHint

- Direct Known Subclasses:
    PickAnyArgumentHint, SimpleType

      public abstract class SingleSignatureClosureHint
      extends ClosureSignatureHint

  A simplified version of a `ClosureSignatureHint` which is suitable for monomorphic closures, that is to say closures which only respond to a single signature.
  Since:
    2.3.0
  Author:
    Cédric Champeau

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `SingleSignatureClosureHint()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.util.List<ClassNode[]>` | `getClosureSignatures(MethodNode node, SourceUnit sourceUnit, CompilationUnit compilationUnit, java.lang.String[] options, ASTNode usage)` Subclasses should implement this method, which returns the list of accepted closure signatures.
    `abstract ClassNode[]` | `getParameterTypes(MethodNode node, java.lang.String[] options, SourceUnit sourceUnit, CompilationUnit unit, ASTNode usage)`

    - ### Methods inherited from class groovy.transform.stc.ClosureSignatureHint

      `findClassNode, pickGenericType, pickGenericType`

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

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

- - ### Constructor Detail

    - #### SingleSignatureClosureHint

          public SingleSignatureClosureHint()

  - ### Method Detail

    - #### getParameterTypes

          public abstract ClassNode[] getParameterTypes(MethodNode node,
                                                        java.lang.String[] options,
                                                        SourceUnit sourceUnit,
                                                        CompilationUnit unit,
                                                        ASTNode usage)

    - #### getClosureSignatures

          public java.util.List<ClassNode[]> getClosureSignatures(MethodNode node,
                                                                  SourceUnit sourceUnit,
                                                                  CompilationUnit compilationUnit,
                                                                  java.lang.String[] options,
                                                                  ASTNode usage)

      Description copied from class: `ClosureSignatureHint`

      Subclasses should implement this method, which returns the list of accepted closure signatures.

      The compiler will call this method each time, in a source file, a method call using a closure literal is encountered and that the target method has the corresponding `Closure` parameter annotated with `ClosureParams`. So imagine the following code needs to be compiled:

      `@groovy.transform.TypeChecked void doSomething() { println ['a','b'].collect { it.toUpperCase() } }`

      The collect method accepts a closure, but normally, the type checker doesn't have enough type information in the sole `DefaultGroovyMethods.collect(java.util.Collection, groovy.lang.Closure)` method signature to infer the type of it. With the annotation, it will now try to find an annotation on the closure parameter. If it finds it, then an instance of the hint class is created and the type checker calls it with the following arguments:

      - the method node corresponding to the target method (here, the `DefaultGroovyMethods.collect(java.util.Collection, groovy.lang.Closure)` method
      - the (optional) list of options found in the annotation

      Now, the hint instance can return the list of expected parameters. Here, it would have to say that the collect method accepts a closure for which the only argument is of the type of the first generic type of the first argument.

      With that type information, the type checker can now infer that the type of it is String, because the first argument (here the receiver of the collect method) is a List<String>

      Subclasses are therefore expected to return the signatures according to the available context, which is only the target method and the potential options.

      Specified by:
        `getClosureSignatures` in class `ClosureSignatureHint`
      Parameters:
        `node` - the method node for which a `Closure` parameter was annotated with `ClosureParams`
        `sourceUnit` - the source unit of the file being compiled
        `compilationUnit` - the compilation unit of the file being compiled
        `options` - the options, corresponding to the `ClosureParams.options()` found on the annotation @return a non-null list of signature, where a signature corresponds to an array of class nodes, each of them matching a parameter.
        `usage` - the AST node, in the compiled file, which triggered a call to this method. Normally only used for logging/error handling