org.checkerframework.common.basetype

Class BaseTypeValidator

java.lang.Object

org.checkerframework.framework.type.visitor.AnnotatedTypeScanner<Void,Tree>

org.checkerframework.common.basetype.BaseTypeValidator

All Implemented Interfaces:

TypeValidator, AnnotatedTypeVisitor<Void,Tree>

Direct Known Subclasses:

ReportVisitor.ReportTypeValidator

public class BaseTypeValidator
extends AnnotatedTypeScanner<Void,Tree>
implements TypeValidator

A visitor to validate the types in a tree.

Field Summary

Fields

Modifier and Type	Field and Description
protected AnnotatedTypeFactory	atypeFactory AnnotatedTypeFactory
protected BaseTypeChecker	checker BaseTypeChecker
protected boolean	checkTopLevelDeclaredType Should the primary annotation on the top level type be checked?
protected boolean	isValid Is the type valid?
protected BaseTypeVisitor<?>	visitor BaseTypeVisitor

Fields inherited from class org.checkerframework.framework.type.visitor.AnnotatedTypeScanner

visitedNodes

Constructor Summary

Constructors

Constructor and Description
BaseTypeValidator(BaseTypeChecker checker, BaseTypeVisitor<?> visitor, AnnotatedTypeFactory atypeFactory)

Method Summary

Modifier and Type	Method and Description
boolean	areBoundsValid(AnnotatedTypeMirror upperBound, AnnotatedTypeMirror lowerBound)
protected Result	isTopLevelValidType(QualifierHierarchy qualifierHierarchy, AnnotatedTypeMirror type) Checks every property listed in isValidType(org.checkerframework.framework.type.QualifierHierarchy, org.checkerframework.framework.type.AnnotatedTypeMirror), but only for the top level type.
boolean	isValid(AnnotatedTypeMirror type, Tree tree) The entry point to the type validator.
protected Result	isValidType(QualifierHierarchy qualifierHierarchy, AnnotatedTypeMirror type) Returns true if the given AnnotatedTypeMirror passed a set of well-formedness checks.
protected void	reportInvalidAnnotationsOnUse(AnnotatedTypeMirror type, Tree p)
protected void	reportInvalidBounds(AnnotatedTypeMirror type, Tree tree) Most errors reported by this class are of the form type.invalid.
protected void	reportInvalidType(AnnotatedTypeMirror type, Tree p)
protected void	reportValidityResult(@CompilerMessageKey String errorType, AnnotatedTypeMirror type, Tree p)
protected void	reportValidityResultOnUnannotatedType(@CompilerMessageKey String errorType, AnnotatedTypeMirror type, Tree p) Like reportValidityResult(java.lang.String, org.checkerframework.framework.type.AnnotatedTypeMirror, com.sun.source.tree.Tree), but the type is printed in the error message without annotations.
protected boolean	shouldCheckTopLevelDeclaredType(AnnotatedTypeMirror type, Tree tree) Should the top-level declared type be checked?
Void	visitArray(AnnotatedTypeMirror.AnnotatedArrayType type, Tree tree) Visits an array type.
Void	visitDeclared(AnnotatedTypeMirror.AnnotatedDeclaredType type, Tree tree) Visits a declared type.
protected Void	visitParameterizedType(AnnotatedTypeMirror.AnnotatedDeclaredType type, ParameterizedTypeTree tree) Checks that the annotations on the type arguments supplied to a type or a method invocation are within the bounds of the type variables as declared, and issues the "type.argument.type.incompatible" error if they are not.
Void	visitPrimitive(AnnotatedTypeMirror.AnnotatedPrimitiveType type, Tree tree) Visits a primitive type.
Void	visitTypeVariable(AnnotatedTypeMirror.AnnotatedTypeVariable type, Tree tree) Visits a type variable.
Void	visitWildcard(AnnotatedTypeMirror.AnnotatedWildcardType type, Tree tree) Visits a wildcard type.

Methods inherited from class org.checkerframework.framework.type.visitor.AnnotatedTypeScanner

reduce, reset, scan, scan, scanAndReduce, scanAndReduce, visit, visit, visitExecutable, visitIntersection, visitNoType, visitNull, visitUnion

Methods inherited from class java.lang.Object

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

Field Detail

isValid

protected boolean isValid

Is the type valid?

checkTopLevelDeclaredType

protected boolean checkTopLevelDeclaredType

Should the primary annotation on the top level type be checked?

checker

protected final BaseTypeChecker checker

BaseTypeChecker

visitor

protected final BaseTypeVisitor<?> visitor

BaseTypeVisitor

atypeFactory

protected final AnnotatedTypeFactory atypeFactory

AnnotatedTypeFactory

Constructor Detail

BaseTypeValidator

public BaseTypeValidator(BaseTypeChecker checker,
                         BaseTypeVisitor<?> visitor,
                         AnnotatedTypeFactory atypeFactory)

Method Detail

isValid

public boolean isValid(AnnotatedTypeMirror type,
                       Tree tree)

The entry point to the type validator. Validate the type against the given tree. Neither this method nor visit should be called directly by a visitor, only use BaseTypeVisitor.validateTypeOf(Tree).

Specified by:

isValid in interface TypeValidator

Parameters:

type - the type to validate

tree - the tree from which the type originated. If the tree is a method tree, validate its return type. If the tree is a variable tree, validate its field type.

Returns:

true, iff the type is valid

shouldCheckTopLevelDeclaredType

protected boolean shouldCheckTopLevelDeclaredType(AnnotatedTypeMirror type,
                                                  Tree tree)

Should the top-level declared type be checked?

Top-level type is not checked if tree is a local variable or an expression tree.

Parameters:

type - AnnotatedTypeMirror being validated

