Package org.codehaus.groovy.transform.stc

# Class DefaultTypeCheckingExtension

java.lang.Object
org.codehaus.groovy.transform.stc.TypeCheckingExtension
org.codehaus.groovy.transform.stc.DefaultTypeCheckingExtension

public class DefaultTypeCheckingExtension extends TypeCheckingExtension
The default type checking handler is used by the standard type checker and doesn't handle any of the type checking errors by default. This just means that whenever a type checking error is detected, there's no additional information available to the type checker that could help it. The default handler is also capable of handling a collection of delegate handlers. If a list of delegates is set, then the type checker will try all the delegates until one is capable of handling an error.

Since:
  2.1.0
Author:
  Cedric Champeau

## Field Summary

Fields
Modifier and Type
Field
Description
`protected final List<TypeCheckingExtension>`
`handlers`

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

`typeCheckingVisitor`

## Constructor Summary

Constructors
Constructor
Description
`DefaultTypeCheckingExtension(StaticTypeCheckingVisitor typeCheckingVisitor)`

## Method Summary

Modifier and Type
Method
Description
`void`
`addHandler(TypeCheckingExtension handler)`
`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`
`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`
`finish()`
Subclasses should implement this method if they need to perform additional checks after the type checker has finished its work.
`List<MethodNode>`
`handleAmbiguousMethods(List<MethodNode> nodes, Expression origin)`
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.
`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.
`boolean`
`handleIncompatibleReturnType(ReturnStatement returnStatement, ClassNode inferredReturnType)`
Allows the extension to catch incompatible return types.
`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.
`void`
`onMethodSelection(Expression expression, MethodNode target)`
Allows the extension to listen to method selection events.
`void`
`removeHandler(TypeCheckingExtension handler)`
`void`
`setup()`
Subclasses should implement this method whenever they need to perform special checks before the type checker starts working.

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

`addStaticTypeError, buildListType, buildMapType, classNodeFor, classNodeFor, existsProperty, existsProperty, extractStaticReceiver, getArgumentTypes, getTargetMethod, getType, isStaticMethodCallOnClass, lookupClassNodeFor, parameterizedType, storeType`

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

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

## Field Details

### handlers

protected final List<TypeCheckingExtension> handlers

## Constructor Details

### DefaultTypeCheckingExtension

public DefaultTypeCheckingExtension(StaticTypeCheckingVisitor typeCheckingVisitor)

## Method Details

### addHandler

public void addHandler(TypeCheckingExtension handler)

### removeHandler

public void removeHandler(TypeCheckingExtension handler)

### 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.

### 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

### 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.

### 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.

### 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

### 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.

### 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

### 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.

### 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`, `StaticMethodCallExpression`, or `ConstructorCallExpression`

### 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`, `StaticMethodCallExpression`, or `ConstructorCallExpression`
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.

### 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

### 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`