org.checkerframework.framework.util.dependenttypes

Class DependentTypesHelper

java.lang.Object

org.checkerframework.framework.util.dependenttypes.DependentTypesHelper

public class DependentTypesHelper
extends Object

A class that helps checkers use qualifiers that are represented by annotations with Java expression strings. This class performs four main functions:

1. Standardizes/canonicalizes the expressions in the annotations such that two expression strings that are equivalent are made to be equal. For example, an instance field f may appear in an expression string as "f" or "this.f"; this class standardizes both strings to "this.f".

2. Viewpoint-adapts annotations on field or method declarations at field accesses or method invocations.

3. Changes invalid expression strings to an error string that includes the reason why the expression is invalid. For example, @KeyFor("m") would be changed to @KeyFor("[error for expression: m error: m: identifier not found]") if m is not a valid identifier.

4. Checks annotated types for error strings that have been added by this class and issues an error if any are found.

Steps 3 and 4 are separated so that an error is issued only once per invalid expression string rather than every time the expression string is parsed. (The expression string is parsed multiple times because annotated types are created multiple times.)

Field Summary

Fields

Modifier and Type	Field and Description
protected AnnotatedTypeFactory	factory

Constructor Summary

Constructors

Constructor and Description
DependentTypesHelper(AnnotatedTypeFactory factory)

Method Summary

Modifier and Type	Method and Description
void	checkMethod(MethodTree methodTree, AnnotatedTypeMirror.AnnotatedExecutableType type) Checks all expressions in the method declaration AnnotatedTypeMirror to see if the expression string is an error string as specified by DependentTypesError#isExpressionError.
void	checkType(AnnotatedTypeMirror atm, Tree errorTree) Checks all expression in the given annotated type to see if the expression string is an error string as specified by DependentTypesError.isExpressionError(java.lang.String).
TreeAnnotator	createDependentTypesTreeAnnotator(AnnotatedTypeFactory factory) Creates a TreeAnnotator that standardizes dependent type annotations.
boolean	hasDependentAnnotations() Returns true if any qualifier in the type system is a dependent type annotation.
protected void	reportErrors(Tree errorTree, List<DependentTypesError> errors)
void	standardizeExpression(ExpressionTree tree, AnnotatedTypeMirror annotatedType)
void	standardizeFieldAccess(MemberSelectTree node, AnnotatedTypeMirror type)
void	standardizeNewClassTree(NewClassTree tree, AnnotatedTypeMirror.AnnotatedDeclaredType type)
void	standardizeReturnType(MethodTree m, AnnotatedTypeMirror atm)
protected String	standardizeString(String expression, FlowExpressionParseUtil.FlowExpressionContext context, TreePath localScope, boolean useLocalScope)
void	standardizeVariable(AnnotatedTypeMirror type, Element elt)
void	standardizeVariable(Tree node, AnnotatedTypeMirror type, Element ele)
void	viewpointAdaptConstructor(NewClassTree newClassTree, AnnotatedTypeMirror.AnnotatedExecutableType constructorType) Viewpoint adapts the dependent type annotations in the constructorType based on the newClassTree.
void	viewpointAdaptMethod(MethodInvocationTree methodInvocationTree, AnnotatedTypeMirror.AnnotatedExecutableType methodDeclType) Viewpoint adapts the dependent type annotations in the methodDeclType based on the methodInvocationTree.
void	viewpointAdaptTypeVariableBounds(TypeElement classDecl, List<AnnotatedTypeParameterBounds> bounds, TreePath pathToUse) Viewpoint adapts the dependent type annotations on the bounds to the use of the type.

Methods inherited from class java.lang.Object

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

Field Detail

factory

protected final AnnotatedTypeFactory factory

Constructor Detail

DependentTypesHelper

public DependentTypesHelper(AnnotatedTypeFactory factory)

Method Detail

createDependentTypesTreeAnnotator

public TreeAnnotator createDependentTypesTreeAnnotator(AnnotatedTypeFactory factory)

Creates a TreeAnnotator that standardizes dependent type annotations.

Parameters:

factory - annotated type factory

Returns:

a new TreeAnnotator that standardizes dependent type annotations

viewpointAdaptTypeVariableBounds

public void viewpointAdaptTypeVariableBounds(TypeElement classDecl,
                                             List<AnnotatedTypeParameterBounds> bounds,
                                             TreePath pathToUse)

Viewpoint adapts the dependent type annotations on the bounds to the use of the type.

Parameters:

classDecl - class or interface declaration whose type variables should be viewpoint adapted

bounds - annotated types of the bounds of the type variables

pathToUse - tree path to the use of the class or interface

viewpointAdaptMethod

public void viewpointAdaptMethod(MethodInvocationTree methodInvocationTree,
                                 AnnotatedTypeMirror.AnnotatedExecutableType methodDeclType)

Viewpoint adapts the dependent type annotations in the methodDeclType based on the methodInvocationTree.

Parameters:

methodInvocationTree - use of the method

methodDeclType - type of the method declaration

viewpointAdaptConstructor

public void viewpointAdaptConstructor(NewClassTree newClassTree,
                                      AnnotatedTypeMirror.AnnotatedExecutableType constructorType)

Viewpoint adapts the dependent type annotations in the constructorType based on the newClassTree.

Parameters:

newClassTree - invocation of the constructor

constructorType - type of the constructor

standardizeNewClassTree

public void standardizeNewClassTree(NewClassTree tree,
                                    AnnotatedTypeMirror.AnnotatedDeclaredType type)

standardizeReturnType

public void standardizeReturnType(MethodTree m,
                                  AnnotatedTypeMirror atm)

standardizeVariable

public void standardizeVariable(Tree node,
                                AnnotatedTypeMirror type,
                                Element ele)

standardizeFieldAccess

public void standardizeFieldAccess(MemberSelectTree node,
                                   AnnotatedTypeMirror type)

standardizeExpression

public void standardizeExpression(ExpressionTree tree,
                                  AnnotatedTypeMirror annotatedType)

standardizeVariable

public void standardizeVariable(AnnotatedTypeMirror type,
                                Element elt)

standardizeString

protected String standardizeString(String expression,
                                   FlowExpressionParseUtil.FlowExpressionContext context,
                                   TreePath localScope,
                                   boolean useLocalScope)

hasDependentAnnotations

public boolean hasDependentAnnotations()

Returns true if any qualifier in the type system is a dependent type annotation.

Returns:

true if any qualifier in the type system is a dependent type annotation

checkType

public void checkType(AnnotatedTypeMirror atm,
                      Tree errorTree)

Checks all expression in the given annotated type to see if the expression string is an error string as specified by DependentTypesError.isExpressionError(java.lang.String). If the annotated type has any errors, a flowexpr.parse.error is issued at the errorTree.

Parameters:

atm - annotated type to check for expression errors

errorTree - the tree at which to report any found errors

reportErrors

protected void reportErrors(Tree errorTree,
                            List<DependentTypesError> errors)

checkMethod

public void checkMethod(MethodTree methodTree,
                        AnnotatedTypeMirror.AnnotatedExecutableType type)

Checks all expressions in the method declaration AnnotatedTypeMirror to see if the expression string is an error string as specified by DependentTypesError#isExpressionError. If the annotated type has any errors, a flowexpr.parse.error is issued.

Parameters:

methodTree - method to check

type - annotated type of the method