tree - Tree whose type is type

Returns:

whether or not the top-level type should be checked

isValidType

protected Result isValidType(QualifierHierarchy qualifierHierarchy,
                             AnnotatedTypeMirror type)

Returns true if the given AnnotatedTypeMirror passed a set of well-formedness checks. The method will never return false for valid types, but might not catch all invalid types.

Currently, the following is checked:

1. There should not be multiple annotations from the same hierarchy.
2. There should not be more annotations than the width of the qualifier hierarchy.
3. If the type is not a type variable, then the number of annotations should be the same as the width of the qualifier hierarchy.
4. These properties should also hold recursively for component types of arrays, as wells as bounds of type variables and wildcards.

isTopLevelValidType

protected Result isTopLevelValidType(QualifierHierarchy qualifierHierarchy,
                                     AnnotatedTypeMirror type)

Checks every property listed in isValidType(org.checkerframework.framework.type.QualifierHierarchy, org.checkerframework.framework.type.AnnotatedTypeMirror), but only for the top level type.

reportValidityResult

protected void reportValidityResult(@CompilerMessageKey String errorType,
                                    AnnotatedTypeMirror type,
                                    Tree p)

reportValidityResultOnUnannotatedType

protected void reportValidityResultOnUnannotatedType(@CompilerMessageKey String errorType,
                                                     AnnotatedTypeMirror type,
                                                     Tree p)

Like reportValidityResult(java.lang.String, org.checkerframework.framework.type.AnnotatedTypeMirror, com.sun.source.tree.Tree), but the type is printed in the error message without annotations. This method would print "annotation @NonNull is not permitted on type int", whereas reportValidityResult(java.lang.String, org.checkerframework.framework.type.AnnotatedTypeMirror, com.sun.source.tree.Tree) would print "annotation @NonNull is not permitted on type @NonNull int".

reportInvalidBounds

protected void reportInvalidBounds(AnnotatedTypeMirror type,
                                   Tree tree)

Most errors reported by this class are of the form type.invalid. This method reports when the bounds of a wildcard or type variable don't make sense. Bounds make sense when the effective annotations on the upper bound are supertypes of those on the lower bounds for all hierarchies. To ensure that this subtlety is not lost on users, we report "bound.type.incompatible" and print the bounds along with the invalid type rather than a "type.invalid".

reportInvalidType

protected void reportInvalidType(AnnotatedTypeMirror type,
                                 Tree p)

reportInvalidAnnotationsOnUse

protected void reportInvalidAnnotationsOnUse(AnnotatedTypeMirror type,
                                             Tree p)

visitDeclared

public Void visitDeclared(AnnotatedTypeMirror.AnnotatedDeclaredType type,
                          Tree tree)

Description copied from interface: AnnotatedTypeVisitor

Visits a declared type.

Specified by:

visitDeclared in interface AnnotatedTypeVisitor<Void,Tree>

Overrides:

visitDeclared in class AnnotatedTypeScanner<Void,Tree>

Parameters:

type - the type to visit

tree - a visitor-specified parameter

Returns:

a visitor-specified result

visitPrimitive

public Void visitPrimitive(AnnotatedTypeMirror.AnnotatedPrimitiveType type,
                           Tree tree)

Description copied from interface: AnnotatedTypeVisitor

Visits a primitive type.

Specified by:

visitPrimitive in interface AnnotatedTypeVisitor<Void,Tree>

Overrides:

visitPrimitive in class AnnotatedTypeScanner<Void,Tree>

Parameters:

type - the type to visit

tree - a visitor-specified parameter

Returns:

a visitor-specified result

visitArray

public Void visitArray(AnnotatedTypeMirror.AnnotatedArrayType type,
                       Tree tree)

Description copied from interface: AnnotatedTypeVisitor

Visits an array type.

Specified by:

visitArray in interface AnnotatedTypeVisitor<Void,Tree>

Overrides:

visitArray in class AnnotatedTypeScanner<Void,Tree>

Parameters:

type - the type to visit

tree - a visitor-specified parameter

Returns:

a visitor-specified result

visitParameterizedType

protected Void visitParameterizedType(AnnotatedTypeMirror.AnnotatedDeclaredType type,
                                      ParameterizedTypeTree tree)

Checks that the annotations on the type arguments supplied to a type or a method invocation are within the bounds of the type variables as declared, and issues the "type.argument.type.incompatible" error if they are not.

This method used to be visitParameterizedType, which incorrectly handles the main annotation on generic types.

visitTypeVariable

public Void visitTypeVariable(AnnotatedTypeMirror.AnnotatedTypeVariable type,
                              Tree tree)

Description copied from interface: AnnotatedTypeVisitor

Visits a type variable.

Specified by:

visitTypeVariable in interface AnnotatedTypeVisitor<Void,Tree>

Overrides:

visitTypeVariable in class AnnotatedTypeScanner<Void,Tree>

Parameters:

type - the type to visit

tree - a visitor-specified parameter

Returns:

a visitor-specified result

visitWildcard

public Void visitWildcard(AnnotatedTypeMirror.AnnotatedWildcardType type,
                          Tree tree)

Description copied from interface: AnnotatedTypeVisitor

Visits a wildcard type.

Specified by:

visitWildcard in interface AnnotatedTypeVisitor<Void,Tree>

Overrides:

visitWildcard in class AnnotatedTypeScanner<Void,Tree>

Parameters:

type - the type to visit

tree - a visitor-specified parameter

Returns:

a visitor-specified result

areBoundsValid

public boolean areBoundsValid(AnnotatedTypeMirror upperBound,
                              AnnotatedTypeMirror lowerBound)

Returns:

true if the effective annotations on the upperBound are above those on the lowerBound