Class BaseTypeValidator

    • Field Detail

      • isValid

        protected boolean isValid
        Is the type valid? This is side-effected by the visitor, and read at the end of visiting.
      • checkTopLevelDeclaredOrPrimitiveType

        protected boolean checkTopLevelDeclaredOrPrimitiveType
        Should the primary annotation on the top level type be checked?
    • Method Detail

      • isValid

        public boolean isValid​(AnnotatedTypeMirror type,
                               com.sun.source.tree.Tree tree)
        Validate the type against the given tree. This method both issues error messages and also returns a boolean value.

        This is the entry point to the type validator. Neither this method nor visit should be called directly by a visitor, only use BaseTypeVisitor.validateTypeOf(Tree).

        This method is only called on top-level types, but it validates the entire type including components of a compound type. Subclasses should override this only if there is special-case behavior that should be performed only on top-level types.

        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, type is its return type. If the tree is a variable tree, type is the variable's type.
        Returns:
        true if the type is valid
      • shouldCheckTopLevelDeclaredOrPrimitiveType

        protected boolean shouldCheckTopLevelDeclaredOrPrimitiveType​(AnnotatedTypeMirror type,
                                                                     com.sun.source.tree.Tree tree)
        Should the top-level declared or primitive type be checked?

        If type is not a declared or primitive type, then this method returns true.

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

        Parameters:
        type - the AnnotatedTypeMirror being validated
        tree - a Tree whose type is type
        Returns:
        whether or not the top-level type should be checked, if type is a declared or primitive type.
      • isValidStructurally

        protected java.util.List<DiagMessage> isValidStructurally​(AnnotatedTypeMirror type)
        Performs some well-formedness checks on the given AnnotatedTypeMirror. Returns a list of failures. If successful, returns an empty list. The method will never return failures for a valid type, but might not catch all invalid types.

        This method ensures that the type is structurally or lexically well-formed, but it does not check whether the annotations are semantically sensible. Subclasses should generally override visit methods such as visitDeclared(org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType, com.sun.source.tree.Tree) rather than this method.

        Currently, this implementation checks the following (subclasses can extend this behavior):

        1. There should not be multiple annotations from the same qualifier hierarchy.
        2. There should not be more annotations than the width of the QualifierHierarchy.
        3. If the type is not a type variable, then the number of annotations should be the same as the width of the QualifierHierarchy.
        4. These properties should also hold recursively for component types of arrays and for bounds of type variables and wildcards.
        This does not test whether the Java type is relevant, because by the time this method is called, the type includes some non-programmer-written annotations.
        Parameters:
        type - the type to test
        Returns:
        list of reasons the type is invalid, or empty list if the type is valid
      • reportInvalidBounds

        protected void reportInvalidBounds​(AnnotatedTypeMirror type,
                                           com.sun.source.tree.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".
        Parameters:
        type - the type with invalid bounds
        tree - where to report the error
      • reportInvalidType

        protected void reportInvalidType​(AnnotatedTypeMirror type,
                                         com.sun.source.tree.Tree p)
      • reportInvalidAnnotationsOnUse

        protected void reportInvalidAnnotationsOnUse​(AnnotatedTypeMirror type,
                                                     com.sun.source.tree.Tree p)
        Report an "annotations.on.use" error for the given type and tree.
        Parameters:
        type - the type with invalid annotations
        p - the tree where to report the error
      • visitClassTypeParameters

        protected void visitClassTypeParameters​(AnnotatedTypeMirror.AnnotatedDeclaredType type,
                                                com.sun.source.tree.ClassTree tree)
        Visits the type parameters of a class tree.
        Parameters:
        type - type of tree
        tree - a class tree
      • visitTypeParameterBounds

        protected void visitTypeParameterBounds​(AnnotatedTypeMirror.AnnotatedTypeVariable typeParameter,
                                                com.sun.source.tree.TypeParameterTree typeParameterTree)
        Visits type parameter bounds.
        Parameters:
        typeParameter - type of typeParameterTree
        typeParameterTree - a type parameter tree
      • visitParameterizedType

        protected java.lang.Void visitParameterizedType​(AnnotatedTypeMirror.AnnotatedDeclaredType type,
                                                        com.sun.source.tree.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.
        Parameters:
        type - the type to check
        tree - the type's tree
      • areBoundsValid

        public boolean areBoundsValid​(AnnotatedTypeMirror upperBound,
                                      AnnotatedTypeMirror lowerBound)
        Returns true if the effective annotations on the upperBound are above (or equal to) those on the lowerBound.
        Parameters:
        upperBound - the upper bound to check
        lowerBound - the lower bound to check
        Returns:
        true if the effective annotations on the upperBound are above (or equal to) those on the lowerBound
      • validateWildCardTargetLocation

        protected void validateWildCardTargetLocation​(AnnotatedTypeMirror.AnnotatedWildcardType type,
                                                      com.sun.source.tree.Tree tree)
        Validate if qualifiers on wildcard are permitted by TargetLocations. Report an error if the actual use of this annotation is not listed in the declared TypeUseLocations in this meta-annotation.
        Parameters:
        type - the type to check
        tree - the tree of this type