Package org.codehaus.groovy.transform.stc

Class GroovyTypeCheckingExtensionSupport

  • public class GroovyTypeCheckingExtensionSupport
extends AbstractTypeCheckingExtension
    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

    • 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

      • setDebug

        public void setDebug​(boolean debug)

      • 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 particularly 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

      • 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

      • 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 triggered this call
        Returns:
        boolean false if the extension does not handle this assignment, true otherwise

      • handleIncompatibleReturnType

        public boolean handleIncompatibleReturnType​(ReturnStatement returnStatement,
                                            ClassNode inferredReturnType)
        Description copied from class: TypeCheckingExtension
        Allows the extension to catch incompatible return types. This event is called whenever the type checker finds that an inferred return type is incompatible with the declared return type of a method.
        Overrides:
        handleIncompatibleReturnType in class TypeCheckingExtension
        Parameters:
        returnStatement - the statement that triggered the error
        inferredReturnType - the inferred return type for this statement
        Returns:
        false if the extension doesn't handle the error, 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 prevent the type checker from throwing 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.

      • handleAmbiguousMethods

        public List<MethodNode> handleAmbiguousMethods​(List<MethodNode> nodes,
                                               Expression origin)
        Description copied from class: TypeCheckingExtension
        This method is called by the type checker before throwing an "ambiguous method" error, giving the chance to the extension to select the method properly. This means that when this method is called, the "nodes" parameter contains at least two methods. If the returned list still contains at least two methods, then the type checker will throw an ambiguous method call error. If the returned method contains 1 element, then the type checker will not throw any error. It is invalid to return an empty list.
        Overrides:
        handleAmbiguousMethods in class TypeCheckingExtension
        Parameters:
        nodes - the list of ambiguous methods
        origin - the expression which originated the method selection process
        Returns:
        a single element list of disambiguated selection, or more elements if still ambiguous. It is not allowed to return an empty list.