org.codehaus.groovy.transform.stc

Class GroovyTypeCheckingExtensionSupport

java.lang.Object

org.codehaus.groovy.transform.stc.TypeCheckingExtension

org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport

public class GroovyTypeCheckingExtensionSupport
extends TypeCheckingExtension

Base class for type checking extensions written in Groovy. Compared to its superclass, TypeCheckingExtension, this class adds a number of utility methods aimed at leveraging the syntax of the Groovy language to improve expressivity and conciseness.

Since:

2.1.0

Author:

Cedric Champeau

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	GroovyTypeCheckingExtensionSupport.TypeCheckingDSL

Field Summary

Fields inherited from class org.codehaus.groovy.transform.stc.TypeCheckingExtension

typeCheckingVisitor

Constructor Summary

Constructors

Constructor and Description
GroovyTypeCheckingExtensionSupport(StaticTypeCheckingVisitor typeCheckingVisitor, String scriptPath, CompilationUnit compilationUnit) Builds a type checking extension relying on a Groovy script (type checking DSL).

Method Summary

Methods

Modifier and Type	Method and Description
void	afterMethodCall(MethodCall call) Allows the extension to perform additional tasks after the type checker actually visits a method call.
void	afterVisitClass(ClassNode node) Allows the extension to perform additional tasks after the type checker actually visited a class node.
void	afterVisitMethod(MethodNode node) Allows the extension to perform additional tasks after the type checker actually visited a method node.
boolean	argTypeMatches(ClassNode[] argTypes, int index, Class clazz)
boolean	argTypeMatches(MethodCall call, int index, Class clazz)
boolean	argTypesMatches(ClassNode[] argTypes, Class... classes)
boolean	argTypesMatches(MethodCall call, Class... classes)
boolean	beforeMethodCall(MethodCall call) Allows the extension to perform additional tasks before the type checker actually visits a method call.
boolean	beforeVisitClass(ClassNode node) Allows the extension to perform additional tasks before the type checker actually visits a class node.
boolean	beforeVisitMethod(MethodNode node) Allows the extension to perform additional tasks before the type checker actually visits a method node.
void	delegatesTo(ClassNode type)
void	delegatesTo(ClassNode type, int strategy)
void	delegatesTo(ClassNode type, int strategy, org.codehaus.groovy.transform.stc.DelegationMetadata parent)
void	finish() Subclasses should implement this method if they need to perform additional checks after the type checker has finished its work.
boolean	firstArgTypesMatches(ClassNode[] argTypes, Class... classes)
boolean	firstArgTypesMatches(MethodCall call, Class... classes)
ArgumentListExpression	getArguments(MethodCall call)
org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope	getCurrentScope()
BinaryExpression	getEnclosingBinaryExpression()
List<BinaryExpression>	getEnclosingBinaryExpressionStack()
ClassNode	getEnclosingClassNode()
List<ClassNode>	getEnclosingClassNodes()
TypeCheckingContext.EnclosingClosure	getEnclosingClosure()
List<TypeCheckingContext.EnclosingClosure>	getEnclosingClosureStack()
MethodNode	getEnclosingMethod()
Expression	getEnclosingMethodCall()
List<Expression>	getEnclosingMethodCalls()
List<MethodNode>	getEnclosingMethods()
boolean	handleIncompatibleAssignment(ClassNode lhsType, ClassNode rhsType, Expression assignmentExpression) This method is called by the type checker when an assignment is not allowed by the type checker.
List<MethodNode>	handleMissingMethod(ClassNode receiver, String name, ArgumentListExpression argumentList, ClassNode[] argumentTypes, MethodCall call) This method is called by the type checker when a method call cannot be resolved.
boolean	handleUnresolvedAttribute(AttributeExpression aexp) This method is called by the type checker when an attribute expression cannot be resolved (for example, when an attribute doesn't exist).
boolean	handleUnresolvedProperty(PropertyExpression pexp) This method is called by the type checker when a property expression cannot be resolved (for example, when a property doesn't exist).
boolean	handleUnresolvedVariableExpression(VariableExpression vexp) This method is called by the type checker when a variable expression cannot be resolved.
boolean	isAnnotatedBy(ASTNode node, Class annotation)
boolean	isAnnotatedBy(ASTNode node, ClassNode annotation)
boolean	isDynamic(VariableExpression var)
boolean	isExtensionMethod(MethodNode node)
boolean	isGenerated(MethodNode node)
boolean	isMethodCall(Object o)
MethodNode	newMethod(String name, Callable<ClassNode> returnType)
MethodNode	newMethod(String name, Class returnType)
MethodNode	newMethod(String name, ClassNode returnType)
org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope	newScope()
org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope	newScope(Closure code)
void	onMethodSelection(Expression expression, MethodNode target) Allows the extension to listen to method selection events.
BinaryExpression	popEnclosingBinaryExpression()
ClassNode	popEnclosingClassNode()
TypeCheckingContext.EnclosingClosure	popEnclosingClosure()
MethodNode	popEnclosingMethod()
Expression	popEnclosingMethodCall()
void	popTemporaryTypeInfo()
void	pushEnclosingBinaryExpression(BinaryExpression binaryExpression)
void	pushEnclosingClassNode(ClassNode classNode)
void	pushEnclosingClosureExpression(ClosureExpression closureExpression)
void	pushEnclosingMethod(MethodNode methodNode)
void	pushEnclosingMethodCall(Expression call)
void	pushTemporaryTypeInfo()
org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope	scopeExit()
org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope	scopeExit(Closure code)
void	setHandled(boolean handled)
void	setup() Subclasses should implement this method whenever they need to perform special checks before the type checker starts working.
List<MethodNode>	unique(MethodNode node)
<R> R	withTypeChecker(Closure<R> code)

Methods inherited from class org.codehaus.groovy.transform.stc.TypeCheckingExtension

addStaticTypeError, classNodeFor, classNodeFor, existsProperty, existsProperty, getArgumentTypes, getTargetMethod, getType, lookupClassNodeFor, parameterizedType, storeType

Methods inherited from class java.lang.Object

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

Constructor Detail

GroovyTypeCheckingExtensionSupport

public GroovyTypeCheckingExtensionSupport(StaticTypeCheckingVisitor typeCheckingVisitor,
                                  String scriptPath,
                                  CompilationUnit compilationUnit)

Builds a type checking extension relying on a Groovy script (type checking DSL).

Parameters:

typeCheckingVisitor - the type checking visitor

scriptPath - the path to the type checking script (in classpath)

compilationUnit -

Method Detail

setup

public void setup()

Description copied from class: TypeCheckingExtension

Subclasses should implement this method whenever they need to perform special checks before the type checker starts working.

Overrides:

setup in class TypeCheckingExtension

finish

public void finish()

Description copied from class: TypeCheckingExtension

Subclasses should implement this method if they need to perform additional checks after the type checker has finished its work. This is particularily useful for situations where you need multiple passes. Some checks in that case may be deferred to the end, using this method.

Overrides:

finish in class TypeCheckingExtension

setHandled

public void setHandled(boolean handled)

newScope

public org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope newScope()

newScope

public org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope newScope(Closure code)

scopeExit

public org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope scopeExit()

getCurrentScope

public org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope getCurrentScope()

scopeExit

public org.codehaus.groovy.transform.stc.GroovyTypeCheckingExtensionSupport.TypeCheckingScope scopeExit(Closure code)

isGenerated

public boolean isGenerated(MethodNode node)

unique

public List<MethodNode> unique(MethodNode node)

newMethod

public MethodNode newMethod(String name,
                   Class returnType)

newMethod

public MethodNode newMethod(String name,
                   ClassNode returnType)

newMethod

public MethodNode newMethod(String name,
                   Callable<ClassNode> returnType)

delegatesTo

public void delegatesTo(ClassNode type)

delegatesTo

public void delegatesTo(ClassNode type,
               int strategy)

delegatesTo

public void delegatesTo(ClassNode type,
               int strategy,
               org.codehaus.groovy.transform.stc.DelegationMetadata parent)

isAnnotatedBy

public boolean isAnnotatedBy(ASTNode node,
                    Class annotation)

isAnnotatedBy

public boolean isAnnotatedBy(ASTNode node,
                    ClassNode annotation)

isDynamic

public boolean isDynamic(VariableExpression var)

isExtensionMethod

public boolean isExtensionMethod(MethodNode node)

getArguments

public ArgumentListExpression getArguments(MethodCall call)

onMethodSelection

public void onMethodSelection(Expression expression,
                     MethodNode target)

Description copied from class: TypeCheckingExtension

Allows the extension to listen to method selection events. Given an expression, which may be a method call expression, a static method call expression, a pre/postfix expression, ..., if a corresponding method is found, this method is called.

Overrides:

onMethodSelection in class TypeCheckingExtension

Parameters:

expression - the expression for which a corresponding method has been found

target - the method which has been chosen by the type checker

afterMethodCall

public void afterMethodCall(MethodCall call)

Description copied from class: TypeCheckingExtension

Allows the extension to perform additional tasks after the type checker actually visits a method call. Compared to a custom visitor, this method ensures that the node being visited is a node which would have been visited by the type checker. This is in particular important for nodes which are marked with TypeCheckingMode.SKIP.

Overrides:

afterMethodCall in class TypeCheckingExtension

Parameters:

call - a method call, either a MethodCallExpression or a StaticMethodCallExpression

beforeMethodCall

public boolean beforeMethodCall(MethodCall call)

Description copied from class: TypeCheckingExtension

Allows the extension to perform additional tasks before the type checker actually visits a method call. Compared to a custom visitor, this method ensures that the node being visited is a node which would have been visited by the type checker. This is in particular important for nodes which are marked with TypeCheckingMode.SKIP.

Overrides:

beforeMethodCall in class TypeCheckingExtension

Parameters:

call - a method call, either a MethodCallExpression or a StaticMethodCallExpression

Returns:

false if the type checker should visit the node, or true if this extension replaces what the type checker would do with the method call.

handleUnresolvedVariableExpression

public boolean handleUnresolvedVariableExpression(VariableExpression vexp)

Description copied from class: TypeCheckingExtension

This method is called by the type checker when a variable expression cannot be resolved. It gives the extension a chance to resolve it for the type checker.

Overrides:

handleUnresolvedVariableExpression in class TypeCheckingExtension

Parameters:

vexp - the unresolved variable extension

Returns:

boolean false if the extension doesn't handle it, true if the extension handles this variable.

handleUnresolvedProperty

public boolean handleUnresolvedProperty(PropertyExpression pexp)

Description copied from class: TypeCheckingExtension

This method is called by the type checker when a property expression cannot be resolved (for example, when a property doesn't exist). It gives the extension a chance to resolve it.

Overrides:

handleUnresolvedProperty in class TypeCheckingExtension

Parameters:

pexp - the unresolved property

Returns:

boolean false if this extension doesn't resolve the property, true if it resolves the property.

handleUnresolvedAttribute

public boolean handleUnresolvedAttribute(AttributeExpression aexp)

Description copied from class: TypeCheckingExtension

This method is called by the type checker when an attribute expression cannot be resolved (for example, when an attribute doesn't exist). It gives the extension a chance to resolve it.

Overrides:

handleUnresolvedAttribute in class TypeCheckingExtension

Parameters:

aexp - the unresolved attribute

Returns:

boolean false if this extension doesn't resolve the attribute, true if it resolves the attribute.

afterVisitMethod

public void afterVisitMethod(MethodNode node)

Description copied from class: TypeCheckingExtension

Allows the extension to perform additional tasks after the type checker actually visited a method node. Compared to a custom visitor, this method ensures that the node being visited is a node which would have been visited by the type checker. This is in particular important for nodes which are marked with TypeCheckingMode.SKIP.

Overrides:

afterVisitMethod in class TypeCheckingExtension

Parameters:

node - a method node

beforeVisitClass

public boolean beforeVisitClass(ClassNode node)

Description copied from class: TypeCheckingExtension

Allows the extension to perform additional tasks before the type checker actually visits a class node. Compared to a custom visitor, this method ensures that the node being visited is a node which would have been visited by the type checker. This is in particular important for nodes which are marked with TypeCheckingMode.SKIP.

Overrides:

beforeVisitClass in class TypeCheckingExtension

Parameters:

node - a class node

Returns:

false if the type checker should visit the node, or true if this extension replaces what the type checker would do with the class.

afterVisitClass

public void afterVisitClass(ClassNode node)

Description copied from class: TypeCheckingExtension

Allows the extension to perform additional tasks after the type checker actually visited a class node. Compared to a custom visitor, this method ensures that the node being visited is a node which would have been visited by the type checker. This is in particular important for nodes which are marked with TypeCheckingMode.SKIP.

Overrides:

afterVisitClass in class TypeCheckingExtension

Parameters:

node - a class node

beforeVisitMethod

public boolean beforeVisitMethod(MethodNode node)

Description copied from class: TypeCheckingExtension

Allows the extension to perform additional tasks before the type checker actually visits a method node. Compared to a custom visitor, this method ensures that the node being visited is a node which would have been visited by the type checker. This is in particular important for nodes which are marked with TypeCheckingMode.SKIP.

Overrides:

beforeVisitMethod in class TypeCheckingExtension

Parameters:

node - a method node

Returns:

false if the type checker should visit the node, or true if this extension replaces what the type checker would do with the method.

handleIncompatibleAssignment

public boolean handleIncompatibleAssignment(ClassNode lhsType,
                                   ClassNode rhsType,
                                   Expression assignmentExpression)

Description copied from class: TypeCheckingExtension

This method is called by the type checker when an assignment is not allowed by the type checker. Extensions may override this method to allow such assignments where the type checker normally disallows them.

Overrides:

handleIncompatibleAssignment in class TypeCheckingExtension

Parameters:

lhsType - the type of the left hand side of the assignment, as found by the type checker

rhsType - the type of the right hand side of the assignment, as found by the type checker

assignmentExpression - the assignment expression which triggerred this call

Returns:

boolean false if the extension does not handle this assignment, true otherwise

handleMissingMethod

public List<MethodNode> handleMissingMethod(ClassNode receiver,
                                   String name,
                                   ArgumentListExpression argumentList,
                                   ClassNode[] argumentTypes,
                                   MethodCall call)

Description copied from class: TypeCheckingExtension

This method is called by the type checker when a method call cannot be resolved. Extensions may override this method to handle missing methods and avoid the type checker to throw an error.

Overrides:

handleMissingMethod in class TypeCheckingExtension

Parameters:

receiver - the type of the receiver

name - the name of the called method

argumentList - the list of arguments of the call

argumentTypes - the types of the arguments of the call

call - the method call itself, if needed

Returns:

an empty list if the extension cannot resolve the method, or a list of potential methods if the extension finds candidates. This method must not return null.

isMethodCall

public boolean isMethodCall(Object o)

argTypesMatches

public boolean argTypesMatches(ClassNode[] argTypes,
                      Class... classes)

argTypesMatches

public boolean argTypesMatches(MethodCall call,
                      Class... classes)

firstArgTypesMatches

public boolean firstArgTypesMatches(ClassNode[] argTypes,
                           Class... classes)

firstArgTypesMatches

public boolean firstArgTypesMatches(MethodCall call,
                           Class... classes)

argTypeMatches

public boolean argTypeMatches(ClassNode[] argTypes,
                     int index,
                     Class clazz)

argTypeMatches

public boolean argTypeMatches(MethodCall call,
                     int index,
                     Class clazz)

withTypeChecker

public <R> R withTypeChecker(Closure<R> code)

getEnclosingBinaryExpression

public BinaryExpression getEnclosingBinaryExpression()

pushEnclosingBinaryExpression

public void pushEnclosingBinaryExpression(BinaryExpression binaryExpression)

pushEnclosingClosureExpression

public void pushEnclosingClosureExpression(ClosureExpression closureExpression)

getEnclosingMethodCall

public Expression getEnclosingMethodCall()

popEnclosingMethodCall

public Expression popEnclosingMethodCall()

popEnclosingMethod

public MethodNode popEnclosingMethod()

getEnclosingClassNode

public ClassNode getEnclosingClassNode()

getEnclosingMethods

public List<MethodNode> getEnclosingMethods()

getEnclosingMethod

public MethodNode getEnclosingMethod()

popTemporaryTypeInfo

public void popTemporaryTypeInfo()

pushEnclosingClassNode

public void pushEnclosingClassNode(ClassNode classNode)

popEnclosingBinaryExpression

public BinaryExpression popEnclosingBinaryExpression()

getEnclosingClassNodes

public List<ClassNode> getEnclosingClassNodes()

getEnclosingClosureStack

public List<TypeCheckingContext.EnclosingClosure> getEnclosingClosureStack()

popEnclosingClassNode

public ClassNode popEnclosingClassNode()

pushEnclosingMethod

public void pushEnclosingMethod(MethodNode methodNode)

getEnclosingBinaryExpressionStack

public List<BinaryExpression> getEnclosingBinaryExpressionStack()

getEnclosingClosure

public TypeCheckingContext.EnclosingClosure getEnclosingClosure()

getEnclosingMethodCalls

public List<Expression> getEnclosingMethodCalls()

pushEnclosingMethodCall

public void pushEnclosingMethodCall(Expression call)

popEnclosingClosure

public TypeCheckingContext.EnclosingClosure popEnclosingClosure()

pushTemporaryTypeInfo

public void pushTemporaryTypeInfo()