org.checkerframework.framework.util.expressionannotations

Class ExpressionAnnotationHelper

java.lang.Object

org.checkerframework.framework.util.expressionannotations.ExpressionAnnotationHelper

public class ExpressionAnnotationHelper
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 List<Class<? extends Annotation>>	expressionAnnos A list of annotations that are expression annotations.
protected AnnotatedTypeFactory	factory

Constructor Summary

Constructors

Constructor and Description
ExpressionAnnotationHelper(AnnotatedTypeFactory factory, Class<? extends Annotation> anno)
ExpressionAnnotationHelper(AnnotatedTypeFactory factory, List<Class<? extends Annotation>> expressionAnnos)

Method Summary

Modifier and Type	Method and Description
void	checkMethod(MethodTree methodTree, AnnotatedTypeMirror.AnnotatedExecutableType type) Checks all expression annotations in the method declaration to see if the expression string is an error string as specified by ExpressionAnnotationError#isExpressionError.
void	checkType(AnnotatedTypeMirror atm, Tree errorTree) Checks all expression annotations in the given annotated type to see if the expression string is an error string as specified by ExpressionAnnotationError#isExpressionError.
TreeAnnotator	createExpressionAnnotationTreeAnnotator(AnnotatedTypeFactory factory) Creates a TreeAnnotator that standarizes expression annotations.
protected void	reportErrors(Tree errorTree, List<ExpressionAnnotationError> 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 expression annotations in the constructorType based on the newClassTree.
void	viewpointAdaptMethod(MethodInvocationTree methodInvocationTree, AnnotatedTypeMirror.AnnotatedExecutableType methodDeclType) Viewpoint adapts the expression annotations in the methodDeclType based on the methodInvocationTree.
void	viewpointAdaptTypeVariableBounds(TypeElement classDecl, List<AnnotatedTypeParameterBounds> bounds, TreePath pathToUse) Viewpoint adapts the expression 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

expressionAnnos

protected final List<Class<? extends Annotation>> expressionAnnos

A list of annotations that are expression annotations.

Constructor Detail

ExpressionAnnotationHelper

public ExpressionAnnotationHelper(AnnotatedTypeFactory factory,
                                  List<Class<? extends Annotation>> expressionAnnos)

ExpressionAnnotationHelper

public ExpressionAnnotationHelper(AnnotatedTypeFactory factory,
                                  Class<? extends Annotation> anno)

Method Detail

createExpressionAnnotationTreeAnnotator

public TreeAnnotator createExpressionAnnotationTreeAnnotator(AnnotatedTypeFactory factory)

Creates a TreeAnnotator that standarizes expression annotations.

Parameters:

factory - annotated type factory

Returns:

a new TreeAnnotator that standarizes expression annotatoions

viewpointAdaptTypeVariableBounds

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

Viewpoint adapts the expression 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 expression 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 expression 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)

checkType

public void checkType(AnnotatedTypeMirror atm,
                      Tree errorTree)

Checks all expression annotations in the given annotated type to see if the expression string is an error string as specified by ExpressionAnnotationError#isExpressionError. 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<ExpressionAnnotationError> errors)

checkMethod

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

Checks all expression annotations in the method declaration to see if the expression string is an error string as specified by ExpressionAnnotationError#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