A closure signature hint class is always used in conjunction with the ClosureParams annotation. It is
called at compile time (or may be used by IDEs) to infer the types of the parameters of a groovy..
A closure hint class is responsible for generating the list of arguments that a closure accepts. Since closures
may accept several signatures, getClosureSignatures(org. should
return a list.
Whenever the type checker encounters a method call that targets a method accepting a closure, it will search
for the ClosureParams annotation on the groovy. argument. If it is found, then it
creates an instance of the hint class and calls the getClosureSignatures(org.
method, which will in turn return the list of signatures.
Note that the signature concept here is used only to describe the parameter types, not the result type, which
is found in the generic type argument of the groovy. class.
Several predefined hints can be found, which should cover most of the use cases.
| Access | Constructor and Description |
|---|---|
| public |
| Modifier and Type | Method and Description |
|---|---|
| protected ClassNode | Returns: a ClassNode representing the typesource unit sourceUnit, final CompilationUnit compilation unit compilationUnit, final String the name of the class we want to get a className)org. forFinds a class node given a string representing the type. |
| public abstract List | getClosureSignatures(MethodNode
the method node for which a node, SourceUnit groovy. parameter was annotated with
ClosureParamsthe source unit of the file being compiled sourceUnit, CompilationUnit the compilation unit of the file being compiled compilationUnit, String[] the options, corresponding to the options, ASTNode 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.the AST node, in the compiled file, which triggered a call to this method. Normally only used for logging/error handling usage)Subclasses should implement this method, which returns the list of accepted closure signatures. |
| public static ClassNode | Returns: the n-th generic type, ororg. if it doesn't exist.the class node from which to pick a generic type type, int the index of the generic type to extract gtIndex)A helper method which will extract the n-th generic type from a class node. |
| public static ClassNode | Returns: the generic type, ororg. if it doesn't exist.the method node from which the generic type should be picked node, int the index of the parameter in the method parameter list parameterIndex, int the index of the generic type to extract gtIndex)A helper method which will extract the n-th generic type from the n-th parameter of a method node. |
| ClosureSignatureHint | back to summary |
|---|---|
| public ClosureSignatureHint() | |
| findClassNode | back to summary |
|---|---|
| protected ClassNode findClassNode(final SourceUnit sourceUnit, final CompilationUnit compilationUnit, final String className) Finds a class node given a string representing the type. Performs a lookup in the compilation unit to check if it is done in the same source unit.
| |
| getClosureSignatures | back to summary |
|---|---|
| public abstract List 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 @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
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.
| |
| pickGenericType | back to summary |
|---|---|
| public static ClassNode pickGenericType(ClassNode type, int gtIndex) A helper method which will extract the n-th generic type from a class node.
| |
| pickGenericType | back to summary |
|---|---|
| public static ClassNode pickGenericType(MethodNode node, int parameterIndex, int gtIndex) A helper method which will extract the n-th generic type from the n-th parameter of a method node.
| |