org.checkerframework.framework.util.dependenttypes

Class DependentTypesHelper

java.lang.Object

org.checkerframework.framework.util.dependenttypes.DependentTypesHelper

Direct Known Subclasses:

OffsetDependentTypesHelper

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. This allows subtyping checks to assume that if two strings are equal and not errors, the reference the same valid Java expression.
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	checkAnnotation(AnnotationMirror annotation, Tree errorTree) Checks every Java expression element of the annotation to see if the expression is an error string as specified by DependentTypesError#isExpressionError.
void	checkClass(ClassTree classTree, AnnotatedTypeMirror.AnnotatedDeclaredType type) Checks all Java expressions in the class declaration AnnotatedTypeMirror to see if the expression string is an error string as specified by DependentTypesError#isExpressionError.
void	checkMethod(MethodTree methodTree, AnnotatedTypeMirror.AnnotatedExecutableType type) Checks all Java 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 Java expressions 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)
AnnotationMirror	standardizeAnnotation(FlowExpressionParseUtil.FlowExpressionContext context, TreePath localScope, AnnotationMirror anno, boolean useLocalScope) Standardizes Java expressions in an annotation.
void	standardizeClass(ClassTree node, AnnotatedTypeMirror type, Element ele) Standardize the Java expressions in annotations in a class declaration.
void	standardizeExpression(ExpressionTree tree, AnnotatedTypeMirror annotatedType)
void	standardizeFieldAccess(MemberSelectTree node, AnnotatedTypeMirror type) Standardize the Java expressions in annotations in a field access.
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) Standardize the Java expressions in annotations in a variable declaration.
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)

standardizeClass

public void standardizeClass(ClassTree node,
                             AnnotatedTypeMirror type,
                             Element ele)

Standardize the Java expressions in annotations in a class declaration.

Parameters:

node - the class declaration

type - the type of the class declaration

ele - the element of the class declaration

standardizeVariable

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

Standardize the Java expressions in annotations in a variable declaration.

Parameters:

node - the variable declaration

type - the type of the variable declaration

ele - the element of the variable declaration

standardizeFieldAccess

public void standardizeFieldAccess(MemberSelectTree node,
                                   AnnotatedTypeMirror type)

Standardize the Java expressions in annotations in a field access.

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

standardizeAnnotation

public AnnotationMirror standardizeAnnotation(FlowExpressionParseUtil.FlowExpressionContext context,
                                              TreePath localScope,
                                              AnnotationMirror anno,
                                              boolean useLocalScope)

Standardizes Java expressions in an annotation. If the annotation is not a dependent type annotation, returns the same annotation unchanged.

Parameters:

context - information about any receiver and arguments

localScope - path to local scope to use

anno - the annotation to be standardized

useLocalScope - whether localScope should be used to resolve identifiers

Returns:

the standardized annotation

checkType

public void checkType(AnnotatedTypeMirror atm,
                      Tree errorTree)

Checks all Java expressions 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)

checkAnnotation

public void checkAnnotation(AnnotationMirror annotation,
                            Tree errorTree)

Checks every Java expression element of the annotation to see if the expression is an error string as specified by DependentTypesError#isExpressionError. If any expression is an error, then an error is reported at errorTree.

Parameters:

annotation - annotation to check

errorTree - location at which to issue errors

checkClass

public void checkClass(ClassTree classTree,
                       AnnotatedTypeMirror.AnnotatedDeclaredType type)

Checks all Java expressions in the class 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. Note that this checks the class declaration itself, not the body or extends/implements clauses.

Parameters:

classTree - class to check

type - annotated type of the class

checkMethod

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

Checks all Java 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